mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 22:09:19 -07:00
756 lines
26 KiB
C++
756 lines
26 KiB
C++
// Copyright 2016 Dolphin Emulator Project
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "Common/Assert.h"
|
|
#include "Common/CommonFuncs.h"
|
|
#include "Common/MathUtil.h"
|
|
|
|
#include "VideoBackends/Vulkan/CommandBufferManager.h"
|
|
#include "VideoBackends/Vulkan/ObjectCache.h"
|
|
#include "VideoBackends/Vulkan/Renderer.h"
|
|
#include "VideoBackends/Vulkan/ShaderCompiler.h"
|
|
#include "VideoBackends/Vulkan/StateTracker.h"
|
|
#include "VideoBackends/Vulkan/StreamBuffer.h"
|
|
#include "VideoBackends/Vulkan/Util.h"
|
|
#include "VideoBackends/Vulkan/VulkanContext.h"
|
|
|
|
namespace Vulkan
|
|
{
|
|
namespace Util
|
|
{
|
|
size_t AlignValue(size_t value, size_t alignment)
|
|
{
|
|
// Have to use mod rather than masking bits in case alignment is not a power of two.
|
|
size_t offset = value % alignment;
|
|
if (offset != 0)
|
|
value += (alignment - offset);
|
|
return value;
|
|
}
|
|
|
|
size_t AlignBufferOffset(size_t offset, size_t alignment)
|
|
{
|
|
// Assume an offset of zero is already aligned to a value larger than alignment.
|
|
if (offset == 0)
|
|
return 0;
|
|
|
|
return AlignValue(offset, alignment);
|
|
}
|
|
|
|
u32 MakeRGBA8Color(float r, float g, float b, float a)
|
|
{
|
|
return (static_cast<u32>(MathUtil::Clamp(static_cast<int>(r * 255.0f), 0, 255)) << 0) |
|
|
(static_cast<u32>(MathUtil::Clamp(static_cast<int>(g * 255.0f), 0, 255)) << 8) |
|
|
(static_cast<u32>(MathUtil::Clamp(static_cast<int>(b * 255.0f), 0, 255)) << 16) |
|
|
(static_cast<u32>(MathUtil::Clamp(static_cast<int>(a * 255.0f), 0, 255)) << 24);
|
|
}
|
|
|
|
bool IsDepthFormat(VkFormat format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case VK_FORMAT_D16_UNORM:
|
|
case VK_FORMAT_D16_UNORM_S8_UINT:
|
|
case VK_FORMAT_D24_UNORM_S8_UINT:
|
|
case VK_FORMAT_D32_SFLOAT:
|
|
case VK_FORMAT_D32_SFLOAT_S8_UINT:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
VkFormat GetLinearFormat(VkFormat format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case VK_FORMAT_R8_SRGB:
|
|
return VK_FORMAT_R8_UNORM;
|
|
case VK_FORMAT_R8G8_SRGB:
|
|
return VK_FORMAT_R8G8_UNORM;
|
|
case VK_FORMAT_R8G8B8_SRGB:
|
|
return VK_FORMAT_R8G8B8_UNORM;
|
|
case VK_FORMAT_R8G8B8A8_SRGB:
|
|
return VK_FORMAT_R8G8B8A8_UNORM;
|
|
case VK_FORMAT_B8G8R8_SRGB:
|
|
return VK_FORMAT_B8G8R8_UNORM;
|
|
case VK_FORMAT_B8G8R8A8_SRGB:
|
|
return VK_FORMAT_B8G8R8A8_UNORM;
|
|
default:
|
|
return format;
|
|
}
|
|
}
|
|
|
|
u32 GetTexelSize(VkFormat format)
|
|
{
|
|
// Only contains pixel formats we use.
|
|
switch (format)
|
|
{
|
|
case VK_FORMAT_R32_SFLOAT:
|
|
return 4;
|
|
|
|
case VK_FORMAT_D32_SFLOAT:
|
|
return 4;
|
|
|
|
case VK_FORMAT_R8G8B8A8_UNORM:
|
|
return 4;
|
|
|
|
case VK_FORMAT_B8G8R8A8_UNORM:
|
|
return 4;
|
|
|
|
default:
|
|
PanicAlert("Unhandled pixel format");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
VkBlendFactor GetAlphaBlendFactor(VkBlendFactor factor)
|
|
{
|
|
switch (factor)
|
|
{
|
|
case VK_BLEND_FACTOR_SRC_COLOR:
|
|
return VK_BLEND_FACTOR_SRC_ALPHA;
|
|
case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
|
|
return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
case VK_BLEND_FACTOR_DST_COLOR:
|
|
return VK_BLEND_FACTOR_DST_ALPHA;
|
|
case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
|
|
return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
|
|
default:
|
|
return factor;
|
|
}
|
|
}
|
|
|
|
RasterizationState GetNoCullRasterizationState()
|
|
{
|
|
RasterizationState state = {};
|
|
state.cull_mode = VK_CULL_MODE_NONE;
|
|
state.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
state.per_sample_shading = VK_FALSE;
|
|
state.depth_clamp = VK_FALSE;
|
|
return state;
|
|
}
|
|
|
|
DepthStencilState GetNoDepthTestingDepthStencilState()
|
|
{
|
|
DepthStencilState state = {};
|
|
state.test_enable = VK_FALSE;
|
|
state.write_enable = VK_FALSE;
|
|
state.compare_op = VK_COMPARE_OP_ALWAYS;
|
|
return state;
|
|
}
|
|
|
|
BlendState GetNoBlendingBlendState()
|
|
{
|
|
BlendState state = {};
|
|
state.blend_enable = VK_FALSE;
|
|
state.blend_op = VK_BLEND_OP_ADD;
|
|
state.src_blend = VK_BLEND_FACTOR_ONE;
|
|
state.dst_blend = VK_BLEND_FACTOR_ZERO;
|
|
state.alpha_blend_op = VK_BLEND_OP_ADD;
|
|
state.src_alpha_blend = VK_BLEND_FACTOR_ONE;
|
|
state.dst_alpha_blend = VK_BLEND_FACTOR_ZERO;
|
|
state.logic_op_enable = VK_FALSE;
|
|
state.logic_op = VK_LOGIC_OP_CLEAR;
|
|
state.write_mask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
|
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
|
return state;
|
|
}
|
|
|
|
void SetViewportAndScissor(VkCommandBuffer command_buffer, int x, int y, int width, int height,
|
|
float min_depth /*= 0.0f*/, float max_depth /*= 1.0f*/)
|
|
{
|
|
VkViewport viewport = {static_cast<float>(x),
|
|
static_cast<float>(y),
|
|
static_cast<float>(width),
|
|
static_cast<float>(height),
|
|
min_depth,
|
|
max_depth};
|
|
|
|
VkRect2D scissor = {{x, y}, {static_cast<uint32_t>(width), static_cast<uint32_t>(height)}};
|
|
|
|
vkCmdSetViewport(command_buffer, 0, 1, &viewport);
|
|
vkCmdSetScissor(command_buffer, 0, 1, &scissor);
|
|
}
|
|
|
|
void BufferMemoryBarrier(VkCommandBuffer command_buffer, VkBuffer buffer,
|
|
VkAccessFlags src_access_mask, VkAccessFlags dst_access_mask,
|
|
VkDeviceSize offset, VkDeviceSize size,
|
|
VkPipelineStageFlags src_stage_mask, VkPipelineStageFlags dst_stage_mask)
|
|
{
|
|
VkBufferMemoryBarrier buffer_info = {
|
|
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType
|
|
nullptr, // const void* pNext
|
|
src_access_mask, // VkAccessFlags srcAccessMask
|
|
dst_access_mask, // VkAccessFlags dstAccessMask
|
|
VK_QUEUE_FAMILY_IGNORED, // uint32_t srcQueueFamilyIndex
|
|
VK_QUEUE_FAMILY_IGNORED, // uint32_t dstQueueFamilyIndex
|
|
buffer, // VkBuffer buffer
|
|
offset, // VkDeviceSize offset
|
|
size // VkDeviceSize size
|
|
};
|
|
|
|
vkCmdPipelineBarrier(command_buffer, src_stage_mask, dst_stage_mask, 0, 0, nullptr, 1,
|
|
&buffer_info, 0, nullptr);
|
|
}
|
|
|
|
void ExecuteCurrentCommandsAndRestoreState(StateTracker* state_tracker, bool execute_off_thread,
|
|
bool wait_for_completion)
|
|
{
|
|
state_tracker->EndRenderPass();
|
|
g_command_buffer_mgr->ExecuteCommandBuffer(execute_off_thread, wait_for_completion);
|
|
state_tracker->InvalidateDescriptorSets();
|
|
state_tracker->SetPendingRebind();
|
|
}
|
|
|
|
VkShaderModule CreateShaderModule(const u32* spv, size_t spv_word_count)
|
|
{
|
|
VkShaderModuleCreateInfo info = {};
|
|
info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
|
|
info.codeSize = spv_word_count * sizeof(u32);
|
|
info.pCode = spv;
|
|
|
|
VkShaderModule module;
|
|
VkResult res = vkCreateShaderModule(g_vulkan_context->GetDevice(), &info, nullptr, &module);
|
|
if (res != VK_SUCCESS)
|
|
{
|
|
LOG_VULKAN_ERROR(res, "vkCreateShaderModule failed: ");
|
|
return VK_NULL_HANDLE;
|
|
}
|
|
|
|
return module;
|
|
}
|
|
|
|
VkShaderModule CompileAndCreateVertexShader(const std::string& source_code, bool prepend_header)
|
|
{
|
|
ShaderCompiler::SPIRVCodeVector code;
|
|
if (!ShaderCompiler::CompileVertexShader(&code, source_code.c_str(), source_code.length(),
|
|
prepend_header))
|
|
{
|
|
return VK_NULL_HANDLE;
|
|
}
|
|
|
|
return CreateShaderModule(code.data(), code.size());
|
|
}
|
|
|
|
VkShaderModule CompileAndCreateGeometryShader(const std::string& source_code, bool prepend_header)
|
|
{
|
|
ShaderCompiler::SPIRVCodeVector code;
|
|
if (!ShaderCompiler::CompileGeometryShader(&code, source_code.c_str(), source_code.length(),
|
|
prepend_header))
|
|
{
|
|
return VK_NULL_HANDLE;
|
|
}
|
|
|
|
return CreateShaderModule(code.data(), code.size());
|
|
}
|
|
|
|
VkShaderModule CompileAndCreateFragmentShader(const std::string& source_code, bool prepend_header)
|
|
{
|
|
ShaderCompiler::SPIRVCodeVector code;
|
|
if (!ShaderCompiler::CompileFragmentShader(&code, source_code.c_str(), source_code.length(),
|
|
prepend_header))
|
|
{
|
|
return VK_NULL_HANDLE;
|
|
}
|
|
|
|
return CreateShaderModule(code.data(), code.size());
|
|
}
|
|
|
|
} // namespace Util
|
|
|
|
template <>
|
|
DeferredResourceDestruction
|
|
DeferredResourceDestruction::Wrapper<VkCommandPool>(VkCommandPool object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.command_pool = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyCommandPool(device, obj.command_pool, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction
|
|
DeferredResourceDestruction::Wrapper<VkDeviceMemory>(VkDeviceMemory object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.device_memory = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkFreeMemory(device, obj.device_memory, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkBuffer>(VkBuffer object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.buffer = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyBuffer(device, obj.buffer, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkBufferView>(VkBufferView object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.buffer_view = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyBufferView(device, obj.buffer_view, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkImage>(VkImage object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.image = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyImage(device, obj.image, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkImageView>(VkImageView object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.image_view = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyImageView(device, obj.image_view, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkRenderPass>(VkRenderPass object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.render_pass = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyRenderPass(device, obj.render_pass, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction
|
|
DeferredResourceDestruction::Wrapper<VkFramebuffer>(VkFramebuffer object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.framebuffer = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyFramebuffer(device, obj.framebuffer, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction
|
|
DeferredResourceDestruction::Wrapper<VkShaderModule>(VkShaderModule object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.shader_module = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyShaderModule(device, obj.shader_module, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
template <>
|
|
DeferredResourceDestruction DeferredResourceDestruction::Wrapper<VkPipeline>(VkPipeline object)
|
|
{
|
|
DeferredResourceDestruction ret;
|
|
ret.object.pipeline = object;
|
|
ret.destroy_callback = [](VkDevice device, const Object& obj) {
|
|
vkDestroyPipeline(device, obj.pipeline, nullptr);
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
UtilityShaderDraw::UtilityShaderDraw(VkCommandBuffer command_buffer,
|
|
VkPipelineLayout pipeline_layout, VkRenderPass render_pass,
|
|
VkShaderModule vertex_shader, VkShaderModule geometry_shader,
|
|
VkShaderModule pixel_shader)
|
|
: m_command_buffer(command_buffer)
|
|
{
|
|
// Populate minimal pipeline state
|
|
m_pipeline_info.vertex_format = g_object_cache->GetUtilityShaderVertexFormat();
|
|
m_pipeline_info.pipeline_layout = pipeline_layout;
|
|
m_pipeline_info.render_pass = render_pass;
|
|
m_pipeline_info.vs = vertex_shader;
|
|
m_pipeline_info.gs = geometry_shader;
|
|
m_pipeline_info.ps = pixel_shader;
|
|
m_pipeline_info.rasterization_state.bits = Util::GetNoCullRasterizationState().bits;
|
|
m_pipeline_info.depth_stencil_state.bits = Util::GetNoDepthTestingDepthStencilState().bits;
|
|
m_pipeline_info.blend_state.bits = Util::GetNoBlendingBlendState().bits;
|
|
m_pipeline_info.primitive_topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
}
|
|
|
|
UtilityShaderVertex* UtilityShaderDraw::ReserveVertices(VkPrimitiveTopology topology, size_t count)
|
|
{
|
|
m_pipeline_info.primitive_topology = topology;
|
|
|
|
if (!g_object_cache->GetUtilityShaderVertexBuffer()->ReserveMemory(
|
|
sizeof(UtilityShaderVertex) * count, sizeof(UtilityShaderVertex), true, true, true))
|
|
PanicAlert("Failed to allocate space for vertices in backend shader");
|
|
|
|
m_vertex_buffer = g_object_cache->GetUtilityShaderVertexBuffer()->GetBuffer();
|
|
m_vertex_buffer_offset = g_object_cache->GetUtilityShaderVertexBuffer()->GetCurrentOffset();
|
|
|
|
return reinterpret_cast<UtilityShaderVertex*>(
|
|
g_object_cache->GetUtilityShaderVertexBuffer()->GetCurrentHostPointer());
|
|
}
|
|
|
|
void UtilityShaderDraw::CommitVertices(size_t count)
|
|
{
|
|
g_object_cache->GetUtilityShaderVertexBuffer()->CommitMemory(sizeof(UtilityShaderVertex) * count);
|
|
m_vertex_count = static_cast<uint32_t>(count);
|
|
}
|
|
|
|
void UtilityShaderDraw::UploadVertices(VkPrimitiveTopology topology, UtilityShaderVertex* vertices,
|
|
size_t count)
|
|
{
|
|
UtilityShaderVertex* upload_vertices = ReserveVertices(topology, count);
|
|
memcpy(upload_vertices, vertices, sizeof(UtilityShaderVertex) * count);
|
|
CommitVertices(count);
|
|
}
|
|
|
|
u8* UtilityShaderDraw::AllocateVSUniforms(size_t size)
|
|
{
|
|
if (!g_object_cache->GetUtilityShaderUniformBuffer()->ReserveMemory(
|
|
size, g_vulkan_context->GetUniformBufferAlignment(), true, true, true))
|
|
PanicAlert("Failed to allocate util uniforms");
|
|
|
|
return g_object_cache->GetUtilityShaderUniformBuffer()->GetCurrentHostPointer();
|
|
}
|
|
|
|
void UtilityShaderDraw::CommitVSUniforms(size_t size)
|
|
{
|
|
m_vs_uniform_buffer.buffer = g_object_cache->GetUtilityShaderUniformBuffer()->GetBuffer();
|
|
m_vs_uniform_buffer.offset = 0;
|
|
m_vs_uniform_buffer.range = size;
|
|
m_ubo_offsets[UBO_DESCRIPTOR_SET_BINDING_VS] =
|
|
static_cast<uint32_t>(g_object_cache->GetUtilityShaderUniformBuffer()->GetCurrentOffset());
|
|
|
|
g_object_cache->GetUtilityShaderUniformBuffer()->CommitMemory(size);
|
|
}
|
|
|
|
u8* UtilityShaderDraw::AllocatePSUniforms(size_t size)
|
|
{
|
|
if (!g_object_cache->GetUtilityShaderUniformBuffer()->ReserveMemory(
|
|
size, g_vulkan_context->GetUniformBufferAlignment(), true, true, true))
|
|
PanicAlert("Failed to allocate util uniforms");
|
|
|
|
return g_object_cache->GetUtilityShaderUniformBuffer()->GetCurrentHostPointer();
|
|
}
|
|
|
|
void UtilityShaderDraw::CommitPSUniforms(size_t size)
|
|
{
|
|
m_ps_uniform_buffer.buffer = g_object_cache->GetUtilityShaderUniformBuffer()->GetBuffer();
|
|
m_ps_uniform_buffer.offset = 0;
|
|
m_ps_uniform_buffer.range = size;
|
|
m_ubo_offsets[UBO_DESCRIPTOR_SET_BINDING_PS] =
|
|
static_cast<uint32_t>(g_object_cache->GetUtilityShaderUniformBuffer()->GetCurrentOffset());
|
|
|
|
g_object_cache->GetUtilityShaderUniformBuffer()->CommitMemory(size);
|
|
}
|
|
|
|
void UtilityShaderDraw::SetPushConstants(const void* data, size_t data_size)
|
|
{
|
|
_assert_(static_cast<u32>(data_size) < PUSH_CONSTANT_BUFFER_SIZE);
|
|
|
|
vkCmdPushConstants(m_command_buffer, m_pipeline_info.pipeline_layout,
|
|
VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0,
|
|
static_cast<u32>(data_size), data);
|
|
}
|
|
|
|
void UtilityShaderDraw::SetPSSampler(size_t index, VkImageView view, VkSampler sampler)
|
|
{
|
|
m_ps_samplers[index].sampler = sampler;
|
|
m_ps_samplers[index].imageView = view;
|
|
m_ps_samplers[index].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
}
|
|
|
|
void UtilityShaderDraw::SetRasterizationState(const RasterizationState& state)
|
|
{
|
|
m_pipeline_info.rasterization_state.bits = state.bits;
|
|
}
|
|
|
|
void UtilityShaderDraw::SetDepthStencilState(const DepthStencilState& state)
|
|
{
|
|
m_pipeline_info.depth_stencil_state.bits = state.bits;
|
|
}
|
|
|
|
void UtilityShaderDraw::SetBlendState(const BlendState& state)
|
|
{
|
|
m_pipeline_info.blend_state.bits = state.bits;
|
|
}
|
|
|
|
void UtilityShaderDraw::BeginRenderPass(VkFramebuffer framebuffer, const VkRect2D& region,
|
|
const VkClearValue* clear_value)
|
|
{
|
|
VkRenderPassBeginInfo begin_info = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
|
|
nullptr,
|
|
m_pipeline_info.render_pass,
|
|
framebuffer,
|
|
region,
|
|
clear_value ? 1u : 0u,
|
|
clear_value};
|
|
|
|
vkCmdBeginRenderPass(m_command_buffer, &begin_info, VK_SUBPASS_CONTENTS_INLINE);
|
|
}
|
|
|
|
void UtilityShaderDraw::EndRenderPass()
|
|
{
|
|
vkCmdEndRenderPass(m_command_buffer);
|
|
}
|
|
|
|
void UtilityShaderDraw::Draw()
|
|
{
|
|
BindVertexBuffer();
|
|
BindDescriptors();
|
|
if (!BindPipeline())
|
|
return;
|
|
|
|
vkCmdDraw(m_command_buffer, m_vertex_count, 1, 0, 0);
|
|
}
|
|
|
|
void UtilityShaderDraw::DrawQuad(int x, int y, int width, int height, float z)
|
|
{
|
|
UtilityShaderVertex vertices[4];
|
|
vertices[0].SetPosition(-1.0f, 1.0f, z);
|
|
vertices[0].SetTextureCoordinates(0.0f, 1.0f);
|
|
vertices[0].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[1].SetPosition(1.0f, 1.0f, z);
|
|
vertices[1].SetTextureCoordinates(1.0f, 1.0f);
|
|
vertices[1].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[2].SetPosition(-1.0f, -1.0f, z);
|
|
vertices[2].SetTextureCoordinates(0.0f, 0.0f);
|
|
vertices[2].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[3].SetPosition(1.0f, -1.0f, z);
|
|
vertices[3].SetTextureCoordinates(1.0f, 0.0f);
|
|
vertices[3].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
Util::SetViewportAndScissor(m_command_buffer, x, y, width, height);
|
|
UploadVertices(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, vertices, ArraySize(vertices));
|
|
Draw();
|
|
}
|
|
|
|
void UtilityShaderDraw::DrawQuad(int dst_x, int dst_y, int dst_width, int dst_height, int src_x,
|
|
int src_y, int src_layer, int src_width, int src_height,
|
|
int src_full_width, int src_full_height, float z)
|
|
{
|
|
float u0 = float(src_x) / float(src_full_width);
|
|
float v0 = float(src_y) / float(src_full_height);
|
|
float u1 = float(src_x + src_width) / float(src_full_width);
|
|
float v1 = float(src_y + src_height) / float(src_full_height);
|
|
float w = static_cast<float>(src_layer);
|
|
|
|
UtilityShaderVertex vertices[4];
|
|
vertices[0].SetPosition(-1.0f, 1.0f, z);
|
|
vertices[0].SetTextureCoordinates(u0, v1, w);
|
|
vertices[0].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[1].SetPosition(1.0f, 1.0f, z);
|
|
vertices[1].SetTextureCoordinates(u1, v1, w);
|
|
vertices[1].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[2].SetPosition(-1.0f, -1.0f, z);
|
|
vertices[2].SetTextureCoordinates(u0, v0, w);
|
|
vertices[2].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
vertices[3].SetPosition(1.0f, -1.0f, z);
|
|
vertices[3].SetTextureCoordinates(u1, v0, w);
|
|
vertices[3].SetColor(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
Util::SetViewportAndScissor(m_command_buffer, dst_x, dst_y, dst_width, dst_height);
|
|
UploadVertices(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, vertices, ArraySize(vertices));
|
|
Draw();
|
|
}
|
|
|
|
void UtilityShaderDraw::DrawColoredQuad(int x, int y, int width, int height, float r, float g,
|
|
float b, float a, float z)
|
|
{
|
|
return DrawColoredQuad(x, y, width, height, Util::MakeRGBA8Color(r, g, b, a), z);
|
|
}
|
|
|
|
void UtilityShaderDraw::DrawColoredQuad(int x, int y, int width, int height, u32 color, float z)
|
|
{
|
|
UtilityShaderVertex vertices[4];
|
|
vertices[0].SetPosition(-1.0f, 1.0f, z);
|
|
vertices[0].SetTextureCoordinates(0.0f, 1.0f);
|
|
vertices[0].SetColor(color);
|
|
vertices[1].SetPosition(1.0f, 1.0f, z);
|
|
vertices[1].SetTextureCoordinates(1.0f, 1.0f);
|
|
vertices[1].SetColor(color);
|
|
vertices[2].SetPosition(-1.0f, -1.0f, z);
|
|
vertices[2].SetTextureCoordinates(0.0f, 0.0f);
|
|
vertices[2].SetColor(color);
|
|
vertices[3].SetPosition(1.0f, -1.0f, z);
|
|
vertices[3].SetTextureCoordinates(1.0f, 0.0f);
|
|
vertices[3].SetColor(color);
|
|
|
|
Util::SetViewportAndScissor(m_command_buffer, x, y, width, height);
|
|
UploadVertices(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, vertices, ArraySize(vertices));
|
|
Draw();
|
|
}
|
|
|
|
void UtilityShaderDraw::SetViewportAndScissor(int x, int y, int width, int height)
|
|
{
|
|
Util::SetViewportAndScissor(m_command_buffer, x, y, width, height, 0.0f, 1.0f);
|
|
}
|
|
|
|
void UtilityShaderDraw::DrawWithoutVertexBuffer(VkPrimitiveTopology primitive_topology,
|
|
u32 vertex_count)
|
|
{
|
|
m_pipeline_info.vertex_format = nullptr;
|
|
m_pipeline_info.primitive_topology = primitive_topology;
|
|
|
|
BindDescriptors();
|
|
if (!BindPipeline())
|
|
return;
|
|
|
|
vkCmdDraw(m_command_buffer, vertex_count, 1, 0, 0);
|
|
}
|
|
|
|
void UtilityShaderDraw::BindVertexBuffer()
|
|
{
|
|
vkCmdBindVertexBuffers(m_command_buffer, 0, 1, &m_vertex_buffer, &m_vertex_buffer_offset);
|
|
}
|
|
|
|
void UtilityShaderDraw::BindDescriptors()
|
|
{
|
|
// TODO: This method is a mess, clean it up
|
|
std::array<VkDescriptorSet, NUM_DESCRIPTOR_SETS> bind_descriptor_sets = {};
|
|
std::array<VkWriteDescriptorSet, NUM_UBO_DESCRIPTOR_SET_BINDINGS + NUM_PIXEL_SHADER_SAMPLERS>
|
|
set_writes = {};
|
|
uint32_t num_set_writes = 0;
|
|
|
|
VkDescriptorBufferInfo dummy_uniform_buffer = {
|
|
g_object_cache->GetUtilityShaderUniformBuffer()->GetBuffer(), 0, 1};
|
|
|
|
// uniform buffers
|
|
if (m_vs_uniform_buffer.buffer != VK_NULL_HANDLE || m_ps_uniform_buffer.buffer != VK_NULL_HANDLE)
|
|
{
|
|
VkDescriptorSet set = g_command_buffer_mgr->AllocateDescriptorSet(
|
|
g_object_cache->GetDescriptorSetLayout(DESCRIPTOR_SET_UNIFORM_BUFFERS));
|
|
if (set == VK_NULL_HANDLE)
|
|
PanicAlert("Failed to allocate descriptor set for utility draw");
|
|
|
|
set_writes[num_set_writes++] = {
|
|
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, set, UBO_DESCRIPTOR_SET_BINDING_VS, 0, 1,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, nullptr,
|
|
(m_vs_uniform_buffer.buffer != VK_NULL_HANDLE) ? &m_vs_uniform_buffer :
|
|
&dummy_uniform_buffer,
|
|
nullptr};
|
|
|
|
set_writes[num_set_writes++] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
|
nullptr,
|
|
set,
|
|
UBO_DESCRIPTOR_SET_BINDING_GS,
|
|
0,
|
|
1,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
|
|
nullptr,
|
|
&dummy_uniform_buffer,
|
|
nullptr};
|
|
|
|
set_writes[num_set_writes++] = {
|
|
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, nullptr, set, UBO_DESCRIPTOR_SET_BINDING_PS, 0, 1,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, nullptr,
|
|
(m_ps_uniform_buffer.buffer != VK_NULL_HANDLE) ? &m_ps_uniform_buffer :
|
|
&dummy_uniform_buffer,
|
|
nullptr};
|
|
|
|
bind_descriptor_sets[DESCRIPTOR_SET_UNIFORM_BUFFERS] = set;
|
|
}
|
|
|
|
// PS samplers
|
|
size_t first_active_sampler;
|
|
for (first_active_sampler = 0; first_active_sampler < NUM_PIXEL_SHADER_SAMPLERS;
|
|
first_active_sampler++)
|
|
{
|
|
if (m_ps_samplers[first_active_sampler].imageView != VK_NULL_HANDLE &&
|
|
m_ps_samplers[first_active_sampler].sampler != VK_NULL_HANDLE)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check if we have any at all, skip the binding process entirely if we don't
|
|
if (first_active_sampler != NUM_PIXEL_SHADER_SAMPLERS)
|
|
{
|
|
// Allocate a new descriptor set
|
|
VkDescriptorSet set = g_command_buffer_mgr->AllocateDescriptorSet(
|
|
g_object_cache->GetDescriptorSetLayout(DESCRIPTOR_SET_PIXEL_SHADER_SAMPLERS));
|
|
if (set == VK_NULL_HANDLE)
|
|
PanicAlert("Failed to allocate descriptor set for utility draw");
|
|
|
|
for (size_t i = 0; i < NUM_PIXEL_SHADER_SAMPLERS; i++)
|
|
{
|
|
const VkDescriptorImageInfo& info = m_ps_samplers[i];
|
|
if (info.imageView != VK_NULL_HANDLE && info.sampler != VK_NULL_HANDLE)
|
|
{
|
|
set_writes[num_set_writes++] = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
|
nullptr,
|
|
set,
|
|
static_cast<uint32_t>(i),
|
|
0,
|
|
1,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
&info,
|
|
nullptr,
|
|
nullptr};
|
|
}
|
|
}
|
|
|
|
bind_descriptor_sets[DESCRIPTOR_SET_PIXEL_SHADER_SAMPLERS] = set;
|
|
}
|
|
|
|
vkUpdateDescriptorSets(g_vulkan_context->GetDevice(), num_set_writes, set_writes.data(), 0,
|
|
nullptr);
|
|
|
|
// Bind only the sets we updated
|
|
if (bind_descriptor_sets[0] != VK_NULL_HANDLE && bind_descriptor_sets[1] == VK_NULL_HANDLE)
|
|
{
|
|
// UBO only
|
|
vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
m_pipeline_info.pipeline_layout, DESCRIPTOR_SET_UNIFORM_BUFFERS, 1,
|
|
&bind_descriptor_sets[0], NUM_UBO_DESCRIPTOR_SET_BINDINGS,
|
|
m_ubo_offsets.data());
|
|
}
|
|
else if (bind_descriptor_sets[0] == VK_NULL_HANDLE && bind_descriptor_sets[1] != VK_NULL_HANDLE)
|
|
{
|
|
// Samplers only
|
|
vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
m_pipeline_info.pipeline_layout, DESCRIPTOR_SET_PIXEL_SHADER_SAMPLERS,
|
|
1, &bind_descriptor_sets[1], 0, nullptr);
|
|
}
|
|
else if (bind_descriptor_sets[0] != VK_NULL_HANDLE && bind_descriptor_sets[1] != VK_NULL_HANDLE)
|
|
{
|
|
// Both
|
|
vkCmdBindDescriptorSets(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
m_pipeline_info.pipeline_layout, DESCRIPTOR_SET_UNIFORM_BUFFERS, 2,
|
|
bind_descriptor_sets.data(), NUM_UBO_DESCRIPTOR_SET_BINDINGS,
|
|
m_ubo_offsets.data());
|
|
}
|
|
}
|
|
|
|
bool UtilityShaderDraw::BindPipeline()
|
|
{
|
|
VkPipeline pipeline = g_object_cache->GetPipeline(m_pipeline_info);
|
|
if (pipeline == VK_NULL_HANDLE)
|
|
{
|
|
PanicAlert("Failed to get pipeline for backend shader draw");
|
|
return false;
|
|
}
|
|
|
|
vkCmdBindPipeline(m_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
return true;
|
|
}
|
|
|
|
} // namespace Vulkan
|