Files
WiVRn/client/render/scene_renderer.cpp
T

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, &copy_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, &copy_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();
}