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

feat: IBL 阶段②——漫反射辐照度卷积，PBR ambient 接入环境光

Browse Source 
- Cubemap 构造期同步 CPU 半球 Lambert 积分（64×32 网格 ≈2048 采样/像素）
  生成 32² irradiance cube（漫反射是超低频信号，分辨率无需高）
- shader：kD 用粗糙度感知 FresnelSchlickRoughness + (1-metallic)，
  N 采样 irradianceMap（Set2 binding 3）替换常数 ambient；
  ambientColor 保留为强度/色调乘子
- CreateNeutral 兜底：无 HDR 资产时 1×1 常数 cube，描述符恒有效
- FaceDir 改为返回单位方向（equirect 查表要求，修掉未归一化的畸变）
This commit is contained in:
atdunbg
2026-09-23 18:50:34 +08:00
parent 4b5990e6c8
commit fa25cb3348
6 changed files with 325 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Engine/src/Renderer/Cubemap.cpp
+243 -123
View File
@@ -1,11 +1,14 @@
//
// Created by atdunbg on 2026/9/23.
//
// Cubemap 实现：HDR 等距柱状 → CPU 重采样 6 面 → fp16 → cube image。
// Cubemap 实现：HDR 等距柱状 → CPU 重采样 6 面 + irradiance 卷积 → fp16 cube。
//
// 一次性加载成本（亚秒级 CPU 重采样），换取运行时零转换开销；
// 一次性加载成本（亚秒级 CPU），换取运行时零转换开销；
// 硬件 Cube 采样（filtering/边缘接缝由 driver 处理）。
// 后续 IBL 阶段的 irradiance/prefilter 卷积复用 FaceDir 方向表。
//
// irradiance 卷积（LearnOpenGL split-sum 的离线端）：对每个法线方向
// 做半球 Lambert 积分 E = ∫ L·cosθ·sinθ dθ dφ，切线基由 up×N 构造。
// 32² 面足够——漫反射辐照度本来就是超低频信号。
//
#include <Engine/Renderer/Cubemap.h>
@@ -29,22 +32,27 @@ namespace Engine
namespace
{
constexpr u32 kFaceCount = 6;
constexpr u32 kIrradianceFaceSize = 32; // 漫反射辐照度面边长（低频）
constexpr u32 kPhiSteps = 64; // 方位角采样数
constexpr u32 kThetaSteps = 32; // 极角采样数
// GL/Vulkan 规范的 cube 面方向表（与 GL spec 立方体选择表互逆）。
// (u,v)∈[0,1]（u 向右 v 向下）→ s,t∈[-1,1] → 单位化前方向。
// (u,v)∈[0,1]（u 向右 v 向下）→ s,t∈[-1,1] → 单位方向。
// Vulkan 面序与 GL 一致：+X -X +Y -Y +Z -Z
glm::vec3 FaceDir(u32 face, f32 u, f32 v)
{
const f32 s = u * 2.0f - 1.0f;
const f32 t = v * 2.0f - 1.0f;
glm::vec3 dir;
switch (face) {
case 0: return { 1.0f, -t, -s }; // +X（面片顶行 = +Y）
case 1: return {-1.0f, -t, s }; // -X
case 2: return { s, 1.0f, t }; // +Y
case 3: return { s,-1.0f, -t }; // -Y
case 4: return { s, -t, 1.0f }; // +Z
default: return {-s, -t,-1.0f }; // -Z
case 0: dir = { 1.0f, -t, -s }; break; // +X（面片顶行 = +Y）
case 1: dir = {-1.0f, -t, s }; break; // -X
case 2: dir = { s, 1.0f, t }; break; // +Y
case 3: dir = { s,-1.0f, -t }; break; // -Y
case 4: dir = { s, -t, 1.0f }; break; // +Z
default: dir = {-s, -t,-1.0f }; break; // -Z
}
return glm::normalize(dir); // equirect 查表要求单位方向
}
// 等距柱状双线性采样（x 环绕跨经度接缝，y 钳制到极点）。
@@ -76,6 +84,39 @@ namespace Engine
return glm::mix(glm::mix(c00, c10, tx), glm::mix(c01, c11, tx), ty);
}
// 漫反射辐照度半球积分（Lambert）：E = ∫ L·cosθ·sinθ dθ dφ。
// 切线基 up×N 构造；φSteps×θSteps 均匀网格 ≈ 2048 采样/像素，
// 对 32² 低频图绰绰有余
glm::vec3 ConvolveIrradiance(const f32* img, u32 w, u32 h,
const glm::vec3& N)
{
const glm::vec3 up = glm::abs(N.y) > 0.999f
? glm::vec3(0.0f, 0.0f, 1.0f) : glm::vec3(0.0f, 1.0f, 0.0f);
const glm::vec3 T = glm::normalize(glm::cross(up, N));
const glm::vec3 B = glm::cross(N, T);
const f32 dPhi = 2.0f * glm::pi<f32>() / static_cast<f32>(kPhiSteps);
const f32 dTheta = 0.5f * glm::pi<f32>() / static_cast<f32>(kThetaSteps);
glm::vec3 irradiance(0.0f);
for (u32 p = 0; p < kPhiSteps; ++p) {
const f32 phi = (static_cast<f32>(p) + 0.5f) * dPhi;
for (u32 t = 0; t < kThetaSteps; ++t) {
const f32 theta = (static_cast<f32>(t) + 0.5f) * dTheta;
const f32 sinT = std::sin(theta);
const f32 cosT = std::cos(theta);
// 切线空间采样方向 → 世界
const glm::vec3 sampleDir =
T * (sinT * std::cos(phi)) +
B * (sinT * std::sin(phi)) +
N * cosT;
irradiance += SampleEquirect(img, w, h, sampleDir) *
(cosT * sinT);
}
}
return irradiance * (dPhi * dTheta);
}
// IEEE754 f32 → fp16（round-to-nearest-even；溢出饱和为 Inf）。
// HDR 环境值域内常规路径足够，次正规/NaN 路径只为数学完备
u16 FloatToHalf(f32 value)
@@ -106,6 +147,125 @@ namespace Engine
// 舍入进位到 0x400 恰好是最小正规 half 的位型，无需特判
return static_cast<u16>(sign | std::min(m, 0x400u));
}
// 上传 6 面 fp16 数据为 cube image（UNDEFINED → TransferDst →
// ShaderRead；一次性命令缓冲）。view 由调用方创建
MemoryAllocator::Allocation UploadCube(Device& device,
MemoryAllocator& allocator,
const std::vector<u16>& faces,
u32 faceSize, vk::Image& outImage)
{
const vk::DeviceSize faceBytes =
static_cast<vk::DeviceSize>(faceSize) * faceSize * 8;
const vk::DeviceSize total = faceBytes * kFaceCount;
auto stagingAlloc = allocator.CreateBuffer(
total,
vk::BufferUsageFlagBits::eTransferSrc,
vk::MemoryPropertyFlagBits::eHostVisible |
vk::MemoryPropertyFlagBits::eHostCoherent);
std::memcpy(stagingAlloc.MappedPtr, faces.data(),
static_cast<size_t>(total));
vk::ImageCreateInfo imageInfo;
imageInfo.setImageType(vk::ImageType::e2D)
.setFormat(vk::Format::eR16G16B16A16Sfloat)
.setExtent({faceSize, faceSize, 1})
.setMipLevels(1)
.setArrayLayers(kFaceCount)
.setSamples(vk::SampleCountFlagBits::e1)
.setTiling(vk::ImageTiling::eOptimal)
.setFlags(vk::ImageCreateFlagBits::eCubeCompatible)
.setUsage(vk::ImageUsageFlagBits::eTransferDst |
vk::ImageUsageFlagBits::eSampled)
.setSharingMode(vk::SharingMode::eExclusive)
.setInitialLayout(vk::ImageLayout::eUndefined);
auto imageAlloc = allocator.CreateImage(imageInfo,
vk::MemoryPropertyFlagBits::eDeviceLocal);
outImage = imageAlloc.Image;
vk::CommandPoolCreateInfo poolInfo;
poolInfo.setQueueFamilyIndex(device.GetGraphicsFamily())
.setFlags(vk::CommandPoolCreateFlagBits::eTransient);
vk::CommandPool pool = device.GetDevice().createCommandPool(poolInfo);
vk::CommandBuffer cmd = device.GetDevice().allocateCommandBuffers(
vk::CommandBufferAllocateInfo{}
.setCommandPool(pool)
.setLevel(vk::CommandBufferLevel::ePrimary)
.setCommandBufferCount(1))[0];
cmd.begin(vk::CommandBufferBeginInfo{
vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
vk::ImageMemoryBarrier2 toTransfer;
toTransfer.setSrcStageMask(vk::PipelineStageFlagBits2::eNone)
.setSrcAccessMask(vk::AccessFlagBits2::eNone)
.setDstStageMask(vk::PipelineStageFlagBits2::eTransfer)
.setDstAccessMask(vk::AccessFlagBits2::eTransferWrite)
.setOldLayout(vk::ImageLayout::eUndefined)
.setNewLayout(vk::ImageLayout::eTransferDstOptimal)
.setImage(outImage)
.setSubresourceRange({vk::ImageAspectFlagBits::eColor,
0, 1, 0, kFaceCount});
cmd.pipelineBarrier2(
vk::DependencyInfo{}.setImageMemoryBarriers(toTransfer));
for (u32 f = 0; f < kFaceCount; ++f) {
vk::BufferImageCopy region;
region.setBufferOffset(faceBytes * f)
.setBufferRowLength(0)
.setBufferImageHeight(0)
.setImageSubresource({vk::ImageAspectFlagBits::eColor,
0, f, 1})
.setImageOffset({0, 0, 0})
.setImageExtent({faceSize, faceSize, 1});
cmd.copyBufferToImage(stagingAlloc.Buffer, outImage,
vk::ImageLayout::eTransferDstOptimal,
region);
}
vk::ImageMemoryBarrier2 toShader;
toShader.setSrcStageMask(vk::PipelineStageFlagBits2::eTransfer)
.setSrcAccessMask(vk::AccessFlagBits2::eTransferWrite)
.setDstStageMask(vk::PipelineStageFlagBits2::eFragmentShader)
.setDstAccessMask(vk::AccessFlagBits2::eShaderRead)
.setOldLayout(vk::ImageLayout::eTransferDstOptimal)
.setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
.setImage(outImage)
.setSubresourceRange({vk::ImageAspectFlagBits::eColor,
0, 1, 0, kFaceCount});
cmd.pipelineBarrier2(
vk::DependencyInfo{}.setImageMemoryBarriers(toShader));
cmd.end();
vk::Fence fence = device.GetDevice().createFence({});
device.GetGraphicsQueue().submit(
vk::SubmitInfo{}.setCommandBuffers(cmd), fence);
if (device.GetDevice().waitForFences(fence, VK_TRUE, UINT64_MAX) !=
vk::Result::eSuccess) {
ENGINE_ERROR("Cubemap upload: waitForFences failed");
}
device.GetDevice().destroyFence(fence);
device.GetDevice().destroyCommandPool(pool);
allocator.Destroy(stagingAlloc);
return imageAlloc;
}
vk::ImageView CreateCubeView(Device& device, vk::Image image)
{
return device.GetDevice().createImageView(
vk::ImageViewCreateInfo{}
.setImage(image)
.setViewType(vk::ImageViewType::eCube)
.setFormat(vk::Format::eR16G16B16A16Sfloat)
.setSubresourceRange({vk::ImageAspectFlagBits::eColor,
0, 1, 0, kFaceCount}));
}
}
Scope<Cubemap> Cubemap::CreateFromHdrEquirect(Device& device,
@@ -123,11 +283,11 @@ namespace Engine
const u32 srcW = static_cast<u32>(w);
const u32 srcH = static_cast<u32>(h);
// ---- 2. 重采样 6 面 + fp16（RGBA16F = 每像素 8B）----
// ---- 2. 重采样 6 面 + irradiance 卷积 + fp16 ----
const u32 facePixels = faceSize * faceSize;
std::vector<u16> faces(kFaceCount * facePixels * 4);
std::vector<u16> envFaces(kFaceCount * facePixels * 4);
for (u32 f = 0; f < kFaceCount; ++f) {
u16* dst = faces.data() + f * facePixels * 4;
u16* dst = envFaces.data() + f * facePixels * 4;
for (u32 y = 0; y < faceSize; ++y) {
for (u32 x = 0; x < faceSize; ++x) {
const f32 u = (static_cast<f32>(x) + 0.5f) / static_cast<f32>(faceSize);
@@ -142,50 +302,37 @@ namespace Engine
}
}
}
stbi_image_free(pixels);
// ---- 3. staging（HOST_VISIBLE 持久映射，逐面偏移拷入）----
const vk::DeviceSize faceBytes =
static_cast<vk::DeviceSize>(facePixels) * 8;
const vk::DeviceSize total = faceBytes * kFaceCount;
const u32 irrPixels = kIrradianceFaceSize * kIrradianceFaceSize;
std::vector<u16> irrFaces(kFaceCount * irrPixels * 4);
for (u32 f = 0; f < kFaceCount; ++f) {
u16* dst = irrFaces.data() + f * irrPixels * 4;
for (u32 y = 0; y < kIrradianceFaceSize; ++y) {
for (u32 x = 0; x < kIrradianceFaceSize; ++x) {
const f32 u = (static_cast<f32>(x) + 0.5f) / static_cast<f32>(kIrradianceFaceSize);
const f32 v = (static_cast<f32>(y) + 0.5f) / static_cast<f32>(kIrradianceFaceSize);
const glm::vec3 rgb = ConvolveIrradiance(
pixels, srcW, srcH, FaceDir(f, u, v));
u16* px = dst + (static_cast<size_t>(y) * kIrradianceFaceSize + x) * 4;
px[0] = FloatToHalf(rgb.r);
px[1] = FloatToHalf(rgb.g);
px[2] = FloatToHalf(rgb.b);
px[3] = 0x3C00;
}
}
}
stbi_image_free(pixels); // 源数据消费完毕（卷积/重采样都在构造期）
auto stagingAlloc = allocator.CreateBuffer(
total,
vk::BufferUsageFlagBits::eTransferSrc,
vk::MemoryPropertyFlagBits::eHostVisible |
vk::MemoryPropertyFlagBits::eHostCoherent);
std::memcpy(stagingAlloc.MappedPtr, faces.data(),
static_cast<size_t>(total));
faces.clear();
faces.shrink_to_fit(); // CPU 侧临时数据尽早释放
// ---- 3. 上传双 cube + 共享采样器 ----
vk::Image envImage, irrImage;
auto envAlloc = UploadCube(device, allocator, envFaces, faceSize, envImage);
auto irrAlloc = UploadCube(device, allocator, irrFaces,
kIrradianceFaceSize, irrImage);
envFaces.clear(); envFaces.shrink_to_fit();
irrFaces.clear(); irrFaces.shrink_to_fit();
// ---- 4. cube image（eCubeCompatible，6 层，fp16）----
vk::ImageCreateInfo imageInfo;
imageInfo.setImageType(vk::ImageType::e2D)
.setFormat(vk::Format::eR16G16B16A16Sfloat)
.setExtent({faceSize, faceSize, 1})
.setMipLevels(1)
.setArrayLayers(kFaceCount)
.setSamples(vk::SampleCountFlagBits::e1)
.setTiling(vk::ImageTiling::eOptimal)
.setFlags(vk::ImageCreateFlagBits::eCubeCompatible)
.setUsage(vk::ImageUsageFlagBits::eTransferDst |
vk::ImageUsageFlagBits::eSampled)
.setSharingMode(vk::SharingMode::eExclusive)
.setInitialLayout(vk::ImageLayout::eUndefined);
auto imageAlloc = allocator.CreateImage(imageInfo,
vk::MemoryPropertyFlagBits::eDeviceLocal);
const vk::Image image = imageAlloc.Image;
// ---- 5. cube view + 环境采样器（clamp-to-edge：cube 采样寻址由面自动处理）----
vk::ImageViewCreateInfo viewInfo;
viewInfo.setImage(image)
.setViewType(vk::ImageViewType::eCube)
.setFormat(vk::Format::eR16G16B16A16Sfloat)
.setSubresourceRange({
vk::ImageAspectFlagBits::eColor, 0, 1, 0, kFaceCount});
vk::ImageView view = device.GetDevice().createImageView(viewInfo);
vk::ImageView envView = CreateCubeView(device, envImage);
vk::ImageView irrView = CreateCubeView(device, irrImage);
vk::SamplerCreateInfo samplerInfo;
samplerInfo.setMagFilter(vk::Filter::eLinear)
@@ -202,81 +349,52 @@ namespace Engine
.setMaxLod(0.0f);
vk::Sampler sampler = device.GetDevice().createSampler(samplerInfo);
// ---- 6. 一次性命令缓冲：整 cube → TransferDst，逐面拷贝 → ShaderRead ----
vk::CommandPoolCreateInfo poolInfo;
poolInfo.setQueueFamilyIndex(device.GetGraphicsFamily())
.setFlags(vk::CommandPoolCreateFlagBits::eTransient);
vk::CommandPool pool = device.GetDevice().createCommandPool(poolInfo);
ENGINE_INFO("Environment cubemap: {} ({}x6 env + {}x6 irradiance, fp16)",
path, faceSize, kIrradianceFaceSize);
vk::CommandBuffer cmd = device.GetDevice().allocateCommandBuffers(
vk::CommandBufferAllocateInfo{}
.setCommandPool(pool)
.setLevel(vk::CommandBufferLevel::ePrimary)
.setCommandBufferCount(1))[0];
cmd.begin(vk::CommandBufferBeginInfo{
vk::CommandBufferUsageFlagBits::eOneTimeSubmit});
// 6 层一起转 layout（subresource range layerCount = 6）
vk::ImageMemoryBarrier2 toTransfer;
toTransfer.setSrcStageMask(vk::PipelineStageFlagBits2::eNone)
.setSrcAccessMask(vk::AccessFlagBits2::eNone)
.setDstStageMask(vk::PipelineStageFlagBits2::eTransfer)
.setDstAccessMask(vk::AccessFlagBits2::eTransferWrite)
.setOldLayout(vk::ImageLayout::eUndefined)
.setNewLayout(vk::ImageLayout::eTransferDstOptimal)
.setImage(image)
.setSubresourceRange({vk::ImageAspectFlagBits::eColor,
0, 1, 0, kFaceCount});
cmd.pipelineBarrier2(
vk::DependencyInfo{}.setImageMemoryBarriers(toTransfer));
return Scope<Cubemap>(new Cubemap(device, allocator, envImage, envView,
irrImage, irrView, sampler,
envAlloc, irrAlloc, faceSize));
}
Scope<Cubemap> Cubemap::CreateNeutral(Device& device,
MemoryAllocator& allocator,
const glm::vec3& rgb)
{
// 1×1×6 常数 cube：env 与 irradiance 同值，描述符恒有效
const u16 px[4] = { FloatToHalf(rgb.r), FloatToHalf(rgb.g),
FloatToHalf(rgb.b), 0x3C00 };
std::vector<u16> faces(kFaceCount * 4, 0);
for (u32 f = 0; f < kFaceCount; ++f) {
vk::BufferImageCopy region;
region.setBufferOffset(faceBytes * f)
.setBufferRowLength(0)
.setBufferImageHeight(0)
.setImageSubresource({vk::ImageAspectFlagBits::eColor,
0, f, 1})
.setImageOffset({0, 0, 0})
.setImageExtent({faceSize, faceSize, 1});
cmd.copyBufferToImage(stagingAlloc.Buffer, image,
vk::ImageLayout::eTransferDstOptimal, region);
std::memcpy(faces.data() + f * 4, px, sizeof(px));
}
vk::ImageMemoryBarrier2 toShader;
toShader.setSrcStageMask(vk::PipelineStageFlagBits2::eTransfer)
.setSrcAccessMask(vk::AccessFlagBits2::eTransferWrite)
.setDstStageMask(vk::PipelineStageFlagBits2::eFragmentShader)
.setDstAccessMask(vk::AccessFlagBits2::eShaderRead)
.setOldLayout(vk::ImageLayout::eTransferDstOptimal)
.setNewLayout(vk::ImageLayout::eShaderReadOnlyOptimal)
.setImage(image)
.setSubresourceRange({vk::ImageAspectFlagBits::eColor,
0, 1, 0, kFaceCount});
cmd.pipelineBarrier2(
vk::DependencyInfo{}.setImageMemoryBarriers(toShader));
vk::Image envImage, irrImage;
auto envAlloc = UploadCube(device, allocator, faces, 1, envImage);
auto irrAlloc = UploadCube(device, allocator, faces, 1, irrImage);
cmd.end();
vk::ImageView envView = CreateCubeView(device, envImage);
vk::ImageView irrView = CreateCubeView(device, irrImage);
// ---- 7. 提交并等待，清理 staging ----
vk::Fence fence = device.GetDevice().createFence({});
device.GetGraphicsQueue().submit(
vk::SubmitInfo{}.setCommandBuffers(cmd), fence);
if (device.GetDevice().waitForFences(fence, VK_TRUE, UINT64_MAX) !=
vk::Result::eSuccess) {
ENGINE_ERROR("Cubemap upload: waitForFences failed");
}
vk::SamplerCreateInfo samplerInfo;
samplerInfo.setMagFilter(vk::Filter::eNearest)
.setMinFilter(vk::Filter::eNearest)
.setMipmapMode(vk::SamplerMipmapMode::eNearest)
.setAddressModeU(vk::SamplerAddressMode::eClampToEdge)
.setAddressModeV(vk::SamplerAddressMode::eClampToEdge)
.setAddressModeW(vk::SamplerAddressMode::eClampToEdge)
.setAnisotropyEnable(VK_FALSE)
.setBorderColor(vk::BorderColor::eIntOpaqueBlack)
.setUnnormalizedCoordinates(VK_FALSE)
.setCompareEnable(VK_FALSE)
.setMinLod(0.0f)
.setMaxLod(0.0f);
vk::Sampler sampler = device.GetDevice().createSampler(samplerInfo);
device.GetDevice().destroyFence(fence);
device.GetDevice().destroyCommandPool(pool);
allocator.Destroy(stagingAlloc);
ENGINE_INFO("Environment cubemap: {} ({}x6 {} faces, fp16)",
path, faceSize, kFaceCount);
return Scope<Cubemap>(new Cubemap(device, allocator, image, view,
sampler, imageAlloc, faceSize));
ENGINE_INFO("Neutral cubemap created (constant fallback)");
return Scope<Cubemap>(new Cubemap(device, allocator, envImage, envView,
irrImage, irrView, sampler,
envAlloc, irrAlloc, 1));
}
Cubemap::~Cubemap()
@@ -284,10 +402,12 @@ namespace Engine
const auto& vkDevice = m_Device.GetDevice();
vkDevice.destroySampler(m_Sampler);
vkDevice.destroyImageView(m_View);
vkDevice.destroyImageView(m_EnvView);
vkDevice.destroyImageView(m_IrrView);
// image 资源与显存经 VMA 成对释放
m_Allocator.Destroy(m_Allocation);
m_Allocator.Destroy(m_EnvAllocation);
m_Allocator.Destroy(m_IrrAllocation);
}
} // namespace Engine
Engine/src/Renderer/Passes/SceneGpu.cpp
+14
View File
@@ -4,6 +4,7 @@
#include <Engine/Renderer/Passes/SceneGpu.h>
#include <Engine/Renderer/Material.h>
#include <Engine/Renderer/Cubemap.h>
#include <Engine/Vulkan/Device.h>
#include <Engine/Vulkan/DescriptorManager.h>
#include <Engine/Vulkan/ShaderManager.h>
@@ -46,12 +47,16 @@ namespace Engine::Passes
textureSetLayout = descriptors.CreateLayout(texBindings);
// Set 2: CSM 级联阴影图（fragment 采样，binding = 级联序号）
// + 漫反射辐照度 cube（IBL 阶段②，binding 3）
std::vector<DescriptorBinding> shadowBindings;
for (u32 c = 0; c < kMaxCascades; ++c) {
shadowBindings.push_back(
{c, vk::DescriptorType::eCombinedImageSampler,
vk::ShaderStageFlagBits::eFragment});
}
shadowBindings.push_back(
{3, vk::DescriptorType::eCombinedImageSampler,
vk::ShaderStageFlagBits::eFragment});
shadowSetLayout = descriptors.CreateLayout(shadowBindings);
// Forward pipeline layout：三个 set；无 push（GPUDriven 经 SSBO）
@@ -157,4 +162,13 @@ namespace Engine::Passes
}
}
void SceneGpu::BindEnvironment(const Cubemap& env)
{
// irradiance view 全程稳定（不随 RG 重编译变化），绑一次即可
for (u32 slot = 0; slot < kMaxFramesInFlight; ++slot) {
m_Descriptors.UpdateTexture(shadowSets[slot], 3, shadowSampler,
env.GetIrradianceView());
}
}
} // namespace Engine::Passes
Engine/src/Renderer/Renderer.cpp
+7 -2
View File
@@ -74,12 +74,15 @@ namespace Engine
m_FullscreenGpu = CreateScope<Passes::FullscreenGpu>(
*m_Device, *m_DescriptorManager, *m_ShaderManager);
// 3.5 环境贴图（IBL 阶段①）：HDR 等距柱状 → cube。
// 文件缺失则跳过（SkyboxPass 自动退化为纯清屏，Forward 不受影响）
// 3.5 环境贴图（IBL）：HDR 等距柱状 → cube + irradiance 卷积。
// 文件缺失则创建中性常数兜底（描述符恒有效，渲染退化为常数环境）
const std::string envPath = "assets/textures/venice_dawn_1_4k.hdr";
if (std::filesystem::exists(envPath)) {
m_Environment = Cubemap::CreateFromHdrEquirect(
*m_Device, *m_Allocator, envPath, 1024);
} else {
m_Environment = Cubemap::CreateNeutral(
*m_Device, *m_Allocator, glm::vec3(0.1f));
}
// 4. Swapchain（只管呈现；渲染目标统一归 RenderGraph）
@@ -107,6 +110,8 @@ namespace Engine
for (auto& pass : m_Passes) {
pass->OnTargetsRebuilt(*m_RenderGraph);
}
// 环境辐照度绑定（view 全程稳定，绑一次）
m_SceneGpu->BindEnvironment(*m_Environment);
// 9. GPU timestamp：每 pass 两枚（前后），按帧槽位分区
m_QueriesPerFrame = static_cast<u32>(m_RenderGraph->GetPassCount()) * 2;