Vulkan: Improve post-shutdown cleanup and minor improvements

src/Cafe/HW/Latte/Core/LatteShaderCache.cpp

@@ -365,6 +365,9 @@ void LatteShaderCache_Load()
 		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureTVId);
 	if (g_shaderCacheLoaderState.textureDRCId)
 		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureDRCId);
+
+	if(Latte_GetStopSignal())
+		LatteThread_Exit();
 }
 
 void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateFunc, bool isPipelines)
@@ -505,8 +508,6 @@ void LatteShaderCache_LoadVulkanPipelineCache(uint64 cacheTitleId)
 	g_shaderCacheLoaderState.loadedPipelines = 0;
 	LatteShaderCache_ShowProgress(LatteShaderCache_updatePipelineLoadingProgress, true);
 	pipelineCache.EndLoading();
-    if(Latte_GetStopSignal())
-        LatteThread_Exit();
 }
 
 bool LatteShaderCache_updatePipelineLoadingProgress()

src/Cafe/HW/Latte/Core/LatteThread.cpp

@@ -257,6 +257,7 @@ void LatteThread_Exit()
     LatteSHRC_UnloadAll();
     // close disk cache
     LatteShaderCache_Close();
+	RendererOutputShader::ShutdownStatic();
     // destroy renderer but make sure that g_renderer remains valid until the destructor has finished
 	if (g_renderer)
 	{

src/Cafe/HW/Latte/Renderer/RendererOuputShader.cpp

@@ -149,8 +149,8 @@ void main(){
 
 RendererOutputShader::RendererOutputShader(const std::string& vertex_source, const std::string& fragment_source)
 {
-	m_vertex_shader = g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, vertex_source, false, false);
-	m_fragment_shader = g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, fragment_source, false, false);
+	m_vertex_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kVertex, 0, 0, vertex_source, false, false));
+	m_fragment_shader.reset(g_renderer->shader_create(RendererShader::ShaderType::kFragment, 0, 0, fragment_source, false, false));
 
 	m_vertex_shader->PreponeCompilation(true);
 	m_fragment_shader->PreponeCompilation(true);
@@ -374,3 +374,15 @@ void RendererOutputShader::InitializeStatic()
 		s_hermit_shader_ud = new RendererOutputShader(vertex_source_ud, s_hermite_shader_source);*/
 	}
 }
+
+void RendererOutputShader::ShutdownStatic()
+{
+	delete s_copy_shader;
+	delete s_copy_shader_ud;
+
+	delete s_bicubic_shader;
+	delete s_bicubic_shader_ud;
+
+	delete s_hermit_shader;
+	delete s_hermit_shader_ud;
+}

src/Cafe/HW/Latte/Renderer/RendererOuputShader.h

@@ -21,15 +21,16 @@ class RendererOutputShader
 
 	RendererShader* GetVertexShader() const
 	{
-		return m_vertex_shader;
+		return m_vertex_shader.get();
 	}
 
 	RendererShader* GetFragmentShader() const
 	{
-		return m_fragment_shader;
+		return m_fragment_shader.get();
 	}
 
 	static void InitializeStatic();
+	static void ShutdownStatic();
 
 	static RendererOutputShader* s_copy_shader;
 	static RendererOutputShader* s_copy_shader_ud;
@@ -44,8 +45,8 @@ class RendererOutputShader
 	static std::string GetOpenGlVertexSource(bool render_upside_down);
 
 protected:
-	RendererShader* m_vertex_shader;
-	RendererShader* m_fragment_shader;
+	std::unique_ptr<RendererShader> m_vertex_shader;
+	std::unique_ptr<RendererShader> m_fragment_shader;
 
 	struct
 	{

src/Cafe/HW/Latte/Renderer/Vulkan/RendererShaderVk.cpp

@@ -211,6 +211,9 @@ RendererShaderVk::~RendererShaderVk()
 {
 	while (!list_pipelineInfo.empty())
 		delete list_pipelineInfo[0];
+
+	VkDevice vkDev = VulkanRenderer::GetInstance()->GetLogicalDevice();
+	vkDestroyShaderModule(vkDev, m_shader_module, nullptr);
 }
 
 void RendererShaderVk::Init()

src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.cpp

@@ -60,7 +60,7 @@ void SwapchainInfoVk::Create()
 	VkAttachmentDescription colorAttachment = {};
 	colorAttachment.format = m_surfaceFormat.format;
 	colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
-	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+	colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 	colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
 	colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 	colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;

src/Cafe/HW/Latte/Renderer/Vulkan/SwapchainInfoVk.h

@@ -70,6 +70,7 @@ struct SwapchainInfoVk
 	VkSurfaceFormatKHR m_surfaceFormat{};
 	VkSwapchainKHR m_swapchain{};
 	Vector2i m_desiredExtent{};
+	VkExtent2D m_actualExtent{};
 	uint32 swapchainImageIndex = (uint32)-1;
 	uint64 m_presentId = 1;
 	uint64 m_queueDepth = 0; // number of frames with pending presentation requests
@@ -92,5 +93,4 @@ struct SwapchainInfoVk
 	VkSemaphore m_currentSemaphore = VK_NULL_HANDLE;
 
 	std::array<uint32, 2> m_swapchainQueueFamilyIndices;
-	VkExtent2D m_actualExtent{};
 };

src/Cafe/HW/Latte/Renderer/Vulkan/VKRBase.h

@@ -205,4 +205,11 @@ class VKRObjectDescriptorSet : public VKRDestructibleObject
 	~VKRObjectDescriptorSet() override;
 
 	VkDescriptorSet descriptorSet{ VK_NULL_HANDLE };
+};
+
+class VKRObjectSampler : public VKRDestructibleObject
+{
+public:
+	~VKRObjectSampler() override;
+	VkSampler sampler { VK_NULL_HANDLE };
 };

src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.cpp

@@ -4,6 +4,14 @@
 
 /* VKRSynchronizedMemoryBuffer */
 
+VKRSynchronizedRingAllocator::~VKRSynchronizedRingAllocator()
+{
+	for(auto& buf : m_buffers)
+	{
+		m_vkrMemMgr->DeleteBuffer(buf.vk_buffer, buf.vk_mem);
+	}
+}
+
 void VKRSynchronizedRingAllocator::addUploadBufferSyncPoint(AllocatorBuffer_t& buffer, uint32 offset)
 {
 	auto cmdBufferId = m_vkr->GetCurrentCommandBufferId();
@@ -169,6 +177,14 @@ void VKRSynchronizedRingAllocator::GetStats(uint32& numBuffers, size_t& totalBuf
 
 /* VkTextureChunkedHeap */
 
+VkTextureChunkedHeap::~VkTextureChunkedHeap()
+{
+	for (auto& i : m_list_chunkInfo)
+	{
+		vkFreeMemory(m_device, i.mem, nullptr);
+	}
+}
+
 uint32 VkTextureChunkedHeap::allocateNewChunk(uint32 chunkIndex, uint32 minimumAllocationSize)
 {
 	cemu_assert_debug(m_list_chunkInfo.size() == chunkIndex);
@@ -473,7 +489,7 @@ VkImageMemAllocation* VKRMemoryManager::imageMemoryAllocate(VkImage image)
 		map_textureHeap.emplace(typeFilter, texHeap);
 	}
 	else
-		texHeap = it->second;
+		texHeap = it->second.get();
 
 	// alloc mem from heap
 	uint32 allocationSize = (uint32)memRequirements.size;

src/Cafe/HW/Latte/Renderer/Vulkan/VKRMemoryManager.h

@@ -18,6 +18,7 @@ class VkTextureChunkedHeap : private ChunkedHeap
 {
 public:
 	VkTextureChunkedHeap(class VKRMemoryManager* memoryManager, uint32 typeFilter, VkDevice device) : m_vkrMemoryManager(memoryManager), m_typeFilter(typeFilter), m_device(device) { };
+	~VkTextureChunkedHeap();
 
 	struct ChunkInfo
 	{
@@ -80,6 +81,7 @@ class VKRSynchronizedRingAllocator
 
 	VKRSynchronizedRingAllocator(class VulkanRenderer* vkRenderer, class VKRMemoryManager* vkMemoryManager, BUFFER_TYPE bufferType, uint32 minimumBufferAllocSize) : m_vkr(vkRenderer), m_vkrMemMgr(vkMemoryManager), m_bufferType(bufferType), m_minimumBufferAllocSize(minimumBufferAllocSize) {};
 	VKRSynchronizedRingAllocator(const VKRSynchronizedRingAllocator&) = delete; // disallow copy
+	~VKRSynchronizedRingAllocator();
 
 	struct BufferSyncPoint_t
 	{
@@ -148,7 +150,7 @@ class VKRMemoryManager
 	}
 
 	// texture memory management
-	std::unordered_map<uint32, VkTextureChunkedHeap*> map_textureHeap; // one heap per memory type
+	std::unordered_map<uint32, std::unique_ptr<VkTextureChunkedHeap>> map_textureHeap; // one heap per memory type
 	std::vector<uint8> m_textureUploadBuffer;
 
 	// texture upload buffer

src/Cafe/HW/Latte/Renderer/Vulkan/VulkanAPI.h

@@ -165,6 +165,7 @@ VKFUNC_DEVICE(vkCmdDraw);
 VKFUNC_DEVICE(vkCmdCopyBufferToImage);
 VKFUNC_DEVICE(vkCmdCopyImageToBuffer);
 VKFUNC_DEVICE(vkCmdClearColorImage);
+VKFUNC_DEVICE(vkCmdClearAttachments);
 VKFUNC_DEVICE(vkCmdBindIndexBuffer);
 VKFUNC_DEVICE(vkCmdBindVertexBuffers);
 VKFUNC_DEVICE(vkCmdDrawIndexed);
@@ -198,6 +199,7 @@ VKFUNC_DEVICE(vkCmdEndTransformFeedbackEXT);
 
 // query
 VKFUNC_DEVICE(vkCreateQueryPool);
+VKFUNC_DEVICE(vkDestroyQueryPool);
 VKFUNC_DEVICE(vkCmdResetQueryPool);
 VKFUNC_DEVICE(vkCmdBeginQuery);
 VKFUNC_DEVICE(vkCmdEndQuery);
@@ -236,6 +238,7 @@ VKFUNC_DEVICE(vkAllocateDescriptorSets);
 VKFUNC_DEVICE(vkFreeDescriptorSets);
 VKFUNC_DEVICE(vkUpdateDescriptorSets);
 VKFUNC_DEVICE(vkCreateDescriptorPool);
+VKFUNC_DEVICE(vkDestroyDescriptorPool);
 VKFUNC_DEVICE(vkDestroyDescriptorSetLayout);
 
 #undef VKFUNC_INIT