OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

- add render pass manager and setup a pipeline for VkRenderState

Browse source
This commit is contained in:
Magnus Norddahl 2019-02-26 11:27:29 +01:00
commit 9ed1c7f40b
15 changed files with 360 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

157
src/rendering/vulkan/renderer/vk_renderpass.cpp Normal file
View file

@ -0,0 +1,157 @@
#include "vk_renderpass.h"
#include "vulkan/shaders/vk_shader.h"
#include "vulkan/system/vk_builders.h"
#include "vulkan/system/vk_framebuffer.h"
#include "vulkan/system/vk_buffers.h"
#include "hwrenderer/data/flatvertices.h"
#include "hwrenderer/scene/hw_viewpointuniforms.h"
VkRenderPassManager::VkRenderPassManager()
{
CreateDynamicSetLayout();
CreateTextureSetLayout();
CreatePipelineLayout();
CreateDescriptorPool();
CreateDynamicSet();
}
void VkRenderPassManager::BeginFrame()
{
if (!SceneColor || SceneColor->width != SCREENWIDTH || SceneColor->height != SCREENHEIGHT)
{
auto fb = GetVulkanFrameBuffer();
RenderPassSetup.reset();
SceneColorView.reset();
SceneDepthStencilView.reset();
SceneDepthView.reset();
SceneColor.reset();
SceneDepthStencil.reset();
ImageBuilder builder;
builder.setSize(SCREENWIDTH, SCREENHEIGHT);
builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT);
builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
SceneColor = builder.create(fb->device);
builder.setFormat(VK_FORMAT_D24_UNORM_S8_UINT);
builder.setUsage(VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
SceneDepthStencil = builder.create(fb->device);
ImageViewBuilder viewbuilder;
viewbuilder.setImage(SceneColor.get(), VK_FORMAT_R16G16B16A16_SFLOAT);
SceneColorView = viewbuilder.create(fb->device);
viewbuilder.setImage(SceneDepthStencil.get(), VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
SceneDepthStencilView = viewbuilder.create(fb->device);
viewbuilder.setImage(SceneDepthStencil.get(), VK_FORMAT_D24_UNORM_S8_UINT, VK_IMAGE_ASPECT_DEPTH_BIT);
SceneDepthView = viewbuilder.create(fb->device);
RenderPassSetup.reset(new VkRenderPassSetup());
}
}
void VkRenderPassManager::CreateDynamicSetLayout()
{
DescriptorSetLayoutBuilder builder;
builder.addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
builder.addBinding(1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
DynamicSetLayout = builder.create(GetVulkanFrameBuffer()->device);
}
void VkRenderPassManager::CreateTextureSetLayout()
{
DescriptorSetLayoutBuilder builder;
builder.addBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
/*
for (int i = 0; i < 6; i++)
{
builder.addBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
}
builder.addBinding(16, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
*/
TextureSetLayout = builder.create(GetVulkanFrameBuffer()->device);
}
void VkRenderPassManager::CreatePipelineLayout()
{
PipelineLayoutBuilder builder;
builder.addSetLayout(DynamicSetLayout.get());
builder.addSetLayout(TextureSetLayout.get());
builder.addPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants));
PipelineLayout = builder.create(GetVulkanFrameBuffer()->device);
}
void VkRenderPassManager::CreateDescriptorPool()
{
DescriptorPoolBuilder builder;
builder.addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1);
builder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, 1);
builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 512 * 6);
builder.setMaxSets(512);
DescriptorPool = builder.create(GetVulkanFrameBuffer()->device);
}
void VkRenderPassManager::CreateDynamicSet()
{
DynamicSet = DescriptorPool->allocate(DynamicSetLayout.get());
auto fb = GetVulkanFrameBuffer();
WriteDescriptors update;
update.addBuffer(DynamicSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->ViewpointUBO->mBuffer.get(), 0, sizeof(HWViewpointUniforms));
update.addBuffer(DynamicSet.get(), 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, fb->LightBufferSSO->mBuffer.get(), 0, 4096);
update.updateSets(fb->device);
}
/////////////////////////////////////////////////////////////////////////////
VkRenderPassSetup::VkRenderPassSetup()
{
CreateRenderPass();
CreatePipeline();
CreateFramebuffer();
}
void VkRenderPassSetup::CreateRenderPass()
{
RenderPassBuilder builder;
builder.addRgba16fAttachment(false, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
builder.addSubpass();
builder.addSubpassColorAttachmentRef(0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
builder.addExternalSubpassDependency();
RenderPass = builder.create(GetVulkanFrameBuffer()->device);
}
void VkRenderPassSetup::CreatePipeline()
{
auto fb = GetVulkanFrameBuffer();
GraphicsPipelineBuilder builder;
builder.addVertexShader(fb->GetShaderManager()->vert.get());
builder.addFragmentShader(fb->GetShaderManager()->frag.get());
builder.addVertexBufferBinding(0, sizeof(FFlatVertex));
builder.addVertexAttribute(0, 0, VK_FORMAT_R32G32B32_SFLOAT, offsetof(FFlatVertex, x));
builder.addVertexAttribute(1, 0, VK_FORMAT_R32G32_SFLOAT, offsetof(FFlatVertex, u));
// To do: not all vertex formats has all the data..
//builder.addVertexAttribute(2, 0, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(FFlatVertex, x));
//builder.addVertexAttribute(3, 0, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(FFlatVertex, x));
//builder.addVertexAttribute(4, 0, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(FFlatVertex, x));
//builder.addVertexAttribute(5, 0, VK_FORMAT_R32G32B32A32_SFLOAT, offsetof(FFlatVertex, x));
builder.setViewport(0.0f, 0.0f, (float)SCREENWIDTH, (float)SCREENHEIGHT);
builder.setScissor(0, 0, SCREENWIDTH, SCREENHEIGHT);
builder.setAlphaBlendMode();
builder.setLayout(fb->GetRenderPassManager()->PipelineLayout.get());
builder.setRenderPass(RenderPass.get());
Pipeline = builder.create(fb->device);
}
void VkRenderPassSetup::CreateFramebuffer()
{
auto fb = GetVulkanFrameBuffer();
FramebufferBuilder builder;
builder.setRenderPass(RenderPass.get());
builder.setSize(SCREENWIDTH, SCREENHEIGHT);
builder.addAttachment(fb->GetRenderPassManager()->SceneColorView.get());
Framebuffer = builder.create(GetVulkanFrameBuffer()->device);
}

50
src/rendering/vulkan/renderer/vk_renderpass.h Normal file
View file

@ -0,0 +1,50 @@
#pragma once
#include "vulkan/system/vk_objects.h"
class VKDataBuffer;
class VkRenderPassSetup
{
public:
VkRenderPassSetup();
std::unique_ptr<VulkanRenderPass> RenderPass;
std::unique_ptr<VulkanPipeline> Pipeline;
std::unique_ptr<VulkanFramebuffer> Framebuffer;
private:
void CreatePipeline();
void CreateRenderPass();
void CreateFramebuffer();
};
class VkRenderPassManager
{
public:
VkRenderPassManager();
void BeginFrame();
std::unique_ptr<VulkanDescriptorSetLayout> DynamicSetLayout;
std::unique_ptr<VulkanDescriptorSetLayout> TextureSetLayout;
std::unique_ptr<VulkanPipelineLayout> PipelineLayout;
std::unique_ptr<VulkanDescriptorPool> DescriptorPool;
std::unique_ptr<VkRenderPassSetup> RenderPassSetup;
std::unique_ptr<VulkanImage> SceneColor;
std::unique_ptr<VulkanImage> SceneDepthStencil;
std::unique_ptr<VulkanImageView> SceneColorView;
std::unique_ptr<VulkanImageView> SceneDepthStencilView;
std::unique_ptr<VulkanImageView> SceneDepthView;
std::unique_ptr<VulkanDescriptorSet> DynamicSet;
private:
void CreateDynamicSetLayout();
void CreateTextureSetLayout();
void CreatePipelineLayout();
void CreateDescriptorPool();
void CreateDynamicSet();
};

72
src/rendering/vulkan/renderer/vk_renderstate.cpp
View file

@ -1,15 +1,23 @@
#include "vk_renderstate.h"
#include "vulkan/system/vk_framebuffer.h"
#include "vulkan/system/vk_builders.h"
#include "vulkan/renderer/vk_renderpass.h"
#include "templates.h"
#include "doomstat.h"
#include "r_data/colormaps.h"
#include "hwrenderer/scene/hw_skydome.h"
#include "hwrenderer/scene/hw_viewpointuniforms.h"
#include "hwrenderer/dynlights/hw_lightbuffer.h"
#include "hwrenderer/utility/hw_cvars.h"
#include "hwrenderer/utility/hw_clock.h"
#include "hwrenderer/data/flatvertices.h"
#include "hwrenderer/data/hw_viewpointbuffer.h"
#include "hwrenderer/data/shaderuniforms.h"
VkRenderState::VkRenderState()
{
}
void VkRenderState::ClearScreen()
{
@ -28,9 +36,10 @@ void VkRenderState::ClearScreen()
void VkRenderState::Draw(int dt, int index, int count, bool apply)
{
if (apply)
{
Apply(dt);
}
else if (mDescriptorsChanged)
BindDescriptorSets();
drawcalls.Clock();
//mCommandBuffer->draw(count, 1, index, 0);
drawcalls.Unclock();
@ -39,9 +48,10 @@ void VkRenderState::Draw(int dt, int index, int count, bool apply)
void VkRenderState::DrawIndexed(int dt, int index, int count, bool apply)
{
if (apply)
{
Apply(dt);
}
else if (mDescriptorsChanged)
BindDescriptorSets();
drawcalls.Clock();
//mCommandBuffer->drawIndexed(count, 1, 0, index * (int)sizeof(uint32_t), 0);
drawcalls.Unclock();
@ -116,8 +126,9 @@ void VkRenderState::EnableLineSmooth(bool on)
void VkRenderState::Apply(int dt)
{
#if 0
auto fb = GetVulkanFrameBuffer();
auto passManager = fb->GetRenderPassManager();
auto passSetup = passManager->RenderPassSetup.get();
bool changingRenderPass = false; // To do: decide if the state matches current bound renderpass
@ -134,16 +145,57 @@ void VkRenderState::Apply(int dt)
if (changingRenderPass)
{
RenderPassBegin beginInfo;
beginInfo.setRenderPass(renderPass);
beginInfo.setRenderPass(passSetup->RenderPass.get());
beginInfo.setRenderArea(0, 0, SCREENWIDTH, SCREENHEIGHT);
beginInfo.setFramebuffer(framebuffer);
beginInfo.setFramebuffer(passSetup->Framebuffer.get());
beginInfo.addClearColor(0.0f, 0.0f, 0.0f, 1.0f);
beginInfo.addClearDepthStencil(0.0f, 0);
mCommandBuffer->beginRenderPass(beginInfo);
mCommandBuffer->bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
mCommandBuffer->bindPipeline(VK_PIPELINE_BIND_POINT_GRAPHICS, passSetup->Pipeline.get());
}
// To do: maybe only push the subset that changed?
mCommandBuffer->pushConstants(pipelineLayout, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, (uint32_t)sizeof(PushConstants), &mPushConstants);
#endif
static_assert(sizeof(PushConstants) % 16 == 0, "std140 layouts must be 16 byte aligned");
//mCommandBuffer->pushConstants(passManager->PipelineLayout.get(), VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, (uint32_t)sizeof(PushConstants), &mPushConstants);
VkBuffer vertexBuffers[] = { static_cast<VKVertexBuffer*>(mVertexBuffer)->mBuffer->buffer };
VkDeviceSize offsets[] = { 0 };
mCommandBuffer->bindVertexBuffers(0, 1, vertexBuffers, offsets);
mCommandBuffer->bindIndexBuffer(static_cast<VKIndexBuffer*>(mIndexBuffer)->mBuffer->buffer, 0, VK_INDEX_TYPE_UINT32);
BindDescriptorSets();
}
void VkRenderState::Bind(int bindingpoint, uint32_t offset)
{
if (bindingpoint == VIEWPOINT_BINDINGPOINT)
{
mViewpointOffset = offset;
}
else if (bindingpoint == LIGHTBUF_BINDINGPOINT)
{
mLightBufferOffset = offset;
}
mDescriptorsChanged = true;
}
void VkRenderState::BindDescriptorSets()
{
auto fb = GetVulkanFrameBuffer();
auto passManager = fb->GetRenderPassManager();
uint32_t offsets[2] = { mViewpointOffset, mLightBufferOffset };
mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->PipelineLayout.get(), 0, passManager->DynamicSet.get(), 2, offsets);
mDescriptorsChanged = false;
}
void VkRenderState::EndRenderPass()
{
if (mCommandBuffer)
{
mCommandBuffer->endRenderPass();
mCommandBuffer = nullptr;
}
}

10
src/rendering/vulkan/renderer/vk_renderstate.h
View file

@ -13,6 +13,8 @@
class VkRenderState : public FRenderState
{
public:
VkRenderState();
// Draw commands
void ClearScreen() override;
void Draw(int dt, int index, int count, bool apply = true) override;
@ -36,10 +38,18 @@ public:
void EnableMultisampling(bool on) override;
void EnableLineSmooth(bool on) override;
void Bind(int bindingpoint, uint32_t offset);
void EndRenderPass();
private:
void Apply(int dt);
void BindDescriptorSets();
bool mLastDepthClamp = true;
VulkanCommandBuffer *mCommandBuffer = nullptr;
PushConstants mPushConstants;
bool mDescriptorsChanged = true;
uint32_t mViewpointOffset = 0, mLastViewpointOffset = 0;
uint32_t mLightBufferOffset = 0, mLastLightBufferOffset = 0;
};