zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-15 09:01:24 +00:00
Code Issues Projects Releases Packages Wiki 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
parent fbfcc30d00
commit 9ed1c7f40b
15 changed files with 360 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/CMakeLists.txt
View file

@ -900,6 +900,7 @@ set( FASTMATH_SOURCES
rendering/vulkan/system/vk_framebuffer.cpp
rendering/vulkan/system/vk_buffers.cpp
rendering/vulkan/renderer/vk_renderstate.cpp
rendering/vulkan/renderer/vk_renderpass.cpp
rendering/vulkan/shaders/vk_shader.cpp
rendering/vulkan/textures/vk_samplers.cpp
rendering/vulkan/textures/vk_hwtexture.cpp

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;
};

28
src/rendering/vulkan/shaders/vk_shader.cpp
View file

@ -48,19 +48,24 @@ static const char *shaderBindings = R"(
// textures
layout(set = 1, binding = 0) uniform sampler2D tex;
layout(set = 1, binding = 1) uniform sampler2D texture2;
layout(set = 1, binding = 2) uniform sampler2D texture3;
layout(set = 1, binding = 3) uniform sampler2D texture4;
layout(set = 1, binding = 4) uniform sampler2D texture5;
layout(set = 1, binding = 5) uniform sampler2D texture6;
layout(set = 1, binding = 16) uniform sampler2D ShadowMap;
// layout(set = 1, binding = 1) uniform sampler2D texture2;
// layout(set = 1, binding = 2) uniform sampler2D texture3;
// layout(set = 1, binding = 3) uniform sampler2D texture4;
// layout(set = 1, binding = 4) uniform sampler2D texture5;
// layout(set = 1, binding = 5) uniform sampler2D texture6;
// layout(set = 1, binding = 16) uniform sampler2D ShadowMap;
// This must match the PushConstants struct
layout(push_constant, std140) uniform PushConstants
{
// matrices
mat4 ModelMatrix;
mat4 NormalModelMatrix;
mat4 TextureMatrix;
int uTextureMode;
vec2 uClipSplit;
float uAlphaThreshold;
vec2 uClipSplit;
// colors
vec4 uObjectColor;
@ -70,6 +75,7 @@ static const char *shaderBindings = R"(
vec4 uFogColor;
float uDesaturationFactor;
float uInterpolationFactor;
float padding0, padding1;
// Glowing walls stuff
vec4 uGlowTopPlane;
@ -95,11 +101,6 @@ static const char *shaderBindings = R"(
// Blinn glossiness and specular level
vec2 uSpecularMaterial;
// matrices
mat4 ModelMatrix;
mat4 NormalModelMatrix;
mat4 TextureMatrix;
};
// material types
@ -117,10 +118,9 @@ static const char *shaderBindings = R"(
#define brighttexture texture2
#endif
#define SUPPORTS_SHADOWMAPS
// #define SUPPORTS_SHADOWMAPS
)";
std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(const char *vert_lump, const char *defines)
{
FString code = GetTargetGlslVersion();

13
src/rendering/vulkan/shaders/vk_shader.h
View file

@ -10,9 +10,14 @@ class VulkanShader;
struct PushConstants
{
// matrices
VSMatrix ModelMatrix;
VSMatrix NormalModelMatrix;
VSMatrix TextureMatrix;
int uTextureMode;
FVector2 uClipSplit;
float uAlphaThreshold;
FVector2 uClipSplit;
// colors
FVector4 uObjectColor;
@ -22,6 +27,7 @@ struct PushConstants
FVector4 uFogColor;
float uDesaturationFactor;
float uInterpolationFactor;
float padding0, padding1;
// Glowing walls stuff
FVector4 uGlowTopPlane;
@ -47,11 +53,6 @@ struct PushConstants
// Blinn glossiness and specular level
FVector2 uSpecularMaterial;
// matrices
VSMatrix ModelMatrix;
VSMatrix NormalModelMatrix;
VSMatrix TextureMatrix;
};
class VkShaderManager

3
src/rendering/vulkan/system/vk_buffers.cpp
View file

@ -2,6 +2,7 @@
#include "vk_buffers.h"
#include "vk_builders.h"
#include "vk_framebuffer.h"
#include "vulkan/renderer/vk_renderstate.h"
#include "doomerrors.h"
void VKBuffer::SetData(size_t size, const void *data, bool staticdata)
@ -112,8 +113,10 @@ void VKVertexBuffer::SetFormat(int numBindingPoints, int numAttributes, size_t s
void VKDataBuffer::BindRange(size_t start, size_t length)
{
GetVulkanFrameBuffer()->GetRenderState()->Bind(bindingpoint, (uint32_t)start);
}
void VKDataBuffer::BindBase()
{
GetVulkanFrameBuffer()->GetRenderState()->Bind(bindingpoint, 0);
}

2
src/rendering/vulkan/system/vk_builders.cpp
View file

@ -170,7 +170,7 @@ std::unique_ptr<VulkanShader> ShaderBuilder::create(VulkanDevice *device)
VkShaderModuleCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = spirv.size();
createInfo.codeSize = spirv.size() * sizeof(unsigned int);
createInfo.pCode = spirv.data();
VkShaderModule shaderModule;

41
src/rendering/vulkan/system/vk_builders.h
View file

@ -285,10 +285,8 @@ private:
class WriteDescriptors
{
public:
void addUniformBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer);
void addUniformBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer, size_t offset, size_t range);
void addStorageBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer);
void addStorageBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer, size_t offset, size_t range);
void addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer);
void addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer, size_t offset, size_t range);
void addStorageImage(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VkImageLayout imageLayout);
void addCombinedImageSampler(VulkanDescriptorSet *descriptorSet, int binding, VulkanImageView *view, VulkanSampler *sampler, VkImageLayout imageLayout);
@ -1041,12 +1039,12 @@ inline void PipelineBarrier::execute(VulkanCommandBuffer *commandBuffer, VkPipel
/////////////////////////////////////////////////////////////////////////////
inline void WriteDescriptors::addUniformBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer)
inline void WriteDescriptors::addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer)
{
addUniformBuffer(descriptorSet, binding, buffer, 0, buffer->size);
addBuffer(descriptorSet, binding, type, buffer, 0, buffer->size);
}
inline void WriteDescriptors::addUniformBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer, size_t offset, size_t range)
inline void WriteDescriptors::addBuffer(VulkanDescriptorSet *descriptorSet, int binding, VkDescriptorType type, VulkanBuffer *buffer, size_t offset, size_t range)
{
VkDescriptorBufferInfo bufferInfo = {};
bufferInfo.buffer = buffer->buffer;
@ -1061,34 +1059,7 @@ inline void WriteDescriptors::addUniformBuffer(VulkanDescriptorSet *descriptorSe
descriptorWrite.dstSet = descriptorSet->set;
descriptorWrite.dstBinding = binding;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &extra->bufferInfo;
writes.push_back(descriptorWrite);
writeExtras.push_back(std::move(extra));
}
inline void WriteDescriptors::addStorageBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer)
{
addStorageBuffer(descriptorSet, binding, buffer, 0, buffer->size);
}
inline void WriteDescriptors::addStorageBuffer(VulkanDescriptorSet *descriptorSet, int binding, VulkanBuffer *buffer, size_t offset, size_t range)
{
VkDescriptorBufferInfo bufferInfo = {};
bufferInfo.buffer = buffer->buffer;
bufferInfo.offset = offset;
bufferInfo.range = range;
auto extra = std::make_unique<WriteExtra>();
extra->bufferInfo = bufferInfo;
VkWriteDescriptorSet descriptorWrite = {};
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrite.dstSet = descriptorSet->set;
descriptorWrite.dstBinding = binding;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
descriptorWrite.descriptorType = type;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &extra->bufferInfo;
writes.push_back(descriptorWrite);

35
src/rendering/vulkan/system/vk_device.cpp
View file

@ -127,6 +127,8 @@ void VulkanDevice::presentFrame()
vkQueuePresentKHR(presentQueue, &presentInfo);
}
//FString allVulkanOutput;
VkBool32 VulkanDevice::debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* callbackData, void* userData)
{
VulkanDevice *device = (VulkanDevice*)userData;
@ -143,6 +145,8 @@ VkBool32 VulkanDevice::debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT mess
Printf("Vulkan validation layer %s: %s\n", prefix, callbackData->pMessage);
//allVulkanOutput.AppendFormat("Vulkan validation layer %s: %s\n", prefix, callbackData->pMessage);
return VK_FALSE;
}
@ -178,7 +182,6 @@ void VulkanDevice::createInstance()
if (layer.layerName == debugLayer)
{
validationLayers.push_back(debugLayer.c_str());
//enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
enabledExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
debugLayerFound = true;
}
@ -203,23 +206,20 @@ void VulkanDevice::createInstance()
{
VkDebugUtilsMessengerCreateInfoEXT createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
createInfo.messageSeverity =
//VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
//VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
createInfo.messageType =
VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
createInfo.pfnUserCallback = debugCallback;
createInfo.pUserData = this;
result = vkCreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger);
if (result != VK_SUCCESS)
throw std::runtime_error("vkCreateDebugUtilsMessengerEXT failed");
/*
VkDebugReportCallbackCreateInfoEXT createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
createInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
createInfo.pfnCallback = debugCallback;
result = vkCreateDebugReportCallbackEXT(instance, &createInfo, nullptr, &vkCallback);
if (result != VK_SUCCESS)
throw std::runtime_error("vkCreateDebugReportCallbackEXT failed");
*/
}
}
@ -397,15 +397,15 @@ void VulkanDevice::releaseResources()
if (device)
vkDeviceWaitIdle(device);
if (!imageAvailableSemaphore)
if (imageAvailableSemaphore)
vkDestroySemaphore(device, imageAvailableSemaphore, nullptr);
imageAvailableSemaphore = 0;
if (!renderFinishedSemaphore)
if (renderFinishedSemaphore)
vkDestroySemaphore(device, renderFinishedSemaphore, nullptr);
renderFinishedSemaphore = 0;
if (!renderFinishedFence)
if (renderFinishedFence)
vkDestroyFence(device, renderFinishedFence, nullptr);
renderFinishedFence = 0;
@ -419,6 +419,9 @@ void VulkanDevice::releaseResources()
vkDestroySurfaceKHR(instance, surface, nullptr);
surface = 0;
if (debugMessenger)
vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
if (instance)
vkDestroyInstance(instance, nullptr);
instance = nullptr;

2
src/rendering/vulkan/system/vk_device.h
View file

@ -54,7 +54,7 @@ private:
void createSemaphores();
void releaseResources();
VkDebugUtilsMessengerEXT debugMessenger;
VkDebugUtilsMessengerEXT debugMessenger = VK_NULL_HANDLE;
static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData);
std::vector<const char *> requiredExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };

18
src/rendering/vulkan/system/vk_framebuffer.cpp
View file

@ -34,11 +34,13 @@
#include "hwrenderer/scene/hw_skydome.h"
#include "hwrenderer/data/hw_viewpointbuffer.h"
#include "hwrenderer/data/flatvertices.h"
#include "hwrenderer/data/shaderuniforms.h"
#include "hwrenderer/dynlights/hw_lightbuffer.h"
#include "vk_framebuffer.h"
#include "vk_buffers.h"
#include "vulkan/renderer/vk_renderstate.h"
#include "vulkan/renderer/vk_renderpass.h"
#include "vulkan/shaders/vk_shader.h"
#include "vulkan/textures/vk_samplers.h"
#include "vulkan/system/vk_builders.h"
@ -73,6 +75,7 @@ void VulkanFrameBuffer::InitializeState()
mShaderManager.reset(new VkShaderManager(device));
mSamplerManager.reset(new VkSamplerManager(device));
mRenderPassManager.reset(new VkRenderPassManager());
mRenderState.reset(new VkRenderState());
}
@ -99,6 +102,9 @@ void VulkanFrameBuffer::Update()
Draw2D();
Clear2D();
mRenderState->EndRenderPass();
//DrawPresentTexture(mOutputLetterbox, true);
mPresentCommands->end();
@ -194,7 +200,16 @@ IIndexBuffer *VulkanFrameBuffer::CreateIndexBuffer()
IDataBuffer *VulkanFrameBuffer::CreateDataBuffer(int bindingpoint, bool ssbo)
{
return new VKDataBuffer(bindingpoint, ssbo);
auto buffer = new VKDataBuffer(bindingpoint, ssbo);
if (bindingpoint == VIEWPOINT_BINDINGPOINT)
{
ViewpointUBO = buffer;
}
else if (bindingpoint == LIGHTBUF_BINDINGPOINT)
{
LightBufferSSO = buffer;
}
return buffer;
}
void VulkanFrameBuffer::UnbindTexUnit(int no)
@ -215,6 +230,7 @@ void VulkanFrameBuffer::UpdatePalette()
void VulkanFrameBuffer::BeginFrame()
{
mRenderPassManager->BeginFrame();
}
void VulkanFrameBuffer::Draw2D()

9
src/rendering/vulkan/system/vk_framebuffer.h
View file

@ -6,7 +6,9 @@
class VkSamplerManager;
class VkShaderManager;
class VkRenderPassManager;
class VkRenderState;
class VKDataBuffer;
class VulkanFrameBuffer : public SystemBaseFrameBuffer
{
@ -18,6 +20,12 @@ public:
VulkanCommandBuffer *GetUploadCommands();
VulkanCommandBuffer *GetDrawCommands();
VkShaderManager *GetShaderManager() { return mShaderManager.get(); }
VkRenderPassManager *GetRenderPassManager() { return mRenderPassManager.get(); }
VkRenderState *GetRenderState() { return mRenderState.get(); }
VKDataBuffer *ViewpointUBO = nullptr;
VKDataBuffer *LightBufferSSO = nullptr;
VulkanFrameBuffer(void *hMonitor, bool fullscreen, VulkanDevice *dev);
~VulkanFrameBuffer();
@ -56,6 +64,7 @@ public:
private:
std::unique_ptr<VkShaderManager> mShaderManager;
std::unique_ptr<VkSamplerManager> mSamplerManager;
std::unique_ptr<VkRenderPassManager> mRenderPassManager;
std::unique_ptr<VulkanCommandPool> mGraphicsCommandPool;
std::unique_ptr<VulkanCommandBuffer> mUploadCommands;
std::unique_ptr<VulkanCommandBuffer> mPresentCommands;

6
src/rendering/vulkan/system/vk_objects.h
View file

@ -229,7 +229,7 @@ public:
void setStencilCompareMask(VkStencilFaceFlags faceMask, uint32_t compareMask);
void setStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask);
void setStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
void bindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VulkanPipelineLayout *layout, VulkanDescriptorSet *descriptorSet, uint32_t dynamicOffsetCount = 0, const uint32_t* pDynamicOffsets = nullptr);
void bindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VulkanPipelineLayout *layout, uint32_t setIndex, VulkanDescriptorSet *descriptorSet, uint32_t dynamicOffsetCount = 0, const uint32_t* pDynamicOffsets = nullptr);
void bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
void bindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
@ -545,9 +545,9 @@ inline void VulkanCommandBuffer::setStencilReference(VkStencilFaceFlags faceMask
vkCmdSetStencilReference(buffer, faceMask, reference);
}
inline void VulkanCommandBuffer::bindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VulkanPipelineLayout *layout, VulkanDescriptorSet *descriptorSet, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
inline void VulkanCommandBuffer::bindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VulkanPipelineLayout *layout, uint32_t setIndex, VulkanDescriptorSet *descriptorSet, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
bindDescriptorSets(pipelineBindPoint, layout->layout, 0, 1, &descriptorSet->set, dynamicOffsetCount, pDynamicOffsets);
bindDescriptorSets(pipelineBindPoint, layout->layout, setIndex, 1, &descriptorSet->set, dynamicOffsetCount, pDynamicOffsets);
}
inline void VulkanCommandBuffer::bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)