VulkanFramebuffer::~VulkanFramebuffer()
{
VkDevice device = mOwner->getDevice().getLogical();
vkDestroyFramebuffer(device, mDefault.framebuffer, gVulkanAllocator);
vkDestroyRenderPass(device, mDefault.renderPass, gVulkanAllocator);
for(auto& entry : mVariants)
{
vkDestroyFramebuffer(device, entry.second.framebuffer, gVulkanAllocator);
vkDestroyRenderPass(device, entry.second.renderPass, gVulkanAllocator);
}
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
vkDestroyImageView(device, attachments.color.view, nullptr);
vkDestroyImage(device, attachments.color.image, nullptr);
vkFreeMemory(device, attachments.color.memory, nullptr);
vkDestroyImageView(device, attachments.depth.view, nullptr);
vkDestroyImage(device, attachments.depth.image, nullptr);
vkFreeMemory(device, attachments.depth.memory, nullptr);
vkDestroyPipeline(device, pipelines.attachmentRead, nullptr);
vkDestroyPipeline(device, pipelines.attachmentWrite, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.attachmentWrite, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.attachmentRead, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.attachmentWrite, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.attachmentRead, nullptr);
vkDestroyRenderPass(device, uiRenderPass, nullptr);
scene.destroy();
uniformBuffers.matrices.destroy();
uniformBuffers.params.destroy();
}
TextureCache::~TextureCache()
{
if (m_render_pass != VK_NULL_HANDLE)
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_render_pass, nullptr);
TextureCache::DeleteShaders();
m_scaler.reset();
}
static void cleanup_vulkan()
{
vkDestroyDescriptorPool(g_Device, g_DescriptorPool, g_Allocator);
for (int i = 0; i < IMGUI_VK_QUEUED_FRAMES; i++)
{
vkDestroyFence(g_Device, g_Fence[i], g_Allocator);
vkFreeCommandBuffers(g_Device, g_CommandPool[i], 1, &g_CommandBuffer[i]);
vkDestroyCommandPool(g_Device, g_CommandPool[i], g_Allocator);
vkDestroySemaphore(g_Device, g_PresentCompleteSemaphore[i], g_Allocator);
vkDestroySemaphore(g_Device, g_RenderCompleteSemaphore[i], g_Allocator);
}
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
}
vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
vkDestroySwapchainKHR(g_Device, g_Swapchain, g_Allocator);
vkDestroySurfaceKHR(g_Instance, g_Surface, g_Allocator);
#ifdef IMGUI_VULKAN_DEBUG_REPORT
// get the proc address of the function pointer, required for used extensions
auto vkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(g_Instance, "vkDestroyDebugReportCallbackEXT");
vkDestroyDebugReportCallbackEXT(g_Instance, g_Debug_Report, g_Allocator);
#endif // IMGUI_VULKAN_DEBUG_REPORT
vkDestroyDevice(g_Device, g_Allocator);
vkDestroyInstance(g_Instance, g_Allocator);
}
VKRenderPass::~VKRenderPass()
{
VKRenderer* renderer = VKRenderer::RendererInstance;
//Free input descriptor sets
vkFreeDescriptorSets(m_device, m_descriptorPool, static_cast<uint32_t>(m_inputTargetDescriptorSets.size()), m_inputTargetDescriptorSets.data());
//Destroy framebuffer images
for (size_t i = 0; i < m_colorImages.size(); i++)
{
Image_vk image = m_colorImages[i];
vkDestroyImageView(m_device, image.view, nullptr);
vkDestroyImage(m_device, image.image, nullptr);
vkFreeMemory(m_device, image.memory, nullptr);
}
//Destroy depth image
vkDestroyImageView(m_device, m_depthImage.view, nullptr);
vkDestroyImage(m_device, m_depthImage.image, nullptr);
vkFreeMemory(m_device, m_depthImage.memory, nullptr);
//Free instance texel buffers
if(m_instanceBlock.buffer != VK_NULL_HANDLE)
DeleteUniformBuffer(m_device, m_instanceBlock);
//Destroy framebuffer
vkDestroyFramebuffer(m_device, m_framebuffer, nullptr);
//Destroy the render pass
vkDestroyRenderPass(m_device, m_renderPass, nullptr);
}
void Tutorial03::ChildClear() {
if( GetDevice() != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( GetDevice() );
if( (Vulkan.GraphicsCommandBuffers.size() > 0) && (Vulkan.GraphicsCommandBuffers[0] != VK_NULL_HANDLE) ) {
vkFreeCommandBuffers( GetDevice(), Vulkan.GraphicsCommandPool, static_cast<uint32_t>(Vulkan.GraphicsCommandBuffers.size()), &Vulkan.GraphicsCommandBuffers[0] );
Vulkan.GraphicsCommandBuffers.clear();
}
if( Vulkan.GraphicsCommandPool != VK_NULL_HANDLE ) {
vkDestroyCommandPool( GetDevice(), Vulkan.GraphicsCommandPool, nullptr );
Vulkan.GraphicsCommandPool = VK_NULL_HANDLE;
}
if( Vulkan.GraphicsPipeline != VK_NULL_HANDLE ) {
vkDestroyPipeline( GetDevice(), Vulkan.GraphicsPipeline, nullptr );
Vulkan.GraphicsPipeline = VK_NULL_HANDLE;
}
if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
Vulkan.RenderPass = VK_NULL_HANDLE;
}
for( size_t i = 0; i < Vulkan.Framebuffers.size(); ++i ) {
if( Vulkan.Framebuffers[i] != VK_NULL_HANDLE ) {
vkDestroyFramebuffer( GetDevice(), Vulkan.Framebuffers[i], nullptr );
Vulkan.Framebuffers[i] = VK_NULL_HANDLE;
}
}
Vulkan.Framebuffers.clear();
}
}
coVulkanPass::~coVulkanPass()
{
if (renderPass_vk != VK_NULL_HANDLE)
{
const VkDevice& device_vk = GetVkDevice();
vkDestroyRenderPass(device_vk, renderPass_vk, nullptr);
}
}
void SwapChain::DestroyRenderPass()
{
if (!m_render_pass)
return;
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_render_pass, nullptr);
m_render_pass = VK_NULL_HANDLE;
}
VulkanExampleBase::~VulkanExampleBase()
{
// Clean up Vulkan resources
swapChain.cleanup();
if (descriptorPool != VK_NULL_HANDLE)
{
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
}
if (setupCmdBuffer != VK_NULL_HANDLE)
{
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
}
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
{
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
}
for (auto& shaderModule : shaderModules)
{
vkDestroyShaderModule(device, shaderModule, nullptr);
}
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
{
delete textureLoader;
}
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
{
vkDebug::freeDebugCallback(instance);
}
vkDestroyInstance(instance, nullptr);
#if defined(__linux)
#if defined(__ANDROID__)
// todo : android cleanup (if required)
#else
xcb_destroy_window(connection, window);
xcb_disconnect(connection);
#endif
#endif
}
void _agpu_framebuffer::lostReferences()
{
vkDestroyFramebuffer(device->device, framebuffer, nullptr);
vkDestroyRenderPass(device->device, renderPass, nullptr);
for (auto view : attachmentViews)
vkDestroyImageView(device->device, view, nullptr);
for (auto texture : attachmentTextures)
texture->release();
}
void FramebufferManager::DestroyEFBRenderPass()
{
if (m_efb_load_render_pass != VK_NULL_HANDLE)
{
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_efb_load_render_pass, nullptr);
m_efb_load_render_pass = VK_NULL_HANDLE;
}
if (m_efb_clear_render_pass != VK_NULL_HANDLE)
{
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_efb_clear_render_pass, nullptr);
m_efb_clear_render_pass = VK_NULL_HANDLE;
}
if (m_depth_resolve_render_pass != VK_NULL_HANDLE)
{
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_depth_resolve_render_pass, nullptr);
m_depth_resolve_render_pass = VK_NULL_HANDLE;
}
}
~VulkanExample()
{
vkDestroyPipeline(device, pipelines.skybox, nullptr);
vkDestroyPipeline(device, pipelines.reflect, nullptr);
vkDestroyPipeline(device, pipelines.composition, nullptr);
vkDestroyPipeline(device, pipelines.bloom[0], nullptr);
vkDestroyPipeline(device, pipelines.bloom[1], nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.models, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.composition, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.bloomFilter, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.models, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.composition, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.bloomFilter, nullptr);
vkDestroySemaphore(device, offscreen.semaphore, nullptr);
vkDestroyRenderPass(device, offscreen.renderPass, nullptr);
vkDestroyRenderPass(device, filterPass.renderPass, nullptr);
vkDestroyFramebuffer(device, offscreen.frameBuffer, nullptr);
vkDestroyFramebuffer(device, filterPass.frameBuffer, nullptr);
vkDestroySampler(device, offscreen.sampler, nullptr);
vkDestroySampler(device, filterPass.sampler, nullptr);
offscreen.depth.destroy(device);
offscreen.color[0].destroy(device);
offscreen.color[1].destroy(device);
filterPass.color[0].destroy(device);
for (auto& model : models.objects) {
model.destroy();
}
models.skybox.destroy();
uniformBuffers.matrices.destroy();
uniformBuffers.params.destroy();
textures.envmap.destroy();
}
void Shadow::Destroy()
{
vkDestroySemaphore(gDevice.VkHandle(), shadowMapCompleteSemaphore, nullptr);
mDepthImage.Destroy();
vkDestroyPipelineLayout(gDevice.VkHandle(), mPipelineLayout, nullptr);
vkDestroyRenderPass(gDevice.VkHandle(), mRenderPass, nullptr);
vkDestroyPipeline(gDevice.VkHandle(), mPipeline, nullptr);
}
/** Destructor. Will only be called by release() if the reference counter drops to zero. */
Anvil::RenderPass::~RenderPass()
{
/* Unregister the object */
Anvil::ObjectTracker::get()->unregister_object(Anvil::OBJECT_TYPE_RENDER_PASS,
this);
if (m_render_pass != VK_NULL_HANDLE)
{
vkDestroyRenderPass(m_render_pass_create_info_ptr->get_device()->get_device_vk(),
m_render_pass,
nullptr /* pAllocator */);
m_render_pass = VK_NULL_HANDLE;
}
m_swapchain_ptr = nullptr;
}
/**
* Default destructor, frees up all Vulkan resources acquired by the text overlay
*/
~VulkanTextOverlay()
{
// Free up all Vulkan resources requested by the text overlay
vertexBuffer.destroy();
vkDestroySampler(vulkanDevice->logicalDevice, sampler, nullptr);
vkDestroyImage(vulkanDevice->logicalDevice, image, nullptr);
vkDestroyImageView(vulkanDevice->logicalDevice, view, nullptr);
vkFreeMemory(vulkanDevice->logicalDevice, imageMemory, nullptr);
vkDestroyDescriptorSetLayout(vulkanDevice->logicalDevice, descriptorSetLayout, nullptr);
vkDestroyDescriptorPool(vulkanDevice->logicalDevice, descriptorPool, nullptr);
vkDestroyPipelineLayout(vulkanDevice->logicalDevice, pipelineLayout, nullptr);
vkDestroyPipelineCache(vulkanDevice->logicalDevice, pipelineCache, nullptr);
vkDestroyPipeline(vulkanDevice->logicalDevice, pipeline, nullptr);
vkDestroyRenderPass(vulkanDevice->logicalDevice, renderPass, nullptr);
vkFreeCommandBuffers(vulkanDevice->logicalDevice, commandPool, static_cast<uint32_t>(cmdBuffers.size()), cmdBuffers.data());
vkDestroyCommandPool(vulkanDevice->logicalDevice, commandPool, nullptr);
vkDestroyFence(vulkanDevice->logicalDevice, fence, nullptr);
}
void cleanup() {
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyRenderPass(device, renderPass, nullptr);
for (auto imageView : swapChainImageViews) {
vkDestroyImageView(device, imageView, nullptr);
}
vkDestroySwapchainKHR(device, swapChain, nullptr);
vkDestroyDevice(device, nullptr);
DestroyDebugReportCallbackEXT(instance, callback, nullptr);
vkDestroySurfaceKHR(instance, surface, nullptr);
vkDestroyInstance(instance, nullptr);
glfwDestroyWindow(window);
glfwTerminate();
}
IRenderPassSP VKTS_APIENTRY renderPassCreate(const VkDevice device, const VkRenderPassCreateFlags flags, const uint32_t attachmentCount, const VkAttachmentDescription* attachments, const uint32_t subpassCount, const VkSubpassDescription* subpasses, const uint32_t dependencyCount, const VkSubpassDependency* dependencies)
{
if (!device)
{
return IRenderPassSP();
}
VkResult result;
VkRenderPassCreateInfo renderPassCreateInfo{};
renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassCreateInfo.flags = flags;
renderPassCreateInfo.attachmentCount = attachmentCount;
renderPassCreateInfo.pAttachments = attachments;
renderPassCreateInfo.subpassCount = subpassCount;
renderPassCreateInfo.pSubpasses = subpasses;
renderPassCreateInfo.dependencyCount = dependencyCount;
renderPassCreateInfo.pDependencies = dependencies;
VkRenderPass renderPass;
result = vkCreateRenderPass(device, &renderPassCreateInfo, nullptr, &renderPass);
if (result != VK_SUCCESS)
{
logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create render pass.");
return IRenderPassSP();
}
auto newInstance = new RenderPass(device, flags, attachmentCount, attachments, subpassCount, subpasses, dependencyCount, dependencies, renderPass);
if (!newInstance)
{
vkDestroyRenderPass(device, renderPass, nullptr);
return IRenderPassSP();
}
return IRenderPassSP(newInstance);
}
~VulkanExample()
{
// Clean up used Vulkan resources
// Note : Inherited destructor cleans up resources stored in base class
// Frame buffer
// Color attachment
vkDestroyImageView(device, offscreenPass.color.view, nullptr);
vkDestroyImage(device, offscreenPass.color.image, nullptr);
vkFreeMemory(device, offscreenPass.color.mem, nullptr);
// Depth attachment
vkDestroyImageView(device, offscreenPass.depth.view, nullptr);
vkDestroyImage(device, offscreenPass.depth.image, nullptr);
vkFreeMemory(device, offscreenPass.depth.mem, nullptr);
vkDestroyRenderPass(device, offscreenPass.renderPass, nullptr);
vkDestroySampler(device, offscreenPass.sampler, nullptr);
vkDestroyFramebuffer(device, offscreenPass.frameBuffer, nullptr);
vkDestroyPipeline(device, pipelines.radialBlur, nullptr);
vkDestroyPipeline(device, pipelines.phongPass, nullptr);
vkDestroyPipeline(device, pipelines.colorPass, nullptr);
vkDestroyPipeline(device, pipelines.offscreenDisplay, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.radialBlur, nullptr);
vkDestroyPipelineLayout(device, pipelineLayouts.scene, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.scene, nullptr);
vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.radialBlur, nullptr);
models.example.destroy();
uniformBuffers.scene.destroy();
uniformBuffers.blurParams.destroy();
textures.gradient.destroy();
}
void VKFramebuffer::cleanup() {
VulkanCore * instance = VulkanCore::getInstance();
VkDevice device = instance->getDevice();
if(mFramebuffer != 0) {
vkDestroyFramebuffer(device, mFramebuffer, nullptr);
mFramebuffer = 0;
}
if(mCascadeFramebuffer.size() != 0) {
for(int i = 0; i < mCascadeFramebuffer.size(); i++)
vkDestroyFramebuffer(device, mCascadeFramebuffer[i], nullptr);
mCascadeFramebuffer.clear();
}
if(mRenderpass != 0) {
vkDestroyRenderPass(device, mRenderpass, nullptr);
mRenderpass = 0;
}
}
VulkanBase::~VulkanBase() {
swapChain.cleanup();
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
if (setupCmdBuffer != VK_NULL_HANDLE)
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
for (auto& shaderModule : shaderModules)
vkDestroyShaderModule(device, shaderModule, nullptr);
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
delete textureLoader;
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
vkDebug::freeDebugCallback(instance);
vkDestroyInstance(instance, nullptr);
}
TextureConverter::~TextureConverter()
{
for (const auto& it : m_palette_conversion_shaders)
{
if (it != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it, nullptr);
}
if (m_texel_buffer_view_r8_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r8_uint, nullptr);
if (m_texel_buffer_view_r16_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r16_uint, nullptr);
if (m_texel_buffer_view_r32g32_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r32g32_uint, nullptr);
if (m_texel_buffer_view_rgba8_unorm != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_rgba8_unorm, nullptr);
if (m_encoding_render_pass != VK_NULL_HANDLE)
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_encoding_render_pass, nullptr);
if (m_encoding_render_framebuffer != VK_NULL_HANDLE)
vkDestroyFramebuffer(g_vulkan_context->GetDevice(), m_encoding_render_framebuffer, nullptr);
for (auto& it : m_encoding_shaders)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it.second, nullptr);
for (const auto& it : m_decoding_pipelines)
{
if (it.second.compute_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it.second.compute_shader, nullptr);
}
if (m_rgb_to_yuyv_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), m_rgb_to_yuyv_shader, nullptr);
if (m_yuyv_to_rgb_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), m_yuyv_to_rgb_shader, nullptr);
}
/**
* Sample using multiple render passes per framebuffer (different x,y extents)
* and multiple subpasses per renderpass.
*/
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Multi-pass render passes";
const bool depthPresent = true;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
info.depth.format = VK_FORMAT_D32_SFLOAT_S8_UINT;
init_depth_buffer(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, false);
init_vertex_buffer(info, g_vb_solid_face_colors_Data,
sizeof(g_vb_solid_face_colors_Data),
sizeof(g_vb_solid_face_colors_Data[0]), false);
init_descriptor_pool(info, false);
init_descriptor_set(info, false);
init_pipeline_cache(info);
/* VULKAN_KEY_START */
/**
* First renderpass in this sample.
* Stenciled rendering: subpass 1 draw to stencil buffer, subpass 2 draw to
* color buffer with stencil test
*/
VkAttachmentDescription attachments[2];
attachments[0].format = info.format;
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].flags = 0;
attachments[1].format = info.depth.format;
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[1].initialLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].finalLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].flags = 0;
VkAttachmentReference color_reference = {};
color_reference.attachment = 0;
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference depth_reference = {};
depth_reference.attachment = 1;
depth_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.flags = 0;
subpass.inputAttachmentCount = 0;
subpass.pInputAttachments = NULL;
subpass.colorAttachmentCount = 0;
subpass.pColorAttachments = NULL;
subpass.pResolveAttachments = NULL;
subpass.pDepthStencilAttachment = &depth_reference;
subpass.preserveAttachmentCount = 0;
subpass.pPreserveAttachments = NULL;
std::vector<VkSubpassDescription> subpasses;
/* first a depthstencil-only subpass */
subpasses.push_back(subpass);
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_reference;
/* then depthstencil and color */
subpasses.push_back(subpass);
/* Set up a dependency between the source and destination subpasses */
VkSubpassDependency dependency = {};
dependency.srcSubpass = 0;
dependency.dstSubpass = 1;
dependency.dependencyFlags = 0;
dependency.srcStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependency.dstStageMask = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
dependency.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
dependency.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
VkRenderPassCreateInfo rp_info = {};
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.pNext = NULL;
rp_info.attachmentCount = 2;
rp_info.pAttachments = attachments;
rp_info.subpassCount = subpasses.size();
rp_info.pSubpasses = subpasses.data();
rp_info.dependencyCount = 1;
rp_info.pDependencies = &dependency;
VkRenderPass stencil_render_pass;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &stencil_render_pass);
assert(!res);
/* now that we have the render pass, create framebuffer and pipelines */
info.render_pass = stencil_render_pass;
init_framebuffers(info, depthPresent);
VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
VkPipelineDynamicStateCreateInfo dynamicState = {};
memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
dynamicState.pDynamicStates = dynamicStateEnables;
dynamicState.dynamicStateCount = 0;
VkPipelineVertexInputStateCreateInfo vi;
vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vi.pNext = NULL;
vi.vertexBindingDescriptionCount = 1;
vi.pVertexBindingDescriptions = &info.vi_binding;
vi.vertexAttributeDescriptionCount = 2;
vi.pVertexAttributeDescriptions = info.vi_attribs;
VkPipelineInputAssemblyStateCreateInfo ia;
ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
ia.pNext = NULL;
ia.primitiveRestartEnable = VK_FALSE;
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkPipelineRasterizationStateCreateInfo rs;
rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rs.pNext = NULL;
rs.polygonMode = VK_POLYGON_MODE_FILL;
rs.cullMode = VK_CULL_MODE_BACK_BIT;
rs.frontFace = VK_FRONT_FACE_CLOCKWISE;
rs.depthClampEnable = VK_FALSE;
rs.rasterizerDiscardEnable = VK_FALSE;
rs.depthBiasEnable = VK_FALSE;
rs.depthBiasConstantFactor = 0;
rs.depthBiasClamp = 0;
rs.depthBiasSlopeFactor = 0;
rs.lineWidth = 0;
VkPipelineColorBlendStateCreateInfo cb;
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
cb.pNext = NULL;
VkPipelineColorBlendAttachmentState att_state[1];
att_state[0].colorWriteMask = 0xf;
att_state[0].blendEnable = VK_FALSE;
att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
cb.attachmentCount = 1;
cb.pAttachments = att_state;
cb.logicOpEnable = VK_FALSE;
cb.logicOp = VK_LOGIC_OP_NO_OP;
cb.blendConstants[0] = 1.0f;
cb.blendConstants[1] = 1.0f;
cb.blendConstants[2] = 1.0f;
cb.blendConstants[3] = 1.0f;
VkPipelineViewportStateCreateInfo vp = {};
vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vp.pNext = NULL;
vp.viewportCount = NUM_VIEWPORTS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_VIEWPORT;
vp.scissorCount = NUM_SCISSORS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_SCISSOR;
VkPipelineDepthStencilStateCreateInfo ds;
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
ds.pNext = NULL;
ds.depthTestEnable = VK_TRUE;
ds.depthWriteEnable = VK_TRUE;
ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
ds.depthBoundsTestEnable = VK_FALSE;
ds.minDepthBounds = 0;
ds.maxDepthBounds = 0;
ds.stencilTestEnable = VK_TRUE;
ds.back.failOp = VK_STENCIL_OP_REPLACE;
ds.back.depthFailOp = VK_STENCIL_OP_REPLACE;
ds.back.passOp = VK_STENCIL_OP_REPLACE;
ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
ds.back.compareMask = 0xff;
ds.back.writeMask = 0xff;
ds.back.reference = 0x44;
ds.front = ds.back;
VkPipelineMultisampleStateCreateInfo ms;
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms.pNext = NULL;
ms.pSampleMask = NULL;
ms.rasterizationSamples = NUM_SAMPLES;
ms.sampleShadingEnable = VK_FALSE;
ms.minSampleShading = 0.0;
ms.alphaToCoverageEnable = VK_FALSE;
ms.alphaToOneEnable = VK_FALSE;
VkGraphicsPipelineCreateInfo pipeline;
pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipeline.pNext = NULL;
pipeline.layout = info.pipeline_layout;
pipeline.basePipelineHandle = VK_NULL_HANDLE;
pipeline.basePipelineIndex = 0;
pipeline.flags = 0;
pipeline.pVertexInputState = &vi;
pipeline.pInputAssemblyState = &ia;
pipeline.pRasterizationState = &rs;
pipeline.pColorBlendState = NULL;
pipeline.pTessellationState = NULL;
pipeline.pMultisampleState = &ms;
pipeline.pDynamicState = &dynamicState;
pipeline.pViewportState = &vp;
pipeline.pDepthStencilState = &ds;
pipeline.pStages = info.shaderStages;
pipeline.stageCount = 2;
pipeline.renderPass = stencil_render_pass;
pipeline.subpass = 0;
init_shaders(info, normalVertShaderText, fragShaderText);
/* The first pipeline will render in subpass 0 to fill the stencil */
pipeline.subpass = 0;
VkPipeline stencil_cube_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &stencil_cube_pipe);
assert(res == VK_SUCCESS);
/* destroy the shaders used for the above pipelin eand replace them with
those for the
fullscreen fill pass */
destroy_shaders(info);
init_shaders(info, fullscreenVertShaderText, fragShaderText);
/* the second pipeline will stencil test but not write, using the same
* reference */
ds.back.failOp = VK_STENCIL_OP_KEEP;
ds.back.depthFailOp = VK_STENCIL_OP_KEEP;
ds.back.passOp = VK_STENCIL_OP_KEEP;
ds.back.compareOp = VK_COMPARE_OP_EQUAL;
ds.front = ds.back;
/* don't test depth, only use stencil test */
ds.depthTestEnable = VK_FALSE;
/* the second pipeline will be a fullscreen triangle strip, with vertices
generated purely from the vertex shader - no inputs needed */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
vi.vertexAttributeDescriptionCount = 0;
vi.vertexBindingDescriptionCount = 0;
/* this pipeline will run in the second subpass */
pipeline.subpass = 1;
pipeline.pColorBlendState = &cb;
VkPipeline stencil_fullscreen_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &stencil_fullscreen_pipe);
assert(res == VK_SUCCESS);
destroy_shaders(info);
info.pipeline = VK_NULL_HANDLE;
VkClearValue clear_values[2];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
clear_values[1].depthStencil.depth = 1.0f;
clear_values[1].depthStencil.stencil = 0;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, NULL,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = stencil_render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width / 2;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 2;
rp_begin.pClearValues = clear_values;
/* Begin the first render pass. This will render in the left half of the
screen. Subpass 0 will render a cube, stencil writing but outputting
no color. Subpass 1 will render a fullscreen pass, stencil testing and
outputting color only where the cube filled in stencil */
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
stencil_cube_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
VkViewport viewport;
viewport.height = (float)info.height;
viewport.width = (float)info.width / 2;
viewport.minDepth = (float)0.0f;
viewport.maxDepth = (float)1.0f;
viewport.x = 0;
viewport.y = 0;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
VkRect2D scissor;
scissor.extent.width = info.width / 2;
scissor.extent.height = info.height;
scissor.offset.x = 0;
scissor.offset.y = 0;
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the cube into stencil */
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
/* Advance to the next subpass */
vkCmdNextSubpass(info.cmd, VK_SUBPASS_CONTENTS_INLINE);
/* Bind the fullscreen pass pipeline */
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
stencil_fullscreen_pipe);
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the fullscreen pass */
vkCmdDraw(info.cmd, 4, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
/**
* Second renderpass in this sample.
* Blended rendering, each subpass blends continuously onto the color
*/
/* note that we reuse a lot of the initialisation strutures from the first
render pass, so this represents a 'delta' from that configuration */
/* This time, the first subpass will use color */
subpasses[0].colorAttachmentCount = 1;
subpasses[0].pColorAttachments = &color_reference;
/* The dependency between the subpasses now includes the color attachment */
dependency.srcAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
dependency.dstAccessMask |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
/* Otherwise, the render pass is identical */
VkRenderPass blend_render_pass;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &blend_render_pass);
assert(!res);
pipeline.renderPass = blend_render_pass;
/* We must recreate the framebuffers with this renderpass as the two render
passes are not compatible. Store the current framebuffers for later
deletion */
VkFramebuffer *stencil_framebuffers = info.framebuffers;
info.framebuffers = NULL;
info.render_pass = blend_render_pass;
init_framebuffers(info, depthPresent);
/* Now create the pipelines for the second render pass */
/* We are rendering the cube again, configure the vertex inputs */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
vi.vertexAttributeDescriptionCount = 2;
vi.vertexBindingDescriptionCount = 1;
/* The first pipeline will depth write and depth test */
ds.depthWriteEnable = VK_TRUE;
ds.depthTestEnable = VK_TRUE;
/* We don't want to stencil test */
ds.stencilTestEnable = VK_FALSE;
/* This time, both pipelines will blend. the first pipeline uses the blend
constant
to determine the blend amount */
att_state[0].colorWriteMask = 0xf;
att_state[0].blendEnable = VK_TRUE;
att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_CONSTANT_ALPHA;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_CONSTANT_ALPHA;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
cb.blendConstants[0] = 1.0f;
cb.blendConstants[1] = 1.0f;
cb.blendConstants[2] = 1.0f;
cb.blendConstants[3] = 0.3f;
init_shaders(info, normalVertShaderText, fragShaderText);
/* This is the first subpass's pipeline, to blend a cube onto the color
* image */
pipeline.subpass = 0;
VkPipeline blend_cube_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &blend_cube_pipe);
assert(res == VK_SUCCESS);
/* Now we will set up the fullscreen pass to render on top. */
destroy_shaders(info);
init_shaders(info, fullscreenVertShaderText, fragShaderText);
/* the second pipeline will be a fullscreen triangle strip with no inputs */
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
vi.vertexAttributeDescriptionCount = 0;
vi.vertexBindingDescriptionCount = 0;
/* We'll use the alpha output from the shader */
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
/* This renders in the second subpass */
pipeline.subpass = 1;
VkPipeline blend_fullscreen_pipe = VK_NULL_HANDLE;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &blend_fullscreen_pipe);
assert(res == VK_SUCCESS);
destroy_shaders(info);
info.pipeline = VK_NULL_HANDLE;
/* Now we are going to render in the right half of the screen */
viewport.x = (float)info.width / 2;
scissor.offset.x = info.width / 2;
rp_begin.renderArea.offset.x = info.width / 2;
/* Use our framebuffer and render pass */
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderPass = blend_render_pass;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
blend_cube_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
/* Draw the cube blending */
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
/* Advance to the next subpass */
vkCmdNextSubpass(info.cmd, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
blend_fullscreen_pipe);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS,
info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
/* Adjust the viewport to be a square in the centre, just overlapping the
* cube */
viewport.x += 25.0f;
viewport.y += 150.0f;
viewport.width -= 50.0f;
viewport.height -= 300.0f;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &viewport);
vkCmdSetScissor(info.cmd, 0, NUM_SCISSORS, &scissor);
vkCmdDraw(info.cmd, 4, 1, 0, 0);
/* The second renderpass is complete */
vkCmdEndRenderPass(info.cmd);
/* VULKAN_KEY_END */
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = 0;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, NULL, 0, NULL,
1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &presentCompleteSemaphore;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "drawsubpasses");
for (uint32_t i = 0; i < info.swapchainImageCount; i++)
vkDestroyFramebuffer(info.device, stencil_framebuffers[i], NULL);
free(stencil_framebuffers);
vkDestroyRenderPass(info.device, stencil_render_pass, NULL);
vkDestroyRenderPass(info.device, blend_render_pass, NULL);
vkDestroyPipeline(info.device, blend_cube_pipe, NULL);
vkDestroyPipeline(info.device, blend_fullscreen_pipe, NULL);
vkDestroyPipeline(info.device, stencil_cube_pipe, NULL);
vkDestroyPipeline(info.device, stencil_fullscreen_pipe, NULL);
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
void ObjectCache::DestroyRenderPassCache()
{
for (auto& it : m_render_pass_cache)
vkDestroyRenderPass(g_vulkan_context->GetDevice(), it.second, nullptr);
m_render_pass_cache.clear();
}
void VulkanDeleteList::PerformDeletes(VkDevice device) {
for (auto &cmdPool : cmdPools_) {
vkDestroyCommandPool(device, cmdPool, nullptr);
}
cmdPools_.clear();
for (auto &descPool : descPools_) {
vkDestroyDescriptorPool(device, descPool, nullptr);
}
descPools_.clear();
for (auto &module : modules_) {
vkDestroyShaderModule(device, module, nullptr);
}
modules_.clear();
for (auto &buf : buffers_) {
vkDestroyBuffer(device, buf, nullptr);
}
buffers_.clear();
for (auto &bufView : bufferViews_) {
vkDestroyBufferView(device, bufView, nullptr);
}
bufferViews_.clear();
for (auto &image : images_) {
vkDestroyImage(device, image, nullptr);
}
images_.clear();
for (auto &imageView : imageViews_) {
vkDestroyImageView(device, imageView, nullptr);
}
imageViews_.clear();
for (auto &mem : deviceMemory_) {
vkFreeMemory(device, mem, nullptr);
}
deviceMemory_.clear();
for (auto &sampler : samplers_) {
vkDestroySampler(device, sampler, nullptr);
}
samplers_.clear();
for (auto &pipeline : pipelines_) {
vkDestroyPipeline(device, pipeline, nullptr);
}
pipelines_.clear();
for (auto &pcache : pipelineCaches_) {
vkDestroyPipelineCache(device, pcache, nullptr);
}
pipelineCaches_.clear();
for (auto &renderPass : renderPasses_) {
vkDestroyRenderPass(device, renderPass, nullptr);
}
renderPasses_.clear();
for (auto &framebuffer : framebuffers_) {
vkDestroyFramebuffer(device, framebuffer, nullptr);
}
framebuffers_.clear();
for (auto &pipeLayout : pipelineLayouts_) {
vkDestroyPipelineLayout(device, pipeLayout, nullptr);
}
pipelineLayouts_.clear();
for (auto &descSetLayout : descSetLayouts_) {
vkDestroyDescriptorSetLayout(device, descSetLayout, nullptr);
}
descSetLayouts_.clear();
for (auto &callback : callbacks_) {
callback.func(callback.userdata);
}
callbacks_.clear();
}
void destroy_swapchain_renderpass(const VulkanBackend& backend, PresentationInfo& presentInfo)
{
vkDestroyRenderPass(backend.device, presentInfo.renderPass, nullptr);
presentInfo.renderPass = VK_NULL_HANDLE;
}
/**
* Good ol' main function.
*/
int main(int argc, char* argv[])
{
static int windowWidth = 800;
static int windowHeight = 600;
static const char * applicationName = "SdlVulkanDemo_03_double_buffering";
static const char * engineName = applicationName;
bool boolResult;
VkResult result;
/*
* SDL2 Initialization
*/
SDL_Window *mySdlWindow;
SDL_SysWMinfo mySdlSysWmInfo;
boolResult = vkdemos::utils::sdl2Initialization(applicationName, windowWidth, windowHeight, mySdlWindow, mySdlSysWmInfo);
assert(boolResult);
/*
* Vulkan initialization.
*/
std::vector<const char *> layersNamesToEnable;
layersNamesToEnable.push_back("VK_LAYER_LUNARG_standard_validation");
std::vector<const char *> extensionsNamesToEnable;
extensionsNamesToEnable.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
extensionsNamesToEnable.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
extensionsNamesToEnable.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME); // TODO: add support for other windowing systems
VkInstance myInstance;
boolResult = vkdemos::createVkInstance(layersNamesToEnable, extensionsNamesToEnable, applicationName, engineName, myInstance);
assert(boolResult);
VkDebugReportCallbackEXT myDebugReportCallback;
vkdemos::createDebugReportCallback(myInstance,
VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | VK_DEBUG_REPORT_DEBUG_BIT_EXT,
vkdemos::debugCallback,
myDebugReportCallback
);
VkPhysicalDevice myPhysicalDevice;
boolResult = vkdemos::chooseVkPhysicalDevice(myInstance, 0, myPhysicalDevice);
assert(boolResult);
VkSurfaceKHR mySurface;
boolResult = vkdemos::createVkSurface(myInstance, mySdlSysWmInfo, mySurface);
assert(boolResult);
VkDevice myDevice;
VkQueue myQueue;
uint32_t myQueueFamilyIndex;
boolResult = vkdemos::createVkDeviceAndVkQueue(myPhysicalDevice, mySurface, layersNamesToEnable, myDevice, myQueue, myQueueFamilyIndex);
assert(boolResult);
VkSwapchainKHR mySwapchain;
VkFormat mySurfaceFormat;
boolResult = vkdemos::createVkSwapchain(myPhysicalDevice, myDevice, mySurface, windowWidth, windowHeight, FRAME_LAG, VK_NULL_HANDLE, mySwapchain, mySurfaceFormat);
assert(boolResult);
std::vector<VkImage> mySwapchainImagesVector;
std::vector<VkImageView> mySwapchainImageViewsVector;
boolResult = vkdemos::getSwapchainImagesAndViews(myDevice, mySwapchain, mySurfaceFormat, mySwapchainImagesVector, mySwapchainImageViewsVector);
assert(boolResult);
VkCommandPool myCommandPool;
boolResult = vkdemos::createCommandPool(myDevice, myQueueFamilyIndex, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, myCommandPool);
assert(boolResult);
VkCommandBuffer myCmdBufferInitialization;
boolResult = vkdemos::allocateCommandBuffer(myDevice, myCommandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, myCmdBufferInitialization);
assert(boolResult);
/*
* Initializations from Demo 02 (Triangle).
*/
VkPhysicalDeviceMemoryProperties myMemoryProperties;
vkGetPhysicalDeviceMemoryProperties(myPhysicalDevice, &myMemoryProperties);
// Create the Depth Buffer's Image and View.
const VkFormat myDepthBufferFormat = VK_FORMAT_D16_UNORM;
VkImage myDepthImage;
VkImageView myDepthImageView;
VkDeviceMemory myDepthMemory;
boolResult = vkdemos::createAndAllocateImage(myDevice,
myMemoryProperties,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
0,
myDepthBufferFormat,
windowWidth,
windowHeight,
myDepthImage,
myDepthMemory,
&myDepthImageView,
VK_IMAGE_ASPECT_DEPTH_BIT
);
assert(boolResult);
// Create the renderpass.
VkRenderPass myRenderPass;
boolResult = demo02CreateRenderPass(myDevice, mySurfaceFormat, myDepthBufferFormat, myRenderPass);
assert(boolResult);
// Create the Framebuffers, based on the number of swapchain images.
std::vector<VkFramebuffer> myFramebuffersVector;
myFramebuffersVector.reserve(mySwapchainImageViewsVector.size());
for(const auto view : mySwapchainImageViewsVector) {
VkFramebuffer fb;
boolResult = vkdemos::utils::createFramebuffer(myDevice, myRenderPass, {view, myDepthImageView}, windowWidth, windowHeight, fb);
assert(boolResult);
myFramebuffersVector.push_back(fb);
}
// Create a buffer to use as the vertex buffer.
const size_t vertexBufferSize = sizeof(TriangleDemoVertex)*NUM_DEMO_VERTICES;
VkBuffer myVertexBuffer;
VkDeviceMemory myVertexBufferMemory;
boolResult = vkdemos::createAndAllocateBuffer(myDevice,
myMemoryProperties,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
vertexBufferSize,
myVertexBuffer,
myVertexBufferMemory
);
assert(boolResult);
// Map vertex buffer and insert data
{
void *mappedBuffer;
result = vkMapMemory(myDevice, myVertexBufferMemory, 0, VK_WHOLE_SIZE, 0, &mappedBuffer);
assert(result == VK_SUCCESS);
memcpy(mappedBuffer, vertices, vertexBufferSize);
vkUnmapMemory(myDevice, myVertexBufferMemory);
}
// Create the pipeline.
const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.setLayoutCount = 0,
.pSetLayouts = nullptr,
.pushConstantRangeCount = 0,
.pPushConstantRanges = nullptr,
};
VkPipelineLayout myPipelineLayout;
result = vkCreatePipelineLayout(myDevice, &pipelineLayoutCreateInfo, nullptr, &myPipelineLayout);
assert(result == VK_SUCCESS);
// Create Pipeline.
VkPipeline myGraphicsPipeline;
boolResult = demo02CreatePipeline(myDevice, myRenderPass, myPipelineLayout, VERTEX_SHADER_FILENAME, FRAGMENT_SHADER_FILENAME, VERTEX_INPUT_BINDING, myGraphicsPipeline);
assert(boolResult);
/*
* In the PerFrameData struct we group all the objects that are used in a single frame, and that
* must remain valid for the duration of that frame.
*
*/
PerFrameData perFrameDataVector[FRAME_LAG];
for(int i = 0; i < FRAME_LAG; i++)
{
boolResult = vkdemos::allocateCommandBuffer(myDevice, myCommandPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, perFrameDataVector[i].presentCmdBuffer);
assert(boolResult);
result = vkdemos::utils::createFence(myDevice, perFrameDataVector[i].presentFence);
assert(result == VK_SUCCESS);
result = vkdemos::utils::createSemaphore(myDevice, perFrameDataVector[i].imageAcquiredSemaphore);
assert(result == VK_SUCCESS);
result = vkdemos::utils::createSemaphore(myDevice, perFrameDataVector[i].renderingCompletedSemaphore);
assert(result == VK_SUCCESS);
perFrameDataVector[i].fenceInitialized = false;
}
/*
* Generation and submission of the initialization commands' command buffer.
*/
// We fill the initialization command buffer with... the initialization commands.
boolResult = demo02FillInitializationCommandBuffer(myCmdBufferInitialization, myDepthImage);
assert(boolResult);
// We now submit the command buffer to the queue we created before, and we wait
// for its completition.
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = nullptr,
.waitSemaphoreCount = 0,
.pWaitSemaphores = nullptr,
.pWaitDstStageMask = nullptr,
.commandBufferCount = 1,
.pCommandBuffers = &myCmdBufferInitialization,
.signalSemaphoreCount = 0,
.pSignalSemaphores = nullptr
};
result = vkQueueSubmit(myQueue, 1, &submitInfo, VK_NULL_HANDLE);
assert(result == VK_SUCCESS);
// Wait for the queue to complete its work.
result = vkQueueWaitIdle(myQueue);
assert(result == VK_SUCCESS);
/*
* Event loop
*/
SDL_Event sdlEvent;
bool quit = false;
// Just some variables for frame statistics
long frameNumber = 0;
long frameMaxTime = LONG_MIN;
long frameMinTime = LONG_MAX;
long frameAvgTimeSum = 0;
long frameAvgTimeSumSquare = 0;
constexpr long FRAMES_PER_STAT = 120; // How many frames to wait before printing frame time statistics.
// The main event/render loop.
while(!quit)
{
// Process events for this frame
while(SDL_PollEvent(&sdlEvent))
{
if (sdlEvent.type == SDL_QUIT) {
quit = true;
}
if (sdlEvent.type == SDL_KEYDOWN && sdlEvent.key.keysym.sym == SDLK_ESCAPE) {
quit = true;
}
}
// Rendering code
if(!quit)
{
// Render a single frame
auto renderStartTime = std::chrono::high_resolution_clock::now();
quit = !demo03RenderSingleFrame(myDevice, myQueue, mySwapchain, myFramebuffersVector, myRenderPass, myGraphicsPipeline, myVertexBuffer, VERTEX_INPUT_BINDING, perFrameDataVector[frameNumber % FRAME_LAG], windowWidth, windowHeight);
auto renderStopTime = std::chrono::high_resolution_clock::now();
// Compute frame time statistics
auto elapsedTimeUs = std::chrono::duration_cast<std::chrono::microseconds>(renderStopTime - renderStartTime).count();
frameMaxTime = std::max(frameMaxTime, elapsedTimeUs);
frameMinTime = std::min(frameMinTime, elapsedTimeUs);
frameAvgTimeSum += elapsedTimeUs;
frameAvgTimeSumSquare += elapsedTimeUs*elapsedTimeUs;
// Print statistics if necessary
if(frameNumber % FRAMES_PER_STAT == 0)
{
auto average = frameAvgTimeSum/FRAMES_PER_STAT;
auto stddev = std::sqrt(frameAvgTimeSumSquare/FRAMES_PER_STAT - average*average);
std::cout << "Frame time: average " << std::setw(6) << average
<< " us, maximum " << std::setw(6) << frameMaxTime
<< " us, minimum " << std::setw(6) << frameMinTime
<< " us, stddev " << (long)stddev
<< " (" << std::fixed << std::setprecision(2) << (stddev/average * 100.0f) << "%)"
<< std::endl;
frameMaxTime = LONG_MIN;
frameMinTime = LONG_MAX;
frameAvgTimeSum = 0;
frameAvgTimeSumSquare = 0;
}
frameNumber++;
}
}
/*
* Deinitialization
*/
// We wait for pending operations to complete before starting to destroy stuff.
result = vkQueueWaitIdle(myQueue);
assert(result == VK_SUCCESS);
// Destroy the objects in the perFrameDataVector array.
for(int i = 0; i < FRAME_LAG; i++)
{
vkDestroyFence(myDevice, perFrameDataVector[i].presentFence, nullptr);
vkDestroySemaphore(myDevice, perFrameDataVector[i].imageAcquiredSemaphore, nullptr);
vkDestroySemaphore(myDevice, perFrameDataVector[i].renderingCompletedSemaphore, nullptr);
}
/*
* For more informations on the following commands, refer to Demo 02.
*/
vkDestroyPipeline(myDevice, myGraphicsPipeline, nullptr);
vkDestroyPipelineLayout(myDevice, myPipelineLayout, nullptr);
vkDestroyBuffer(myDevice, myVertexBuffer, nullptr);
vkFreeMemory(myDevice, myVertexBufferMemory, nullptr);
for(auto framebuffer : myFramebuffersVector)
vkDestroyFramebuffer(myDevice, framebuffer, nullptr);
vkDestroyRenderPass(myDevice, myRenderPass, nullptr);
vkDestroyImageView(myDevice, myDepthImageView, nullptr);
vkDestroyImage(myDevice, myDepthImage, nullptr);
vkFreeMemory(myDevice, myDepthMemory, nullptr);
/*
* For more informations on the following commands, refer to Demo 01.
*/
vkDestroyCommandPool(myDevice, myCommandPool, nullptr);
for(auto imgView : mySwapchainImageViewsVector)
vkDestroyImageView(myDevice, imgView, nullptr);
vkDestroySwapchainKHR(myDevice, mySwapchain, nullptr);
vkDestroyDevice(myDevice, nullptr);
vkDestroySurfaceKHR(myInstance, mySurface, nullptr);
vkdemos::destroyDebugReportCallback(myInstance, myDebugReportCallback);
vkDestroyInstance(myInstance, nullptr);
SDL_DestroyWindow(mySdlWindow);
SDL_Quit();
return 0;
}
void Renderer::_DeInitRenderPass() {
vkDestroyRenderPass(_device, _render_pass, nullptr);
_render_pass = nullptr;
}
static void resize_vulkan(GLFWwindow* /*window*/, int w, int h)
{
VkResult err;
VkSwapchainKHR old_swapchain = g_Swapchain;
err = vkDeviceWaitIdle(g_Device);
check_vk_result(err);
// Destroy old Framebuffer:
for (uint32_t i = 0; i < g_BackBufferCount; i++)
if (g_BackBufferView[i])
vkDestroyImageView(g_Device, g_BackBufferView[i], g_Allocator);
for (uint32_t i = 0; i < g_BackBufferCount; i++)
if (g_Framebuffer[i])
vkDestroyFramebuffer(g_Device, g_Framebuffer[i], g_Allocator);
if (g_RenderPass)
vkDestroyRenderPass(g_Device, g_RenderPass, g_Allocator);
// Create Swapchain:
{
VkSwapchainCreateInfoKHR info = {};
info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
info.surface = g_Surface;
info.imageFormat = g_SurfaceFormat.format;
info.imageColorSpace = g_SurfaceFormat.colorSpace;
info.imageArrayLayers = 1;
info.imageUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
info.presentMode = g_PresentMode;
info.clipped = VK_TRUE;
info.oldSwapchain = old_swapchain;
VkSurfaceCapabilitiesKHR cap;
err = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(g_Gpu, g_Surface, &cap);
check_vk_result(err);
if (cap.maxImageCount > 0)
info.minImageCount = (cap.minImageCount + 2 < cap.maxImageCount) ? (cap.minImageCount + 2) : cap.maxImageCount;
else
info.minImageCount = cap.minImageCount + 2;
if (cap.currentExtent.width == 0xffffffff)
{
fb_width = w;
fb_height = h;
info.imageExtent.width = fb_width;
info.imageExtent.height = fb_height;
}
else
{
fb_width = cap.currentExtent.width;
fb_height = cap.currentExtent.height;
info.imageExtent.width = fb_width;
info.imageExtent.height = fb_height;
}
err = vkCreateSwapchainKHR(g_Device, &info, g_Allocator, &g_Swapchain);
check_vk_result(err);
err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, NULL);
check_vk_result(err);
err = vkGetSwapchainImagesKHR(g_Device, g_Swapchain, &g_BackBufferCount, g_BackBuffer);
check_vk_result(err);
}
if (old_swapchain)
vkDestroySwapchainKHR(g_Device, old_swapchain, g_Allocator);
// Create the Render Pass:
{
VkAttachmentDescription attachment = {};
attachment.format = g_SurfaceFormat.format;
attachment.samples = VK_SAMPLE_COUNT_1_BIT;
attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference color_attachment = {};
color_attachment.attachment = 0;
color_attachment.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_attachment;
VkRenderPassCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
info.attachmentCount = 1;
info.pAttachments = &attachment;
info.subpassCount = 1;
info.pSubpasses = &subpass;
err = vkCreateRenderPass(g_Device, &info, g_Allocator, &g_RenderPass);
check_vk_result(err);
}
// Create The Image Views
{
VkImageViewCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
info.viewType = VK_IMAGE_VIEW_TYPE_2D;
info.format = g_SurfaceFormat.format;
info.components.r = VK_COMPONENT_SWIZZLE_R;
info.components.g = VK_COMPONENT_SWIZZLE_G;
info.components.b = VK_COMPONENT_SWIZZLE_B;
info.components.a = VK_COMPONENT_SWIZZLE_A;
info.subresourceRange = g_ImageRange;
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
info.image = g_BackBuffer[i];
err = vkCreateImageView(g_Device, &info, g_Allocator, &g_BackBufferView[i]);
check_vk_result(err);
}
}
// Create Framebuffer:
{
VkImageView attachment[1];
VkFramebufferCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
info.renderPass = g_RenderPass;
info.attachmentCount = 1;
info.pAttachments = attachment;
info.width = fb_width;
info.height = fb_height;
info.layers = 1;
for (uint32_t i = 0; i < g_BackBufferCount; i++)
{
attachment[0] = g_BackBufferView[i];
err = vkCreateFramebuffer(g_Device, &info, g_Allocator, &g_Framebuffer[i]);
check_vk_result(err);
}
}
}
int main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Renderpass Sample";
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_connection(info);
init_window_size(info, 50, 50);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
init_depth_buffer(info);
/* VULKAN_KEY_START */
/* Need attachments for render target and depth buffer */
VkAttachmentDescription attachments[2];
attachments[0].format = info.format;
attachments[0].samples = NUM_SAMPLES;
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[0].initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachments[0].flags = 0;
attachments[1].format = info.depth.format;
attachments[1].samples = NUM_SAMPLES;
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].initialLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].finalLayout =
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachments[1].flags = 0;
VkAttachmentReference color_reference = {};
color_reference.attachment = 0;
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference depth_reference = {};
depth_reference.attachment = 1;
depth_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.flags = 0;
subpass.inputAttachmentCount = 0;
subpass.pInputAttachments = NULL;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_reference;
subpass.pResolveAttachments = NULL;
subpass.pDepthStencilAttachment = &depth_reference;
subpass.preserveAttachmentCount = 0;
subpass.pPreserveAttachments = NULL;
VkRenderPassCreateInfo rp_info = {};
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.pNext = NULL;
rp_info.attachmentCount = 2;
rp_info.pAttachments = attachments;
rp_info.subpassCount = 1;
rp_info.pSubpasses = &subpass;
rp_info.dependencyCount = 0;
rp_info.pDependencies = NULL;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &info.render_pass);
assert(res == VK_SUCCESS);
execute_end_command_buffer(info);
execute_queue_command_buffer(info);
/* VULKAN_KEY_END */
vkDestroyRenderPass(info.device, info.render_pass, NULL);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
agpu_framebuffer *_agpu_framebuffer::create(agpu_device *device, agpu_uint width, agpu_uint height, agpu_uint colorCount, agpu_texture_view_description* colorViews, agpu_texture_view_description* depthStencilView)
{
agpu_framebuffer *result = nullptr;
// Attachments
std::vector<VkAttachmentDescription> attachments(colorCount + (depthStencilView != nullptr ? 1 : 0));
for (agpu_uint i = 0; i < colorCount; ++i)
{
auto view = &colorViews[i];
auto &attachment = attachments[i];
if (!view || !view->texture)
return nullptr;
attachment.format = mapTextureFormat(view->format);
attachment.samples = VK_SAMPLE_COUNT_1_BIT;
attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachment.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
if (depthStencilView != nullptr)
{
if (!depthStencilView->texture)
return nullptr;
auto &attachment = attachments.back();
attachment.format = mapTextureFormat(depthStencilView->format);
attachment.samples = VK_SAMPLE_COUNT_1_BIT;
attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
attachment.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
attachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
}
// Color reference
std::vector<VkAttachmentReference> colorReference(colorCount);
for (agpu_uint i = 0; i < colorCount; ++i)
{
colorReference[i].attachment = i;
colorReference[i].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
}
// Depth reference
VkAttachmentReference depthReference;
memset(&depthReference, 0, sizeof(depthReference));
depthReference.attachment = colorCount;
depthReference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
// Sub pass
VkSubpassDescription subpass;
memset(&subpass, 0, sizeof(subpass));
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.colorAttachmentCount = colorCount;
subpass.pColorAttachments = &colorReference[0];
subpass.pDepthStencilAttachment = &depthReference;
if (!depthStencilView)
subpass.pDepthStencilAttachment = nullptr;
// Render pass
VkRenderPassCreateInfo renderPassCreateInfo;
memset(&renderPassCreateInfo, 0, sizeof(renderPassCreateInfo));
renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassCreateInfo.attachmentCount = attachments.size();
renderPassCreateInfo.pAttachments = &attachments[0];
renderPassCreateInfo.subpassCount = 1;
renderPassCreateInfo.pSubpasses = &subpass;
VkRenderPass renderPass;
auto error = vkCreateRenderPass(device->device, &renderPassCreateInfo, nullptr, &renderPass);
if (error)
return nullptr;
// Create the framebuffer
std::vector<VkImageView> attachmentViews(attachments.size());
for (agpu_uint i = 0; i < colorCount; ++i)
{
auto view = agpu_texture::createImageView(device, &colorViews[i]);
if (!view)
goto failure;
attachmentViews[i] = view;
}
if (depthStencilView)
{
auto view = agpu_texture::createImageView(device, depthStencilView);
if (!view)
goto failure;
attachmentViews.back() = view;
}
VkFramebufferCreateInfo createInfo;
memset(&createInfo, 0, sizeof(createInfo));
createInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
createInfo.attachmentCount = attachmentViews.size();
createInfo.pAttachments = &attachmentViews[0];
createInfo.renderPass = renderPass;
createInfo.width = width;
createInfo.height = height;
createInfo.layers = 1;
VkFramebuffer framebuffer;
error = vkCreateFramebuffer(device->device, &createInfo, nullptr, &framebuffer);
if (error)
goto failure;
result = new agpu_framebuffer(device);
result->colorCount = colorCount;
result->hasDepthStencil = depthStencilView != nullptr;
result->width = width;
result->height = height;
result->renderPass = renderPass;
result->framebuffer = framebuffer;
result->attachmentViews = attachmentViews;
result->attachmentTextures.resize(attachmentViews.size());
for (agpu_uint i = 0; i < colorCount; ++i)
{
auto texture = colorViews[i].texture;
texture->retain();
result->attachmentTextures[i] = texture;
}
if (depthStencilView)
{
auto texture = depthStencilView->texture;
texture->retain();
result->attachmentTextures.back() = texture;
}
return result;
failure:
vkDestroyRenderPass(device->device, renderPass, nullptr);
for (auto view : attachmentViews)
{
if (view)
vkDestroyImageView(device->device, view, nullptr);
}
return nullptr;
}
