OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

Remove vulkan shader modules

Browse source
This commit is contained in:
dpjudas 2025-04-19 08:24:43 +02:00
commit 22b7f02305
15 changed files with 217 additions and 305 deletions
Download patch file Download diff file Expand all files Collapse all files

21
libraries/ZVulkan/include/zvulkan/vulkanbuilders.h
View file

@ -227,19 +227,6 @@ private:
friend class GLSLCompilerIncluderImpl;
};
class ShaderBuilder
{
public:
ShaderBuilder& Code(std::vector<uint32_t> spirv) { code = std::move(spirv); return *this; }
ShaderBuilder& DebugName(const char* name) { debugName = name; return *this; }
std::unique_ptr<VulkanShader> Create(const char* shadername, VulkanDevice* device);
private:
std::vector<uint32_t> code;
const char* debugName = nullptr;
};
class AccelerationStructureBuilder
{
public:
@ -264,7 +251,7 @@ public:
ComputePipelineBuilder& Cache(VulkanPipelineCache* cache);
ComputePipelineBuilder& Layout(VulkanPipelineLayout *layout);
ComputePipelineBuilder& ComputeShader(VulkanShader *shader);
ComputePipelineBuilder& ComputeShader(std::vector<uint32_t> spirv) { computeShader = std::move(spirv); return *this; }
ComputePipelineBuilder& DebugName(const char* name) { debugName = name; return *this; }
std::unique_ptr<VulkanPipeline> Create(VulkanDevice *device);
@ -272,6 +259,7 @@ public:
private:
VkComputePipelineCreateInfo pipelineInfo = {};
VkPipelineShaderStageCreateInfo stageInfo = {};
std::vector<uint32_t> computeShader;
VulkanPipelineCache* cache = nullptr;
const char* debugName = nullptr;
};
@ -386,8 +374,8 @@ public:
GraphicsPipelineBuilder& AddColorBlendAttachment(VkPipelineColorBlendAttachmentState state);
GraphicsPipelineBuilder& AddVertexShader(VulkanShader *shader);
GraphicsPipelineBuilder& AddFragmentShader(VulkanShader *shader);
GraphicsPipelineBuilder& AddVertexShader(std::vector<uint32_t> spirv);
GraphicsPipelineBuilder& AddFragmentShader(std::vector<uint32_t> spirv);
GraphicsPipelineBuilder& AddConstant(uint32_t constantID, const void* data, size_t size);
GraphicsPipelineBuilder& AddConstant(uint32_t constantID, uint32_t value);
@ -431,6 +419,7 @@ private:
std::vector<VkVertexInputAttributeDescription> vertexInputAttributes;
std::vector<VkDynamicState> dynamicStates;
std::vector<VkPipeline> libraries;
std::vector<std::vector<uint32_t>> shaderCode;
struct ShaderSpecialization
{

78
libraries/ZVulkan/src/vulkanbuilders.cpp
View file

@ -205,26 +205,6 @@ std::vector<uint32_t> GLSLCompiler::Compile(uint32_t apiVersion)
/////////////////////////////////////////////////////////////////////////////
std::unique_ptr<VulkanShader> ShaderBuilder::Create(const char* shadername, VulkanDevice* device)
{
VkShaderModuleCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = code.size() * sizeof(uint32_t);
createInfo.pCode = code.data();
VkShaderModule shaderModule;
VkResult result = vkCreateShaderModule(device->device, &createInfo, nullptr, &shaderModule);
if (result != VK_SUCCESS)
VulkanError("Could not create vulkan shader module");
auto obj = std::make_unique<VulkanShader>(device, shaderModule);
if (debugName)
obj->SetDebugName(debugName);
return obj;
}
/////////////////////////////////////////////////////////////////////////////
CommandPoolBuilder::CommandPoolBuilder()
{
}
@ -627,6 +607,31 @@ std::unique_ptr<VulkanAccelerationStructure> AccelerationStructureBuilder::Creat
/////////////////////////////////////////////////////////////////////////////
static std::unique_ptr<VulkanShader> CreateShaderModule(VulkanDevice* device, const char* debugName, const uint32_t* code, size_t size)
{
// To do:
// If we have VK_KHR_maintenance5 enabled or Vulkan 1.4 we can chain
// VkShaderModuleCreateInfo to VkPipelineShaderStageCreateInfo instead of
// creating this pointless object.
VkShaderModuleCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = size * sizeof(uint32_t);
createInfo.pCode = code;
VkShaderModule shaderModule;
VkResult result = vkCreateShaderModule(device->device, &createInfo, nullptr, &shaderModule);
if (result != VK_SUCCESS)
VulkanError("Could not create vulkan shader module");
auto obj = std::make_unique<VulkanShader>(device, shaderModule);
if (debugName)
obj->SetDebugName(debugName);
return obj;
}
/////////////////////////////////////////////////////////////////////////////
ComputePipelineBuilder::ComputePipelineBuilder()
{
pipelineInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
@ -645,18 +650,14 @@ ComputePipelineBuilder& ComputePipelineBuilder::Layout(VulkanPipelineLayout* lay
return *this;
}
ComputePipelineBuilder& ComputePipelineBuilder::ComputeShader(VulkanShader* shader)
std::unique_ptr<VulkanPipeline> ComputePipelineBuilder::Create(VulkanDevice* device)
{
auto shader = CreateShaderModule(device, debugName, computeShader.data(), computeShader.size());
stageInfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
stageInfo.module = shader->module;
stageInfo.pName = "main";
pipelineInfo.stage = stageInfo;
return *this;
}
std::unique_ptr<VulkanPipeline> ComputePipelineBuilder::Create(VulkanDevice* device)
{
VkPipeline pipeline;
vkCreateComputePipelines(device->device, cache ? cache->cache : VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline);
auto obj = std::make_unique<VulkanPipeline>(device, pipeline);
@ -1087,31 +1088,25 @@ GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddColorBlendAttachment(VkPipe
return *this;
}
GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexShader(VulkanShader* shader)
GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddVertexShader(std::vector<uint32_t> spirv)
{
VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertShaderStageInfo.module = shader->module;
vertShaderStageInfo.pName = "main";
shaderStages.push_back(vertShaderStageInfo);
pipelineInfo.stageCount = (uint32_t)shaderStages.size();
pipelineInfo.pStages = shaderStages.data();
shaderCode.push_back(std::move(spirv));
return *this;
}
GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddFragmentShader(VulkanShader* shader)
GraphicsPipelineBuilder& GraphicsPipelineBuilder::AddFragmentShader(std::vector<uint32_t> spirv)
{
VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragShaderStageInfo.module = shader->module;
fragShaderStageInfo.pName = "main";
shaderStages.push_back(fragShaderStageInfo);
pipelineInfo.stageCount = (uint32_t)shaderStages.size();
pipelineInfo.pStages = shaderStages.data();
shaderCode.push_back(std::move(spirv));
return *this;
}
@ -1208,6 +1203,17 @@ std::unique_ptr<VulkanPipeline> GraphicsPipelineBuilder::Create(VulkanDevice* de
libraryCreate.pLibraries = libraries.data();
}
std::vector<std::unique_ptr<VulkanShader>> shaders;
shaders.reserve(shaderStages.size());
for (size_t i = 0; i < shaderStages.size(); i++)
{
auto shader = CreateShaderModule(device, debugName, shaderCode[i].data(), shaderCode[i].size());
shaderStages[i].module = shader->module;
shaders.push_back(std::move(shader));
}
pipelineInfo.stageCount = (uint32_t)shaderStages.size();
pipelineInfo.pStages = shaderStages.data();
const void** ppNext = &pipelineInfo.pNext;
if (libraryCreate.libraryCount > 0 && device->SupportsExtension(VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME))

2
src/common/rendering/vulkan/commands/vk_commandbuffer.h
View file

@ -40,7 +40,6 @@ public:
std::vector<std::unique_ptr<VulkanAccelerationStructure>> AccelStructs;
std::vector<std::unique_ptr<VulkanDescriptorPool>> DescriptorPools;
std::vector<std::unique_ptr<VulkanDescriptorSet>> Descriptors;
std::vector<std::unique_ptr<VulkanShader>> Shaders;
std::vector<std::unique_ptr<VulkanCommandBuffer>> CommandBuffers;
size_t TotalSize = 0;
@ -53,7 +52,6 @@ public:
void Add(std::unique_ptr<VulkanDescriptorPool> obj) { if (obj) { DescriptorPools.push_back(std::move(obj)); } }
void Add(std::unique_ptr<VulkanDescriptorSet> obj) { if (obj) { Descriptors.push_back(std::move(obj)); } }
void Add(std::unique_ptr<VulkanCommandBuffer> obj) { if (obj) { CommandBuffers.push_back(std::move(obj)); } }
void Add(std::unique_ptr<VulkanShader> obj) { if (obj) { Shaders.push_back(std::move(obj)); } }
};
std::unique_ptr<DeleteList> TransferDeleteList = std::make_unique<DeleteList>();

4
src/common/rendering/vulkan/pipelines/vk_pprenderpass.cpp
View file

@ -64,8 +64,8 @@ void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey& key)
{
GraphicsPipelineBuilder builder;
builder.Cache(fb->GetRenderPassManager()->GetCache());
builder.AddVertexShader(key.Shader->VertexShader.get());
builder.AddFragmentShader(key.Shader->FragmentShader.get());
builder.AddVertexShader(key.Shader->VertexShader);
builder.AddFragmentShader(key.Shader->FragmentShader);
builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT);
builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR);

6
src/common/rendering/vulkan/pipelines/vk_renderpass.cpp
View file

@ -875,7 +875,7 @@ void VkRenderPassSetup::AddVertexInputInterface(GraphicsPipelineBuilder& builder
void VkRenderPassSetup::AddPreRasterizationShaders(GraphicsPipelineBuilder& builder, const VkPipelineKey& key, VkShaderProgram* program)
{
builder.PolygonMode(key.DrawLine ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL);
builder.AddVertexShader(program->vert.get());
builder.AddVertexShader(program->vert);
builder.AddConstant(0, (uint32_t)key.ShaderKey.AsQWORD);
builder.AddConstant(1, (uint32_t)(key.ShaderKey.AsQWORD >> 32));
@ -890,9 +890,9 @@ void VkRenderPassSetup::AddPreRasterizationShaders(GraphicsPipelineBuilder& buil
void VkRenderPassSetup::AddFragmentShader(GraphicsPipelineBuilder& builder, const VkPipelineKey& key, VkShaderProgram* program)
{
if (program->frag)
if (!program->frag.empty())
{
builder.AddFragmentShader(program->frag.get());
builder.AddFragmentShader(program->frag);
builder.AddConstant(0, (uint32_t)key.ShaderKey.AsQWORD);
builder.AddConstant(1, (uint32_t)(key.ShaderKey.AsQWORD >> 32));
}

39
src/common/rendering/vulkan/shaders/vk_ppshader.cpp
View file

@ -35,25 +35,19 @@ VkPPShader::VkPPShader(VulkanRenderDevice* fb, PPShader *shader) : fb(fb)
prolog = CreateUniformBlockDecl("Uniforms", shader->Uniforms, -1);
prolog += shader->Defines;
VertexShader = ShaderBuilder()
.Code(GLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource(shader->VertexShader.GetChars(), LoadShaderCode(shader->VertexShader, "", shader->Version).GetChars())
.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
.Compile(fb->GetDevice()))
.DebugName(shader->VertexShader.GetChars())
.Create(shader->VertexShader.GetChars(), fb->GetDevice());
VertexShader = GLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource(shader->VertexShader.GetChars(), LoadShaderCode(shader->VertexShader, "", shader->Version).GetChars())
.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
.Compile(fb->GetDevice());
FragmentShader = ShaderBuilder()
.Code(GLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource(shader->FragmentShader.GetChars(), LoadShaderCode(shader->FragmentShader, prolog, shader->Version).GetChars())
.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
.Compile(fb->GetDevice()))
.DebugName(shader->FragmentShader.GetChars())
.Create(shader->FragmentShader.GetChars(), fb->GetDevice());
FragmentShader = GLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource(shader->FragmentShader.GetChars(), LoadShaderCode(shader->FragmentShader, prolog, shader->Version).GetChars())
.OnIncludeLocal([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); })
.OnIncludeSystem([=](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); })
.Compile(fb->GetDevice());
fb->GetShaderManager()->AddVkPPShader(this);
}
@ -64,15 +58,6 @@ VkPPShader::~VkPPShader()
fb->GetShaderManager()->RemoveVkPPShader(this);
}
void VkPPShader::Reset()
{
if (fb)
{
fb->GetCommands()->DrawDeleteList->Add(std::move(VertexShader));
fb->GetCommands()->DrawDeleteList->Add(std::move(FragmentShader));
}
}
ShaderIncludeResult VkPPShader::OnInclude(FString headerName, FString includerName, size_t depth, bool system)
{
if (depth > 8)

6
src/common/rendering/vulkan/shaders/vk_ppshader.h
View file

@ -14,13 +14,11 @@ public:
VkPPShader(VulkanRenderDevice* fb, PPShader *shader);
~VkPPShader();
void Reset();
VulkanRenderDevice* fb = nullptr;
std::list<VkPPShader*>::iterator it;
std::unique_ptr<VulkanShader> VertexShader;
std::unique_ptr<VulkanShader> FragmentShader;
std::vector<uint32_t> VertexShader;
std::vector<uint32_t> FragmentShader;
private:
FString LoadShaderCode(const FString &lumpname, const FString &defines, int version);

120
src/common/rendering/vulkan/shaders/vk_shader.cpp
View file

@ -34,51 +34,36 @@
VkShaderManager::VkShaderManager(VulkanRenderDevice* fb) : fb(fb)
{
ZMinMax.vert = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/vert_zminmax.glsl", LoadPrivateShaderLump("shaders/scene/vert_zminmax.glsl").GetChars())
.Compile(fb))
.DebugName("ZMinMax.vert")
.Create("ZMinMax.vert", fb->GetDevice());
ZMinMax.vert = CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/vert_zminmax.glsl", LoadPrivateShaderLump("shaders/scene/vert_zminmax.glsl").GetChars())
.Compile(fb);
ZMinMax.frag[0] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
.Compile(fb))
.DebugName("ZMinMax0.frag")
.Create("ZMinMax0.frag", fb->GetDevice());
ZMinMax.frag[0] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
.Compile(fb);
ZMinMax.frag[1] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", "#define MULTISAMPLE\n")
.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
.Compile(fb))
.DebugName("ZMinMax0.frag")
.Create("ZMinMax0.frag", fb->GetDevice());
ZMinMax.frag[1] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", "#define MULTISAMPLE\n")
.AddSource("shaders/scene/frag_zminmax0.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax0.glsl").GetChars())
.Compile(fb);
ZMinMax.frag[2] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/frag_zminmax1.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax1.glsl").GetChars())
.Compile(fb))
.DebugName("ZMinMax1.frag")
.Create("ZMinMax1.frag", fb->GetDevice());
ZMinMax.frag[2] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/frag_zminmax1.glsl", LoadPrivateShaderLump("shaders/scene/frag_zminmax1.glsl").GetChars())
.Compile(fb);
LightTiles = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Compute)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/comp_lighttiles.glsl", LoadPrivateShaderLump("shaders/scene/comp_lighttiles.glsl").GetChars())
.Compile(fb))
.DebugName("LightTiles.comp")
.Create("LightTiles.comp", fb->GetDevice());
LightTiles = CachedGLSLCompiler()
.Type(ShaderType::Compute)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("shaders/scene/comp_lighttiles.glsl", LoadPrivateShaderLump("shaders/scene/comp_lighttiles.glsl").GetChars())
.Compile(fb);
}
VkShaderManager::~VkShaderManager()
@ -94,7 +79,7 @@ void VkShaderManager::Deinit()
VkShaderProgram* VkShaderManager::Get(const VkShaderKey& key, bool isUberShader)
{
VkShaderProgram& program = isUberShader ? generic[key.GeneralizedShaderKey()] : specialized[key];
if (program.frag)
if (!program.frag.empty())
return &program;
const char* mainvp = "shaders/scene/vert_main.glsl";
@ -468,7 +453,7 @@ void VkShaderManager::BuildDefinesBlock(FString &definesBlock, const char *defin
}
}
std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
std::vector<uint32_t> VkShaderManager::LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
{
FString definesBlock;
BuildDefinesBlock(definesBlock, defines, false, key, shader, isUberShader);
@ -488,20 +473,17 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(FString shadername
codeBlock << LoadPrivateShaderLump("shaders/scene/vert_nocustom.glsl").GetChars() << "\n";
}
return ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", definesBlock.GetChars())
.AddSource("LayoutBlock", layoutBlock.GetChars())
.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
.AddSource(vert_lump_custom ? vert_lump_custom : vert_lump, codeBlock.GetChars())
.Compile(fb))
.DebugName(shadername.GetChars())
.Create(shadername.GetChars(), fb->GetDevice());
return CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", definesBlock.GetChars())
.AddSource("LayoutBlock", layoutBlock.GetChars())
.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
.AddSource(vert_lump_custom ? vert_lump_custom : vert_lump, codeBlock.GetChars())
.Compile(fb);
}
std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *light_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
std::vector<uint32_t> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *light_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader)
{
FString definesBlock;
BuildDefinesBlock(definesBlock, defines, true, key, shader, isUberShader);
@ -587,21 +569,18 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername
mateffectBlock << LoadPrivateShaderLump(mateffect_lump).GetChars();
}
return ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", definesBlock.GetChars())
.AddSource("LayoutBlock", layoutBlock.GetChars())
.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
.AddSource("shaders/scene/includes.glsl", LoadPrivateShaderLump("shaders/scene/includes.glsl").GetChars())
.AddSource(mateffectname.GetChars(), mateffectBlock.GetChars())
.AddSource(materialname.GetChars(), materialBlock.GetChars())
.AddSource(lightname.GetChars(), lightBlock.GetChars())
.AddSource(frag_lump, codeBlock.GetChars())
.Compile(fb))
.DebugName(shadername.GetChars())
.Create(shadername.GetChars(), fb->GetDevice());
return CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", GetVersionBlock().GetChars())
.AddSource("DefinesBlock", definesBlock.GetChars())
.AddSource("LayoutBlock", layoutBlock.GetChars())
.AddSource("shaders/scene/layout_shared.glsl", LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars())
.AddSource("shaders/scene/includes.glsl", LoadPrivateShaderLump("shaders/scene/includes.glsl").GetChars())
.AddSource(mateffectname.GetChars(), mateffectBlock.GetChars())
.AddSource(materialname.GetChars(), materialBlock.GetChars())
.AddSource(lightname.GetChars(), lightBlock.GetChars())
.AddSource(frag_lump, codeBlock.GetChars())
.Compile(fb);
}
FString VkShaderManager::GetVersionBlock()
@ -652,7 +631,6 @@ void VkShaderManager::AddVkPPShader(VkPPShader* shader)
void VkShaderManager::RemoveVkPPShader(VkPPShader* shader)
{
shader->Reset();
shader->fb = nullptr;
PPShaders.erase(shader->it);
}

20
src/common/rendering/vulkan/shaders/vk_shader.h
View file

@ -154,8 +154,8 @@ static_assert(sizeof(VkShaderKey) == 24, "sizeof(VkShaderKey) is not its expecte
class VkShaderProgram
{
public:
std::unique_ptr<VulkanShader> vert;
std::unique_ptr<VulkanShader> frag;
std::vector<uint32_t> vert;
std::vector<uint32_t> frag;
UniformStructHolder Uniforms;
};
@ -177,13 +177,13 @@ public:
void AddVkPPShader(VkPPShader* shader);
void RemoveVkPPShader(VkPPShader* shader);
VulkanShader* GetZMinMaxVertexShader() { return ZMinMax.vert.get(); }
VulkanShader* GetZMinMaxFragmentShader(int index) { return ZMinMax.frag[index].get(); }
VulkanShader* GetLightTilesShader() { return LightTiles.get(); }
const std::vector<uint32_t>& GetZMinMaxVertexShader() const { return ZMinMax.vert; }
const std::vector<uint32_t>& GetZMinMaxFragmentShader(int index) const { return ZMinMax.frag[index]; }
const std::vector<uint32_t>& GetLightTilesShader() const { return LightTiles; }
private:
std::unique_ptr<VulkanShader> LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
std::unique_ptr<VulkanShader> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *lightmodel_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
std::vector<uint32_t> LoadVertShader(FString shadername, const char *vert_lump, const char *vert_lump_custom, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
std::vector<uint32_t> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump_shared, const char *lightmodel_lump, const char *defines, const VkShaderKey& key, const UserShaderDesc *shader, bool isUberShader);
FString GetVersionBlock();
FString LoadPublicShaderLump(const char *lumpname);
@ -201,9 +201,9 @@ private:
struct
{
std::unique_ptr<VulkanShader> vert;
std::unique_ptr<VulkanShader> frag[3];
std::vector<uint32_t> vert;
std::vector<uint32_t> frag[3];
} ZMinMax;
std::unique_ptr<VulkanShader> LightTiles;
std::vector<uint32_t> LightTiles;
};

30
src/common/rendering/vulkan/vk_levelmesh.cpp
View file

@ -504,8 +504,8 @@ void VkLevelMesh::RaytraceScene(const VkRenderPassKey& renderPassKey, VulkanComm
builder.RenderPass(fb->GetRenderPassManager()->GetRenderPass(renderPassKey)->GetRenderPass(0));
builder.Layout(Viewer.PipelineLayout.get());
builder.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP);
builder.AddVertexShader(Viewer.VertexShader.get());
builder.AddFragmentShader(Viewer.FragmentShader.get());
builder.AddVertexShader(Viewer.VertexShader);
builder.AddFragmentShader(Viewer.FragmentShader);
builder.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT);
builder.AddDynamicState(VK_DYNAMIC_STATE_SCISSOR);
builder.RasterizationSamples((VkSampleCountFlagBits)renderPassKey.Samples);
@ -604,23 +604,17 @@ void VkLevelMesh::CreateViewerObjects()
versionBlock += "#define USE_RAYQUERY\r\n";
}
Viewer.VertexShader = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("versionblock", versionBlock)
.AddSource("vert_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_viewer.glsl").GetChars())
.Compile(fb))
.DebugName("Viewer.VertexShader")
.Create("vertex", fb->GetDevice());
Viewer.VertexShader = CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("versionblock", versionBlock)
.AddSource("vert_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_viewer.glsl").GetChars())
.Compile(fb);
Viewer.FragmentShader = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("versionblock", versionBlock)
.AddSource("frag_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_viewer.glsl").GetChars())
.Compile(fb))
.DebugName("Viewer.FragmentShader")
.Create("vertex", fb->GetDevice());
Viewer.FragmentShader = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("versionblock", versionBlock)
.AddSource("frag_viewer.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_viewer.glsl").GetChars())
.Compile(fb);
Viewer.PipelineLayout = PipelineLayoutBuilder()
.AddSetLayout(Viewer.DescriptorSetLayout.get())

4
src/common/rendering/vulkan/vk_levelmesh.h
View file

@ -160,8 +160,8 @@ private:
std::unique_ptr<VulkanDescriptorSetLayout> DescriptorSetLayout;
std::unique_ptr<VulkanDescriptorPool> DescriptorPool;
std::unique_ptr<VulkanDescriptorSet> DescriptorSet;
std::unique_ptr<VulkanShader> VertexShader;
std::unique_ptr<VulkanShader> FragmentShader;
std::vector<uint32_t> VertexShader;
std::vector<uint32_t> FragmentShader;
//std::unique_ptr<VulkanRenderPass> RenderPass;
std::unique_ptr<VulkanPipelineLayout> PipelineLayout;
std::map<VkRenderPassKey, std::unique_ptr<VulkanPipeline>> Pipeline;

120
src/common/rendering/vulkan/vk_lightmapper.cpp
View file

@ -502,32 +502,23 @@ void VkLightmapper::CreateShaders()
traceprefix += "#define USE_RAYQUERY\r\n";
}
shaders.vertRaytrace = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_raytrace.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.VertRaytrace")
.Create("VkLightmapper.VertRaytrace", fb->GetDevice());
shaders.vertRaytrace = CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_raytrace.glsl").GetChars())
.Compile(fb);
shaders.vertScreenquad = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_screenquad.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_screenquad.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.VertScreenquad")
.Create("VkLightmapper.VertScreenquad", fb->GetDevice());
shaders.vertScreenquad = CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_screenquad.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_screenquad.glsl").GetChars())
.Compile(fb);
shaders.vertCopy = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_copy.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.VertCopy")
.Create("VkLightmapper.VertCopy", fb->GetDevice());
shaders.vertCopy = CachedGLSLCompiler()
.Type(ShaderType::Vertex)
.AddSource("VersionBlock", prefix)
.AddSource("vert_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/vert_copy.glsl").GetChars())
.Compile(fb);
for (int i = 0; i < 16; i++)
{
@ -541,51 +532,36 @@ void VkLightmapper::CreateShaders()
if (i & 8)
defines += "#define USE_BOUNCE\n";
shaders.fragRaytrace[i] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", defines)
.AddSource("frag_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_raytrace.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.FragRaytrace")
.Create("VkLightmapper.FragRaytrace", fb->GetDevice());
shaders.fragRaytrace[i] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", defines)
.AddSource("frag_raytrace.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_raytrace.glsl").GetChars())
.Compile(fb);
}
shaders.fragResolve = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix)
.AddSource("frag_resolve.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_resolve.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.FragResolve")
.Create("VkLightmapper.FragResolve", fb->GetDevice());
shaders.fragResolve = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix)
.AddSource("frag_resolve.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_resolve.glsl").GetChars())
.Compile(fb);
shaders.fragBlur[0] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix + "#define BLUR_HORIZONTAL\r\n")
.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.FragBlur")
.Create("VkLightmapper.FragBlur", fb->GetDevice());
shaders.fragBlur[0] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix + "#define BLUR_HORIZONTAL\r\n")
.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
.Compile(fb);
shaders.fragBlur[1] = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix + "#define BLUR_VERTICAL\r\n")
.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.FragBlur")
.Create("VkLightmapper.FragBlur", fb->GetDevice());
shaders.fragBlur[1] = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix + "#define BLUR_VERTICAL\r\n")
.AddSource("frag_blur.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_blur.glsl").GetChars())
.Compile(fb);
shaders.fragCopy = ShaderBuilder()
.Code(CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix)
.AddSource("frag_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_copy.glsl").GetChars())
.Compile(fb))
.DebugName("VkLightmapper.FragCopy")
.Create("VkLightmapper.FragCopy", fb->GetDevice());
shaders.fragCopy = CachedGLSLCompiler()
.Type(ShaderType::Fragment)
.AddSource("VersionBlock", prefix)
.AddSource("frag_copy.glsl", LoadPrivateShaderLump("shaders/lightmap/frag_copy.glsl").GetChars())
.Compile(fb);
}
int VkLightmapper::GetRaytracePipelineIndex()
@ -680,8 +656,8 @@ void VkLightmapper::CreateRaytracePipeline()
raytrace.pipeline[i] = GraphicsPipelineBuilder()
.Layout(raytrace.pipelineLayout.get())
.RenderPass(raytrace.renderPass.get())
.AddVertexShader(shaders.vertRaytrace.get())
.AddFragmentShader(shaders.fragRaytrace[i].get())
.AddVertexShader(shaders.vertRaytrace)
.AddFragmentShader(shaders.fragRaytrace[i])
.AddVertexBufferBinding(0, sizeof(FFlatVertex))
.AddVertexAttribute(0, 0, VK_FORMAT_R32G32B32A32_SFLOAT, 0)
.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
@ -788,8 +764,8 @@ void VkLightmapper::CreateResolvePipeline()
resolve.pipeline = GraphicsPipelineBuilder()
.Layout(resolve.pipelineLayout.get())
.RenderPass(resolve.renderPass.get())
.AddVertexShader(shaders.vertScreenquad.get())
.AddFragmentShader(shaders.fragResolve.get())
.AddVertexShader(shaders.vertScreenquad)
.AddFragmentShader(shaders.fragResolve)
.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
.Viewport(0.0f, 0.0f, 0.0f, 0.0f)
@ -843,8 +819,8 @@ void VkLightmapper::CreateBlurPipeline()
blur.pipeline[i] = GraphicsPipelineBuilder()
.Layout(blur.pipelineLayout.get())
.RenderPass(blur.renderPass.get())
.AddVertexShader(shaders.vertScreenquad.get())
.AddFragmentShader(shaders.fragBlur[i].get())
.AddVertexShader(shaders.vertScreenquad)
.AddFragmentShader(shaders.fragBlur[i])
.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
.Viewport(0.0f, 0.0f, 0.0f, 0.0f)
@ -902,8 +878,8 @@ void VkLightmapper::CreateCopyPipeline()
copy.pipeline = GraphicsPipelineBuilder()
.Layout(copy.pipelineLayout.get())
.RenderPass(copy.renderPass.get())
.AddVertexShader(shaders.vertCopy.get())
.AddFragmentShader(shaders.fragCopy.get())
.AddVertexShader(shaders.vertCopy)
.AddFragmentShader(shaders.fragCopy)
.Topology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
.AddDynamicState(VK_DYNAMIC_STATE_VIEWPORT)
.Viewport(0.0f, 0.0f, 0.0f, 0.0f)

14
src/common/rendering/vulkan/vk_lightmapper.h
View file

@ -177,13 +177,13 @@ private:
struct
{
std::unique_ptr<VulkanShader> vertRaytrace;
std::unique_ptr<VulkanShader> vertScreenquad;
std::unique_ptr<VulkanShader> vertCopy;
std::unique_ptr<VulkanShader> fragRaytrace[16];
std::unique_ptr<VulkanShader> fragResolve;
std::unique_ptr<VulkanShader> fragBlur[2];
std::unique_ptr<VulkanShader> fragCopy;
std::vector<uint32_t> vertRaytrace;
std::vector<uint32_t> vertScreenquad;
std::vector<uint32_t> vertCopy;
std::vector<uint32_t> fragRaytrace[16];
std::vector<uint32_t> fragResolve;
std::vector<uint32_t> fragBlur[2];
std::vector<uint32_t> fragCopy;
} shaders;
struct

31
src/common/rendering/vulkan/vk_lightprober.cpp
View file

@ -23,8 +23,6 @@ VkLightprober::~VkLightprober()
void VkLightprober::CreateBrdfLutResources()
{
brdfLut.shader = CompileShader("comp_brdf_convolute.glsl", "shaders/lightprobe/comp_brdf_convolute.glsl", "VkLightprober.BrdfLut");
brdfLut.descriptorSetLayout = DescriptorSetLayoutBuilder()
.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
.Create(fb->GetDevice());
@ -34,7 +32,7 @@ void VkLightprober::CreateBrdfLutResources()
.Create(fb->GetDevice());
brdfLut.pipeline = ComputePipelineBuilder()
.ComputeShader(brdfLut.shader.get())
.ComputeShader(CompileShader("shaders/lightprobe/comp_brdf_convolute.glsl"))
.Layout(brdfLut.pipelineLayout.get())
.Create(fb->GetDevice());
@ -209,8 +207,6 @@ void VkLightprober::RenderEnvironmentMap(std::function<void(IntRect&, int)> rend
void VkLightprober::CreateIrradianceMap()
{
irradianceMap.shader = CompileShader("comp_irradiance_convolute.glsl", "shaders/lightprobe/comp_irradiance_convolute.glsl", "VkLightprober.IrradianceMap");
irradianceMap.descriptorSetLayout = DescriptorSetLayoutBuilder()
.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
.AddBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT)
@ -227,7 +223,7 @@ void VkLightprober::CreateIrradianceMap()
.Create(fb->GetDevice());
irradianceMap.pipeline = ComputePipelineBuilder()
.ComputeShader(irradianceMap.shader.get())
.ComputeShader(CompileShader("shaders/lightprobe/comp_irradiance_convolute.glsl"))
.Layout(irradianceMap.pipelineLayout.get())
.Create(fb->GetDevice());
@ -356,8 +352,6 @@ bool VkLightprober::GenerateIrradianceMap(TArrayView<uint16_t>& databuffer)
void VkLightprober::CreatePrefilterMap()
{
prefilterMap.shader = CompileShader("comp_prefilter_convolute.glsl", "shaders/lightprobe/comp_prefilter_convolute.glsl", "VkLightprober.PrefilterMap");
prefilterMap.descriptorSetLayout = DescriptorSetLayoutBuilder()
.AddBinding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT)
.AddBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_COMPUTE_BIT)
@ -369,7 +363,7 @@ void VkLightprober::CreatePrefilterMap()
.Create(fb->GetDevice());
prefilterMap.pipeline = ComputePipelineBuilder()
.ComputeShader(prefilterMap.shader.get())
.ComputeShader(CompileShader("shaders/lightprobe/comp_prefilter_convolute.glsl"))
.Layout(prefilterMap.pipelineLayout.get())
.Create(fb->GetDevice());
@ -509,7 +503,7 @@ bool VkLightprober::GeneratePrefilterMap(TArrayView<uint16_t>& databuffer)
return true;
}
std::unique_ptr<VulkanShader> VkLightprober::CompileShader(const std::string& name, const std::string& filename, const char* debugName)
std::vector<uint32_t> VkLightprober::CompileShader(const std::string& filename)
{
std::string prefix = "#version 460\r\n";
prefix += "#extension GL_GOOGLE_include_directive : enable\n";
@ -518,16 +512,13 @@ std::unique_ptr<VulkanShader> VkLightprober::CompileShader(const std::string& na
auto onIncludeLocal = [](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, false); };
auto onIncludeSystem = [](std::string headerName, std::string includerName, size_t depth) { return OnInclude(headerName.c_str(), includerName.c_str(), depth, true); };
return ShaderBuilder()
.Code(GLSLCompiler()
.Type(ShaderType::Compute)
.AddSource("VersionBlock", prefix)
.AddSource(name, LoadPrivateShaderLump(filename.c_str()).GetChars())
.OnIncludeLocal(onIncludeLocal)
.OnIncludeSystem(onIncludeSystem)
.Compile(fb->GetDevice()))
.DebugName(debugName)
.Create(debugName, fb->GetDevice());
return GLSLCompiler()
.Type(ShaderType::Compute)
.AddSource("VersionBlock", prefix)
.AddSource(filename, LoadPrivateShaderLump(filename.c_str()).GetChars())
.OnIncludeLocal(onIncludeLocal)
.OnIncludeSystem(onIncludeSystem)
.Compile(fb->GetDevice());
}
FString VkLightprober::LoadPrivateShaderLump(const char* lumpname)

5
src/common/rendering/vulkan/vk_lightprober.h
View file

@ -45,7 +45,7 @@ private:
void CreatePrefilterMap();
void GenerateBrdfLut();
std::unique_ptr<VulkanShader> CompileShader(const std::string& name, const std::string& filename, const char* debugName);
std::vector<uint32_t> CompileShader(const std::string& filename);
static FString LoadPrivateShaderLump(const char* lumpname);
static FString LoadPublicShaderLump(const char* lumpname);
@ -53,7 +53,6 @@ private:
struct
{
std::unique_ptr<VulkanShader> shader;
std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
std::unique_ptr<VulkanDescriptorPool> descriptorPool;
std::unique_ptr<VulkanDescriptorSet> descriptorSet;
@ -78,7 +77,6 @@ private:
struct
{
std::unique_ptr<VulkanShader> shader;
std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
std::unique_ptr<VulkanDescriptorPool> descriptorPool;
std::unique_ptr<VulkanDescriptorSet> descriptorSets[6];
@ -96,7 +94,6 @@ private:
maxlevels = 5,
levelsSize = DFrameBuffer::prefilterMapLevelsSize
};
std::unique_ptr<VulkanShader> shader;
std::unique_ptr<VulkanDescriptorSetLayout> descriptorSetLayout;
std::unique_ptr<VulkanDescriptorPool> descriptorPool;
std::unique_ptr<VulkanDescriptorSet> descriptorSets[6 * maxlevels];