~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);
}