atdunbg/HelloVulkan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: CSM 级联阴影（3 级联 × 1024²，实用分割 + 纹素对齐）

Browse Source 
- SceneRenderer::ComputeCascades：相机视锥实用分割（λ=0.6）→ 反投影
  取切片角点 → 光空间 AABB 拟合 → 纹素对齐（消除相机移动时阴影边缘
  闪烁）→ [0,1] 深度重映射
- Shadow pass 单 pass 渲 3 个 region，每级联 push 各自光空间 VP
- Forward：UBO lightSpace[3]+cascadeSplits（视图深度选级联），Set2
  三张级联图按 binding 0/1/2 采样；vertex 输出 fragViewDepth
- 光源视锥剔除用最远级联（覆盖全阴影范围）；双视锥独立剔除铁律保留
- 旧单张 2048 全场景图退役；近处级联分辨率 ~128px/unit（约 2× 提升）
- 编译零错误、validation 零警告、8 秒冒烟通过（10 pass 全活跃）
This commit is contained in:
atdunbg
2026-09-23 13:48:43 +08:00
parent 27b7f8785c
commit 0328d4aaeb
13 changed files with 250 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Engine/include/Engine/Renderer/Passes/ForwardPass.h
+4 -3
View File
@@ -19,10 +19,11 @@ namespace Engine::Passes {
public:
ForwardPass(SceneGpu& gpu, FrameSceneData& frame,
RG::TextureHandle hdrColor, RG::TextureHandle velocity,
RG::TextureHandle depth, RG::TextureHandle shadowMap)
RG::TextureHandle depth,
const std::array<RG::TextureHandle, kMaxCascades>& shadowMaps)
: m_Gpu(gpu), m_Frame(frame),
m_HDRColor(hdrColor), m_Velocity(velocity),
m_Depth(depth), m_ShadowMap(shadowMap) {}
m_Depth(depth), m_ShadowMaps(shadowMaps) {}
void Register(RG::RenderGraph& rg) override;
@@ -32,7 +33,7 @@ namespace Engine::Passes {
RG::TextureHandle m_HDRColor;
RG::TextureHandle m_Velocity; // TAA 运动向量（第二颜色附件）
RG::TextureHandle m_Depth;
RG::TextureHandle m_ShadowMap;
std::array<RG::TextureHandle, kMaxCascades> m_ShadowMaps;
};
} // namespace Engine::Passes
Engine/include/Engine/Renderer/Passes/SceneGpu.h
+5 -2
View File
@@ -12,8 +12,10 @@
#define HELLOVULKAN_SCENEGPU_H
#include <Engine/Core/FrameContext.h>
#include <Engine/Renderer/SceneTypes.h>
#include <Engine/RenderGraph/RenderGraph.h>
#include <vulkan/vulkan.hpp>
#include <array>
#include <vector>
namespace Engine {
@@ -39,7 +41,7 @@ namespace Engine {
// ---- set 布局（shader 契约，改绑定必须同步 shaders/）----
vk::DescriptorSetLayout uboSetLayout; // Set0 = {UBO, ObjectBuffer, PrevObjectBuffer}
vk::DescriptorSetLayout textureSetLayout; // Set1 = {albedo}
vk::DescriptorSetLayout shadowSetLayout; // Set2 = {shadow map}
vk::DescriptorSetLayout shadowSetLayout; // Set2 = {级联 0/1/2 阴影图}
vk::PipelineLayout forwardLayout; // 3 sets，无 push（GPUDriven 经 SSBO）
vk::PipelineLayout shadowLayout; // Set0，push = lightVP 64B
@@ -55,7 +57,8 @@ namespace Engine {
vk::ShaderEXT shadowVert{}, shadowFrag{};
// RG 重编译后重绑阴影图（物理镜像按槽位各一份）
void BindShadowMap(RG::RenderGraph& rg, RG::TextureHandle shadowMap);
void BindShadowMaps(RG::RenderGraph& rg,
const std::array<RG::TextureHandle, kMaxCascades>& maps);
private:
Device& m_Device;
Engine/include/Engine/Renderer/Passes/ShadowPass.h
+8 -5
View File
@@ -1,8 +1,9 @@
//
// Created by atdunbg on 2026/9/23.
//
// ShadowPass：光源视角写深度。GPUDriven batch 消费光源视锥剔除结果
// （FrameSceneData::shadowView——相机外实体仍投影子）。
// ShadowPass：CSM 级联阴影。单 pass 渲 kMaxCascades 个 region，
// 每级联独立光源 VP（FrameSceneData::lightSpace[c]，SceneRenderer 拟合），
// 消费光源视锥剔除结果（FrameSceneData::shadowView——相机外实体仍投影子）。
//
#ifndef HELLOVULKAN_SHADOWPASS_H
@@ -11,13 +12,15 @@
#include <Engine/Renderer/Passes/RenderPass.h>
#include <Engine/Renderer/Passes/SceneGpu.h>
#include <Engine/Renderer/SceneTypes.h>
#include <array>
namespace Engine::Passes {
class ShadowPass final : public RenderPass {
public:
ShadowPass(SceneGpu& gpu, FrameSceneData& frame, RG::TextureHandle shadowMap)
: m_Gpu(gpu), m_Frame(frame), m_ShadowMap(shadowMap) {}
ShadowPass(SceneGpu& gpu, FrameSceneData& frame,
const std::array<RG::TextureHandle, kMaxCascades>& shadowMaps)
: m_Gpu(gpu), m_Frame(frame), m_ShadowMaps(shadowMaps) {}
void Register(RG::RenderGraph& rg) override;
void OnTargetsRebuilt(RG::RenderGraph& rg) override;
@@ -25,7 +28,7 @@ namespace Engine::Passes {
private:
SceneGpu& m_Gpu;
FrameSceneData& m_Frame;
RG::TextureHandle m_ShadowMap;
std::array<RG::TextureHandle, kMaxCascades> m_ShadowMaps;
};
} // namespace Engine::Passes
Engine/include/Engine/Renderer/Renderer.h
+2 -1
View File
@@ -25,6 +25,7 @@
#include <Engine/Renderer/SceneTypes.h>
#include <Engine/RenderGraph/RenderGraph.h>
#include <vulkan/vulkan.hpp>
#include <array>
#include <vector>
namespace Engine {
@@ -125,7 +126,7 @@ namespace Engine {
// ---- RenderGraph 资源句柄 ----
RG::TextureHandle m_Backbuffer{};
RG::TextureHandle m_Depth{};
RG::TextureHandle m_ShadowMap{};
std::array<RG::TextureHandle, kMaxCascades> m_ShadowMaps{}; // CSM 级联
RG::TextureHandle m_HDRColor{}; // Forward 输出（线性 HDR），TAA 归一
RG::TextureHandle m_Velocity{}; // Forward 输出（clip 空间运动向量）
RG::TextureHandle m_TAAColor{}; // TAA 累积输出（自引用历史），后处理源
Engine/include/Engine/Renderer/SceneRenderer.h
+4 -3
View File
@@ -45,9 +45,10 @@ namespace Engine {
f32 GetCollectMs() const { return m_Frame.collectMs; }
private:
// 阴影光空间矩阵：光源正交投影（覆盖场景，[0,1] 深度重映射）。
// 写入（Shadow pass push）与采样（Forward UBO）共用同一矩阵。
void ComputeLightSpace(const glm::vec3& shadowDir);
// CSM：把相机视锥按实用分割切 N 段，每段独立拟合光源正交投影
//（含纹素对齐防阴影边缘闪烁）。写入（Shadow pass push）与采样
//（Forward UBO）共用同一组矩阵。
void ComputeCascades(const glm::vec3& shadowDir);
FrameSceneData m_Frame;
Engine/include/Engine/Renderer/SceneTypes.h
+6 -4
View File
@@ -34,7 +34,8 @@ namespace Engine {
constexpr u32 kMaxLights = 4;
constexpr u32 kMaxInstances = 16384; // 实例 SSBO 容量（矩阵数）
constexpr u32 kShadowMapSize = 2048; // 阴影图边长
constexpr u32 kMaxCascades = 3; // CSM 级联数
constexpr u32 kCascadeRes = 1024; // 每级联阴影图边长
// 镜像 shader 侧 UBO 布局的灯光项
struct LightData {
@@ -43,15 +44,16 @@ namespace Engine {
};
// 镜像 simple_shader 的 UBO 布局（std140 语义由 shader 侧对齐）。
// 字段只能追加在尾部（shadow.vert 共用本 set 前缀，前插会错位）。
// 字段顺序改动必须同步 simple_shader.vert/frag（shadow.vert 只用 SSBO）。
struct UniformBufferObject {
glm::mat4 view;
glm::mat4 proj; // 抖动后的投影（光栅化用）
glm::mat4 lightSpace; // 阴影光源 VP（写入与采样共用同一矩阵）
glm::mat4 lightSpace[kMaxCascades]; // CSM 各级联光空间 VP（[0,1] 重映射）
glm::vec4 cascadeSplits; // xyz = 级联 0..2 远边界（视图深度，正值），w 未用
glm::vec4 ambientColor;
LightData lights[kMaxLights];
// ---- TAA（尾部追加；velocity 在 vertex 里算）----
// ---- TAA（velocity 在 vertex 里算）----
glm::mat4 projNoJitter; // 未抖动投影（velocity 当前帧 clip 用）
glm::mat4 prevView; // 上一帧视图（velocity）
glm::mat4 prevProj; // 上一帧未抖动投影（velocity）
Engine/src/Renderer/Passes/ForwardPass.cpp
+5 -1
View File
@@ -146,7 +146,11 @@ namespace Engine::Passes
.Write(m_HDRColor, RG::ResourceUse::ColorAttachment)
.Write(m_Velocity, RG::ResourceUse::ColorAttachment)
.Write(m_Depth, RG::ResourceUse::DepthAttachment)
.Read(m_ShadowMap, RG::ResourceUse::ShaderRead,
.Read(m_ShadowMaps[0], RG::ResourceUse::ShaderRead,
vk::ShaderStageFlagBits::eFragment)
.Read(m_ShadowMaps[1], RG::ResourceUse::ShaderRead,
vk::ShaderStageFlagBits::eFragment)
.Read(m_ShadowMaps[2], RG::ResourceUse::ShaderRead,
vk::ShaderStageFlagBits::eFragment);
}
Engine/src/Renderer/Passes/SceneGpu.cpp
+14 -8
View File
@@ -37,10 +37,13 @@ namespace Engine::Passes
};
textureSetLayout = descriptors.CreateLayout(texBindings);
// Set 2: shadow map（fragment 采样）
std::vector<DescriptorBinding> shadowBindings = {
{0, vk::DescriptorType::eCombinedImageSampler, vk::ShaderStageFlagBits::eFragment},
};
// Set 2: CSM 级联阴影图（fragment 采样，binding = 级联序号）
std::vector<DescriptorBinding> shadowBindings;
for (u32 c = 0; c < kMaxCascades; ++c) {
shadowBindings.push_back(
{c, vk::DescriptorType::eCombinedImageSampler,
vk::ShaderStageFlagBits::eFragment});
}
shadowSetLayout = descriptors.CreateLayout(shadowBindings);
// Forward pipeline layout：三个 set；无 push（GPUDriven 经 SSBO）
@@ -133,13 +136,16 @@ namespace Engine::Passes
vkDevice.destroyDescriptorSetLayout(shadowSetLayout);
}
void SceneGpu::BindShadowMap(RG::RenderGraph& rg, RG::TextureHandle shadowMap)
void SceneGpu::BindShadowMaps(RG::RenderGraph& rg,
const std::array<RG::TextureHandle, kMaxCascades>& maps)
{
// 物理镜像按帧槽位各一份：每个槽位的描述符绑各自的 view
for (u32 slot = 0; slot < kMaxFramesInFlight; ++slot) {
m_Descriptors.UpdateTexture(
shadowSets[slot], 0, shadowSampler,
rg.GetPhysicalView(shadowMap, slot));
for (u32 c = 0; c < kMaxCascades; ++c) {
m_Descriptors.UpdateTexture(
shadowSets[slot], c, shadowSampler,
rg.GetPhysicalView(maps[c], slot));
}
}
}
Engine/src/Renderer/Passes/ShadowPass.cpp
+74 -66
View File
@@ -12,93 +12,101 @@ namespace Engine::Passes
{
void ShadowPass::Register(RG::RenderGraph& rg)
{
// 所有渲染体都写入，不做实体级开关——castShadow 应由材质/实体
// 数据驱动剔除，而非 pass 逻辑特判
// 所有渲染体都写入每个级联，不做实体级开关——castShadow 应由
// 材质/实体数据驱动剔除，而非 pass 逻辑特判。
// （每级联独立剔除是后续优化点：shadowView 细分为 per-cascade 列表）
rg.AddPass("Shadow", [this](RG::RenderGraphContext& ctx) {
const vk::CommandBuffer cmd = ctx.cmd;
vk::RenderingAttachmentInfo depthAttachment;
depthAttachment.setImageView(ctx.View(m_ShadowMap))
.setImageLayout(vk::ImageLayout::eDepthAttachmentOptimal)
.setLoadOp(vk::AttachmentLoadOp::eClear)
.setStoreOp(vk::AttachmentStoreOp::eStore)
.setClearValue(vk::ClearValue(
vk::ClearDepthStencilValue(1.0f, 0)));
for (u32 c = 0; c < kMaxCascades; ++c) {
vk::RenderingAttachmentInfo depthAttachment;
depthAttachment.setImageView(ctx.View(m_ShadowMaps[c]))
.setImageLayout(vk::ImageLayout::eDepthAttachmentOptimal)
.setLoadOp(vk::AttachmentLoadOp::eClear)
.setStoreOp(vk::AttachmentStoreOp::eStore)
.setClearValue(vk::ClearValue(
vk::ClearDepthStencilValue(1.0f, 0)));
vk::RenderingInfo renderingInfo;
renderingInfo.setRenderArea({{0, 0}, {kShadowMapSize, kShadowMapSize}})
.setLayerCount(1)
.setPDepthAttachment(&depthAttachment);
vk::RenderingInfo renderingInfo;
renderingInfo.setRenderArea({{0, 0}, {kCascadeRes, kCascadeRes}})
.setLayerCount(1)
.setPDepthAttachment(&depthAttachment);
cmd.beginRendering(renderingInfo);
cmd.beginRendering(renderingInfo);
std::array<vk::ShaderStageFlagBits, 2> stages = {
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment
};
std::array<vk::ShaderEXT, 2> shaders = {m_Gpu.shadowVert, m_Gpu.shadowFrag};
cmd.bindShadersEXT(stages, shaders);
std::array<vk::ShaderStageFlagBits, 2> stages = {
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment
};
std::array<vk::ShaderEXT, 2> shaders = {m_Gpu.shadowVert, m_Gpu.shadowFrag};
cmd.bindShadersEXT(stages, shaders);
// ---- 动态状态（depth-only）----
cmd.setRasterizerDiscardEnable(VK_FALSE);
// ---- 动态状态（depth-only）----
cmd.setRasterizerDiscardEnable(VK_FALSE);
cmd.setDepthTestEnable(VK_TRUE);
cmd.setDepthWriteEnable(VK_TRUE);
cmd.setDepthCompareOp(vk::CompareOp::eLess);
cmd.setDepthBoundsTestEnable(VK_FALSE);
cmd.setDepthTestEnable(VK_TRUE);
cmd.setDepthWriteEnable(VK_TRUE);
cmd.setDepthCompareOp(vk::CompareOp::eLess);
cmd.setDepthBoundsTestEnable(VK_FALSE);
cmd.setStencilTestEnable(VK_FALSE);
// 深度 bias 压平 shadow acne（NDC 量级）
cmd.setDepthBiasEnable(VK_TRUE);
cmd.setDepthBias(0.0025f, 0.0f, 0.003f);
cmd.setPolygonModeEXT(vk::PolygonMode::eFill);
cmd.setCullMode(vk::CullModeFlagBits::eNone);
cmd.setFrontFace(vk::FrontFace::eCounterClockwise);
cmd.setPrimitiveTopology(vk::PrimitiveTopology::eTriangleList);
cmd.setPrimitiveRestartEnable(VK_FALSE);
cmd.setStencilTestEnable(VK_FALSE);
// 深度 bias 压平 shadow acne（NDC 量级）
cmd.setDepthBiasEnable(VK_TRUE);
cmd.setDepthBias(0.0025f, 0.0f, 0.003f);
cmd.setPolygonModeEXT(vk::PolygonMode::eFill);
cmd.setCullMode(vk::CullModeFlagBits::eNone);
cmd.setFrontFace(vk::FrontFace::eCounterClockwise);
cmd.setPrimitiveTopology(vk::PrimitiveTopology::eTriangleList);
cmd.setPrimitiveRestartEnable(VK_FALSE);
auto binding = Vertex::GetBindingDescription();
auto attributes = Vertex::GetAttributeDescriptions();
cmd.setVertexInputEXT(binding, attributes);
auto binding = Vertex::GetBindingDescription();
auto attributes = Vertex::GetAttributeDescriptions();
cmd.setVertexInputEXT(binding, attributes);
cmd.setRasterizationSamplesEXT(vk::SampleCountFlagBits::e1);
vk::SampleMask sampleMask = 0xFFFFFFFF;
cmd.setSampleMaskEXT(vk::SampleCountFlagBits::e1, sampleMask);
cmd.setAlphaToCoverageEnableEXT(VK_FALSE);
cmd.setAlphaToOneEnableEXT(VK_FALSE);
cmd.setRasterizationSamplesEXT(vk::SampleCountFlagBits::e1);
vk::SampleMask sampleMask = 0xFFFFFFFF;
cmd.setSampleMaskEXT(vk::SampleCountFlagBits::e1, sampleMask);
cmd.setAlphaToCoverageEnableEXT(VK_FALSE);
cmd.setAlphaToOneEnableEXT(VK_FALSE);
vk::Viewport viewport(0.0f, 0.0f,
static_cast<float>(kShadowMapSize),
static_cast<float>(kShadowMapSize),
0.0f, 1.0f);
cmd.setViewportWithCount(viewport);
vk::Viewport viewport(0.0f, 0.0f,
static_cast<float>(kCascadeRes),
static_cast<float>(kCascadeRes),
0.0f, 1.0f);
cmd.setViewportWithCount(viewport);
vk::Rect2D scissor({0, 0}, {kShadowMapSize, kShadowMapSize});
cmd.setScissorWithCount(scissor);
vk::Rect2D scissor({0, 0}, {kCascadeRes, kCascadeRes});
cmd.setScissorWithCount(scissor);
// ---- 绘制：GPUDriven——与 Forward 共用实例数据，但用
// 光源视锥剔除后的 batch（相机外实体仍投影子）----
cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
m_Gpu.shadowLayout, 0,
m_Gpu.uboSets[ctx.frame.frameSlot], {});
// ---- 绘制：GPUDriven——与 Forward 共用实例数据，但用
// 光源视锥剔除后的 batch（相机外实体仍投影子）----
cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
m_Gpu.shadowLayout, 0,
m_Gpu.uboSets[ctx.frame.frameSlot], {});
// stage 必须覆盖 layout range 声明的全部 stage（VUID-01796）
cmd.pushConstants(m_Gpu.shadowLayout,
vk::ShaderStageFlagBits::eVertex |
vk::ShaderStageFlagBits::eFragment,
0, sizeof(glm::mat4), &m_Frame.ubo.lightSpace);
// stage 必须覆盖 layout range 声明的全部 stage（VUID-01796）
// 每级联 push 各自的光空间 VP
cmd.pushConstants(m_Gpu.shadowLayout,
vk::ShaderStageFlagBits::eVertex |
vk::ShaderStageFlagBits::eFragment,
0, sizeof(glm::mat4),
&m_Frame.ubo.lightSpace[c]);
for (const auto& batch : m_Frame.shadowView.batches) {
batch.mesh->Draw(cmd, batch.count, batch.first);
for (const auto& batch : m_Frame.shadowView.batches) {
batch.mesh->Draw(cmd, batch.count, batch.first);
}
cmd.endRendering();
}
cmd.endRendering();
}).Write(m_ShadowMap, RG::ResourceUse::DepthAttachment);
})
.Write(m_ShadowMaps[0], RG::ResourceUse::DepthAttachment)
.Write(m_ShadowMaps[1], RG::ResourceUse::DepthAttachment)
.Write(m_ShadowMaps[2], RG::ResourceUse::DepthAttachment);
}
void ShadowPass::OnTargetsRebuilt(RG::RenderGraph& rg)
{
m_Gpu.BindShadowMap(rg, m_ShadowMap);
m_Gpu.BindShadowMaps(rg, m_ShadowMaps);
}
} // namespace Engine::Passes
Engine/src/Renderer/Renderer.cpp
+9 -6
View File
@@ -183,10 +183,13 @@ namespace Engine
m_Depth = m_RenderGraph->CreateTexture(
"MainDepth", RG::TextureDesc{depthFormat});
// 阴影图：固定尺寸正交深度图（D32 采样）
m_ShadowMap = m_RenderGraph->CreateTexture(
"ShadowMap",
RG::TextureDesc{vk::Format::eD32Sfloat, kShadowMapSize, kShadowMapSize});
// CSM 级联阴影图：每级联独立 1024² 正交深度图（D32 采样），
// 范围由 SceneRenderer::ComputeCascades 按相机视锥切片拟合
for (u32 c = 0; c < kMaxCascades; ++c) {
m_ShadowMaps[c] = m_RenderGraph->CreateTexture(
"ShadowMap" + std::to_string(c),
RG::TextureDesc{vk::Format::eD32Sfloat, kCascadeRes, kCascadeRes});
}
// HDR 颜色图：Forward 的输出（线性光照值 + 抖动），TAA 显式完成
// 时域累积后写入 TAAColor（对齐 UE/Unity 管线）
@@ -222,9 +225,9 @@ namespace Engine
// 要加新 pass：new 一个 RenderPass 子类，在这里 push 一行。
FrameSceneData& frame = m_SceneRenderer->Frame();
m_Passes.push_back(CreateScope<Passes::ShadowPass>(
*m_SceneGpu, frame, m_ShadowMap));
*m_SceneGpu, frame, m_ShadowMaps));
m_Passes.push_back(CreateScope<Passes::ForwardPass>(
*m_SceneGpu, frame, m_HDRColor, m_Velocity, m_Depth, m_ShadowMap));
*m_SceneGpu, frame, m_HDRColor, m_Velocity, m_Depth, m_ShadowMaps));
m_Passes.push_back(CreateScope<Passes::TAAPass>(
*m_FullscreenGpu, /*historyAlpha*/ 0.9f, m_HDRColor, m_Velocity,
m_TAAColor));
Engine/src/Renderer/SceneRenderer.cpp
+80 -23
View File
@@ -16,6 +16,7 @@
#include <glm/gtc/matrix_transform.hpp>
#include <chrono>
#include <limits>
namespace Engine
{
@@ -23,11 +24,11 @@ namespace Engine
namespace
{
// 光源正交包围盒（覆盖当前场景；后续按场景 AABB 自适应）
constexpr f32 kLightOrthoExtent = 15.0f;
constexpr f32 kLightDistance = 30.0f;
constexpr f32 kLightNear = 1.0f;
constexpr f32 kLightFar = 80.0f;
// 相机裁剪范围（与 BuildFrame 中 GetProjection 的参数一致）
constexpr f32 kCameraNear = 0.1f;
constexpr f32 kCameraFar = 100.0f;
// 实用分割插值因子（0=均匀，1=对数；0.6 是业界常用值）
constexpr f32 kCascadeLambda = 0.6f;
// Halton 低差异序列（TAA 子像素抖动）
f32 Halton(u32 index, u32 base)
@@ -42,26 +43,80 @@ namespace Engine
}
}
void SceneRenderer::ComputeLightSpace(const glm::vec3& shadowDir)
void SceneRenderer::ComputeCascades(const glm::vec3& shadowDir)
{
// 光源位置在光方向的反方向远处，看向场景中心
const glm::vec3 lightPos = -shadowDir * kLightDistance;
// up 与视线平行时叉积退化（NaN），切换 up
constexpr u32 N = kMaxCascades;
// ---- 1. 实用分割：均匀与对数分割按 λ 插值（视图深度，正值）----
f32 splits[N];
for (u32 i = 1; i <= N; ++i) {
const f32 t = static_cast<f32>(i) / N;
const f32 uniform = kCameraNear + (kCameraFar - kCameraNear) * t;
const f32 log = kCameraNear * glm::pow(kCameraFar / kCameraNear, t);
splits[i - 1] = glm::mix(uniform, log, kCascadeLambda);
}
for (u32 c = 0; c < N; ++c) {
m_Frame.ubo.cascadeSplits[c] = splits[c];
}
// ---- 2. 全视锥 8 角反投影到世界（NDC z: 0=近 1=远，Vulkan [0,1]）----
const glm::mat4 invVP = glm::inverse(m_Frame.ubo.projNoJitter * m_Frame.ubo.view);
glm::vec3 nearC[4], farC[4];
const glm::vec2 ndcXY[4] = {{-1,-1},{1,-1},{-1,1},{1,1}};
for (u32 i = 0; i < 4; ++i) {
glm::vec4 p = invVP * glm::vec4(ndcXY[i], 0.0f, 1.0f);
nearC[i] = glm::vec3(p / p.w);
p = invVP * glm::vec4(ndcXY[i], 1.0f, 1.0f);
farC[i] = glm::vec3(p / p.w);
}
// ---- 3. 每级联：切片角点 → 光空间 AABB 拟合 → 纹素对齐 ----
const glm::vec3 up = glm::abs(shadowDir.y) > 0.999f
? glm::vec3(0.0f, 0.0f, 1.0f) : glm::vec3(0.0f, 1.0f, 0.0f);
const glm::mat4 lightView = glm::lookAt(
lightPos, glm::vec3(0.0f), up);
glm::mat4 lightProj = glm::ortho(
-kLightOrthoExtent, kLightOrthoExtent,
-kLightOrthoExtent, kLightOrthoExtent,
kLightNear, kLightFar);
// Vulkan clip 深度 [0,1]：z' = 0.5*z + 0.5*w。
// ortho 的 w_clip = 1，偏移折算进 z 的平移分量（与 perspective 公式不同！）
lightProj[2][2] *= 0.5f;
lightProj[3][2] = lightProj[3][2] * 0.5f + 0.5f;
for (u32 c = 0; c < N; ++c) {
const f32 d0 = (c == 0) ? kCameraNear : splits[c - 1];
const f32 d1 = splits[c];
const f32 t0 = (d0 - kCameraNear) / (kCameraFar - kCameraNear);
const f32 t1 = (d1 - kCameraNear) / (kCameraFar - kCameraNear);
m_Frame.ubo.lightSpace = lightProj * lightView;
glm::vec3 slice[8];
for (u32 i = 0; i < 4; ++i) {
slice[i] = glm::mix(nearC[i], farC[i], t0);
slice[4 + i] = glm::mix(nearC[i], farC[i], t1);
}
// 光视图：位于切片中心，沿光方向看
glm::vec3 center(0.0f);
for (const auto& p : slice) center += p;
center *= (1.0f / 8.0f);
const glm::mat4 lightView = glm::lookAt(center, center + shadowDir, up);
glm::vec3 mn( std::numeric_limits<f32>::max());
glm::vec3 mx( std::numeric_limits<f32>::lowest());
for (const auto& p : slice) {
const glm::vec3 lv = glm::vec3(lightView * glm::vec4(p, 1.0f));
mn = glm::min(mn, lv);
mx = glm::max(mx, lv);
}
// 纹素对齐：X/Y 边界量化到纹素网格（消除相机移动时的阴影边缘闪烁）
const f32 texelX = (mx.x - mn.x) / static_cast<f32>(kCascadeRes);
const f32 texelY = (mx.y - mn.y) / static_cast<f32>(kCascadeRes);
mn.x = glm::floor(mn.x / texelX) * texelX;
mn.y = glm::floor(mn.y / texelY) * texelY;
mx.x = mn.x + glm::ceil((mx.x - mn.x) / texelX) * texelX;
mx.y = mn.y + glm::ceil((mx.y - mn.y) / texelY) * texelY;
// 光视图空间里 z 为负（看向 -Z）；近远距离取正
glm::mat4 lightProj = glm::ortho(mn.x, mx.x, mn.y, mx.y,
-mx.z, -mn.z);
// Vulkan clip 深度 [0,1]（ortho 的 w_clip=1，偏移折进 z 平移分量）
lightProj[2][2] *= 0.5f;
lightProj[3][2] = lightProj[3][2] * 0.5f + 0.5f;
m_Frame.ubo.lightSpace[c] = lightProj * lightView;
}
}
bool SceneRenderer::BuildFrame(ECS::Scene& scene, Assets::AssetManager& assets,
@@ -121,7 +176,7 @@ namespace Engine
ubo.lights[i].direction = glm::vec4(0.0f);
ubo.lights[i].color = glm::vec4(0.0f);
}
ComputeLightSpace(shadowDir);
ComputeCascades(shadowDir);
// ---- 3. GPUDriven：单趟收集 + 双视图剔除 ----
// 每个实例对相机视锥、光源视锥分别做包围球测试：
@@ -140,9 +195,11 @@ namespace Engine
bool instanceTruncated = false;
// 剔除平面提取按 [0,1] 深度约定——相机 proj 与 lightSpace 都已
// 做 [0,1] 重映射；原始 [-1,1] 矩阵的 near 平面公式不同，勿用
// 做 [0,1] 重映射；原始 [-1,1] 矩阵的 near 平面公式不同，勿用。
// 光源视锥用最远级联（覆盖全阴影范围）
const Frustum mainFrustum = Frustum::FromMatrix(ubo.proj * ubo.view);
const Frustum shadowFrustum = Frustum::FromMatrix(ubo.lightSpace);
const Frustum shadowFrustum =
Frustum::FromMatrix(ubo.lightSpace[kMaxCascades - 1]);
scene.Each<TransformComponent, MeshRendererComponent>(
[&](Entity entity, TransformComponent& t, MeshRendererComponent& mr) {