Adjust some init/deinit code and rename some things

src/common/rendering/vulkan/renderer/vk_descriptorset.cpp

@@ -39,6 +39,8 @@
 
 VkDescriptorSetManager::VkDescriptorSetManager(VulkanFrameBuffer* fb) : fb(fb)
 {
+	CreateHWBufferSetLayout();
+	CreateFixedSetLayout();
 }
 
 VkDescriptorSetManager::~VkDescriptorSetManager()
@@ -49,52 +51,74 @@ VkDescriptorSetManager::~VkDescriptorSetManager()
 
 void VkDescriptorSetManager::Init()
 {
-	CreateFixedSet();
+	UpdateFixedSet();
-	CreateDynamicSet();
+	UpdateHWBufferSet();
 }
 
-void VkDescriptorSetManager::CreateDynamicSet()
+void VkDescriptorSetManager::Deinit()
+{
+	while (!Materials.empty())
+		RemoveMaterial(Materials.back());
+}
+
+void VkDescriptorSetManager::BeginFrame()
+{
+	UpdateFixedSet();
+	UpdateHWBufferSet();
+}
+
+void VkDescriptorSetManager::CreateHWBufferSetLayout()
 {
 	DescriptorSetLayoutBuilder builder;
 	builder.addBinding(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
 	builder.addBinding(1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
 	builder.addBinding(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
-	DynamicSetLayout = builder.create(fb->device);
+	builder.addBinding(3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
-	DynamicSetLayout->SetDebugName("VkDescriptorSetManager.DynamicSetLayout");
+	HWBufferSetLayout = builder.create(fb->device);
+	HWBufferSetLayout->SetDebugName("VkDescriptorSetManager.HWBufferSetLayout");
+}
+
+void VkDescriptorSetManager::UpdateHWBufferSet()
+{
+	fb->GetCommands()->DrawDeleteList->Add(std::move(HWBufferSet));
+	fb->GetCommands()->DrawDeleteList->Add(std::move(HWBufferDescriptorPool));
 
 	DescriptorPoolBuilder poolbuilder;
 	poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 3);
+	poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
 	poolbuilder.setMaxSets(1);
-	DynamicDescriptorPool = poolbuilder.create(fb->device);
+	HWBufferDescriptorPool = poolbuilder.create(fb->device);
-	DynamicDescriptorPool->SetDebugName("VkDescriptorSetManager.DynamicDescriptorPool");
+	HWBufferDescriptorPool->SetDebugName("VkDescriptorSetManager.HWBufferDescriptorPool");
 
-	DynamicSet = DynamicDescriptorPool->allocate(DynamicSetLayout.get());
+	HWBufferSet = HWBufferDescriptorPool->allocate(HWBufferSetLayout.get());
-	if (!DynamicSet)
+	if (!HWBufferSet)
-		I_FatalError("CreateDynamicSet failed.\n");
+		I_FatalError("CreateHWBufferSet failed.\n");
-}
 
-void VkDescriptorSetManager::UpdateDynamicSet()
-{
 	WriteDescriptors update;
-	update.addBuffer(DynamicSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->ViewpointUBO->mBuffer.get(), 0, sizeof(HWViewpointUniforms));
+	update.addBuffer(HWBufferSet.get(), 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->ViewpointUBO->mBuffer.get(), 0, sizeof(HWViewpointUniforms));
-	update.addBuffer(DynamicSet.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->MatrixBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(MatricesUBO));
+	update.addBuffer(HWBufferSet.get(), 1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->MatrixBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(MatricesUBO));
-	update.addBuffer(DynamicSet.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->StreamBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(StreamUBO));
+	update.addBuffer(HWBufferSet.get(), 2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, fb->GetBufferManager()->StreamBuffer->UniformBuffer->mBuffer.get(), 0, sizeof(StreamUBO));
+	update.addBuffer(HWBufferSet.get(), 3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightBufferSSO->mBuffer.get());
 	update.updateSets(fb->device);
 }
 
-void VkDescriptorSetManager::CreateFixedSet()
+void VkDescriptorSetManager::CreateFixedSetLayout()
 {
 	DescriptorSetLayoutBuilder builder;
 	builder.addBinding(0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
 	builder.addBinding(1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
-	builder.addBinding(2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
 	if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME))
-		builder.addBinding(3, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
+		builder.addBinding(2, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
 	FixedSetLayout = builder.create(fb->device);
 	FixedSetLayout->SetDebugName("VkDescriptorSetManager.FixedSetLayout");
+}
+
+void VkDescriptorSetManager::UpdateFixedSet()
+{
+	fb->GetCommands()->DrawDeleteList->Add(std::move(FixedSet));
+	fb->GetCommands()->DrawDeleteList->Add(std::move(FixedDescriptorPool));
 
 	DescriptorPoolBuilder poolbuilder;
-	poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1);
 	poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2);
 	if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME))
 		poolbuilder.addPoolSize(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1);
@@ -105,16 +129,12 @@ void VkDescriptorSetManager::CreateFixedSet()
 	FixedSet = FixedDescriptorPool->allocate(FixedSetLayout.get());
 	if (!FixedSet)
 		I_FatalError("CreateFixedSet failed.\n");
-}
 
-void VkDescriptorSetManager::UpdateFixedSet()
-{
 	WriteDescriptors update;
 	update.addCombinedImageSampler(FixedSet.get(), 0, fb->GetTextureManager()->Shadowmap.View.get(), fb->GetSamplerManager()->ShadowmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 	update.addCombinedImageSampler(FixedSet.get(), 1, fb->GetTextureManager()->Lightmap.View.get(), fb->GetSamplerManager()->LightmapSampler.get(), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
-	update.addBuffer(FixedSet.get(), 2, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, fb->GetBufferManager()->LightBufferSSO->mBuffer.get());
 	if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME))
-		update.addAccelerationStructure(FixedSet.get(), 3, fb->GetRaytrace()->GetAccelStruct());
+		update.addAccelerationStructure(FixedSet.get(), 2, fb->GetRaytrace()->GetAccelStruct());
 	update.updateSets(fb->device);
 }
 

src/common/rendering/vulkan/renderer/vk_descriptorset.h

@@ -16,15 +16,17 @@ public:
 	~VkDescriptorSetManager();
 
 	void Init();
+	void Deinit();
+	void BeginFrame();
 	void UpdateFixedSet();
-	void UpdateDynamicSet();
+	void UpdateHWBufferSet();
 	void ResetHWTextureSets();
 
-	VulkanDescriptorSetLayout* GetDynamicSetLayout() { return DynamicSetLayout.get(); }
+	VulkanDescriptorSetLayout* GetHWBufferSetLayout() { return HWBufferSetLayout.get(); }
 	VulkanDescriptorSetLayout* GetFixedSetLayout() { return FixedSetLayout.get(); }
 	VulkanDescriptorSetLayout* GetTextureSetLayout(int numLayers);
 
-	VulkanDescriptorSet* GetDynamicDescriptorSet() { return DynamicSet.get(); }
+	VulkanDescriptorSet* GetHWBufferDescriptorSet() { return HWBufferSet.get(); }
 	VulkanDescriptorSet* GetFixedDescriptorSet() { return FixedSet.get(); }
 	VulkanDescriptorSet* GetNullTextureDescriptorSet();
 
@@ -36,18 +38,18 @@ public:
 	void RemoveMaterial(VkMaterial* texture);
 
 private:
-	void CreateDynamicSet();
+	void CreateHWBufferSetLayout();
-	void CreateFixedSet();
+	void CreateFixedSetLayout();
 
 	std::unique_ptr<VulkanDescriptorSet> AllocatePPDescriptorSet(VulkanDescriptorSetLayout* layout);
 
 	VulkanFrameBuffer* fb = nullptr;
 
-	std::unique_ptr<VulkanDescriptorSetLayout> DynamicSetLayout;
+	std::unique_ptr<VulkanDescriptorSetLayout> HWBufferSetLayout;
 	std::unique_ptr<VulkanDescriptorSetLayout> FixedSetLayout;
 	std::vector<std::unique_ptr<VulkanDescriptorSetLayout>> TextureSetLayouts;
 
-	std::unique_ptr<VulkanDescriptorPool> DynamicDescriptorPool;
+	std::unique_ptr<VulkanDescriptorPool> HWBufferDescriptorPool;
 	std::unique_ptr<VulkanDescriptorPool> FixedDescriptorPool;
 
 	std::unique_ptr<VulkanDescriptorPool> PPDescriptorPool;
@@ -56,7 +58,7 @@ private:
 	int TextureDescriptorsLeft = 0;
 	std::vector<std::unique_ptr<VulkanDescriptorPool>> TextureDescriptorPools;
 
-	std::unique_ptr<VulkanDescriptorSet> DynamicSet;
+	std::unique_ptr<VulkanDescriptorSet> HWBufferSet;
 	std::unique_ptr<VulkanDescriptorSet> FixedSet;
 	std::unique_ptr<VulkanDescriptorSet> NullTextureDescriptorSet;
 

src/common/rendering/vulkan/renderer/vk_raytrace.cpp

@@ -28,57 +28,40 @@
 
 VkRaytrace::VkRaytrace(VulkanFrameBuffer* fb) : fb(fb)
 {
+	NullMesh.MeshVertices.Push({ -1.0f, -1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f, -1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f,  1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ -1.0f, -1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ -1.0f,  1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f,  1.0f, -1.0f });
+	NullMesh.MeshVertices.Push({ -1.0f, -1.0f,  1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f, -1.0f,  1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f,  1.0f,  1.0f });
+	NullMesh.MeshVertices.Push({ -1.0f, -1.0f,  1.0f });
+	NullMesh.MeshVertices.Push({ -1.0f,  1.0f,  1.0f });
+	NullMesh.MeshVertices.Push({ 1.0f,  1.0f,  1.0f });
+	for (int i = 0; i < 3 * 4; i++)
+		NullMesh.MeshElements.Push(i);
+
+	SetLevelMesh(nullptr);
 }
 
 void VkRaytrace::SetLevelMesh(hwrenderer::LevelMesh* mesh)
 {
+	if (!mesh)
+		mesh = &NullMesh;
+
 	if (mesh != Mesh)
 	{
 		Reset();
 		Mesh = mesh;
-		if (Mesh)
+		if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME))
 		{
-			if (fb->device->SupportsDeviceExtension(VK_KHR_RAY_QUERY_EXTENSION_NAME))
+			CreateVulkanObjects();
-			{
-				CreateVulkanObjects();
-			}
 		}
 	}
 }
 
-VulkanAccelerationStructure* VkRaytrace::GetAccelStruct()
-{
-	if (tlAccelStruct)
-		return tlAccelStruct.get();
-
-	// We need a dummy accel struct to keep vulkan happy:
-	hwrenderer::LevelMesh dummy;
-
-	dummy.MeshVertices.Push({ -1.0f, -1.0f, -1.0f });
-	dummy.MeshVertices.Push({  1.0f, -1.0f, -1.0f });
-	dummy.MeshVertices.Push({  1.0f,  1.0f, -1.0f });
-
-	dummy.MeshVertices.Push({ -1.0f, -1.0f, -1.0f });
-	dummy.MeshVertices.Push({ -1.0f,  1.0f, -1.0f });
-	dummy.MeshVertices.Push({  1.0f,  1.0f, -1.0f });
-
-	dummy.MeshVertices.Push({ -1.0f, -1.0f,  1.0f });
-	dummy.MeshVertices.Push({  1.0f, -1.0f,  1.0f });
-	dummy.MeshVertices.Push({  1.0f,  1.0f,  1.0f });
-
-	dummy.MeshVertices.Push({ -1.0f, -1.0f,  1.0f });
-	dummy.MeshVertices.Push({ -1.0f,  1.0f,  1.0f });
-	dummy.MeshVertices.Push({  1.0f,  1.0f,  1.0f });
-
-	for (int i = 0; i < 3 * 4; i++)
-		dummy.MeshElements.Push(i);
-
-	Mesh = &dummy;
-	CreateVulkanObjects();
-	Mesh = nullptr;
-	return tlAccelStruct.get();
-}
-
 void VkRaytrace::Reset()
 {
 	auto deletelist = fb->GetCommands()->DrawDeleteList.get();

src/common/rendering/vulkan/renderer/vk_raytrace.h

@@ -13,7 +13,7 @@ public:
 
 	void SetLevelMesh(hwrenderer::LevelMesh* mesh);
 
-	VulkanAccelerationStructure* GetAccelStruct();
+	VulkanAccelerationStructure* GetAccelStruct() { return tlAccelStruct.get(); }
 
 private:
 	void Reset();
@@ -24,6 +24,7 @@ private:
 
 	VulkanFrameBuffer* fb = nullptr;
 
+	hwrenderer::LevelMesh NullMesh;
 	hwrenderer::LevelMesh* Mesh = nullptr;
 
 	std::unique_ptr<VulkanBuffer> vertexBuffer;

src/common/rendering/vulkan/renderer/vk_renderpass.cpp

@@ -113,7 +113,7 @@ VulkanPipelineLayout* VkRenderPassManager::GetPipelineLayout(int numLayers)
 
 	PipelineLayoutBuilder builder;
 	builder.addSetLayout(descriptors->GetFixedSetLayout());
-	builder.addSetLayout(descriptors->GetDynamicSetLayout());
+	builder.addSetLayout(descriptors->GetHWBufferSetLayout());
 	if (numLayers != 0)
 		builder.addSetLayout(descriptors->GetTextureSetLayout(numLayers));
 	builder.addPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants));

src/common/rendering/vulkan/renderer/vk_renderstate.cpp

@@ -458,7 +458,7 @@ void VkRenderState::ApplyDynamicSet()
 		auto descriptors = fb->GetDescriptorSetManager();
 
 		uint32_t offsets[3] = { mViewpointOffset, matrixOffset, streamDataOffset };
-		mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 1, descriptors->GetDynamicDescriptorSet(), 3, offsets);
+		mCommandBuffer->bindDescriptorSet(VK_PIPELINE_BIND_POINT_GRAPHICS, passManager->GetPipelineLayout(mPipelineKey.NumTextureLayers), 1, descriptors->GetHWBufferDescriptorSet(), 3, offsets);
 
 		mLastViewpointOffset = mViewpointOffset;
 		mLastMatricesOffset = matrixOffset;

src/common/rendering/vulkan/renderer/vk_streambuffer.cpp

@@ -28,7 +28,7 @@
 
 VkStreamBufferWriter::VkStreamBufferWriter(VulkanFrameBuffer* fb)
 {
-	mBuffer = fb->GetBufferManager()->StreamBuffer;
+	mBuffer = fb->GetBufferManager()->StreamBuffer.get();
 }
 
 bool VkStreamBufferWriter::Write(const StreamData& data)
@@ -57,7 +57,7 @@ void VkStreamBufferWriter::Reset()
 
 VkMatrixBufferWriter::VkMatrixBufferWriter(VulkanFrameBuffer* fb)
 {
-	mBuffer = fb->GetBufferManager()->MatrixBuffer;
+	mBuffer = fb->GetBufferManager()->MatrixBuffer.get();
 	mIdentityMatrix.loadIdentity();
 }
 

src/common/rendering/vulkan/shaders/vk_ppshader.cpp

@@ -21,11 +21,13 @@
 */
 
 #include "vk_ppshader.h"
+#include "vk_shader.h"
 #include "vulkan/system/vk_framebuffer.h"
 #include "vulkan/system/vk_builders.h"
+#include "vulkan/system/vk_commandbuffer.h"
 #include "filesystem.h"
 
-VkPPShader::VkPPShader(VulkanFrameBuffer* fb, PPShader *shader)
+VkPPShader::VkPPShader(VulkanFrameBuffer* fb, PPShader *shader) : fb(fb)
 {
 	FString prolog;
 	if (!shader->Uniforms.empty())
@@ -41,6 +43,23 @@ VkPPShader::VkPPShader(VulkanFrameBuffer* fb, PPShader *shader)
 	fragbuilder.setFragmentShader(LoadShaderCode(shader->FragmentShader, prolog, shader->Version));
 	FragmentShader = fragbuilder.create(shader->FragmentShader.GetChars(), fb->device);
 	FragmentShader->SetDebugName(shader->FragmentShader.GetChars());
+
+	fb->GetShaderManager()->AddVkPPShader(this);
+}
+
+VkPPShader::~VkPPShader()
+{
+	if (fb)
+		fb->GetShaderManager()->RemoveVkPPShader(this);
+}
+
+void VkPPShader::Reset()
+{
+	if (fb)
+	{
+		fb->GetCommands()->DrawDeleteList->Add(std::move(VertexShader));
+		fb->GetCommands()->DrawDeleteList->Add(std::move(FragmentShader));
+	}
 }
 
 FString VkPPShader::LoadShaderCode(const FString &lumpName, const FString &defines, int version)

src/common/rendering/vulkan/shaders/vk_ppshader.h

@@ -3,6 +3,7 @@
 
 #include "hwrenderer/postprocessing/hw_postprocess.h"
 #include "vulkan/system/vk_objects.h"
+#include <list>
 
 class VulkanFrameBuffer;
 
@@ -10,6 +11,12 @@ class VkPPShader : public PPShaderBackend
 {
 public:
 	VkPPShader(VulkanFrameBuffer* fb, PPShader *shader);
+	~VkPPShader();
+
+	void Reset();
+
+	VulkanFrameBuffer* fb = nullptr;
+	std::list<VkPPShader*>::iterator it;
 
 	std::unique_ptr<VulkanShader> VertexShader;
 	std::unique_ptr<VulkanShader> FragmentShader;

src/common/rendering/vulkan/shaders/vk_shader.cpp

@@ -124,6 +124,12 @@ VkShaderManager::~VkShaderManager()
 	ShFinalize();
 }
 
+void VkShaderManager::Deinit()
+{
+	while (!PPShaders.empty())
+		RemoveVkPPShader(PPShaders.back());
+}
+
 VkShaderProgram *VkShaderManager::GetEffect(int effect, EPassType passType)
 {
 	if (compileIndex == -1 && effect >= 0 && effect < MAX_EFFECTS && mEffectShaders[passType][effect].frag)
@@ -152,15 +158,8 @@ static const char *shaderBindings = R"(
 
 	layout(set = 0, binding = 0) uniform sampler2D ShadowMap;
 	layout(set = 0, binding = 1) uniform sampler2DArray LightMap;
-
-	// light buffers
-	layout(set = 0, binding = 2, std430) buffer LightBufferSSO
-	{
-	    vec4 lights[];
-	};
-
 	#ifdef SUPPORTS_RAYTRACING
-	layout(set = 0, binding = 3) uniform accelerationStructureEXT TopLevelAS;
+	layout(set = 0, binding = 2) uniform accelerationStructureEXT TopLevelAS;
 	#endif
 
 	// This must match the HWViewpointUniforms struct
@@ -223,6 +222,12 @@ static const char *shaderBindings = R"(
 		StreamData data[MAX_STREAM_DATA];
 	};
 
+	// light buffers
+	layout(set = 1, binding = 3, std430) buffer LightBufferSSO
+	{
+	    vec4 lights[];
+	};
+
 	// textures
 	layout(set = 2, binding = 0) uniform sampler2D tex;
 	layout(set = 2, binding = 1) uniform sampler2D texture2;
@@ -465,3 +470,15 @@ VkPPShader* VkShaderManager::GetVkShader(PPShader* shader)
 		shader->Backend = std::make_unique<VkPPShader>(fb, shader);
 	return static_cast<VkPPShader*>(shader->Backend.get());
 }
+
+void VkShaderManager::AddVkPPShader(VkPPShader* shader)
+{
+	shader->it = PPShaders.insert(PPShaders.end(), shader);
+}
+
+void VkShaderManager::RemoveVkPPShader(VkPPShader* shader)
+{
+	shader->Reset();
+	shader->fb = nullptr;
+	PPShaders.erase(shader->it);
+}

src/common/rendering/vulkan/shaders/vk_shader.h

@@ -7,6 +7,7 @@
 #include "matrix.h"
 #include "name.h"
 #include "hw_renderstate.h"
+#include <list>
 
 #define SHADER_MIN_REQUIRED_TEXTURE_LAYERS 8
 
@@ -66,12 +67,17 @@ public:
 	VkShaderManager(VulkanFrameBuffer* fb);
 	~VkShaderManager();
 
+	void Deinit();
+
 	VkShaderProgram *GetEffect(int effect, EPassType passType);
 	VkShaderProgram *Get(unsigned int eff, bool alphateston, EPassType passType);
 	bool CompileNextShader();
 
 	VkPPShader* GetVkShader(PPShader* shader);
 
+	void AddVkPPShader(VkPPShader* shader);
+	void RemoveVkPPShader(VkPPShader* shader);
+
 private:
 	std::unique_ptr<VulkanShader> LoadVertShader(FString shadername, const char *vert_lump, const char *defines);
 	std::unique_ptr<VulkanShader> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char *light_lump, const char *defines, bool alphatest, bool gbufferpass);
@@ -87,4 +93,6 @@ private:
 	std::vector<VkShaderProgram> mEffectShaders[MAX_PASS_TYPES];
 	uint8_t compilePass = 0, compileState = 0;
 	int compileIndex = 0;
+
+	std::list<VkPPShader*> PPShaders;
 };

src/common/rendering/vulkan/system/vk_buffer.cpp

@@ -31,18 +31,22 @@ VkBufferManager::VkBufferManager(VulkanFrameBuffer* fb) : fb(fb)
 
 VkBufferManager::~VkBufferManager()
 {
-	delete MatrixBuffer;
-	delete StreamBuffer;
 }
 
 void VkBufferManager::Init()
 {
-	MatrixBuffer = new VkStreamBuffer(this, sizeof(MatricesUBO), 50000);
+	MatrixBuffer.reset(new VkStreamBuffer(this, sizeof(MatricesUBO), 50000));
-	StreamBuffer = new VkStreamBuffer(this, sizeof(StreamUBO), 300);
+	StreamBuffer.reset(new VkStreamBuffer(this, sizeof(StreamUBO), 300));
 
 	CreateFanToTrisIndexBuffer();
 }
 
+void VkBufferManager::Deinit()
+{
+	while (!Buffers.empty())
+		RemoveBuffer(Buffers.back());
+}
+
 void VkBufferManager::AddBuffer(VkHardwareBuffer* buffer)
 {
 	buffer->it = Buffers.insert(Buffers.end(), buffer);

src/common/rendering/vulkan/system/vk_buffer.h

@@ -19,6 +19,7 @@ public:
 	~VkBufferManager();
 
 	void Init();
+	void Deinit();
 
 	IVertexBuffer* CreateVertexBuffer();
 	IIndexBuffer* CreateIndexBuffer();
@@ -33,8 +34,8 @@ public:
 	VkHardwareDataBuffer* LightLines = nullptr;
 	VkHardwareDataBuffer* LightList = nullptr;
 
-	VkStreamBuffer* MatrixBuffer = nullptr;
+	std::unique_ptr<VkStreamBuffer> MatrixBuffer;
-	VkStreamBuffer* StreamBuffer = nullptr;
+	std::unique_ptr<VkStreamBuffer> StreamBuffer;
 
 	std::unique_ptr<IIndexBuffer> FanToTrisIndexBuffer;
 

src/common/rendering/vulkan/system/vk_commandbuffer.h

@@ -36,6 +36,7 @@ public:
 		std::vector<std::unique_ptr<VulkanAccelerationStructure>> AccelStructs;
 		std::vector<std::unique_ptr<VulkanDescriptorPool>> DescriptorPools;
 		std::vector<std::unique_ptr<VulkanDescriptorSet>> Descriptors;
+		std::vector<std::unique_ptr<VulkanShader>> Shaders;
 		std::vector<std::unique_ptr<VulkanCommandBuffer>> CommandBuffers;
 		size_t TotalSize = 0;
 
@@ -48,6 +49,7 @@ public:
 		void Add(std::unique_ptr<VulkanDescriptorPool> obj) { if (obj) { DescriptorPools.push_back(std::move(obj)); } }
 		void Add(std::unique_ptr<VulkanDescriptorSet> obj) { if (obj) { Descriptors.push_back(std::move(obj)); } }
 		void Add(std::unique_ptr<VulkanCommandBuffer> obj) { if (obj) { CommandBuffers.push_back(std::move(obj)); } }
+		void Add(std::unique_ptr<VulkanShader> obj) { if (obj) { Shaders.push_back(std::move(obj)); } }
 	};
 
 	std::unique_ptr<DeleteList> TransferDeleteList = std::make_unique<DeleteList>();

src/common/rendering/vulkan/system/vk_framebuffer.cpp

@@ -98,6 +98,11 @@ VulkanFrameBuffer::~VulkanFrameBuffer()
 	delete mLights;
 	mShadowMap.Reset();
 
+	mDescriptorSetManager->Deinit();
+	mTextureManager->Deinit();
+	mBufferManager->Deinit();
+	mShaderManager->Deinit();
+
 	mCommands->DeleteFrameObjects();
 }
 
@@ -405,16 +410,12 @@ TArray<uint8_t> VulkanFrameBuffer::GetScreenshotBuffer(int &pitch, ESSType &colo
 void VulkanFrameBuffer::BeginFrame()
 {
 	SetViewportRects(nullptr);
+	mCommands->BeginFrame();
 	mTextureManager->BeginFrame();
 	mScreenBuffers->BeginFrame(screen->mScreenViewport.width, screen->mScreenViewport.height, screen->mSceneViewport.width, screen->mSceneViewport.height);
 	mSaveBuffers->BeginFrame(SAVEPICWIDTH, SAVEPICHEIGHT, SAVEPICWIDTH, SAVEPICHEIGHT);
 	mRenderState->BeginFrame();
-
+	mDescriptorSetManager->BeginFrame();
-	WaitForCommands(false);
-	mDescriptorSetManager->UpdateFixedSet();
-	mDescriptorSetManager->UpdateDynamicSet();
-
-	mCommands->BeginFrame();
 }
 
 void VulkanFrameBuffer::InitLightmap(int LMTextureSize, int LMTextureCount, TArray<uint16_t>& LMTextureData)

src/common/rendering/vulkan/system/vk_hwbuffer.cpp

@@ -179,7 +179,7 @@ void VkHardwareBuffer::Resize(size_t newsize)
 	// Transfer data from old to new
 	fb->GetCommands()->GetTransferCommands()->copyBuffer(oldBuffer.get(), mBuffer.get(), 0, 0, oldsize);
 	fb->GetCommands()->WaitForCommands(false);
-	fb->GetDescriptorSetManager()->UpdateDynamicSet(); // Old buffer may be part of the dynamic set
+	fb->GetDescriptorSetManager()->UpdateHWBufferSet(); // Old buffer may be part of the bound descriptor set
 
 	// Fetch pointer to new buffer
 	map = mBuffer->Map(0, newsize);

src/common/rendering/vulkan/textures/vk_pptexture.cpp

@@ -25,7 +25,7 @@
 #include "vulkan/system/vk_framebuffer.h"
 #include "vulkan/system/vk_commandbuffer.h"
 
-VkPPTexture::VkPPTexture(VulkanFrameBuffer* fb, PPTexture *texture)
+VkPPTexture::VkPPTexture(VulkanFrameBuffer* fb, PPTexture *texture) : fb(fb)
 {
 	VkFormat format;
 	int pixelsize;

src/common/rendering/vulkan/textures/vk_texture.cpp

@@ -42,6 +42,14 @@ VkTextureManager::~VkTextureManager()
 		RemovePPTexture(PPTextures.back());
 }
 
+void VkTextureManager::Deinit()
+{
+	while (!Textures.empty())
+		RemoveTexture(Textures.back());
+	while (!PPTextures.empty())
+		RemovePPTexture(PPTextures.back());
+}
+
 void VkTextureManager::BeginFrame()
 {
 	if (!Shadowmap.Image || Shadowmap.Image->width != gl_shadowmap_quality)

src/common/rendering/vulkan/textures/vk_texture.h

@@ -19,6 +19,8 @@ public:
 	VkTextureManager(VulkanFrameBuffer* fb);
 	~VkTextureManager();
 
+	void Deinit();
+
 	void BeginFrame();
 
 	void SetLightmap(int LMTextureSize, int LMTextureCount, const TArray<uint16_t>& LMTextureData);

wadsrc/static/shaders/glsl/main.fp

@@ -352,7 +352,7 @@ float shadowAttenuation(vec4 lightpos, float lightcolorA)
 	vec3 origin = pixelpos.xyz;
 	vec3 direction = normalize(lightpos.xyz - pixelpos.xyz);
 	float lightDistance = distance(pixelpos.xyz, lightpos.xyz);
-
+/*
 	rayQueryEXT rayQuery;
 	rayQueryInitializeEXT(rayQuery, TopLevelAS, gl_RayFlagsTerminateOnFirstHitEXT, 0xFF, origin, 0.01f, direction, lightDistance);
 
@@ -364,7 +364,7 @@ float shadowAttenuation(vec4 lightpos, float lightcolorA)
 	{
 		return 0.0;
 	}
-
+*/
 	return 1.0;
 }