~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(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class // Clean up texture resources vkDestroyImageView(device, cubeMap.view, nullptr); vkDestroyImage(device, cubeMap.image, nullptr); vkDestroySampler(device, cubeMap.sampler, nullptr); vkFreeMemory(device, cubeMap.deviceMemory, nullptr); vkDestroyPipeline(device, pipelines.skybox, nullptr); vkDestroyPipeline(device, pipelines.reflect, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); for (auto& model : models.objects) { model.destroy(); } models.skybox.destroy(); uniformBuffers.object.destroy(); uniformBuffers.skybox.destroy(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.terrain, nullptr); if (pipelines.wireframe != VK_NULL_HANDLE) { vkDestroyPipeline(device, pipelines.wireframe, nullptr); } vkDestroyPipeline(device, pipelines.skysphere, nullptr); vkDestroyPipelineLayout(device, pipelineLayouts.skysphere, nullptr); vkDestroyPipelineLayout(device, pipelineLayouts.terrain, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.terrain, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayouts.skysphere, nullptr); models.terrain.destroy(); models.skysphere.destroy(); uniformBuffers.skysphereVertex.destroy(); uniformBuffers.terrainTessellation.destroy(); textures.heightMap.destroy(); textures.skySphere.destroy(); textures.terrainArray.destroy(); if (queryPool != VK_NULL_HANDLE) { vkDestroyQueryPool(device, queryPool, nullptr); vkDestroyBuffer(device, queryResult.buffer, nullptr); vkFreeMemory(device, queryResult.memory, nullptr); } }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.logos, nullptr); vkDestroyPipeline(device, pipelines.models, nullptr); vkDestroyPipeline(device, pipelines.skybox, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkTools::destroyUniformData(device, &uniformData.meshVS); for (auto& mesh : meshes) { vkDestroyBuffer(device, mesh->vertexBuffer.buf, nullptr); vkFreeMemory(device, mesh->vertexBuffer.mem, nullptr); vkDestroyBuffer(device, mesh->indexBuffer.buf, nullptr); vkFreeMemory(device, mesh->indexBuffer.mem, nullptr); } textureLoader->destroyTexture(textures.skybox); delete(demoMeshes.logos); delete(demoMeshes.background); delete(demoMeshes.models); delete(demoMeshes.skybox); }
~VulkanExample() { vkDestroyPipeline(device, pipelines.phong, nullptr); vkDestroyPipeline(device, pipelines.textured, nullptr); vkDestroyPipeline(device, pipelines.toon, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); models.cube.destroy(); textures.colormap.destroy(); uniformBuffer.destroy(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.solid, nullptr); vkDestroyPipeline(device, pipelines.normals, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); models.object.destroy(); uniformBuffers.GS.destroy(); uniformBuffers.VS.destroy(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.solid, nullptr); vkDestroyPipeline(device, pipelines.normals, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkMeshLoader::freeMeshBufferResources(device, &meshes.object); vkTools::destroyUniformData(device, &uniformData.VS); vkTools::destroyUniformData(device, &uniformData.GS); }
~VulkanExample() { vkDestroyPipeline(device, pipelines.phong, nullptr); vkDestroyPipeline(device, pipelines.textured, nullptr); vkDestroyPipeline(device, pipelines.toon, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkMeshLoader::freeMeshBufferResources(device, &meshes.cube); textureLoader->destroyTexture(textures.colormap); uniformBuffer.destroy(); }
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(); } }
void Copy_To_Swapchain::destroy() { vkDestroyDescriptorSetLayout(vk.device, set_layout, nullptr); vkDestroyPipelineLayout(vk.device, pipeline_layout, nullptr); vkDestroyPipeline(vk.device, pipeline, nullptr); vkDestroySampler(vk.device, point_sampler, nullptr); sets.clear(); }
//============================================================================== PipelineImpl::~PipelineImpl() { if(m_handle) { vkDestroyPipeline(getDevice(), m_handle, nullptr); } }
void VulkanTexturedQuad::ShutdownImpl() { vkDestroyPipeline(device_, pipeline_, nullptr); vkDestroyPipelineLayout(device_, pipelineLayout_, nullptr); vkDestroyBuffer(device_, vertexBuffer_, nullptr); vkDestroyBuffer(device_, indexBuffer_, nullptr); vkFreeMemory(device_, deviceBufferMemory_, nullptr); vkDestroyImageView (device_, rubyImageView_, nullptr); vkDestroyImage (device_, rubyImage_, nullptr); vkFreeMemory (device_, deviceImageMemory_, nullptr); vkDestroyBuffer (device_, uploadImageBuffer_, nullptr); vkFreeMemory (device_, uploadImageMemory_, nullptr); vkDestroyBuffer (device_, uploadBufferBuffer_, nullptr); vkFreeMemory (device_, uploadBufferMemory_, nullptr); vkDestroyDescriptorSetLayout (device_, descriptorSetLayout_, nullptr); vkDestroyDescriptorPool (device_, descriptorPool_, nullptr); vkDestroySampler (device_, sampler_, nullptr); vkDestroyShaderModule(device_, vertexShader_, nullptr); vkDestroyShaderModule(device_, fragmentShader_, nullptr); VulkanSample::ShutdownImpl(); }
void ImGui_ImplGlfwVulkan_InvalidateDeviceObjects() { ImGui_ImplGlfwVulkan_InvalidateFontUploadObjects(); for (int i=0; i<IMGUI_VK_QUEUED_FRAMES; i++) { if (g_VertexBuffer[i]) vkDestroyBuffer(g_Device, g_VertexBuffer[i], g_Allocator); if (g_VertexBufferMemory[i]) vkFreeMemory(g_Device, g_VertexBufferMemory[i], g_Allocator); if (g_IndexBuffer[i]) vkDestroyBuffer(g_Device, g_IndexBuffer[i], g_Allocator); if (g_IndexBufferMemory[i]) vkFreeMemory(g_Device, g_IndexBufferMemory[i], g_Allocator); } if (g_FontView) vkDestroyImageView(g_Device, g_FontView, g_Allocator); if (g_FontImage) vkDestroyImage(g_Device, g_FontImage, g_Allocator); if (g_FontMemory) vkFreeMemory(g_Device, g_FontMemory, g_Allocator); if (g_FontSampler) vkDestroySampler(g_Device, g_FontSampler, g_Allocator); if (g_DescriptorSetLayout) vkDestroyDescriptorSetLayout(g_Device, g_DescriptorSetLayout, g_Allocator); if (g_PipelineLayout) vkDestroyPipelineLayout(g_Device, g_PipelineLayout, g_Allocator); if (g_Pipeline) vkDestroyPipeline(g_Device, g_Pipeline, g_Allocator); }
void Example::terminateResources(const vkts::IUpdateThreadContext& updateContext) { if (device.get()) { for (int32_t i = 0; i < (int32_t)swapchainImagesCount; i++) { if (cmdBuffer[i].get()) { cmdBuffer[i]->destroy(); } if (framebuffer[i].get()) { framebuffer[i]->destroy(); } if (swapchainImageView[i].get()) { swapchainImageView[i]->destroy(); } } if (pipeline != VK_NULL_HANDLE) { vkDestroyPipeline(device->getDevice(), pipeline, nullptr); pipeline = VK_NULL_HANDLE; } if (renderPass.get()) { renderPass->destroy(); } } }
/** * Destroy the graphics pipeline. */ VkcPipeline::~VkcPipeline() { if (logicalDevice != VK_NULL_HANDLE) { if (descriptorSet != VK_NULL_HANDLE) vkFreeDescriptorSets(logicalDevice, descriptorPool, 1, &descriptorSet); if (setLayout != VK_NULL_HANDLE) vkDestroyDescriptorSetLayout(logicalDevice, setLayout, nullptr); if (descriptorPool != VK_NULL_HANDLE) vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr); if (vertShader != VK_NULL_HANDLE) vkDestroyShaderModule(logicalDevice, vertShader, nullptr); if (fragShader != VK_NULL_HANDLE) vkDestroyShaderModule(logicalDevice, fragShader, nullptr); if (layout != VK_NULL_HANDLE) vkDestroyPipelineLayout(logicalDevice, layout, nullptr); if (handle != VK_NULL_HANDLE) vkDestroyPipeline(logicalDevice, handle, nullptr); } }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.solid, nullptr); if (pipelines.wireframe != VK_NULL_HANDLE) { vkDestroyPipeline(device, pipelines.wireframe, nullptr); } vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); model.destroy(device); textures.colorMap.destroy(); uniformBuffers.scene.destroy(); }
void SkinningAppVk::shutdownRendering(void) { vkDeviceWaitIdle(device()); // destroy other resources here vkDestroyPipeline(device(), mPipeline, NULL); }
~VulkanExample() { vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); uniformBuffer.destroy(); conditionalBuffer.destroy(); }
void preparePipelines() { if (pipeline != VK_NULL_HANDLE) { vkDestroyPipeline(device, pipeline, nullptr); } const std::vector<VkDynamicState> dynamicStateEnables = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCI = vks::initializers::pipelineInputAssemblyStateCreateInfo(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE); VkPipelineColorBlendAttachmentState blendAttachmentState = vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE); VkPipelineColorBlendStateCreateInfo colorBlendStateCI = vks::initializers::pipelineColorBlendStateCreateInfo(1, &blendAttachmentState); VkPipelineDepthStencilStateCreateInfo depthStencilStateCI = vks::initializers::pipelineDepthStencilStateCreateInfo(VK_TRUE, VK_FALSE, VK_COMPARE_OP_LESS_OR_EQUAL); VkPipelineViewportStateCreateInfo viewportStateCI = vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0); VkPipelineMultisampleStateCreateInfo multisampleStateCI = vks::initializers::pipelineMultisampleStateCreateInfo(VK_SAMPLE_COUNT_1_BIT, 0); VkPipelineDynamicStateCreateInfo dynamicStateCI = vks::initializers::pipelineDynamicStateCreateInfo(dynamicStateEnables.data(), static_cast<uint32_t>(dynamicStateEnables.size()), 0); VkPipelineRasterizationStateCreateInfo rasterizationStateCI{}; rasterizationStateCI.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; rasterizationStateCI.polygonMode = VK_POLYGON_MODE_FILL; rasterizationStateCI.lineWidth = 1.0f; rasterizationStateCI.cullMode = VK_CULL_MODE_NONE + cullMode; rasterizationStateCI.frontFace = windingOrder == 0 ? VK_FRONT_FACE_CLOCKWISE : VK_FRONT_FACE_COUNTER_CLOCKWISE; // Vertex bindings and attributes std::vector<VkVertexInputBindingDescription> vertexInputBindings = { vks::initializers::vertexInputBindingDescription(0, sizeof(float) * 5, VK_VERTEX_INPUT_RATE_VERTEX), }; std::vector<VkVertexInputAttributeDescription> vertexInputAttributes = { vks::initializers::vertexInputAttributeDescription(0, 0, VK_FORMAT_R32G32B32_SFLOAT, 0), // Position vks::initializers::vertexInputAttributeDescription(0, 1, VK_FORMAT_R32G32_SFLOAT, sizeof(float) * 3), // uv }; VkPipelineVertexInputStateCreateInfo vertexInputState = vks::initializers::pipelineVertexInputStateCreateInfo(); vertexInputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertexInputBindings.size()); vertexInputState.pVertexBindingDescriptions = vertexInputBindings.data(); vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertexInputAttributes.size()); vertexInputState.pVertexAttributeDescriptions = vertexInputAttributes.data(); VkGraphicsPipelineCreateInfo pipelineCreateInfoCI = vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0); //pipelineCreateInfoCI.pVertexInputState = &emptyInputState; pipelineCreateInfoCI.pVertexInputState = &vertexInputState; pipelineCreateInfoCI.pInputAssemblyState = &inputAssemblyStateCI; pipelineCreateInfoCI.pRasterizationState = &rasterizationStateCI; pipelineCreateInfoCI.pColorBlendState = &colorBlendStateCI; pipelineCreateInfoCI.pMultisampleState = &multisampleStateCI; pipelineCreateInfoCI.pViewportState = &viewportStateCI; pipelineCreateInfoCI.pDepthStencilState = &depthStencilStateCI; pipelineCreateInfoCI.pDynamicState = &dynamicStateCI; const std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages = { loadShader(getAssetPath() + "shaders/negativeviewportheight/quad.vert.spv", VK_SHADER_STAGE_VERTEX_BIT), loadShader(getAssetPath() + "shaders/negativeviewportheight/quad.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT) }; pipelineCreateInfoCI.stageCount = static_cast<uint32_t>(shaderStages.size()); pipelineCreateInfoCI.pStages = shaderStages.data(); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfoCI, nullptr, &pipeline)); }
~VulkanExample() { vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); textures.CW.destroy(); textures.CCW.destroy(); quad.destroy(); }
void GraphicsPipeline::destroy() { if (pipeline) { vkDestroyPipeline(device, pipeline, nullptr); pipeline = VK_NULL_HANDLE; } }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.parallaxMapping, nullptr); vkDestroyPipeline(device, pipelines.normalMapping, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkMeshLoader::freeMeshBufferResources(device, &meshes.quad); vkTools::destroyUniformData(device, &uniformData.vertexShader); vkTools::destroyUniformData(device, &uniformData.fragmentShader); textureLoader->destroyTexture(textures.colorMap); textureLoader->destroyTexture(textures.normalHeightMap); }
GraphicsPipeline::~GraphicsPipeline() { Isolate* isolate = Isolate::GetCurrent(); HandleScope handle_scope(isolate); puts("GraphicsPipeline::~GraphicsPipeline()"); vkDestroyPipeline(ObjectWrap::Unwrap<Device>(parent_device.Get(isolate))->vulkan_handle, vulkan_handle, nullptr); }
VKPipeline::~VKPipeline () { if (!_dev.ptr ()) return; VkDevice dev_id = _dev->get_dev_id (); if (XCAM_IS_VALID_VK_ID (_pipe_id)) vkDestroyPipeline (dev_id, _pipe_id, _allocator.ptr ()); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.solid, nullptr); vkDestroyPipeline(device, pipelines.wire, nullptr); vkDestroyPipeline(device, pipelines.solidPassThrough, nullptr); vkDestroyPipeline(device, pipelines.wirePassThrough, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkMeshLoader::freeMeshBufferResources(device, &meshes.object); uniformBuffers.tessControl.destroy(); uniformBuffers.tessEval.destroy(); textureLoader->destroyTexture(textures.colorMap); }
void Renderer::_DeInitGraphicsPipeline() { vkDestroyPipelineLayout(_device, _pipeline_layout, nullptr); _pipeline_layout = nullptr; vkDestroyShaderModule(_device, _frag_module, nullptr); _frag_module = nullptr; vkDestroyShaderModule(_device, _vert_module, nullptr); _vert_module = nullptr; vkDestroyPipeline(_device, _graphics_pipeline, nullptr); _graphics_pipeline = nullptr; }
//------------------------------------------------------------------------------ // //------------------------------------------------------------------------------ bool RendererVk::terminateGraphics() { if(!m_bValid) return true; // destroy the super-sampling pass system m_nvFBOBox.Finish(); // destroys commandBuffers: but not really needed since m_cmdPool later gets destroyed nvk.vkDestroyFence(m_sceneFence[0]); m_sceneFence[0] = NULL; nvk.vkDestroyFence(m_sceneFence[1]); m_sceneFence[1] = NULL; nvk.vkFreeCommandBuffer(m_cmdPool, m_cmdScene[0]); m_cmdScene[0] = NULL; nvk.vkFreeCommandBuffer(m_cmdPool, m_cmdScene[1]); m_cmdScene[1] = NULL; nvk.vkDestroyCommandPool(m_cmdPool); // destroys commands that are inside, obviously for(int i=0; i<DSET_TOTALAMOUNT; i++) { vkDestroyDescriptorSetLayout(nvk.m_device, m_descriptorSetLayouts[i], NULL); // general layout and objects layout m_descriptorSetLayouts[i] = 0; } //vkFreeDescriptorSets(nvk.m_device, m_descPool, 1, &m_descriptorSetGlobal); // no really necessary: we will destroy the pool after that m_descriptorSetGlobal = NULL; vkDestroyDescriptorPool(nvk.m_device, m_descPool, NULL); m_descPool = NULL; vkDestroyPipelineLayout(nvk.m_device, m_pipelineLayout, NULL); m_pipelineLayout = NULL; vkDestroyPipeline(nvk.m_device, m_pipelinefur, NULL); m_pipelinefur = NULL; m_furBuffer.release(); m_matrix.release(); deinitTimers(); nvk.vkDestroySemaphore(m_semOpenGLReadDone); nvk.vkDestroySemaphore(m_semVKRenderingDone); m_semOpenGLReadDone = NULL; m_semVKRenderingDone = NULL; //glGetVkInstanceProcAddrNV = NULL; glWaitVkSemaphoreNV = NULL; glSignalVkSemaphoreNV = NULL; glSignalVkFenceNV = NULL; glDrawVkImageNV = NULL; nvk.DestroyDevice(); m_bValid = false; return false; }
~VulkanExample() { vkDestroyPipeline(device, pipeline, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkDestroyQueryPool(device, queryPool, nullptr); uniformBuffers.VS.destroy(); for (auto& model : models.objects) { model.destroy(); } }
~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(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.postCompute, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkDestroyBuffer(device, computeStorageBuffer.buffer, nullptr); vkFreeMemory(device, computeStorageBuffer.memory, nullptr); vkTools::destroyUniformData(device, &uniformData.computeShader.ubo); vkDestroyPipelineLayout(device, computePipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, computeDescriptorSetLayout, nullptr); vkDestroyPipeline(device, pipelines.compute, nullptr); textureLoader->destroyTexture(textures.particle); textureLoader->destroyTexture(textures.gradient); }