mirror of
https://github.com/WiVRn/WiVRn.git
synced 2026-11-20 09:01:39 -08:00
807 lines
26 KiB
C++
807 lines
26 KiB
C++
#include "scene_renderer.h"
|
|
#include "application.h"
|
|
#include "spdlog/spdlog.h"
|
|
#include "utils/strings.h"
|
|
|
|
namespace
|
|
{
|
|
VkFormat gltf_to_vkformat(int component, int bits, int pixel_type, bool srgb)
|
|
{
|
|
switch (pixel_type)
|
|
{
|
|
case TINYGLTF_COMPONENT_TYPE_BYTE:
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
assert(bits == 8);
|
|
break;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_SHORT:
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
|
|
assert(bits == 32);
|
|
break;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_INT:
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
|
|
case TINYGLTF_COMPONENT_TYPE_FLOAT:
|
|
assert(bits == 32);
|
|
break;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_DOUBLE:
|
|
assert(bits == 64);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (component)
|
|
{
|
|
case 1:
|
|
switch (pixel_type)
|
|
{
|
|
case TINYGLTF_COMPONENT_TYPE_BYTE:
|
|
return VK_FORMAT_R8_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return srgb ? VK_FORMAT_R8_SRGB : VK_FORMAT_R8_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_SHORT:
|
|
return VK_FORMAT_R16_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return VK_FORMAT_R16_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_INT:
|
|
return VK_FORMAT_R32_SINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
|
|
return VK_FORMAT_R32_UINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_FLOAT:
|
|
return VK_FORMAT_R32_SFLOAT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_DOUBLE:
|
|
return VK_FORMAT_R64_SFLOAT;
|
|
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
case 2:
|
|
switch (pixel_type)
|
|
{
|
|
case TINYGLTF_COMPONENT_TYPE_BYTE:
|
|
return VK_FORMAT_R8G8_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return srgb ? VK_FORMAT_R8G8_SRGB : VK_FORMAT_R8G8_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_SHORT:
|
|
return VK_FORMAT_R16G16_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return VK_FORMAT_R16G16_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_INT:
|
|
return VK_FORMAT_R32G32_SINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
|
|
return VK_FORMAT_R32G32_UINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_FLOAT:
|
|
return VK_FORMAT_R32G32_SFLOAT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_DOUBLE:
|
|
return VK_FORMAT_R64G64_SFLOAT;
|
|
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
case 3:
|
|
switch (pixel_type)
|
|
{
|
|
case TINYGLTF_COMPONENT_TYPE_BYTE:
|
|
return VK_FORMAT_R8G8B8_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return srgb ? VK_FORMAT_R8G8B8_SRGB : VK_FORMAT_R8G8B8_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_SHORT:
|
|
return VK_FORMAT_R16G16B16_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return VK_FORMAT_R16G16B16_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_INT:
|
|
return VK_FORMAT_R32G32B32_SINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
|
|
return VK_FORMAT_R32G32B32_UINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_FLOAT:
|
|
return VK_FORMAT_R32G32B32_SFLOAT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_DOUBLE:
|
|
return VK_FORMAT_R64G64B64_SFLOAT;
|
|
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
case 4:
|
|
switch (pixel_type)
|
|
{
|
|
case TINYGLTF_COMPONENT_TYPE_BYTE:
|
|
return VK_FORMAT_R8G8B8A8_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE:
|
|
return srgb ? VK_FORMAT_R8G8B8A8_SRGB : VK_FORMAT_R8G8B8A8_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_SHORT:
|
|
return VK_FORMAT_R16G16B16A16_SNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT:
|
|
return VK_FORMAT_R16G16B16A16_UNORM;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_INT:
|
|
return VK_FORMAT_R32G32B32A32_SINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT:
|
|
return VK_FORMAT_R32G32B32A32_UINT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_FLOAT:
|
|
return VK_FORMAT_R32G32B32A32_SFLOAT;
|
|
|
|
case TINYGLTF_COMPONENT_TYPE_DOUBLE:
|
|
return VK_FORMAT_R64G64B64A64_SFLOAT;
|
|
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
default:
|
|
return VK_FORMAT_UNDEFINED;
|
|
}
|
|
}
|
|
|
|
int bytes_per_pixel(VkFormat format)
|
|
{
|
|
switch (format)
|
|
{
|
|
case VK_FORMAT_R8_SINT:
|
|
case VK_FORMAT_R8_UINT:
|
|
case VK_FORMAT_R8_SNORM:
|
|
case VK_FORMAT_R8_UNORM:
|
|
case VK_FORMAT_R8_SSCALED:
|
|
case VK_FORMAT_R8_USCALED:
|
|
case VK_FORMAT_R8_SRGB:
|
|
return 1;
|
|
|
|
case VK_FORMAT_R16_SINT:
|
|
case VK_FORMAT_R16_UINT:
|
|
case VK_FORMAT_R16_SNORM:
|
|
case VK_FORMAT_R16_UNORM:
|
|
case VK_FORMAT_R16_SSCALED:
|
|
case VK_FORMAT_R16_USCALED:
|
|
return 2;
|
|
|
|
case VK_FORMAT_R32_SINT:
|
|
case VK_FORMAT_R32_UINT:
|
|
case VK_FORMAT_R32_SFLOAT:
|
|
return 4;
|
|
|
|
case VK_FORMAT_R64_SFLOAT:
|
|
return 8;
|
|
|
|
case VK_FORMAT_R8G8_SINT:
|
|
case VK_FORMAT_R8G8_UINT:
|
|
case VK_FORMAT_R8G8_SNORM:
|
|
case VK_FORMAT_R8G8_UNORM:
|
|
case VK_FORMAT_R8G8_SSCALED:
|
|
case VK_FORMAT_R8G8_USCALED:
|
|
case VK_FORMAT_R8G8_SRGB:
|
|
return 2;
|
|
|
|
case VK_FORMAT_R16G16_SINT:
|
|
case VK_FORMAT_R16G16_UINT:
|
|
case VK_FORMAT_R16G16_SNORM:
|
|
case VK_FORMAT_R16G16_UNORM:
|
|
case VK_FORMAT_R16G16_SSCALED:
|
|
case VK_FORMAT_R16G16_USCALED:
|
|
return 4;
|
|
|
|
case VK_FORMAT_R32G32_SINT:
|
|
case VK_FORMAT_R32G32_UINT:
|
|
case VK_FORMAT_R32G32_SFLOAT:
|
|
return 8;
|
|
|
|
case VK_FORMAT_R64G64_SFLOAT:
|
|
return 16;
|
|
|
|
case VK_FORMAT_R8G8B8_SINT:
|
|
case VK_FORMAT_R8G8B8_UINT:
|
|
case VK_FORMAT_R8G8B8_SNORM:
|
|
case VK_FORMAT_R8G8B8_UNORM:
|
|
case VK_FORMAT_R8G8B8_SSCALED:
|
|
case VK_FORMAT_R8G8B8_USCALED:
|
|
case VK_FORMAT_R8G8B8_SRGB:
|
|
return 3;
|
|
|
|
case VK_FORMAT_R16G16B16_SINT:
|
|
case VK_FORMAT_R16G16B16_UINT:
|
|
case VK_FORMAT_R16G16B16_SNORM:
|
|
case VK_FORMAT_R16G16B16_UNORM:
|
|
case VK_FORMAT_R16G16B16_SSCALED:
|
|
case VK_FORMAT_R16G16B16_USCALED:
|
|
return 6;
|
|
|
|
case VK_FORMAT_R32G32B32_SINT:
|
|
case VK_FORMAT_R32G32B32_UINT:
|
|
case VK_FORMAT_R32G32B32_SFLOAT:
|
|
return 12;
|
|
|
|
case VK_FORMAT_R64G64B64_SFLOAT:
|
|
return 24;
|
|
|
|
case VK_FORMAT_R8G8B8A8_SINT:
|
|
case VK_FORMAT_R8G8B8A8_UINT:
|
|
case VK_FORMAT_R8G8B8A8_SNORM:
|
|
case VK_FORMAT_R8G8B8A8_UNORM:
|
|
case VK_FORMAT_R8G8B8A8_SSCALED:
|
|
case VK_FORMAT_R8G8B8A8_USCALED:
|
|
case VK_FORMAT_R8G8B8A8_SRGB:
|
|
return 4;
|
|
|
|
case VK_FORMAT_R16G16B16A16_SINT:
|
|
case VK_FORMAT_R16G16B16A16_UINT:
|
|
case VK_FORMAT_R16G16B16A16_SNORM:
|
|
case VK_FORMAT_R16G16B16A16_UNORM:
|
|
case VK_FORMAT_R16G16B16A16_SSCALED:
|
|
case VK_FORMAT_R16G16B16A16_USCALED:
|
|
return 8;
|
|
|
|
case VK_FORMAT_R32G32B32A32_SINT:
|
|
case VK_FORMAT_R32G32B32A32_UINT:
|
|
case VK_FORMAT_R32G32B32A32_SFLOAT:
|
|
return 16;
|
|
|
|
case VK_FORMAT_R64G64B64A64_SFLOAT:
|
|
return 32;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
scene_renderer::scene_renderer(VkDevice device, VkPhysicalDevice physical_device, VkQueue queue) :
|
|
device(device), physical_device(physical_device), queue(queue)
|
|
{
|
|
try
|
|
{
|
|
vkGetPhysicalDeviceProperties(physical_device, &physical_device_properties);
|
|
|
|
command_pool = vk::command_pool(device, application::queue_family_index());
|
|
|
|
VkFenceCreateInfo fence_info{
|
|
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
|
|
};
|
|
CHECK_VK(vkCreateFence(device, &fence_info, nullptr, &staging_fence));
|
|
}
|
|
catch (...)
|
|
{
|
|
if (device && staging_fence)
|
|
vkDestroyFence(device, staging_fence, nullptr);
|
|
|
|
throw;
|
|
}
|
|
}
|
|
|
|
scene_renderer::~scene_renderer()
|
|
{
|
|
if (device && staging_fence)
|
|
vkDestroyFence(device, staging_fence, nullptr);
|
|
}
|
|
|
|
void scene_renderer::reserve(size_t size)
|
|
{
|
|
if (size > staging_buffer_size)
|
|
{
|
|
VkBufferCreateInfo buffer_info{};
|
|
buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
|
|
buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
buffer_info.size = size;
|
|
buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
|
|
|
staging_buffer = vk::buffer(device, buffer_info);
|
|
staging_memory =
|
|
vk::device_memory(device, physical_device, staging_buffer, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
staging_buffer_size = size;
|
|
staging_memory.map_memory();
|
|
}
|
|
}
|
|
|
|
void scene_renderer::load_buffer(VkBuffer b, const void * data, size_t size)
|
|
{
|
|
reserve(size);
|
|
|
|
memcpy(staging_memory.data(), data, size);
|
|
|
|
VkCommandBuffer staging_command_buffer = command_pool.allocate_command_buffer();
|
|
try
|
|
{
|
|
CHECK_VK(vkResetCommandBuffer(staging_command_buffer, 0));
|
|
VkCommandBufferBeginInfo begin_info{};
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
CHECK_VK(vkBeginCommandBuffer(staging_command_buffer, &begin_info));
|
|
|
|
VkBufferCopy copy_info{.srcOffset = 0, .dstOffset = 0, .size = size};
|
|
vkCmdCopyBuffer(staging_command_buffer, staging_buffer, b, 1, ©_info);
|
|
|
|
CHECK_VK(vkEndCommandBuffer(staging_command_buffer));
|
|
|
|
VkSubmitInfo submit_info{};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &staging_command_buffer;
|
|
CHECK_VK(vkQueueSubmit(queue, 1, &submit_info, staging_fence));
|
|
|
|
CHECK_VK(vkWaitForFences(device, 1, &staging_fence, VK_TRUE, -1));
|
|
CHECK_VK(vkResetFences(device, 1, &staging_fence));
|
|
}
|
|
catch (...)
|
|
{
|
|
command_pool.free_command_buffer(staging_command_buffer);
|
|
throw;
|
|
}
|
|
|
|
command_pool.free_command_buffer(staging_command_buffer);
|
|
}
|
|
|
|
void scene_renderer::load_image(VkImage i, void * data, VkExtent2D size, VkFormat format, uint32_t mipmap_count, VkImageLayout final_layout)
|
|
{
|
|
reserve(size.height * size.width * bytes_per_pixel(format));
|
|
|
|
VkCommandBuffer staging_command_buffer = command_pool.allocate_command_buffer();
|
|
|
|
try
|
|
{
|
|
CHECK_VK(vkResetCommandBuffer(staging_command_buffer, 0));
|
|
VkCommandBufferBeginInfo begin_info{};
|
|
begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
|
CHECK_VK(vkBeginCommandBuffer(staging_command_buffer, &begin_info));
|
|
|
|
VkImageMemoryBarrier barrier{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.srcAccessMask = 0,
|
|
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
|
|
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
|
.image = i,
|
|
.subresourceRange =
|
|
{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.baseMipLevel = 0,
|
|
.levelCount = mipmap_count,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
},
|
|
};
|
|
vkCmdPipelineBarrier(staging_command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
|
|
VkBufferImageCopy copy_info{.bufferOffset = 0,
|
|
.bufferRowLength = 0,
|
|
.bufferImageHeight = 0,
|
|
.imageSubresource =
|
|
VkImageSubresourceLayers{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.mipLevel = 0,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
},
|
|
.imageOffset = {0, 0, 0},
|
|
.imageExtent = {size.width, size.height, 1}};
|
|
vkCmdCopyBufferToImage(staging_command_buffer, staging_buffer, i, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_info);
|
|
|
|
VkOffset3D size_src = {(int32_t)size.width, (int32_t)size.height, 1};
|
|
for (uint32_t mipmap = 1; mipmap < mipmap_count; mipmap++)
|
|
{
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
|
barrier.subresourceRange.baseMipLevel = mipmap - 1;
|
|
barrier.subresourceRange.levelCount = 1;
|
|
vkCmdPipelineBarrier(staging_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
|
|
VkOffset3D size_dst = {std::max(1, size_src.x / 2), std::max(1, size_src.y / 2), 1};
|
|
VkImageBlit blit_info{
|
|
.srcSubresource =
|
|
{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.mipLevel = mipmap - 1,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
},
|
|
.srcOffsets = {{0, 0, 0}, size_src},
|
|
.dstSubresource =
|
|
{
|
|
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.mipLevel = mipmap,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1,
|
|
},
|
|
.dstOffsets = {{0, 0, 0}, size_dst},
|
|
};
|
|
vkCmdBlitImage(staging_command_buffer, i, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, i, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit_info, VK_FILTER_LINEAR);
|
|
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
|
barrier.newLayout = final_layout;
|
|
barrier.subresourceRange.baseMipLevel = mipmap - 1;
|
|
vkCmdPipelineBarrier(staging_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
|
|
size_src = size_dst;
|
|
}
|
|
|
|
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
|
barrier.newLayout = final_layout;
|
|
barrier.subresourceRange.baseMipLevel = mipmap_count - 1;
|
|
vkCmdPipelineBarrier(staging_command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
|
|
|
|
CHECK_VK(vkEndCommandBuffer(staging_command_buffer));
|
|
|
|
VkSubmitInfo submit_info{};
|
|
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
|
submit_info.commandBufferCount = 1;
|
|
submit_info.pCommandBuffers = &staging_command_buffer;
|
|
CHECK_VK(vkQueueSubmit(queue, 1, &submit_info, staging_fence));
|
|
|
|
CHECK_VK(vkWaitForFences(device, 1, &staging_fence, VK_TRUE, -1));
|
|
CHECK_VK(vkResetFences(device, 1, &staging_fence));
|
|
}
|
|
catch (...)
|
|
{
|
|
command_pool.free_command_buffer(staging_command_buffer);
|
|
throw;
|
|
}
|
|
|
|
command_pool.free_command_buffer(staging_command_buffer);
|
|
}
|
|
|
|
void scene_renderer::cleanup()
|
|
{
|
|
shaders.clear();
|
|
images.clear();
|
|
buffers.clear();
|
|
|
|
cleanup_output_images();
|
|
}
|
|
|
|
void scene_renderer::cleanup_output_images()
|
|
{
|
|
output_images.clear();
|
|
|
|
for (VkImageView image_view: output_image_views)
|
|
vkDestroyImageView(device, image_view, nullptr);
|
|
output_image_views.clear();
|
|
|
|
for (VkFramebuffer framebuffer: output_framebuffers)
|
|
vkDestroyFramebuffer(device, framebuffer, nullptr);
|
|
output_framebuffers.clear();
|
|
}
|
|
|
|
void scene_renderer::set_output_images(std::vector<VkImage> output_images_, VkExtent2D output_size_, VkFormat output_format_)
|
|
{
|
|
output_images = std::move(output_images_);
|
|
output_size = output_size_;
|
|
output_format = output_format_;
|
|
|
|
// Create renderpass
|
|
VkAttachmentReference color_ref{.attachment = 0, .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
|
|
|
|
vk::renderpass::info renderpass_info{.attachments = {VkAttachmentDescription{
|
|
.format = output_format,
|
|
.samples = VK_SAMPLE_COUNT_1_BIT,
|
|
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
|
|
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
|
|
.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
}},
|
|
.subpasses = {VkSubpassDescription{
|
|
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
.colorAttachmentCount = 1,
|
|
.pColorAttachments = &color_ref,
|
|
}},
|
|
.dependencies = {}};
|
|
|
|
renderpass = vk::renderpass(device, renderpass_info);
|
|
|
|
// Create image views and framebuffers
|
|
output_image_views.reserve(output_images.size());
|
|
output_framebuffers.reserve(output_images.size());
|
|
for (VkImage image: output_images)
|
|
{
|
|
VkImageViewCreateInfo iv_info{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
|
.image = image,
|
|
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
|
.format = output_format,
|
|
.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY},
|
|
.subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.baseMipLevel = 0,
|
|
.levelCount = 1,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1}};
|
|
|
|
VkImageView image_view;
|
|
CHECK_VK(vkCreateImageView(device, &iv_info, nullptr, &image_view));
|
|
output_image_views.push_back(image_view);
|
|
|
|
VkFramebufferCreateInfo fb_create_info{
|
|
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
|
|
.renderPass = renderpass,
|
|
.attachmentCount = 1,
|
|
.pAttachments = &image_view,
|
|
.width = output_size.width,
|
|
.height = output_size.height,
|
|
.layers = 1,
|
|
};
|
|
|
|
VkFramebuffer framebuffer;
|
|
CHECK_VK(vkCreateFramebuffer(device, &fb_create_info, nullptr, &framebuffer));
|
|
output_framebuffers.push_back(framebuffer);
|
|
}
|
|
}
|
|
|
|
void scene_renderer::cleanup_shader(shader * s)
|
|
{
|
|
for (auto & i: s->descriptor_set_layouts)
|
|
vkDestroyDescriptorSetLayout(device, i, nullptr);
|
|
for (auto & i: s->descriptor_pools)
|
|
vkDestroyDescriptorPool(device, i, nullptr);
|
|
for (auto & i: s->pipelines)
|
|
vkDestroyPipeline(device, i.second, nullptr);
|
|
|
|
if (s->pipeline_layout)
|
|
vkDestroyPipelineLayout(device, s->pipeline_layout, nullptr);
|
|
if (s->fragment_shader)
|
|
vkDestroyShaderModule(device, s->fragment_shader, nullptr);
|
|
if (s->vertex_shader)
|
|
vkDestroyShaderModule(device, s->vertex_shader, nullptr);
|
|
}
|
|
|
|
std::weak_ptr<scene_renderer::shader>
|
|
scene_renderer::create_shader(std::string name, std::vector<std::vector<VkDescriptorSetLayoutBinding>> uniform_bindings)
|
|
{
|
|
auto s = std::shared_ptr<shader>(new shader, [&](shader * s) { cleanup_shader(s); });
|
|
|
|
// Create graphics pipeline
|
|
s->vertex_shader = vk::shader(device, name + ".vert").release();
|
|
s->fragment_shader = vk::shader(device, name + ".frag").release();
|
|
|
|
s->descriptor_set_layouts.reserve(uniform_bindings.size());
|
|
for (std::vector<VkDescriptorSetLayoutBinding> & bindings: uniform_bindings)
|
|
{
|
|
VkDescriptorSetLayoutCreateInfo layout_info{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
|
|
.bindingCount = (uint32_t)uniform_bindings.size(),
|
|
.pBindings = bindings.data(),
|
|
};
|
|
|
|
VkDescriptorSetLayout descriptor_set_layout;
|
|
CHECK_VK(vkCreateDescriptorSetLayout(device, &layout_info, nullptr, &descriptor_set_layout));
|
|
s->descriptor_set_layouts.push_back(descriptor_set_layout);
|
|
}
|
|
|
|
VkPipelineLayoutCreateInfo pipeline_layout_create_info{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
|
|
.setLayoutCount = (uint32_t)s->descriptor_set_layouts.size(),
|
|
.pSetLayouts = s->descriptor_set_layouts.data(),
|
|
};
|
|
|
|
CHECK_VK(vkCreatePipelineLayout(device, &pipeline_layout_create_info, nullptr, &s->pipeline_layout));
|
|
|
|
return shaders.emplace_back(s);
|
|
}
|
|
|
|
VkPipeline scene_renderer::get_shader_pipeline(std::weak_ptr<shader> weak_shader, VkPrimitiveTopology topology, std::span<VkVertexInputBindingDescription> vertex_bindings, std::span<VkVertexInputAttributeDescription> vertex_attributes)
|
|
{
|
|
auto shader = weak_shader.lock();
|
|
if (!shader)
|
|
return VK_NULL_HANDLE;
|
|
|
|
for (auto & i: shader->pipelines)
|
|
{
|
|
if (topology != i.first.topology)
|
|
continue;
|
|
|
|
if (vertex_bindings.size() != i.first.vertex_bindings.size())
|
|
continue;
|
|
|
|
if (memcmp(vertex_bindings.data(), i.first.vertex_bindings.data(), vertex_bindings.size() * sizeof(VkVertexInputBindingDescription)))
|
|
continue;
|
|
|
|
if (vertex_attributes.size() != i.first.vertex_attributes.size())
|
|
continue;
|
|
|
|
if (memcmp(vertex_attributes.data(), i.first.vertex_attributes.data(), vertex_attributes.size() * sizeof(VkVertexInputAttributeDescription)))
|
|
continue;
|
|
|
|
return i.second;
|
|
}
|
|
|
|
shader::pipeline_info info{
|
|
.topology = topology,
|
|
.vertex_bindings = {vertex_bindings.begin(), vertex_bindings.end()},
|
|
.vertex_attributes = {vertex_attributes.begin(), vertex_attributes.end()},
|
|
};
|
|
|
|
VkPipelineColorBlendAttachmentState pcbas{
|
|
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT};
|
|
|
|
vk::pipeline::graphics_info pipeline_info{
|
|
.shader_stages =
|
|
{{.stage = VK_SHADER_STAGE_VERTEX_BIT, .module = shader->vertex_shader, .pName = "main"},
|
|
{.stage = VK_SHADER_STAGE_FRAGMENT_BIT, .module = shader->fragment_shader, .pName = "main"}},
|
|
.vertex_input_bindings = info.vertex_bindings,
|
|
.vertex_input_attributes = info.vertex_attributes,
|
|
.InputAssemblyState = {.topology = topology},
|
|
.viewports = {VkViewport{.x = 0,
|
|
.y = 0,
|
|
.width = (float)output_size.width,
|
|
.height = (float)output_size.height,
|
|
.minDepth = 0,
|
|
.maxDepth = 1}},
|
|
.scissors = {VkRect2D{
|
|
.offset = {0, 0},
|
|
.extent = output_size,
|
|
}},
|
|
.RasterizationState = {.polygonMode = VK_POLYGON_MODE_FILL, .lineWidth = 1},
|
|
.MultisampleState = {.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT},
|
|
.ColorBlendState = {.attachmentCount = 1, .pAttachments = &pcbas},
|
|
.dynamic_states = {},
|
|
.renderPass = renderpass,
|
|
.subpass = 0,
|
|
};
|
|
|
|
vk::pipeline pipeline(device, pipeline_info, shader->pipeline_layout);
|
|
|
|
return shader->pipelines.emplace_back(info, pipeline.release()).second;
|
|
}
|
|
|
|
void scene_renderer::cleanup_image(scene_renderer::image * i)
|
|
{
|
|
if (i->image_view)
|
|
vkDestroyImageView(device, i->image_view, nullptr);
|
|
|
|
if (i->vk_image)
|
|
vkDestroyImage(device, i->vk_image, nullptr);
|
|
|
|
if (i->memory)
|
|
vkFreeMemory(device, i->memory, nullptr);
|
|
}
|
|
|
|
std::weak_ptr<scene_renderer::image> scene_renderer::create_image(void * data, VkExtent2D size, VkFormat format)
|
|
{
|
|
auto i = std::shared_ptr<image>(new image, [&](image * i) { cleanup_image(i); });
|
|
|
|
uint32_t mipmaps = std::log2(std::max(size.width, size.height)) + 1;
|
|
|
|
VkImageCreateInfo image_info{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
|
|
.flags = 0,
|
|
.imageType = VK_IMAGE_TYPE_2D,
|
|
.format = format,
|
|
.extent = {size.width, size.height, 1},
|
|
.mipLevels = mipmaps,
|
|
.arrayLayers = 1,
|
|
.samples = VK_SAMPLE_COUNT_1_BIT,
|
|
.tiling = VK_IMAGE_TILING_OPTIMAL,
|
|
.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
|
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
|
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
|
|
};
|
|
|
|
i->vk_image = vk::image(device, image_info).release();
|
|
i->memory =
|
|
vk::device_memory(device, physical_device, i->vk_image, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT).release();
|
|
|
|
load_image(i->vk_image, data, size, format, mipmaps);
|
|
|
|
VkImageViewCreateInfo image_view_info{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
|
.flags = 0,
|
|
.image = i->vk_image,
|
|
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
|
.format = format,
|
|
.components = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY},
|
|
.subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
|
.baseMipLevel = 0,
|
|
.levelCount = mipmaps,
|
|
.baseArrayLayer = 0,
|
|
.layerCount = 1}};
|
|
CHECK_VK(vkCreateImageView(device, &image_view_info, nullptr, &i->image_view));
|
|
|
|
return images.emplace_back(i);
|
|
}
|
|
|
|
void scene_renderer::cleanup_buffer(scene_renderer::buffer * b)
|
|
{
|
|
if (b->vk_buffer)
|
|
vkDestroyBuffer(device, b->vk_buffer, nullptr);
|
|
if (b->memory)
|
|
vkFreeMemory(device, b->memory, nullptr);
|
|
}
|
|
|
|
std::weak_ptr<scene_renderer::buffer> scene_renderer::create_buffer(const void * data, size_t size, VkBufferUsageFlags usage)
|
|
{
|
|
auto b = std::shared_ptr<buffer>(new buffer, [&](buffer * b) { cleanup_buffer(b); });
|
|
|
|
VkBufferCreateInfo buffer_info{
|
|
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
|
.size = size,
|
|
.usage = usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
|
};
|
|
|
|
b->vk_buffer = vk::buffer(device, buffer_info).release();
|
|
b->memory =
|
|
vk::device_memory(device, physical_device, b->vk_buffer, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT).release();
|
|
|
|
load_buffer(b->vk_buffer, data, size);
|
|
|
|
return buffers.emplace_back(b);
|
|
}
|
|
|
|
scene_renderer::model * scene_renderer::load_gltf(const std::string & filename)
|
|
{
|
|
std::string err, warn;
|
|
|
|
auto m = std::make_unique<model>();
|
|
|
|
bool success = false;
|
|
|
|
if (filename.ends_with(".glb"))
|
|
success = gltf_loader.LoadBinaryFromFile(&m->gltf_model, &err, &warn, filename);
|
|
else if (filename.ends_with(".gltf"))
|
|
success = gltf_loader.LoadASCIIFromFile(&m->gltf_model, &err, &warn, filename);
|
|
else
|
|
err = "Wrong file extension, must be .gltf or .glb";
|
|
|
|
if (warn != "")
|
|
spdlog::warn("Loading {}: {}", filename, utils::trim(warn));
|
|
|
|
if (err != "")
|
|
spdlog::error("Loading {}: {}", filename, utils::trim(err));
|
|
|
|
if (!success)
|
|
throw std::runtime_error("GLTF error: " + utils::trim(err));
|
|
|
|
for (tinygltf::Buffer & i: m->gltf_model.buffers)
|
|
{
|
|
m->buffers.push_back(
|
|
create_buffer(i.data, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT));
|
|
}
|
|
|
|
std::vector<bool> srgb(m->gltf_model.images.size(), false);
|
|
for (tinygltf::Material & i: m->gltf_model.materials)
|
|
{
|
|
if (i.emissiveTexture.index >= 0 && i.emissiveTexture.index < (int)srgb.size())
|
|
srgb[i.emissiveTexture.index] = true;
|
|
|
|
if (i.pbrMetallicRoughness.baseColorTexture.index >= 0 &&
|
|
i.pbrMetallicRoughness.baseColorTexture.index < (int)srgb.size())
|
|
srgb[i.pbrMetallicRoughness.baseColorTexture.index] = true;
|
|
}
|
|
|
|
int n = 0;
|
|
for (tinygltf::Image & i: m->gltf_model.images)
|
|
{
|
|
VkFormat format = gltf_to_vkformat(i.component, i.bits, i.pixel_type, srgb[n++]);
|
|
m->images.push_back(create_image(i.image.data(), {(uint32_t)i.width, (uint32_t)i.height}, format));
|
|
}
|
|
|
|
return models.emplace_back(std::move(m)).get();
|
|
}
|