VulkanRenderManager - big refactoring of the Vulkan code

Common/Common.vcxproj

@@ -249,6 +249,7 @@
     <ClInclude Include="Vulkan\VulkanImage.h" />
     <ClInclude Include="Vulkan\VulkanLoader.h" />
     <ClInclude Include="Vulkan\VulkanMemory.h" />
+    <ClInclude Include="Vulkan\VulkanRenderManager.h" />
     <ClInclude Include="x64Analyzer.h" />
     <ClInclude Include="x64Emitter.h" />
   </ItemGroup>
@@ -320,6 +321,7 @@
     <ClCompile Include="Vulkan\VulkanImage.cpp" />
     <ClCompile Include="Vulkan\VulkanLoader.cpp" />
     <ClCompile Include="Vulkan\VulkanMemory.cpp" />
+    <ClCompile Include="Vulkan\VulkanRenderManager.cpp" />
     <ClCompile Include="x64Analyzer.cpp" />
     <ClCompile Include="x64Emitter.cpp" />
   </ItemGroup>

Common/Common.vcxproj.filters

@@ -75,6 +75,7 @@
     </ClInclude>
     <ClInclude Include="OSVersion.h" />
     <ClInclude Include="Hashmaps.h" />
+    <ClInclude Include="Vulkan\VulkanRenderManager.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="stdafx.cpp" />
@@ -138,6 +139,7 @@
     <ClCompile Include="MemArenaAndroid.cpp" />
     <ClCompile Include="MemArenaDarwin.cpp" />
     <ClCompile Include="OSVersion.cpp" />
+    <ClCompile Include="Vulkan\VulkanRenderManager.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Crypto">
@@ -153,4 +155,4 @@
       <UniqueIdentifier>{c14d66ef-5f7c-4565-975a-72774e7ccfb9}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
-</Project>
+</Project>

Common/Vulkan/VulkanRenderManager.cpp

@@ -0,0 +1,116 @@
+#include "base/logging.h"
+
+#include "VulkanRenderManager.h"
+
+void VulkanRenderManager::BeginFrameWrites() {
+	vulkan_->BeginFrame();
+	renderPasses_.push_back(new VKRRenderPass);
+	curRp_ = renderPasses_.back();
+}
+
+void VulkanRenderManager::EndFrame() {
+	vulkan_->EndFrame();
+}
+
+
+void VulkanRenderManager::Clear(uint32_t clearColor, float clearZ, int clearStencil, int clearMask) {
+	// If this is the first drawing command, merge it into the pass.
+	if (curRp_->numDraws == 0) {
+		curRp_->clearColor = clearColor;
+		curRp_->clearZ = clearZ;
+		curRp_->clearStencil = clearStencil;
+		curRp_->clearMask = clearMask;
+	} else {
+		VkRenderData data{ VKR_CLEAR };
+		data.clear.clearColor = clearColor;
+		data.clear.clearZ = clearZ;
+		data.clear.clearStencil = clearStencil;
+		data.clear.clearMask = clearMask;
+		curRp_->commands.push_back(data);
+	}
+}
+
+void VulkanRenderManager::Flush(VkCommandBuffer cmdbuf) {
+	// Optimizes renderpasses, then sequences them.
+	for (int i = 0; i < renderPasses_.size(); i++) {
+		auto &commands = renderPasses_[i]->commands;
+		for (const auto &c : commands) {
+			switch (c.cmd) {
+			case VKR_VIEWPORT:
+				vkCmdSetViewport(cmdbuf, 0, 1, &c.viewport.vp);
+				break;
+
+			case VKR_SCISSOR:
+				vkCmdSetScissor(cmdbuf, 0, 1, &c.scissor.scissor);
+				break;
+
+			case VKR_DRAW_INDEXED:
+				vkCmdBindPipeline(cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, c.drawIndexed.pipeline);
+				vkCmdBindDescriptorSets(cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, c.drawIndexed.pipelineLayout, 0, 1, &c.drawIndexed.ds, c.drawIndexed.numUboOffsets, c.drawIndexed.uboOffsets);
+				vkCmdBindIndexBuffer(cmdbuf, c.drawIndexed.ibuffer, c.drawIndexed.ioffset, VK_INDEX_TYPE_UINT16);
+				vkCmdBindVertexBuffers(cmdbuf, 0, 1, &c.drawIndexed.vbuffer, &c.drawIndexed.voffset);
+				vkCmdDrawIndexed(cmdbuf, c.drawIndexed.count, c.drawIndexed.instances, 0, 0, 0);
+				break;
+
+			case VKR_DRAW:
+				vkCmdBindPipeline(cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, c.draw.pipeline);
+				vkCmdBindDescriptorSets(cmdbuf, VK_PIPELINE_BIND_POINT_GRAPHICS, c.draw.pipelineLayout, 0, 1, &c.draw.ds, c.draw.numUboOffsets, c.draw.uboOffsets);
+				vkCmdBindVertexBuffers(cmdbuf, 0, 1, &c.draw.vbuffer, &c.draw.voffset);
+				vkCmdDraw(cmdbuf, c.draw.count, 1, 0, 0);
+				break;
+
+			case VKR_STENCIL:
+				vkCmdSetStencilWriteMask(cmdbuf, VK_STENCIL_FRONT_AND_BACK, c.stencil.stencilWriteMask);
+				vkCmdSetStencilCompareMask(cmdbuf, VK_STENCIL_FRONT_AND_BACK, c.stencil.stencilCompareMask);
+				vkCmdSetStencilReference(cmdbuf, VK_STENCIL_FRONT_AND_BACK, c.stencil.stencilRef);
+				break;
+
+			case VKR_BLEND:
+				vkCmdSetBlendConstants(cmdbuf, c.blendColor.color);
+				break;
+
+			case VKR_CLEAR:
+			{
+				int numAttachments = 0;
+				VkClearRect rc{};
+				rc.baseArrayLayer = 0;
+				rc.layerCount = 1;
+				rc.rect.extent.width = curWidth_;
+				rc.rect.extent.height = curHeight_;
+				VkClearAttachment attachments[2];
+				if (c.clear.clearMask & VK_IMAGE_ASPECT_COLOR_BIT) {
+					VkClearAttachment &attachment = attachments[numAttachments++];
+					attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+					attachment.colorAttachment = 0;
+					Uint8x4ToFloat4(attachment.clearValue.color.float32, c.clear.clearColor);
+				}
+				if (c.clear.clearMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
+					VkClearAttachment &attachment = attachments[numAttachments++];
+					attachment.aspectMask = 0;
+					if (c.clear.clearMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
+						attachment.clearValue.depthStencil.depth = c.clear.clearZ;
+						attachment.aspectMask |= VK_IMAGE_ASPECT_DEPTH_BIT;
+					}
+					if (c.clear.clearMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
+						attachment.clearValue.depthStencil.stencil = c.clear.clearStencil;
+						attachment.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+					}
+				}
+				if (numAttachments) {
+					vkCmdClearAttachments(cmdbuf, numAttachments, attachments, 1, &rc);
+				}
+				break;
+			}
+			default:
+				ELOG("Unimpl queue command");
+				;
+			}
+		}
+		delete renderPasses_[i];
+	}
+	renderPasses_.clear();
+}
+
+void VulkanRenderManager::Sync(VkCommandBuffer cmd) {
+
+}

Common/Vulkan/VulkanRenderManager.h

@@ -0,0 +1,168 @@
+#pragma once
+
+#include <cstdint>
+#include <thread>
+
+#include "Common/Vulkan/VulkanContext.h"
+#include "math/dataconv.h"
+#include "thin3d/thin3d.h"
+
+// Takes the role that a GL driver does of sequencing and optimizing render passes.
+// Only draws and binds are handled here, resource creation and allocations are handled as normal -
+// that's the nice thing with Vulkan.
+
+// The cool thing is that you can Flush on a different thread than you record the commands on!
+
+enum VkRenderCmd : uint8_t {
+	VKR_STENCIL,
+	VKR_BLEND,
+	VKR_VIEWPORT,
+	VKR_SCISSOR,
+	VKR_CLEAR,
+	VKR_DRAW,
+	VKR_DRAW_INDEXED,
+};
+
+struct VkRenderData {
+	VkRenderCmd cmd;
+	union {
+		struct {
+			VkPipeline pipeline;
+			VkPipelineLayout pipelineLayout;
+			VkDescriptorSet ds;
+			int numUboOffsets;
+			uint32_t uboOffsets[3];
+			VkBuffer vbuffer;
+			VkDeviceSize voffset;
+			int count;
+		} draw;
+		struct {
+			VkPipeline pipeline;
+			VkPipelineLayout pipelineLayout;
+			VkDescriptorSet ds;
+			int numUboOffsets;
+			uint32_t uboOffsets[3];
+			VkBuffer vbuffer;  // might need to increase at some point
+			VkDeviceSize voffset;
+			VkBuffer ibuffer;
+			VkDeviceSize ioffset;
+			int16_t count;
+			int16_t instances;
+			VkIndexType indexType;
+		} drawIndexed;
+		struct {
+			uint32_t clearColor;
+			float clearZ;
+			int clearStencil;
+			int clearMask;   // VK_IMAGE_ASPECT_COLOR_BIT etc
+		} clear;
+
+		struct {
+			VkViewport vp;
+		} viewport;
+		struct {
+			VkRect2D scissor;
+		} scissor;
+		struct {
+			uint8_t stencilWriteMask;
+			uint8_t stencilCompareMask;
+			uint8_t stencilRef;
+		} stencil;
+		struct {
+			float color[4];
+		} blendColor;
+		struct {
+
+		} beginRp;
+		struct {
+
+		} endRp;
+	};
+};
+
+struct VKRRenderPass {
+	VkFramebuffer framebuffer;
+	uint32_t clearColor;
+	float clearZ;
+	int clearStencil;
+	int clearMask = 0;   // VK_IMAGE_ASPECT_COLOR_BIT etc
+	int dontCareMask = 0;
+	int numDraws;
+	std::vector<VkRenderData> commands;
+};
+
+class VulkanRenderManager {
+public:
+	VulkanRenderManager(VulkanContext *vulkan) : vulkan_(vulkan) {}
+
+	// Makes sure that the GPU has caught up enough that we can start writing buffers of this frame again.
+	void BeginFrameWrites();
+	void EndFrame();
+
+	void SetViewport(const VkViewport &vp) {
+		VkRenderData data{ VKR_VIEWPORT };
+		data.viewport.vp = vp;
+		curRp_->commands.push_back(data);
+	}
+
+	void SetScissor(const VkRect2D &rc) {
+		VkRenderData data{ VKR_SCISSOR };
+		data.scissor.scissor = rc;
+		curRp_->commands.push_back(data);
+	}
+
+	void SetBlendFactor(float color[4]) {
+		VkRenderData data{ VKR_BLEND };
+		CopyFloat4(data.blendColor.color, color);
+		curRp_->commands.push_back(data);
+	}
+
+	void Clear(uint32_t clearColor, float clearZ, int clearStencil, int clearMask);
+
+	void Draw(VkPipeline pipeline, VkPipelineLayout layout, VkDescriptorSet descSet, int numUboOffsets, uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, int count) {
+		VkRenderData data{ VKR_DRAW };
+		data.draw.count = count;
+		data.draw.pipeline = pipeline;
+		data.draw.pipelineLayout = layout;
+		data.draw.ds = descSet;
+		data.draw.vbuffer = vbuffer;
+		data.draw.voffset = voffset;
+		data.draw.numUboOffsets = numUboOffsets;
+		for (int i = 0; i < numUboOffsets; i++)
+			data.draw.uboOffsets[i] = uboOffsets[i];
+		curRp_->commands.push_back(data);
+		curRp_->numDraws++;
+	}
+
+	void DrawIndexed(VkPipeline pipeline, VkPipelineLayout layout, VkDescriptorSet descSet, int numUboOffsets, uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, VkBuffer ibuffer, int ioffset, int count, VkIndexType indexType) {
+		VkRenderData data{ VKR_DRAW };
+		data.drawIndexed.count = count;
+		data.drawIndexed.pipeline = pipeline;
+		data.drawIndexed.pipelineLayout = layout;
+		data.drawIndexed.ds = descSet;
+		data.drawIndexed.vbuffer = vbuffer;
+		data.drawIndexed.voffset = voffset;
+		data.drawIndexed.ibuffer = ibuffer;
+		data.drawIndexed.ioffset = ioffset;
+		data.drawIndexed.numUboOffsets = numUboOffsets;
+		for (int i = 0; i < numUboOffsets; i++)
+			data.drawIndexed.uboOffsets[i] = uboOffsets[i];
+		data.drawIndexed.indexType = indexType;
+		curRp_->commands.push_back(data);
+		curRp_->numDraws++;
+	}
+
+	// Can run on a different thread! Just make sure to use BeginFrameWrites.
+	void Flush(VkCommandBuffer cmd);
+
+	// Bad for performance but sometimes necessary for synchronous CPU readbacks (screenshots and whatnot).
+	void Sync(VkCommandBuffer cmd);
+
+	std::vector<VKRRenderPass *> renderPasses_;
+	VKRRenderPass *curRp_;
+
+private:
+	VulkanContext *vulkan_;
+	int curWidth_;
+	int curHeight_;
+};

ext/native/thin3d/thin3d.h

@@ -325,6 +325,7 @@ enum class NativeObject {
 	CURRENT_RENDERPASS,
 	RENDERPASS_COMMANDBUFFER,
 	BOUND_TEXTURE_IMAGEVIEW,
+	RENDER_MANAGER,
 };
 
 enum FBColorDepth {