企业官网建设流程全解析

1. 项目概述：为什么我们需要GPU加速的模糊？

在UE5里做后期效果，模糊（Blur）可以说是最基础、最常用的操作之一。无论是景深模拟、UI柔化、运动模糊，还是风格化渲染，都离不开它。传统上，我们习惯在材质编辑器里用像素着色器（Pixel Shader）来实现，比如写个简单的均值模糊或高斯模糊节点网络。这种方法上手快，对于小尺寸纹理或者非实时需求来说，完全够用。

但问题很快就来了。当你把项目分辨率调到4K，或者需要在一个画面里叠加多层不同半径、不同方向的模糊效果时，性能瓶颈会变得非常明显。我自己的项目里就踩过这个坑：一个全屏的后处理材质，里面嵌套了两个高斯模糊，在1080p下跑得挺流畅，一到4K，GPU帧时间直接飙升了十几毫秒，整个画面都卡顿了。原因很简单，像素着色器的计算是“每个像素执行一次”，对于一张4K纹理（约830万个像素），一个5x5的模糊核，意味着每个像素要采样周围25个像素并进行加权计算，这个计算量是乘数级增长的。更别提那些需要大半径模糊（比如13x13甚至更大）的场景了，GPU负载会高得吓人。

这时候，Compute Shader的优势就体现出来了。它不像像素着色器那样被渲染管线（如屏幕空间）束缚，而是允许我们直接组织GPU上的大量线程，对任意缓冲区（Buffer）进行并行读写。对于模糊这种典型的、高度并行且数据局部性强的图像处理任务，Compute Shader简直是量身定做。它可以把整张纹理划分成无数个小块，让成千上万个GPU线程同时处理，极大地提升了计算效率。实测下来，用Compute Shader实现的高斯模糊，在处理4K纹理时，性能可以比传统像素着色器方法提升数倍，而且更加稳定，不容易因为分辨率提升而导致帧率骤降。

所以，这个“5分钟搞定”的项目，核心目标不是教你写一个模糊算法（算法本身是经典的），而是带你快速打通UE5中Compute Shader从创建、绑定、调度到渲染的完整流程。一旦这个流程跑通了，你收获的不仅仅是一个高性能的模糊效果，更是一把开启GPU通用计算大门的钥匙，以后实现粒子模拟、物理计算、光线追踪降噪等复杂效果，思路都是相通的。

2. 核心思路与方案选型

2.1 为什么选择Compute Shader而非Pixel Shader？

上面提到了性能，这里再深入拆解一下。Pixel Shader（在UE材质中体现）本质上是为“光栅化后的每个片段（Fragment）”设计的。它的执行被屏幕网格和渲染流程（如后处理体积）所限定。当你对一个Render Target进行模糊时，UE引擎内部可能需要多次绘制调用（Draw Call）和Render Target切换（俗称“乒乓”操作），这本身就有开销。

而Compute Shader属于DirectX/OpenGL/Vulkan中的Compute Pipeline，它独立于图形渲染管线。它的工作方式是：你定义线程组（Thread Group）和线程（Thread）的三维数量，GPU会调度这些线程直接对资源（如纹理、缓冲区）进行读写。对于图像模糊，我们可以让一个线程负责输出纹理中的一个像素。由于模糊计算只需要读取输入纹理某一区域的数据，线程之间几乎没有依赖，并行度可以达到极致。

从资源访问模式来看，Pixel Shader对纹理的采样可能受缓存效率影响。而Compute Shader允许我们使用“共享内存”（Shared Memory），这是一个线程组内所有线程都能高速访问的一小块片上内存。我们可以先把纹理的一块区域加载到共享内存中，让组内的所有线程从这里读取数据，这能大幅减少对全局显存的访问次数，这是性能提升的关键之一。虽然在这个入门级的模糊例子中我们可能不立即用到共享内存，但了解这个机制很重要，它是Compute Shader处理图像卷积类算法的终极优化手段。

2.2 UE5中Compute Shader的实现路径选择

在UE5中，使用Compute Shader主要有两种主流方式，我们需要根据项目需求做出选择：

方案一：使用“自定义渲染通道”（Custom Render Pass）或“渲染图”（Render Graph）

这是UE5（特别是5.1及以上版本）更现代、更推荐的方式。Render Graph是UE5新引入的渲染管线框架，它能够自动管理资源生命周期、处理依赖关系，避免资源泄露和冗余屏障（Barrier）。通过继承FRDGGlobalShader并实现ModifyCompilationEnvironment和Execute函数，我们可以将Compute Shader集成到渲染图中。这种方式与引擎的渲染流程结合紧密，适合用于需要与引擎其他渲染阶段（如BasePass、阴影）深度交互的后处理效果。

方案二：使用“RHI命令列表”（RHI Command List）直接分发

这是一种相对底层、直接的方式。我们通过ENQUEUE_RENDER_COMMAND宏，将计算任务提交到渲染线程，然后使用RHI（Rendering Hardware Interface）接口创建着色器、参数绑定并分发调度。这种方式更加灵活，不依赖于特定的渲染阶段，你可以在任何时机（比如GameThread tick时）触发计算。它更适合于那些独立于主渲染流程的通用计算任务，比如GPU粒子更新、地形数据生成等。

对于本项目的目标——“5分钟快速实现一个可运行的GPU加速模糊”——我们选择方案二。原因如下：

1. 上手快速：无需深入理解UE5庞大的Render Graph体系，直击Compute Shader使用核心。
2. 依赖清晰：逻辑集中在C++端和HLSL着色器文件，流程直观，便于理解和调试。
3. 通用性强：学会这种方法后，其代码框架可以很容易地迁移到其他独立的GPU计算任务中。

我们的技术路线图因此确定为：编写一个C++类（如FBlurComputeShader）来管理着色器资源、设置参数、分发任务；同时编写一个HLSL文件（.usf后缀）来实现具体的模糊计算内核；最后，提供一个简单的蓝图函数库或组件接口，让设计师能在蓝图中一键调用这个模糊效果。

2.3 模糊算法的选择：高斯模糊（Gaussian Blur）

模糊算法有很多，如均值模糊、中值模糊、运动模糊等。这里我们选择最经典、应用最广泛的高斯模糊。它的原理是使用一个符合高斯函数（正态分布）的卷积核（Kernel）对图像进行卷积操作。离中心像素越远的像素，其权重越低。

为什么选它？

• 效果平滑：高斯模糊产生的过渡非常自然平滑，没有明显的块状或环形瑕疵，符合人眼视觉特性。
• 可分离性：这是关键！一个二维的高斯卷积核可以分解为两个一维卷积核（水平方向和垂直方向）的连续应用。这意味着一个N x N的二维模糊，可以拆解为先进行一次1 x N的水平模糊，再进行一次N x 1的垂直模糊。计算复杂度从O(N²)降到了O(2N)，对于大半径模糊，性能提升是指数级的。我们将利用这一特性，在Compute Shader中分两步（两个Pass）来实现。

3. 环境准备与核心代码结构

3.1 创建插件与着色器文件

首先，为了模块化管理，我建议创建一个UE插件（Plugin）。在UE编辑器的“编辑”->“插件”窗口中，点击“添加”按钮，选择“空白”模板，命名为“GPGPUBlur”（或其他你喜欢的名字）。创建插件的好处是代码隔离性好，易于在项目间迁移。

在插件目录的Source/GPGPUBlur/Private文件夹下，我们将创建主要的C++类。同时，Compute Shader的HLSL代码需要放在一个引擎能够编译到的特殊位置。UE引擎编译着色器（.usf文件）有其固定路径。最稳妥的方式是在你的插件目录下创建Shaders/Private文件夹来存放.usf文件。但为了让引擎发现并编译它，我们需要在插件的.Build.cs文件中添加对应的配置。

打开GPGPUBlur.Build.cs文件，添加对渲染模块的依赖，并指定着色器目录：

using UnrealBuildTool; public class GPGPUBlur : ModuleRules { public GPGPUBlur(ReadOnlyTargetRules Target) : base(Target) { PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs; PublicDependencyModuleNames.AddRange( new string[] { "Core", "RenderCore", // 核心渲染模块 "RHI", // 渲染硬件接口 } ); PrivateDependencyModuleNames.AddRange( new string[] { "CoreUObject", "Engine", "Projects", // 为了获取插件目录路径 } ); // 告诉引擎，我们这个模块包含需要编译的着色器文件 // 这行是关键！它会将`Shaders`目录下的所有.usf文件加入编译列表 AddEngineThirdPartyPrivateStaticDependencies(Target, "DX11"); // 根据你的目标平台调整，如"Vulkan", "OpenGLDrv" } }

注意：AddEngineThirdPartyPrivateStaticDependencies这一行在某些UE版本或纯插件项目中可能不是必须的，更通用的方法是确保你的.usf文件被放置在引擎或项目能扫描到的标准着色器目录下。一个更可靠的做法是：将Shaders文件夹放在插件根目录（与Source同级），然后在GPGPUBlur.cpp的StartupModule函数中，使用FShaderCore::AddShaderSourceDirectoryMapping函数，将你插件的着色器目录虚拟映射到引擎的着色器路径下。这是确保自定义着色器能被编译和加载的“标准操作”。

3.2 编写HLSL Compute Shader内核

在插件根目录创建Shaders/Private/BlurComputeShader.usf。这个文件包含了我们模糊算法的GPU代码。

// BlurComputeShader.usf // 定义常量缓冲区，用于从CPU传递参数到GPU cbuffer BlurConstants : register(b0) { uint2 TextureSize; // 输入纹理的尺寸 (width, height) float BlurRadius; // 模糊半径（像素单位） int bHorizontalPass; // 0表示垂直Pass，1表示水平Pass }; // 定义输入和输出纹理 Texture2D<float4> InputTexture : register(t0); RWTexture2D<float4> OutputTexture : register(u0); // 线程组大小，通常设为16x16或32x32，需要权衡占用率和内存访问效率 // 这里我们选择16x16，一个线程组处理256个像素 #define GROUP_SIZE 16 // 一个简化的一维高斯核权重计算函数 // 在实际项目中，为了效率，我们通常会在CPU端预计算好权重数组并传入 float GetGaussianWeight(float offset, float sigma) { // sigma 通常与 BlurRadius 相关，例如 sigma = BlurRadius / 2.0 // 这里为了简化，我们使用一个固定的衰减系数 return exp(-(offset * offset) / (2.0 * sigma * sigma)); } [numthreads(GROUP_SIZE, GROUP_SIZE, 1)] void MainCS( uint3 GroupId : SV_GroupID, uint3 GroupThreadId : SV_GroupThreadID, uint3 DispatchThreadId : SV_DispatchThreadID ) { // 计算当前线程要处理的像素坐标 uint2 PixelPos = DispatchThreadId.xy; // 边界检查：确保线程不会处理超出纹理范围的像素 if (PixelPos.x >= TextureSize.x || PixelPos.y >= TextureSize.y) { return; } float4 blurSum = float4(0.0, 0.0, 0.0, 0.0); float weightSum = 0.0; // 根据是水平还是垂直Pass，决定采样方向 int2 sampleDirection = int2(bHorizontalPass, 1 - bHorizontalPass); // 计算sigma，用于权重计算 float sigma = max(BlurRadius / 2.0, 0.001); // 遍历模糊核范围内的像素 for (int i = -BlurRadius; i <= BlurRadius; ++i) { // 计算采样偏移 int2 sampleOffset = i * sampleDirection; int2 samplePos = PixelPos + sampleOffset; // 纹理采样时进行钳位（Clamp）处理，避免采样到纹理外 samplePos = clamp(samplePos, int2(0, 0), int2(TextureSize.x - 1, TextureSize.y - 1)); // 采样输入纹理 float4 sampleColor = InputTexture.Load(int3(samplePos, 0)); // 计算高斯权重（这里使用简化计算，生产环境建议预计算传入） float weight = GetGaussianWeight(abs(i), sigma); // 累加颜色和权重 blurSum += sampleColor * weight; weightSum += weight; } // 归一化，得到最终模糊颜色 float4 finalColor = blurSum / weightSum; // 将结果写入输出纹理 OutputTexture[PixelPos] = finalColor; }

这段HLSL代码是核心。numthreads定义了每个线程组包含16x16x1个线程。SV_DispatchThreadID给出了当前线程在全局调度中的位置，即它要处理的像素坐标。我们通过一个循环，根据bHorizontalPass参数，沿着水平或垂直方向，对周围BlurRadius范围内的像素进行采样并加权平均。这里为了代码清晰，权重是在着色器内实时计算的，实际上为了性能，最好在CPU端预计算好权重数组，通过常量缓冲区传入。

3.3 构建C++端的管理类

接下来，在插件的Private文件夹创建BlurComputeShader.cpp和BlurComputeShader.h。这个类负责加载着色器、设置参数、并执行渲染命令。

BlurComputeShader.h

#pragma once #include "CoreMinimal.h" #include "GlobalShader.h" // 需要包含全局着色器头文件 #include "ShaderParameterStruct.h" // 声明我们的Compute Shader类，继承自FGlobalShader class FBlurComputeShader : public FGlobalShader { DECLARE_GLOBAL_SHADER(FBlurComputeShader); SHADER_USE_PARAMETER_STRUCT(FBlurComputeShader, FGlobalShader); // 定义着色器参数布局 BEGIN_SHADER_PARAMETER_STRUCT(FParameters, ) SHADER_PARAMETER(FIntPoint, TextureSize) SHADER_PARAMETER(float, BlurRadius) SHADER_PARAMETER(uint32, bHorizontalPass) // 使用uint32传递布尔值 SHADER_PARAMETER_SRV(Texture2D<float4>, InputTexture) SHADER_PARAMETER_UAV(RWTexture2D<float4>, OutputTexture) END_SHADER_PARAMETER_STRUCT() // 确保着色器在不同情况下都能被编译（例如，不同的功能级别） static bool ShouldCompilePermutation(const FGlobalShaderPermutationParameters& Parameters) { return IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5); } // 可选：用于设置编译环境 static void ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment); };

BlurComputeShader.cpp

#include "BlurComputeShader.h" #include "ShaderCore.h" // 实现宏定义 IMPLEMENT_GLOBAL_SHADER(FBlurComputeShader, "/GPGPUBlur/Private/BlurComputeShader.usf", "MainCS", SF_Compute); void FBlurComputeShader::ModifyCompilationEnvironment(const FGlobalShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment) { FGlobalShader::ModifyCompilationEnvironment(Parameters, OutEnvironment); // 可以在这里定义一些着色器编译时的宏，例如： // OutEnvironment.SetDefine(TEXT("GROUP_SIZE"), 16); }

这个类定义了着色器参数的结构，并与我们之前写的.usf文件关联起来。IMPLEMENT_GLOBAL_SHADER宏是关键，它将C++类FBlurComputeShader与HLSL文件路径（"/GPGPUBlur/Private/BlurComputeShader.usf"）和入口函数名（"MainCS"）绑定。

3.4 创建渲染代理与工具函数

为了在游戏线程中安全地调用渲染命令，我们需要创建一个渲染代理（Render Proxy）。在插件的Private文件夹下创建一个新的文件BlurShaderExecutor.cpp/.h。

BlurShaderExecutor.h

#pragma once #include "CoreMinimal.h" #include "RHI.h" #include "RHICommandList.h" #include "RHIResources.h" class UTextureRenderTarget2D; class GPGPUBLUR_API FBlurShaderExecutor { public: // 静态工具函数：对给定的RenderTarget应用高斯模糊 static void ApplyGaussianBlur( UTextureRenderTarget2D* InputRenderTarget, UTextureRenderTarget2D* OutputRenderTarget, float Radius = 4.0f ); };

BlurShaderExecutor.cpp

#include "BlurShaderExecutor.h" #include "BlurComputeShader.h" #include "Engine/TextureRenderTarget2D.h" void FBlurShaderExecutor::ApplyGaussianBlur(UTextureRenderTarget2D* InputRenderTarget, UTextureRenderTarget2D* OutputRenderTarget, float Radius) { if (!InputRenderTarget || !OutputRenderTarget) { UE_LOG(LogTemp, Error, TEXT("Invalid render targets provided to FBlurShaderExecutor::ApplyGaussianBlur")); return; } FTextureRenderTargetResource* InputRTResource = InputRenderTarget->GameThread_GetRenderTargetResource(); FTextureRenderTargetResource* OutputRTResource = OutputRenderTarget->GameThread_GetRenderTargetResource(); if (!InputRTResource || !OutputRTResource) { return; } // 获取纹理尺寸 FIntPoint TextureSize(InputRenderTarget->SizeX, InputRenderTarget->SizeY); // 我们需要两个临时的RenderTarget来进行“乒乓”操作：水平模糊 -> 垂直模糊 // 这里为了简化，假设调用者已经提供了两个不同的RenderTarget作为输入和输出。 // 更健壮的实现应该内部创建和管理临时RT。 // 将任务提交到渲染线程 ENQUEUE_RENDER_COMMAND(BlurComputeShaderCommand)( [InputRTResource, OutputRTResource, TextureSize, Radius](FRHICommandListImmediate& RHICmdList) { // 1. 获取输入输出纹理的RHI引用 FTextureRHIRef InputTextureRHI = InputRTResource->GetRenderTargetTexture(); FTextureRHIRef OutputTextureRHI = OutputRTResource->GetRenderTargetTexture(); if (!InputTextureRHI.IsValid() || !OutputTextureRHI.IsValid()) { return; } // 2. 创建着色器参数实例并填充数据 FBlurComputeShader::FParameters PassParameters; // 第一遍：水平模糊 (Input -> Temp) // 注意：这里需要一个中间纹理。为了示例清晰，我们假设OutputRenderTarget就是我们的“中间纹理”。 // 实际应用中，你需要创建两个RenderTarget：TempRT和FinalRT。 // 步骤应为：Input -> TempRT (水平模糊) -> FinalRT (垂直模糊) // 以下代码演示单次Pass，你需要调用两次，并切换输入/输出纹理和bHorizontalPass参数。 // 示例：执行水平模糊（从InputTexture到OutputTexture） PassParameters.TextureSize = TextureSize; PassParameters.BlurRadius = Radius; PassParameters.bHorizontalPass = 1; // 1 代表水平 PassParameters.InputTexture = InputTextureRHI; // 创建UAV（无序访问视图）用于写入输出纹理 FRHIUnorderedAccessView* OutputTextureUAV = RHICreateUnorderedAccessView(OutputTextureRHI); PassParameters.OutputTexture = OutputTextureUAV; // 3. 获取Compute Shader的引用 TShaderMapRef<FBlurComputeShader> ComputeShader(GetGlobalShaderMap(GMaxRHIFeatureLevel)); // 4. 设置计算管线状态并分发调度 RHICmdList.SetComputeShader(ComputeShader.GetComputeShader()); SetShaderParameters(RHICmdList, ComputeShader, ComputeShader.GetComputeShader(), PassParameters); // 计算需要多少个线程组来覆盖整个纹理 // 每个线程组处理GROUP_SIZE x GROUP_SIZE个像素 const uint32 GroupSizeX = FMath::DivideAndRoundUp((uint32)TextureSize.X, 16); const uint32 GroupSizeY = FMath::DivideAndRoundUp((uint32)TextureSize.Y, 16); RHICmdList.DispatchComputeShader(GroupSizeX, GroupSizeY, 1); // 5. 解除参数绑定（可选，但推荐） SetShaderParameters(RHICmdList, ComputeShader, ComputeShader.GetComputeShader(), FBlurComputeShader::FParameters()); // 重要：释放UAV引用 // RHIDestroyUnorderedAccessView(OutputTextureUAV); // 注意：RHI资源的销毁需要谨慎管理生命周期，通常由引擎管理。这里创建的是临时视图。 // 在实际的双Pass模糊中，这里需要： // a) 将第一遍（水平模糊）的输出设置为第二遍的输入。 // b) 将PassParameters.bHorizontalPass设为0，执行垂直模糊。 // c) 将垂直模糊的结果输出到最终的RenderTarget。 } ); }

这段代码是核心的调度部分。ENQUEUE_RENDER_COMMAND确保所有RHI操作在渲染线程安全执行。我们获取了输入和输出RenderTarget的RHI资源，填充了着色器参数（纹理尺寸、模糊半径、方向），然后通过SetComputeShader和SetShaderParameters将数据和着色器绑定，最后用DispatchComputeShader分发计算任务。注意，这里为了代码清晰，只演示了单次Pass（水平模糊）。一个完整的高斯模糊需要两个Pass，并且需要一个中间纹理来存储第一次Pass的结果。

4. 在UE编辑器中集成与调用

4.1 创建蓝图函数库

为了让美术和策划能方便地使用这个功能，我们创建一个蓝图函数库（Blueprint Function Library）。

BlurBlueprintLibrary.h

#pragma once #include "Kismet/BlueprintFunctionLibrary.h" #include "BlurBlueprintLibrary.generated.h" UCLASS() class GPGPUBLUR_API UBlurBlueprintLibrary : public UBlueprintFunctionLibrary { GENERATED_BODY() public: UFUNCTION(BlueprintCallable, Category = "GPGPU|Blur", meta = (WorldContext = "WorldContextObject")) static void ApplyComputeShaderBlur( UObject* WorldContextObject, class UTextureRenderTarget2D* InputRT, class UTextureRenderTarget2D* OutputRT, float BlurRadius = 4.0f ); };

BlurBlueprintLibrary.cpp

#include "BlurBlueprintLibrary.h" #include "BlurShaderExecutor.h" #include "Engine/TextureRenderTarget2D.h" void UBlurBlueprintLibrary::ApplyComputeShaderBlur(UObject* WorldContextObject, UTextureRenderTarget2D* InputRT, UTextureRenderTarget2D* OutputRT, float BlurRadius) { if (!InputRT || !OutputRT) { UE_LOG(LogTemp, Warning, TEXT("ApplyComputeShaderBlur: Invalid RenderTargets.")); return; } // 检查尺寸是否匹配 if (InputRT->SizeX != OutputRT->SizeX || InputRT->SizeY != OutputRT->SizeY) { UE_LOG(LogTemp, Error, TEXT("ApplyComputeShaderBlur: Input and Output RenderTarget sizes must match!")); return; } // 调用我们之前写的执行器 FBlurShaderExecutor::ApplyGaussianBlur(InputRT, OutputRT, BlurRadius); }

4.2 在编辑器中的使用流程

1. 创建RenderTarget：在内容浏览器中右键，选择“渲染目标纹理”（Render Target），创建两个，分别命名为RT_Input和RT_Output（或者RT_Intermediate）。将它们的尺寸设置为你的目标分辨率（如1920x1080）。
2. 填充输入RT：你需要用某种方式将场景内容渲染到RT_Input中。这可以通过“场景捕获组件”（Scene Capture Component）来实现，或者从已有的纹理复制。
3. 调用蓝图节点：在任意蓝图的Event Tick或某个自定义事件中，调用我们创建的蓝图节点Apply Compute Shader Blur，将RT_Input和RT_Output连接进去，并设置模糊半径。
4. 使用模糊结果：模糊后的图像就存储在RT_Output中。你可以将其作为材质参数，赋给一个全屏后处理材质（通过SceneTexture节点选择Custom纹理并指向RT_Output），或者用于UI材质等。

4.3 实现完整的双Pass模糊

上面FBlurShaderExecutor::ApplyGaussianBlur的示例是单Pass的。一个完整的、高效的双Pass高斯模糊实现，需要在渲染线程命令中管理一个中间纹理。由于创建RHI纹理比较繁琐，一个更实用的方法是：要求调用者提供三个RenderTarget：InputRT、TempRT、OutputRT。执行流程如下：

// 伪代码逻辑： // Pass 1: 水平模糊， InputRT -> TempRT SetParameters(InputRT, TempRT, true); DispatchComputeShader(); // 在GPU命令之间插入一个资源转换屏障(Resource Transition Barrier)，确保Pass1写完TempRT后，Pass2才能读 RHICmdList.TransitionResource(EResourceTransitionAccess::ERWBarrier, EResourceTransitionPipeline::EComputeToCompute, TempRT->UAV); // Pass 2: 垂直模糊， TempRT -> OutputRT SetParameters(TempRT, OutputRT, false); DispatchComputeShader();

在实际编码中，你需要在ENQUEUE_RENDER_COMMAND内部，使用RHICreateTexture2D等API动态创建中间纹理的RHI资源，或者更简单地，在C++端创建并管理一个UTextureRenderTarget2D作为成员变量，在初始化时创建好。

5. 性能调优与常见问题排查

5.1 性能优化要点

1. 线程组大小（Thread Group Size）：我们在HLSL中定义了[numthreads(16, 16, 1)]。这个值不是随便设的。它需要适配GPU的硬件特性（如NVIDIA GPU的Warp大小为32，AMD GPU的Wavefront大小为64）。16x16=256是一个常用值，它能较好地平衡线程利用率和寄存器压力。你可以尝试8x8或32x32，并通过UE的GPU性能分析工具（如Unreal Insights）查看哪个效率更高。
2. 共享内存（Shared Memory）优化：当前示例中，每个线程都直接从纹理中读取数据。对于模糊这类邻域操作，相邻线程读取的纹理区域有很大重叠。我们可以使用共享内存进行优化：让整个线程组协作，将所需的一块纹理数据先加载到共享内存（一个groupshared数组）中，然后所有线程从共享内存中读取。这能极大减少对全局显存的访问，是性能提升的关键。但这会增加代码复杂度，需要处理边界和同步（GroupMemoryBarrierWithGroupSync）。
3. 权重预计算：在着色器循环中计算高斯权重是低效的。最佳实践是在CPU端根据模糊半径预计算好权重数组，通过一个StructuredBuffer或常量缓冲区传入着色器。对于可分离高斯模糊，你只需要传入一个一维的权重数组。
4. 避免纹理采样器：注意我们在HLSL中使用的是InputTexture.Load(int3(samplePos, 0))，而不是Sample或SampleLevel。Load是直接读取纹理指定Mip Level、指定坐标的纹素，不经过滤波和寻址模式处理，对于这种精确的、程序化的访问更快。Sample会使用采样器，可能引入额外的开销和缓存行为。

5.2 常见问题与解决方案实录

问题1：屏幕上一片黑或粉红色（未初始化颜色）

• 可能原因：Compute Shader没有正确执行，或者输出纹理的UAV没有正确绑定。
• 排查步骤：
  1. 检查着色器是否编译成功。在输出日志（Output Log）中搜索你的着色器名称，看是否有编译错误。编译错误通常会导致着色器引用为空（TShaderMapRef获取失败）。
  2. 在ENQUEUE_RENDER_COMMAND内部开始处添加UE_LOG(LogTemp, Log, TEXT("Render Command Executed"));，确认命令被提交。
  3. 使用图形调试工具（如RenderDoc）捕获一帧，查看Compute Shader的Dispatch命令是否被调用，以及其输出纹理的内容。这是最直接的诊断方法。

问题2：模糊效果不对，有奇怪的条纹或错位

• 可能原因：纹理坐标计算错误，或者边界处理不当。
• 排查步骤：
  1. 检查TextureSize参数是否正确从CPU传入。确保传入的是纹理的宽度和高度（FIntPoint(Width, Height)）。
  2. 检查HLSL中的边界钳位（clamp）逻辑。确保samplePos不会超出[0, TextureSize-1]的范围。超出范围的采样在Load函数中行为是未定义的。
  3. 检查bHorizontalPass参数。确保水平Pass时sampleDirection是(1,0)，垂直Pass时是(0,1)。

问题3：性能提升不明显，甚至更差

• 可能原因：模糊半径太小，Compute Shader的调度开销抵消了并行优势；或者没有利用共享内存，显存带宽成为瓶颈。
• 排查步骤：
  1. 使用STAT GPU或Unreal Insights查看GPU时间。对比Pixel Shader版本和Compute Shader版本的耗时。对于小半径（如3x3）模糊，Pixel Shader可能更快，因为开销小。Compute Shader的优势在大半径（如>=7x7）时才会明显。
  2. 检查线程组调度数量。DispatchComputeShader的参数是线程组数量，不是线程数量。确保计算正确：组数 = ceil(纹理尺寸 / 线程组尺寸)。
  3. 考虑实现共享内存优化。对于大半径模糊，这是必经之路。

问题4：引擎崩溃或报RHI错误

• 可能原因：资源状态错误（例如，纹理同时被绑定为SRV和UAV而未正确转换），或命令列表使用不当。
• 排查步骤：
  1. 确保在将纹理用作UAV之前，其状态已经转换为UAV。在双Pass模糊中，中间纹理在第一个Pass是UAV（可写），在第二个Pass是SRV（可读）。需要在两个Pass之间插入资源转换屏障（Resource Transition Barrier）。在UE的RHI中，这通常通过RHICmdList.TransitionResource来完成。
  2. 确保所有RHI资源的创建和销毁都在渲染线程进行，并且生命周期管理正确。避免GameThread持有RHI资源指针。

最后，我个人在将这套流程集成到实际项目时的体会是，调试是关键。Graphics Debugger（如RenderDoc）是你最好的朋友。它能让你看到每一帧具体的GPU命令、着色器代码、纹理和缓冲区的数据，对于验证Compute Shader是否正确工作、数据是否正确传递，是无可替代的。开始时可以先用一个极小的纹理（如8x8）和固定的颜色输入，在着色器中输出调试颜色（比如根据线程ID输出渐变），在RenderDoc里验证计算逻辑，然后再逐步应用到全分辨率纹理上，这样能快速定位问题所在。