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 vkImageBase::cleanup() { VulkanCore * instance = VulkanCore::getInstance(); VkDevice device = instance->getDevice(); if(imageView != 0) { vkDestroyImageView(device, imageView, nullptr); imageView = 0; } if(imageHandle != 0 ) { vkDestroyImage(device, imageHandle, nullptr); imageHandle = 0; } if(device_memory != 0) { vkFreeMemory(device, device_memory, nullptr); device_memory = 0; } if(cascadeImageView.size() != 0) { for(int i = 0; i < cascadeImageView.size(); i++) vkDestroyImageView(device, cascadeImageView[i], nullptr); cascadeImageView.clear(); } }
~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(); }
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); }
~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(); }
VulkanCommon::~VulkanCommon() { if( Vulkan.Device != VK_NULL_HANDLE ) { vkDeviceWaitIdle( Vulkan.Device ); for( size_t i = 0; i < Vulkan.SwapChain.Images.size(); ++i ) { if( Vulkan.SwapChain.Images[i].ImageView != VK_NULL_HANDLE ) { vkDestroyImageView( GetDevice(), Vulkan.SwapChain.Images[i].ImageView, nullptr ); } } if( Vulkan.SwapChain.Handle != VK_NULL_HANDLE ) { vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain.Handle, nullptr ); } vkDestroyDevice( Vulkan.Device, nullptr ); } if( Vulkan.PresentationSurface != VK_NULL_HANDLE ) { vkDestroySurfaceKHR( Vulkan.Instance, Vulkan.PresentationSurface, nullptr ); } if( Vulkan.Instance != VK_NULL_HANDLE ) { vkDestroyInstance( Vulkan.Instance, nullptr ); } if( VulkanLibrary ) { #if defined(VK_USE_PLATFORM_WIN32_KHR) FreeLibrary( VulkanLibrary ); #elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) dlclose( VulkanLibrary ); #endif } }
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); }
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(); }
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 vkeGameRendererDynamic::releaseFramebuffer(){ VulkanDC *dc = VulkanDC::Get(); VulkanDC::Device *device = dc->getDefaultDevice(); device->waitIdle(); vkDestroyImageView(device->getVKDevice(), m_depth_attachment.view, NULL); vkDestroyImageView(device->getVKDevice(), m_color_attachment.view, NULL); vkDestroyImageView(device->getVKDevice(), m_resolve_attachment[0].view, NULL); vkDestroyImageView(device->getVKDevice(), m_resolve_attachment[1].view, NULL); m_depth_attachment.view = NULL; m_color_attachment.view = NULL; m_resolve_attachment[0].view = NULL; m_resolve_attachment[1].view = NULL; vkDestroyImage(device->getVKDevice(), m_depth_attachment.image, NULL); vkDestroyImage(device->getVKDevice(), m_color_attachment.image, NULL); vkDestroyImage(device->getVKDevice(), m_resolve_attachment[0].image, NULL); vkDestroyImage(device->getVKDevice(), m_resolve_attachment[1].image, NULL); m_depth_attachment.image = NULL; m_color_attachment.image = NULL; m_resolve_attachment[0].image = NULL; m_resolve_attachment[1].image = NULL; vkFreeMemory(device->getVKDevice(), m_depth_attachment.memory, NULL); vkFreeMemory(device->getVKDevice(), m_color_attachment.memory, NULL); vkFreeMemory(device->getVKDevice(), m_resolve_attachment[0].memory, NULL); vkFreeMemory(device->getVKDevice(), m_resolve_attachment[1].memory, NULL); m_depth_attachment.memory = NULL; m_color_attachment.memory = NULL; m_resolve_attachment[0].memory = NULL; m_resolve_attachment[1].memory = NULL; vkDestroyFramebuffer(device->getVKDevice(), m_framebuffers[0], NULL); vkDestroyFramebuffer(device->getVKDevice(), m_framebuffers[1], NULL); m_framebuffers[0] = NULL; m_framebuffers[1] = NULL; }
// Free all Vulkan resources used by the swap chain void cleanup() { for (uint32_t i = 0; i < imageCount; i++) { vkDestroyImageView(device, buffers[i].view, nullptr); } fpDestroySwapchainKHR(device, swapChain, nullptr); vkDestroySurfaceKHR(instance, surface, nullptr); }
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 destroy_swapchain_framebuffers(const VulkanBackend& backend, PresentationInfo& presentInfo) { for (size_t i = 0; i < presentInfo.framebuffers.size(); i++) { vkDestroyImageView(backend.device, presentInfo.imageViews[i], nullptr); vkDestroyFramebuffer(backend.device, presentInfo.framebuffers[i], nullptr); } presentInfo.imageViews.clear(); presentInfo.framebuffers.clear(); }
// Free all Vulkan resources used a texture object void destroyTextureImage(Texture texture) { if (texture.view != VK_NULL_HANDLE) vkDestroyImageView(device, texture.view, nullptr); if (texture.image != VK_NULL_HANDLE) vkDestroyImage(device, texture.image, nullptr); if (texture.sampler != VK_NULL_HANDLE) vkDestroySampler(device, texture.sampler, nullptr); if (texture.deviceMemory != VK_NULL_HANDLE) vkFreeMemory(device, texture.deviceMemory, nullptr); }
void VulkanWindow::FinalizeImageViews() { for ( auto& i : mVkSwapchainImageViews ) { if ( i != VK_NULL_HANDLE ) { vkDestroyImageView ( mVulkanRenderer.GetDevice(), i, nullptr ); i = VK_NULL_HANDLE; } } }
void DestroySwapchainInfo(const DeviceInfo* deviceInfo, SwapchainInfo* swapchainInfo) { for (uint32_t i = 0; i < swapchainInfo->imageCount; i++) { //TODO is image destroyed along with its associated imageview? //vkDestroyImage(device, surfaceInfo->images[i], nullptr); vkDestroyImageView(deviceInfo->device, swapchainInfo->views[i], nullptr); } DestroySwapchainKHR(deviceInfo->device, swapchainInfo->swapChain, nullptr); *swapchainInfo = {}; }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class // Texture target textureLoader->destroyTexture(offScreenFrameBuf.textureTarget); // Frame buffer // Color attachment vkDestroyImageView(device, offScreenFrameBuf.color.view, nullptr); vkDestroyImage(device, offScreenFrameBuf.color.image, nullptr); vkFreeMemory(device, offScreenFrameBuf.color.mem, nullptr); // Depth attachment vkDestroyImageView(device, offScreenFrameBuf.depth.view, nullptr); vkDestroyImage(device, offScreenFrameBuf.depth.image, nullptr); vkFreeMemory(device, offScreenFrameBuf.depth.mem, nullptr); vkDestroyFramebuffer(device, offScreenFrameBuf.frameBuffer, nullptr); vkDestroyPipeline(device, pipelines.quad, nullptr); vkDestroyPipeline(device, pipelines.offscreen, nullptr); vkDestroyPipelineLayout(device, pipelineLayouts.quad, nullptr); vkDestroyPipelineLayout(device, pipelineLayouts.offscreen, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); // Meshes vkMeshLoader::freeMeshBufferResources(device, &meshes.scene); vkMeshLoader::freeMeshBufferResources(device, &meshes.quad); // Uniform buffers vkTools::destroyUniformData(device, &uniformDataVS); vkTools::destroyUniformData(device, &uniformDataOffscreenVS); vkFreeCommandBuffers(device, cmdPool, 1, &offScreenCmdBuffer); }
void swapChainCleanup( struct SwapChain *swapChain ) { struct SwapChainBuffer *buf; int n; for( n = 0; n < swapChain->nImages; n++ ) { vkDestroyImageView( swapChain->device, swapChain->images[n], NULL ); } swapChain->fpDestroySwapchainKHR( swapChain->device, swapChain->swapChain, NULL ); vkDestroySurfaceKHR( swapChain->instance, swapChain->surface, NULL ); }
void Image::destroy() { if (view) { vkDestroyImageView(vk, view, NULL); view = NULL; } if (mem) { vkFreeMemory(vk, mem, NULL); mem = NULL; if (image) vkDestroyImage(vk, image, NULL); } image = NULL; }
~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 VkContext::Destroy() { vkDeviceWaitIdle(dev); // Free command buffers if (drawCmdBuffers.size() > 0) { vkFreeCommandBuffers(dev, cmdPool, (u32)drawCmdBuffers.size(), &drawCmdBuffers[0]); } // Destroy command pools vkDestroyCommandPool(dev, cmdPool, nullptr); // Destroy semaphores vkDestroySemaphore(dev, acquireCompleteSemaphore, nullptr); vkDestroySemaphore(dev, renderCompleteSemaphore, nullptr); // Destroy swapchain image views for (u32 i = 0; i < swapchainImageViews.size(); i++) { vkDestroyImageView(dev, swapchainImageViews[i], nullptr); } // Destroy swapchain if (swapchain) { vkDestroySwapchainKHR(dev, swapchain, nullptr); } // Destroy surface if (surf) { vkDestroySurfaceKHR(instance, surf, nullptr); } // Destroy device if (dev) { vkDestroyDevice(dev, nullptr); } #ifdef VOXL_DEBUG // Destroy debug report callback if (msgCallback != VK_NULL_HANDLE) { vkDestroyDebugReportCallbackEXT(instance, msgCallback, nullptr); } #endif // Destroy instance if (instance) { vkDestroyInstance(instance, nullptr); } // Terminate GLFW glfwTerminate(); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.solid, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); vkMeshLoader::freeMeshBufferResources(device, &meshes.example); // Destroy MSAA target vkDestroyImage(device, multisampleTarget.color.image, nullptr); vkDestroyImageView(device, multisampleTarget.color.view, nullptr); vkFreeMemory(device, multisampleTarget.color.memory, nullptr); vkDestroyImage(device, multisampleTarget.depth.image, nullptr); vkDestroyImageView(device, multisampleTarget.depth.view, nullptr); vkFreeMemory(device, multisampleTarget.depth.memory, nullptr); textureLoader->destroyTexture(textures.colorMap); vkTools::destroyUniformData(device, &uniformData.vsScene); }
~VulkanExample() { // Clean up used Vulkan resources // Note : Inherited destructor cleans up resources stored in base class vkDestroyPipeline(device, pipelines.MSAA, nullptr); vkDestroyPipeline(device, pipelines.MSAASampleShading, nullptr); vkDestroyPipelineLayout(device, pipelineLayout, nullptr); vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr); models.example.destroy(); // Destroy MSAA target vkDestroyImage(device, multisampleTarget.color.image, nullptr); vkDestroyImageView(device, multisampleTarget.color.view, nullptr); vkFreeMemory(device, multisampleTarget.color.memory, nullptr); vkDestroyImage(device, multisampleTarget.depth.image, nullptr); vkDestroyImageView(device, multisampleTarget.depth.view, nullptr); vkFreeMemory(device, multisampleTarget.depth.memory, nullptr); textures.colorMap.destroy(); uniformBuffer.destroy(); }
void destroy_vulkan_texture(vulkan_texture& texture) { if (texture.sampler != VK_NULL_HANDLE) { vkDestroySampler(_vulkan_device, texture.sampler, NULL); } if (texture.image != VK_NULL_HANDLE) { vkDestroyImage(_vulkan_device, texture.image, NULL); } if (texture.view != VK_NULL_HANDLE) { vkDestroyImageView(_vulkan_device, texture.view, NULL); } if (texture.device_memory != VK_NULL_HANDLE) { vkFreeMemory(_vulkan_device, texture.device_memory, NULL); } }
SwapChain::~SwapChain() { if (VK_NULL_HANDLE != mVkSurfaceKHR) { const VulkanRenderer& vulkanRenderer = static_cast<VulkanRenderer&>(getRenderer()); const VkDevice vkDevice = vulkanRenderer.getContext().getVkDevice(); for (uint32_t i = 0; i < mSwapchainImageCount; ++i) { vkDestroyImageView(vkDevice, mSwapChainBuffer[i].view, nullptr); } if (VK_NULL_HANDLE != mVkSwapchainKHR) { vkDestroySwapchainKHR(vkDevice, mVkSwapchainKHR, nullptr); } vkDestroySurfaceKHR(vulkanRenderer.getVulkanRuntimeLinking().getVkInstance(), mVkSurfaceKHR, 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 WImage::_DestroyResources() { VkDevice device = m_app->GetVulkanDevice(); if (m_stagingBuffer) vkDestroyBuffer(device, m_stagingBuffer, nullptr); if (m_stagingMemory) vkFreeMemory(device, m_stagingMemory, nullptr); if (m_image) vkDestroyImage(device, m_image, nullptr); if (m_deviceMemory) vkFreeMemory(device, m_deviceMemory, nullptr); if (m_view) vkDestroyImageView(device, m_view, nullptr); m_stagingBuffer = VK_NULL_HANDLE; m_stagingMemory = VK_NULL_HANDLE; m_image = VK_NULL_HANDLE; m_deviceMemory = VK_NULL_HANDLE; m_view = VK_NULL_HANDLE; }
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(); }
void VulkanExampleBase::windowResize() { if (!prepared) { return; } prepared = false; // Recreate swap chain width = destWidth; height = destHeight; createSetupCommandBuffer(); setupSwapChain(); // Recreate the frame buffers vkDestroyImageView(device, depthStencil.view, nullptr); vkDestroyImage(device, depthStencil.image, nullptr); vkFreeMemory(device, depthStencil.mem, nullptr); setupDepthStencil(); for (uint32_t i = 0; i < frameBuffers.size(); i++) { vkDestroyFramebuffer(device, frameBuffers[i], nullptr); } setupFrameBuffer(); flushSetupCommandBuffer(); // Command buffers need to be recreated as they may store // references to the recreated frame buffer destroyCommandBuffers(); createCommandBuffers(); buildCommandBuffers(); vkQueueWaitIdle(queue); vkDeviceWaitIdle(device); // Notify derived class windowResized(); viewChanged(); prepared = true; }
Anvil::ImageView::~ImageView() { /* Unregister the object */ Anvil::ObjectTracker::get()->unregister_object(Anvil::OBJECT_TYPE_IMAGE_VIEW, this); if (m_image_view != VK_NULL_HANDLE) { lock(); { vkDestroyImageView(m_device_ptr->get_device_vk(), m_image_view, nullptr /* pAllocator */); } unlock(); m_image_view = VK_NULL_HANDLE; } }