刘耀宇的博客 https://liuyaoyu.top/ 先吃面吧 Sun, 28 Jun 2026 00:44:43 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed en-US All rights reserved 2026, NotionNext <![CDATA[从ue5 BRDF看UE shader分支选择]]> https://liuyaoyu.top/article/example-36 https://liuyaoyu.top/article/example-36 Mon, 12 Jan 2026 00:00:00 GMT
我们先来看ue的一段BRDF:
除了传统的#if SHADING_PATH_MOBILE
这种宏分支外，我们还能看到if (bHasAnisotropy) 以及 BRANCH 关键字
这两者为什么怎么用？
在shader内少使用if 动态分支是每个TA都知道，但是往往忽略了 相干性（Coherence）
我们看这句：
如果这个材质开启了各向异性（Anisotropy），那么这个 Draw Call 绘制的所有像素，其 bHasAnisotropy 几乎都是 true。
再说个通俗的例子：如果if（guffer.roughness>0.8） 这个动态分支
如果确实roughness要么是0.9 要么是0.7 那么他的消耗其实是很低的 （一致性分支）
最怕的就是这个roughness是较为随机的，这才是if 动态分支真正害怕
这种分支会让 GPU 的并行线程「分化」，一部分走 if，一部分走 else，严重降低并行效率，是性能杀手

用动态分支减少变体数量

那么为什么不直接用宏来实现bHasAnisotropy的分支？
比如定义一个这个的宏 然后#define HASANISOTROPY ？
这是因为：减少变体
每增加一个宏开关，Shader 的变体数量就会翻倍（2的n）
UE 将一些不是极其昂贵或者逻辑复杂的特性，放在运行时用 BRANCH 来处理。这样多个材质可以共享同一个编译出来的二进制文件（PSO），只是运行时的逻辑路径不同

BRANCH关键字

Branch 是DX11 + 的 HLSL 高级编译指令，是给 GPU 的分支执行「明确的指令」，作用是告诉 GPU：这个 if/else 分支，按「动态分支」的方式执行。
如果不写这个关键字 就是默认模式flatten
使用if else 是真的会把两个代码都跑一遍 然后丢弃不需要的代码

那 一致性条件 起到了什么作用？

既然 [branch] 是跳转，为什么大家还要强调 一致性 呢？这就涉及到 GPU 的 Warp（线程束） 机制了：
  • 如果条件一致（比如 0 或 1）： 整个 Warp（比如 32 个像素）都要跳。这时候 GPU 效率极高，因为它直接让这 32 个线程一起“飞”过不用的代码段。这就是最理想的动态分支。
  • 如果条件不一致（分歧）： 如果 Warp 里有 16 个像素想走 if，16 个想走 else。 这时 [branch] 就会变慢：它必须先带着 16 个线程跑 if（另外 16 个发呆），再带着剩下的 16 个跑 else（前 16 个发呆）。 注意： 即使这种情况下，它依然比 flatten 好，因为它至少在某一时刻只跑了一半的指令量，而 flatten 是全量跑

总结：BRANCH 和 条件一致性

好了 就这么简单 BRANCH 和 一致性的条件 形成了黄金组合
]]> <![CDATA[基于houdini理解Billboard算法]]> https://liuyaoyu.top/article/example-35 https://liuyaoyu.top/article/example-35 Mon, 12 Jan 2026 00:00:00 GMT
较为简单的矩阵计算，但是温故以下：

前言

这个算法其实直观性较差，尝试用houdini进行拆建：
在houdini中，我们常常要让copytopoints的对象（位置不同 ）同时面向 另一个一个对象，并且是随动的
这个和bb的是一样的，我们的做法是：
计算目标中心 和 目标对象（以下简称R对象）的归一化向量
基于这个归一化向量创建一个矩阵
然后通过 点坐标*矩阵的 方式 来改变点的位置。我们在shader中实现一下：

最垃圾链路（局部空间完成旋转）

这贼垃圾，纯脑洞，得把摄像机转到局部空间，纯闲的
并且你需要自己建立矩阵，用cross的方式

常规链路（view空间完成旋转）

这个是unity 等引擎用的
步骤 1：面片局部坐标→View 空间
P_view = P_l × world矩阵 × view矩阵（先转世界，再转 View 空间）。
 
步骤 2：在 View 空间构建 “朝向相机的旋转矩阵 R_view”
View 空间中相机在原点(0,0,0)，且：
相机前向是 View 空间的-Z轴（forward_view = (0,0,-1)，固定不变）；
相机右向是 View 空间的X轴（right_view = (1,0,0)）；
相机上向是 View 空间的Y轴（up_view = (0,1,0)）；→ 旋转矩阵R_view = [right_view, up_view, forward_view]（单位矩阵，甚至可以省略旋转，直接用 View 空间的 X/Y 轴偏移）。
步骤 3：View 空间旋转 + 转裁切空间
View 空间旋转：P_view_rot = P_view × R_view（对 View 空间的面片顶点旋转，本质是对齐相机 X/Y 轴）；
View→裁切：P_clip = P_view_rot × proj矩阵。

优化后链路（NX用世界空间+世界空间旋转偏移）

步骤 1：局部顶点 → 局部方向向量（剥离位置，只保留偏移）
P_l = 面片中心局部坐标(0,0,0) + 局部偏移向量V_l
因为面片的中心就是（0，0，0）
所以 局部偏移向量V_l = 顶点坐标
代码里用的是(借用uv)：
local_position_offset = float3((input.texcoord0.x-0.5)*2.0, 0.0, (input.texcoord0.y-0.5)*2.0);
 
步骤 2：局部偏移向量 → 世界空间旋转后的偏移向量
local_position_offset 和 旋转矩阵 进行 mul
这个旋转矩阵可以借用view矩阵进行构建：
一个是view_up ，一个是view_right，因为local_position_offset 有一个分量是0 所以没必要弄第三个
world_camera_facing_offset = (local_position_offset.x * view_up + local_position_offset.z * view_right) × s
（这里不用mul 直接用矩阵的乘法的拆开 节省这个指令）
s是scale是缩放
这一步完成了旋转和转化到世界空间（这个旋转矩阵来自view转化矩阵 view 矩阵的前 3 列（Cam_R/Cam_U/Cam_F）的空间属性是世界空间—— 因为它们描述的是 “相机的右 / 上 / 前方向在世界空间中指向哪里 即但它的列向量数据是 “世界空间的相机方向” 所以这个旋转矩阵同时把偏移转化到世界空间）
 
步骤三：世界坐标+世界空间旋转后的偏移向量
这个不难 世界坐标 + 世界坐标的偏移就是 新的坐标
 
]]> <![CDATA[描边outline（屏幕空间描边）]]> https://liuyaoyu.top/article/example-34 https://liuyaoyu.top/article/example-34 Sat, 29 Nov 2025 00:00:00 GMT
在项目里，描边是在后处理实现
notion image
我们先来聊聊我们熟悉的方案：对模型物体进行顶点偏移扩大，这个方案前向渲染，对模型顶点做向外偏移，渲染一个扩大的 “轮廓网格”（通常用纯色），再渲染原模型，靠两层叠加形成描边 —— 这种方案需要为每个要描边的模型单独处理（改 Shader / 加轮廓网格）。
屏幕空间后处理描边（属于 “像素级描边”）：完全脱离模型 / 顶点，在场景渲染完成后，对「屏幕纹理 + 深度纹理」做像素级计算，识别出需要描边的屏幕像素区域并着色 —— 全程在 2D 屏幕空间操作，不碰任何 3D 模型 / 顶点，这是两者最核心的区别。

输入贴图：

输入资源
类型
作用（核心：判定描边的核心依据）
t_tex0（Texture0）
2D 纹理
描边掩码纹理 / 目标纹理：▸ 核心作用：标记 “需要描边的物体区域”—— 需要描边的物体像素值≠0（比如纯色 / ID 值），不需要的 = 0；▸ 举例：若只想给角色描边，渲染场景时会单独输出 “角色区域为白色、其他区域为黑色” 的纹理作为t_tex0。
t_tex1（Texture1）
2D 纹理
原场景颜色纹理：▸ 非 FrameBuffer Fetch 模式下，作为原场景的基础颜色，最终描边会叠加到这个纹理上；▸ 若启用 FrameBuffer Fetch（移动端 Metal 优化），则直接读取帧缓冲，无需传入t_tex1。
t_scene_depth
深度纹理
场景深度缓冲：▸ 记录每个屏幕像素的深度值（距离相机的距离）；▸ 用于 “深度过滤”（比如outline_depth_threshold_clip_player参数：过滤掉过远 / 过近的物体，避免给背景 / 超近物体描边）。
u_rt_size
float4
渲染目标（RT）的尺寸（宽 / 高 + 1 / 宽、1 / 高）：用于计算屏幕空间的采样偏移（描边宽度）。
width
float
描边宽度：控制邻域采样的偏移量，值越大描边越宽。
outline_depth_threshold_clip_player
float
深度阈值：过滤不需要描边的深度区域（比如值 = 0.9 时，深度值超过 0.9 的像素不描边，避免给远处物体描边）。
notion image

这个tex怎么来的？（tex0判定需要描边物体的核心）

  1. 渲染场景时，先执行一个 “预处理 Pass”：
    1. 对需要描边的物体（比如角色、交互道具），渲染到t_tex0时输出 “非 0 值”（比如白色、物体 ID、纯色）；
    2. 对不需要描边的物体（比如场景、背景、水体），渲染到t_tex0时输出 “0 值”（黑色）；
  1. 后处理 Pass 中，Shader 采样t_tex0，只有 “非 0 值区域的边缘” 会被判定为 “需要描边的边缘”，最终生成描边。

Ps:

顶点阶段不处理任何模型，只针对 “全屏四边形”（后处理的标准做法：用一个覆盖整个屏幕的四边形作为渲染载体）做操作：
  1. 接收全屏四边形的顶点坐标（input_position）和 UV 坐标（input_texcoord0，范围 0~1，对应屏幕像素）；
  1. 计算采样偏移量：u_rt_size.zw是1/屏幕宽、1/屏幕高（归一化的像素尺寸），乘以width（描边宽度），得到 “单个像素的偏移量”（_v_0）；
  1. 生成 5 个采样坐标：
    1. _Varying_texcoord0：当前像素的 UV（中心坐标）；
    2. _Varying_texcoord1/_Varying_texcoord2：当前像素上下偏移后的 UV；
    3. _Varying_texcoord3/_Varying_texcoord4：当前像素左右偏移后的 UV；→ 这 5 个坐标是为像素阶段 “邻域采样” 做准备（检测上下左右像素的差值）。

Vs

对每个像素做：
notion image
具体步骤：
  1. 邻域采样：用顶点阶段生成的 5 个 UV，采样t_tex0（描边掩码纹理），得到 5 个像素值：
    1. _p_4：当前像素的 t_tex0 值；
    2. _p_5/_p_6/_p_7/_p_8：上下左右四个方向偏移后的 t_tex0 值；
  1. 边缘检测（核心！判定哪里需要描边）：
    1. 计算 “当前像素” 与 “上下左右像素平均值” 的差值：_p_4 - (((_p_5 + _p_6) + _p_7) + _p_8) * 0.25f；
    2. 用sign(length(差值))判断是否为边缘：▸ 若差值≠0 → sign返回 1 → 判定为 “物体边缘”（需要描边）；▸ 若差值 = 0 → sign返回 0 → 非边缘（不需要描边）；→ 本质：t_tex0中 “需要描边的物体区域” 和 “背景区域” 的交界像素，差值会显著变大，从而被判定为边缘。
  1. 深度过滤（筛选需要描边的物体）：
    1. 采样深度纹理t_scene_depth，得到当前像素的深度值_p_10；
    2. 适配深度范围（SYSTEM_DEPTH_RANGE_NEGATIVE/USE_REVERSED_Z）：处理不同 API（D3D/OpenGL）的深度值范围差异（0~1 或 - 1~1）；
    3. 用outline_depth_threshold_clip_player过滤：1.0f - step(...) → 深度值超过阈值的像素，描边强度置 0（不描边）。
  1. 描边叠加 + 输出：
    1. 取邻域采样的最大值_p_11（强化边缘对比度）；
    2. 把边缘检测得到的描边颜色，叠加到原场景颜色（_p_0，来自t_tex1/FrameBuffer Fetch）上；
    3. 最终输出_entryPointOutput：叠加描边后的屏幕像素颜色。
]]> <![CDATA[Hlod基础知识]]> https://liuyaoyu.top/article/example-33 https://liuyaoyu.top/article/example-33 Mon, 10 Nov 2025 00:00:00 GMT
这个东西还是在修bug 看到的
notion image
那么什么是hlod？
notion image

是什么？

HLOD（分层细节级别）的核心机制正是将远距离的多个零散物体 "集群化"，生成一个低多边形代理模型来替代逐个渲染
普通的 LOD 是针对单个模型（比如一棵树、一块石头）的优化。而 HLOD 是针对一群物体的优化。

怎么做？

HLOD 合并是一个两步流程：

1️⃣ 第一步：生成集群（Generate Clusters）

  • 在场景中划定区域（HLOD Volume），将区域内的静态物体（如树木、石头）分组
  • 这些物体必须设置为 "Static"（静态），且不能是骨骼动画网格（Skeletal Mesh）
  • 集群会按照空间距离和屏幕尺寸自动分组，确保同一集群内的物体在远距离观察时 "看起来像一个整体"

2️⃣ 第二步：生成代理网格（Generate Proxy Meshes）

烘焙：
  • 将集群内所有物体的网格合并，生成一个全新的低多边形网格（通常只有原模型总面数的 5-20%）
  • 同时将这些物体的材质和纹理合并为一张大纹理（Atlas Texture）
  • 最终生成一个单一的 Static Mesh，替代集群内的所有原始模型

特殊点

特性
HLOD 合并
普通 Actor 合并
合并范围
只对远距离物体生效，近距仍用原始模型
永久合并，远近都用同一个模型
细节处理
生成多级 LOD（从高细节到低细节），根据距离自动切换
只有一个合并后的模型，无 LOD 切换
纹理处理
自动生成纹理图集，优化渲染性能
可选择合并材质，但通常保留多个材质
适用场景
仅用于开放世界的远景优化（如山体植被、城市建筑群）
适用于任何场景的静态物体优化
性能影响
仅远距离节省性能，近距无额外开销
无论远近都减少 Draw Call，但增加单个模型复杂度

脚本

可以通过 ue 脚本插件完成
用户鼠标右键文件夹，即可批量为文件夹下子关卡生成hlod资源
这个具体问ai 很简单的脚本
]]> <![CDATA[关于米氏散射]]> https://liuyaoyu.top/article/example-32 https://liuyaoyu.top/article/example-32 Sat, 29 Nov 2025 00:00:00 GMT

现实现象：

  1. 云 雾 雾霾 能看见就是米氏散射的原因（无差别散射所有颜色的光）
  1. 你注意一下。当你正对着太阳看，然后太阳旁边的云就是发出很白很亮的光，当你背对着太阳看云，你会看到云就不会那么亮那么白，这也是米氏散射。
再比如，你开车如果雾天。你开远光灯，前面的雾会更白茫茫一片，更看不清。
这是因为，车灯（尤其是远光灯）发出的强光，在驾驶人视野前方的雾滴上发生了剧烈的前向散射（米氏散射的核心特征）
  1. 波长。波长越长（黄、红光），穿透力越强，被散射得越少。现实现象就是：雾灯氏黄的。 还有晚霞氏黄色红色的。因为此时光的路径长，到人眼这里只有红光和黄光能穿透了。

相关代码：

notion image
 
]]> <![CDATA[高度指数雾]]> https://liuyaoyu.top/article/example-31 https://liuyaoyu.top/article/example-31 Sat, 29 Nov 2025 00:00:00 GMT

1.前言

重点是模拟真实雾的高度分布和距离衰减，随着高度的增加，雾的密度会下降
公式核心为：雾密度 = 基础密度 × exp(- 高度衰减系数 × (目标高度 - 雾的基准高度))
这是整个雾效计算的物理基础，所有后续步骤都围绕这个密度模型展开。
exp(x) 是单调递增
exp（-x）是单调递减
具体说 当目标高度 > 基准高度 则雾越淡（x项为负 单调递减）
当目标高度 < 基准高度 则雾越浓（x项为正 单调递增）

总雾density的计算

总雾量 = 积分项 × 调整后的路径长度（RayLength）× 雾密度基础项（RayOriginTerms）
（总雾量 = 单位路径积累量 × 路径长度 x 起点浓度）
  • 雾衰减因子 = max(-12.7, 雾高度衰减系数 × 调整后射线Y方向)
  • 单位路径积分 = (1.0 - 2^(-雾衰减因子)) / 雾衰减因子
  • 积分泰勒近似 = ln(2) - 0.5 × (ln(2))² × 雾衰减因子
  • 有效单位积分 = 如果 |雾衰减因子| > 极小值 则 单位路径积分 否则 积分泰勒近似
关于这个单位路径积分：
类似:总水量 = 水源压力 × 流量调整系数 × 水管长度
就是 单位路径积分 这个系数本身就包含了 “连续变化” 的信息，所以不用再除以总长度求平均，直接乘总长度就能得到总累积值

2.计算步骤：

本质上是计算，从相机到渲染点的路径长度（路径越长，叠加的浓度越大）

向量准备：

为此我们需要准备：
1.相机到渲染的向量（WorldPositionRelativeToCamera），长度（CameraToReceiverLength）
2.处理雾的起始距离（ExcludeDistance）：强制让雾从指定距离后生效（避免近距离物体被雾遮挡），这个其实就是把相机起点往 那个路径方向 偏移一下

积分雾的总浓度计算（核心）

雾的 density 由「路径长度 × 路径上的雾密度积分」决定。这里要 计算积分，兼顾性能和精度：
  1. 计算射线起点的雾密度（RayOriginTerms）：基于调整后射线起点的高度，计算指数衰减项（exp2(-Exponent2)），再乘以基础密度（u_fog_info_raw.y），代表射线起点处的雾密度系数（max (-12.7) 是为了避免exp2溢出）。
  1. 计算积分项（LineIntegral）：针对指数密度模型，积分公式为 [1 - exp(-Falloff)] / Falloff（Falloff是高度衰减系数 × 射线方向 Z 分量），表示 “单位路径长度上的雾密度积分”；
  1. 处理边界情况：当Falloff接近 0（射线几乎水平）时，用泰勒展开近似积分（避免除零错误）；
  1. 总雾量 = 积分项 × 调整后的路径长度（RayLength）× 雾密度基础项（RayOriginTerms）。
notion image
伪代码如下：

计算雾的混合因子和颜色

获取基础雾颜色

这里有个函数GetFogColor ，依据距离获取雾的颜色
half3 GetFogColor(float dis_to_camera)
{
half3 Isvlmfog_ambient = half3(u_ambient.rgb * u_atmosphere_param.y); //环境光适配因子
half linear_factor = smoothstep(u_fog_near_color.w * u_camera_info.y, u_camera_info.y * max(u_fog_near_color.w + 0.001, u_fog_color.w), dis_to_camera);
half3 fog_color = lerp(half3(u_fog_near_color.rgb), half3(u_fog_color.rgb), linear_factor) * Isvlmfog_ambient;
//fog_color = u_fog_near_color.rgb;
return fog_color;
}
里面的近雾色 和 远雾色 是美术通过引擎进行调节的
u_ambient.rgb 是场景的环境光
u_atmosphere_param.y：环境光对雾的影响强度（0 = 雾色不受环境光影响，1 = 雾色完全贴合环境光）
相乘就是Isvlmfog_ambient，即影响雾的环境光底色
所以就是美术可调的远近雾色 叠加 环境光影响

获取雾的定向散射颜色

其实就是米氏散射拉
这个颜色不是雾本身的底色，而是 “雾反射了特定方向光源的颜色”，且只在 “视线与光源方向接近” 时才明显
关于米氏散射
要算这个也要分几步：
1.先算光源方向
代码里用的这个：
FogStruct_InscatteringLightDirection 其中xyz是光源的世界空间方向 w是定向散射的生效起始距离
2.计算 散射强度：视线与光源方向越近，散射越强
这个类似那个sss的计算，就是逆光的时候强度最大呗。dot（-v，L）
然后 pow(..., max(2.0, 雾散射指数×30.0))） 就是最低都得是2的pow
视线正对光源（逆光）时，散射最强；视线背向光源时，散射最弱（几乎没有）。
3.计算 “散射颜色”：光源颜色 × 雾的散射特性
  • 先算米氏散射颜色（mie_color）：混合 定向光源颜色（比如太阳的白色 / 橙黄色）和 雾的米氏散射底色（u_mie_color），模拟雾滴对不同波长光线的散射差异（比如雾对红光散射弱、蓝光散射强，但定向散射时更偏向光源颜色，这是米氏散射的原理 关于米氏散射
  • 再乘「散射强度」和「大气散射开关」：控制定向散射的 浓淡 和 是否启用；
  • 最后用「定向散射积分」控制生效范围：只有雾的有效路径长度超过 “定向散射起始距离” 时，才会叠加这个颜色（避免近距离雾过亮）。
最终雾色 = 基础雾色 × (1 - 雾透射因子) + 定向散射颜色
其实就是雾的底色 + 雾的散射的光（逆光最大的米氏散射的颜色）

3.入口：

先是这个入口
notion image
重点还是GetExponentialHeightFog函数
伪代码如下：
函数 核心指数高度雾计算(相机世界位置, 目标点相对相机向量, 初始排除距离) -> 雾颜色+混合因子:
// 注：所有「全局参数」均对应原代码的全局变量，括号内标注原代码变量名
最小雾不透明度 = 0.0 // 原代码：const half MinFogOpacity = 0.0
// ===================== 第一步：射线预处理（算清“雾计算的路径基础”）=====================
// 目的：把“相机→目标点”的射线属性算透，为后续雾量积分做准备
相机到目标点向量 = 目标点相对相机向量 // 原代码：CameraToReceiver = WorldPositionRelativeToCamera
射线长度平方 = 点积(相机到目标点向量, 相机到目标点向量) // 原代码：CameraToReceiverLengthSqr
射线长度倒数 = 1.0 / 平方根(射线长度平方) // 原代码：CameraToReceiverLengthInv = rsqrt(...)
射线总长度 = 射线长度平方 × 射线长度倒数 // 原代码：CameraToReceiverLength（等价于sqrt(平方)，优化性能）
射线单位向量 = 相机到目标点向量 × 射线长度倒数 // 原代码：CameraToReceiverNormalized（方向标准化）
// ===================== 第二步：雾生效距离处理（控制“雾从哪里开始出现”）=====================
// 目的：避免近距离物体被雾遮挡，只让雾在「指定距离后」生效
// 最终雾生效起始距离 = 取初始值、全局配置值的最大值（原代码：ExcludeDistance = max(ExcludeDistance, max(u_fog_info.x,0.001))）
最终雾生效起始距离 = 最大值(初始排除距离, 最大值(全局参数.雾起始距离, 0.001)) // 全局参数.雾起始距离 = 原代码u_fog_info.x
交点在射线上的比例 = 最终雾生效起始距离 × 射线长度倒数 // 原代码：ExcludeIntersectionTime（射线参数t：0=相机，1=目标点）
相机到交点的Y分量 = 交点在射线上的比例 × 相机到目标点向量.y // 原代码：CameraToExclusionIntersectionZ（注意原代码变量名写Z但实际用y，伪代码修正为Y更准确）
交点的世界高度 = 相机世界位置.y + 相机到交点的Y分量 // 原代码：ExclusionIntersectionZ（生效距离处的高度，雾密度核心关联值）
交点到目标点的Y分量 = 相机到目标点向量.y - 相机到交点的Y分量 // 原代码：ExclusionIntersectionToReceiverZ（调整后射线的Y方向长度）
调整后射线长度 = (1.0 - 交点在射线上的比例) × 射线总长度 // 原代码：RayLength（仅计算“生效距离→目标点”的雾量，前面的路径无雾）
调整后射线Y方向 = 交点到目标点的Y分量 // 原代码：RayDirectionZ（实际是Y方向，伪代码修正命名）
// ===================== 第三步：起点雾密度计算（算“生效距离处的雾浓淡基准”）=====================
// 目的：基于“高度衰减模型”，计算雾生效起点的密度（高度越低，密度越大）
// 高度指数项：max(-12.7)避免exp2溢出（原代码：Exponent2 = max(-12.70f, u_fog_info.z * (...)）
高度指数项 = 最大值(-12.7, 全局参数.雾高度衰减系数 × (交点的世界高度 - 全局参数.雾基准高度))
// 全局参数.雾高度衰减系数 = 原代码u_fog_info.z；全局参数.雾基准高度 = 原代码u_fog_info_raw.x
射线起点雾密度项 = 全局参数.雾基础密度 × 2^(-高度指数项) // 原代码：RayOriginTerms = u_fog_info_raw.y * exp2(-Exponent2)（exp2(x)=2^x，这里明确负号，和原代码完全一致）
// 全局参数.雾基础密度 = 原代码u_fog_info_raw.y
// ===================== 第四步：路径雾量积分（核心！算“路径上的总雾浓”）=====================
// 目的：用数学解析解计算“射线穿过雾的总雾量”，既快又准
// 雾衰减因子：反映射线方向对雾密度的影响（原代码：Falloff = max(-12.70f, u_fog_info.z * RayDirectionZ)）
雾衰减因子 = 最大值(-12.7, 全局参数.雾高度衰减系数 × 调整后射线Y方向)
// 解析解积分：单位长度路径上的雾密度总和（原代码：LineIntegral = (1.0f - exp2(-Falloff)) / Falloff）
单位路径积分 = (1.0 - 2^(-雾衰减因子)) / 雾衰减因子
// 泰勒展开：处理雾衰减因子≈0（射线水平）的情况，避免除零错误（原代码：LineIntegralTaylor）
积分泰勒近似 = 自然对数(2.0) - 0.5 × (自然对数(2.0))² × 雾衰减因子
// 选择稳定的积分方案（原代码：abs(Falloff) > FLT_EPSILON2 ? LineIntegral : LineIntegralTaylor）
如果 绝对值(雾衰减因子) > 极小值: // 极小值=原代码FLT_EPSILON2（避免除零）
有效单位积分 = 单位路径积分
否则:
有效单位积分 = 积分泰勒近似
// 总雾量积分：起点密度 × 单位积分 × 路径长度（原代码：ExponentialHeightLineIntegral = ...）
总雾量积分 = 射线起点雾密度项 × 有效单位积分 × 调整后射线长度 // 核心结果：雾的总浓度
// ===================== 第五步：雾颜色计算（算“雾该是什么颜色”）=====================
// 1. 基础雾色：按距离取雾的基础颜色（原代码：dis_to_camera = length(...)，实际就是射线总长度）
目标点到相机距离 = 射线总长度 // 复用前面计算结果，优化性能（原代码逻辑一致）
基础雾颜色 = 调用GetFogColor(目标点到相机距离) // 原代码：GetFogColor(dis_to_camera)（外部函数：按距离返回雾色，比如远→蓝）
// 2. 定向散射颜色（可选：模拟阳光等定向光在雾中的散射，比如逆光雾更亮）
定向散射颜色 = (0, 0, 0) // 默认无定向散射
如果 启用定向光雾散射: // 原代码：#if SUPPORT_FOG_DIRECTIONAL_LIGHT_INSCATTERING
定向散射起始距离 = 全局参数.光源方向.w // 原代码：FogStruct_InscatteringLightDirection.w（定向散射生效距离）
// 米氏散射颜色：模拟雾滴对光线的散射（原代码：mie_color = lerp(u_dir_color.rgb, u_mie_color.rgb*..., u_mie_color.a)）
米氏散射颜色 = 线性插值(全局参数.定向光颜色, 全局参数.米氏颜色×全局参数.米氏颜色, 全局参数.米氏颜色.a)
// 全局参数.定向光颜色=原代码u_dir_color.rgb；全局参数.米氏颜色=原代码u_mie_color
// 散射强度：视线与光线方向越近，散射越强（原代码：pow(saturate(dot(...)), max(2.0, u_fog_info.y*30.0))）
视线与光线夹角余弦 = 饱和值(点积(射线单位向量, 全局参数.光源方向.xyz)) // 夹角余弦∈[0,1]，越近越亮
散射强度 = 视线与光线夹角余弦 ^ 最大值(2.0, 全局参数.雾散射指数 × 30.0) // 幂次集中散射效果（原代码u_fog_info.y=雾散射指数）
// 定向散射基础色：米氏颜色×强度×开关（原代码：Isvlmfog_inscatter = u_atmosphere_param.w）
定向散射基础 = 米氏散射颜色 × 散射强度 × 全局参数.大气散射开关 // 全局参数.大气散射开关=原代码u_atmosphere_param.w
// 定向散射有效积分：只在“定向散射起始距离后”生效（原代码：DirExponentialHeightLineIntegral）
定向散射积分 = 射线起点雾密度项 × 有效单位积分 × 最大值(调整后射线长度 - 定向散射起始距离, 0.0)
定向散射透射因子 = 饱和值(2^(-定向散射积分)) // 散射越强，透射因子越小
定向散射颜色 = 定向散射基础 × (1.0 - 定向散射透射因子) // 透射越少，散射颜色越明显
// ===================== 第六步：透射因子计算（算“物体被雾挡多少”）=====================
// 目的：控制物体与雾的混合比例（原代码：ExpFogFactor = max(saturate(exp2(-...)), MinFogOpacity)）
雾透射因子 = 最大值(饱和值(2^(-总雾量积分)), 最小雾不透明度)
// 逻辑：总雾量越大 → 2^(-总雾量)越小 → 透射因子越接近0 → 物体越透明，雾越明显
// ===================== 第七步：结果合成（输出“最终雾色+混合因子”）=====================
// 最终雾色 = 基础雾色×雾可见比例 + 定向散射色（原代码：FogColor = (InscatteringColor)*(1-...) + DirectionalInscattering）
最终雾颜色 = 基础雾颜色 × (1.0 - 雾透射因子) + 定向散射颜色
// 1-雾透射因子：雾的可见比例（透射因子越小，雾越明显）
// 返回格式：RGB=雾颜色，A=透射因子（原代码：return half4(FogColor, ExpFogFactor)）
返回 (最终雾颜色.r, 最终雾颜色.g, 最终雾颜色.b, 雾透射因子)
]]>