Merge branch 'master' into feature_openxr_stereo

Common/Data/Collections/TinySet.h

@@ -3,10 +3,12 @@
 #include <vector>
 
 // Insert-only small-set implementation. Performs no allocation unless MaxFastSize is exceeded.
+// Can also be used as a small vector, then use push_back (or push_in_place) instead of insert.
+// Duplicates are thus allowed if you use that, but not if you exclusively use insert.
 template <class T, int MaxFastSize>
 struct TinySet {
 	~TinySet() { delete slowLookup_; }
-	inline void insert(T t) {
+	inline void insert(const T &t) {
 		// Fast linear scan.
 		for (int i = 0; i < fastCount; i++) {
 			if (fastLookup_[i] == t)
@@ -20,6 +22,41 @@ struct TinySet {
 		// Fall back to slow path.
 		insertSlow(t);
 	}
+	inline void push_back(const T &t) {
+		if (fastCount < MaxFastSize) {
+			fastLookup_[fastCount++] = t;
+			return;
+		}
+		if (!slowLookup_) {
+			slowLookup_ = new std::vector<T>();
+		}
+		slowLookup_->push_back(t);
+	}
+	inline T *add_back() {
+		if (fastCount < MaxFastSize) {
+			return &fastLookup_[fastCount++];
+		}
+		if (!slowLookup_) {
+			slowLookup_ = new std::vector<T>();
+		}
+		T t;
+		slowLookup_->push_back(t);
+		return slowLookup_->back();
+	}
+	void append(const TinySet<T, MaxFastSize> &other) {
+		size_t otherSize = other.size();
+		if (size() + otherSize <= MaxFastSize) {
+			// Fast case
+			for (int i = 0; i < otherSize; i++) {
+				fastLookup_[fastCount + i] = other.fastLookup_[i];
+			}
+			fastCount += other.fastCount;
+		} else {
+			for (int i = 0; i < otherSize; i++) {
+				push_back(other[i]);
+			}
+		}
+	}
 	bool contains(T t) const {
 		for (int i = 0; i < fastCount; i++) {
 			if (fastLookup_[i] == t)
@@ -52,6 +89,26 @@ struct TinySet {
 		slowLookup_ = nullptr;
 		fastCount = 0;
 	}
+	bool empty() const {
+		return fastCount == 0;
+	}
+	size_t size() const {
+		if (!slowLookup_) {
+			return fastCount;
+		} else {
+			return slowLookup_->size() + MaxFastSize;
+		}
+	}
+	const T &operator[] (size_t index) const {
+		if (index < MaxFastSize) {
+			return fastLookup_[index];
+		} else {
+			return (*slowLookup_)[index - MaxFastSize];
+		}
+	}
+	const T &back() const {
+		return (*this)[size() - 1];
+	}
 
 private:
 	void insertSlow(T t) {

Common/GPU/D3D9/D3D9ShaderCompiler.cpp

@@ -54,7 +54,7 @@ LPD3DBLOB CompileShaderToByteCodeD3D9(const char *code, const char *target, std:
 }
 
 bool CompilePixelShaderD3D9(LPDIRECT3DDEVICE9 device, const char *code, LPDIRECT3DPIXELSHADER9 *pShader, std::string *errorMessage) {
-	LPD3DBLOB pShaderCode = CompileShaderToByteCodeD3D9(code, "ps_2_0", errorMessage);
+	LPD3DBLOB pShaderCode = CompileShaderToByteCodeD3D9(code, "ps_3_0", errorMessage);
 	if (pShaderCode) {
 		// Create pixel shader.
 		device->CreatePixelShader((DWORD*)pShaderCode->GetBufferPointer(), pShader);
@@ -66,7 +66,7 @@ bool CompilePixelShaderD3D9(LPDIRECT3DDEVICE9 device, const char *code, LPDIRECT
 }
 
 bool CompileVertexShaderD3D9(LPDIRECT3DDEVICE9 device, const char *code, LPDIRECT3DVERTEXSHADER9 *pShader, std::string *errorMessage) {
-	LPD3DBLOB pShaderCode = CompileShaderToByteCodeD3D9(code, "vs_2_0", errorMessage);
+	LPD3DBLOB pShaderCode = CompileShaderToByteCodeD3D9(code, "vs_3_0", errorMessage);
 	if (pShaderCode) {
 		// Create vertex shader.
 		device->CreateVertexShader((DWORD*)pShaderCode->GetBufferPointer(), pShader);

Common/GPU/D3D9/thin3d_d3d9.cpp

@@ -1069,11 +1069,7 @@ bool D3D9ShaderModule::Compile(LPDIRECT3DDEVICE9 device, const uint8_t *data, si
 	auto compile = [&](const char *profile) -> HRESULT {
 		return dyn_D3DCompile(source, (UINT)strlen(source), nullptr, defines, includes, "main", profile, 0, 0, &codeBuffer, &errorBuffer);
 	};
-	HRESULT hr = compile(stage_ == ShaderStage::Fragment ? "ps_2_0" : "vs_2_0");
-	if (FAILED(hr) && hr == D3DXERR_INVALIDDATA) {
-		// Might be a post shader.  Let's try using shader model 3.
-		hr = compile(stage_ == ShaderStage::Fragment ? "ps_3_0" : "vs_3_0");
-	}
+	HRESULT hr = compile(stage_ == ShaderStage::Fragment ? "ps_3_0" : "vs_3_0");
 	if (FAILED(hr)) {
 		const char *error = errorBuffer ? (const char *)errorBuffer->GetBufferPointer() : "(no errorbuffer returned)";
 		if (hr == ERROR_MOD_NOT_FOUND) {

Common/GPU/DataFormat.h

@@ -77,5 +77,6 @@ inline bool DataFormatIsColor(DataFormat fmt) {
 void ConvertFromRGBA8888(uint8_t *dst, const uint8_t *src, uint32_t dstStride, uint32_t srcStride, uint32_t width, uint32_t height, DataFormat format);
 void ConvertFromBGRA8888(uint8_t *dst, const uint8_t *src, uint32_t dstStride, uint32_t srcStride, uint32_t width, uint32_t height, DataFormat format);
 void ConvertToD32F(uint8_t *dst, const uint8_t *src, uint32_t dstStride, uint32_t srcStride, uint32_t width, uint32_t height, DataFormat format);
+void ConvertToD16(uint8_t *dst, const uint8_t *src, uint32_t dstStride, uint32_t srcStride, uint32_t width, uint32_t height, DataFormat format);
 
 }  // namespace

Common/GPU/Vulkan/VulkanQueueRunner.cpp

@@ -347,6 +347,7 @@ void VulkanQueueRunner::RunSteps(VkCommandBuffer cmd, std::vector<VKRStep *> &st
 		profile->cpuStartTime = time_now_d();
 
 	bool emitLabels = vulkan_->Extensions().EXT_debug_utils;
+
 	for (size_t i = 0; i < steps.size(); i++) {
 		const VKRStep &step = *steps[i];
 
@@ -685,7 +686,7 @@ void VulkanQueueRunner::ApplyRenderPassMerge(std::vector<VKRStep *> &steps) {
 	auto mergeRenderSteps = [](VKRStep *dst, VKRStep *src) {
 		// OK. Now, if it's a render, slurp up all the commands and kill the step.
 		// Also slurp up any pretransitions.
-		dst->preTransitions.insert(dst->preTransitions.end(), src->preTransitions.begin(), src->preTransitions.end());
+		dst->preTransitions.append(src->preTransitions);
 		dst->commands.insert(dst->commands.end(), src->commands.begin(), src->commands.end());
 		MergeRenderAreaRectInto(&dst->render.renderArea, src->render.renderArea);
 		// So we don't consider it for other things, maybe doesn't matter.
@@ -1060,7 +1061,8 @@ void TransitionFromOptimal(VkCommandBuffer cmd, VkImage colorImage, VkImageLayou
 }
 
 void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer cmd) {
-	for (const auto &iter : step.preTransitions) {
+	for (size_t i = 0; i < step.preTransitions.size(); i++) {
+		const TransitionRequest &iter = step.preTransitions[i];
 		if (iter.aspect == VK_IMAGE_ASPECT_COLOR_BIT && iter.fb->color.layout != iter.targetLayout) {
 			recordBarrier_.TransitionImageAuto(
 				iter.fb->color.image,
@@ -1151,6 +1153,8 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 	// The stencil ones are very commonly mostly redundant so let's eliminate them where possible.
 	// Might also want to consider scissor and viewport.
 	VkPipeline lastPipeline = VK_NULL_HANDLE;
+	VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
+
 	int lastStencilWriteMask = -1;
 	int lastStencilCompareMask = -1;
 	int lastStencilReference = -1;
@@ -1166,6 +1170,7 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 			VkPipeline pipeline = c.pipeline.pipeline;
 			if (pipeline != lastGraphicsPipeline) {
 				vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
+				pipelineLayout = c.pipeline.pipelineLayout;
 				lastGraphicsPipeline = pipeline;
 				// Reset dynamic state so it gets refreshed with the new pipeline.
 				lastStencilWriteMask = -1;
@@ -1187,6 +1192,7 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 			}
 			if (pipeline->pipeline != lastGraphicsPipeline && pipeline->pipeline != VK_NULL_HANDLE) {
 				vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->pipeline);
+				pipelineLayout = c.pipeline.pipelineLayout;
 				lastGraphicsPipeline = pipeline->pipeline;
 				// Reset dynamic state so it gets refreshed with the new pipeline.
 				lastStencilWriteMask = -1;
@@ -1208,6 +1214,7 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 			}
 			if (pipeline->pipeline != lastComputePipeline && pipeline->pipeline != VK_NULL_HANDLE) {
 				vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline->pipeline);
+				pipelineLayout = c.pipeline.pipelineLayout;
 				lastComputePipeline = pipeline->pipeline;
 			}
 			break;
@@ -1257,7 +1264,7 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 		}
 
 		case VKRRenderCommand::PUSH_CONSTANTS:
-			vkCmdPushConstants(cmd, c.push.pipelineLayout, c.push.stages, c.push.offset, c.push.size, c.push.data);
+			vkCmdPushConstants(cmd, pipelineLayout, c.push.stages, c.push.offset, c.push.size, c.push.data);
 			break;
 
 		case VKRRenderCommand::STENCIL:
@@ -1276,14 +1283,17 @@ void VulkanQueueRunner::PerformRenderPass(const VKRStep &step, VkCommandBuffer c
 			break;
 
 		case VKRRenderCommand::DRAW_INDEXED:
-			vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, c.drawIndexed.pipelineLayout, 0, 1, &c.drawIndexed.ds, c.drawIndexed.numUboOffsets, c.drawIndexed.uboOffsets);
-			vkCmdBindIndexBuffer(cmd, c.drawIndexed.ibuffer, c.drawIndexed.ioffset, c.drawIndexed.indexType);
-			vkCmdBindVertexBuffers(cmd, 0, 1, &c.drawIndexed.vbuffer, &c.drawIndexed.voffset);
+		{
+			vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &c.drawIndexed.ds, c.drawIndexed.numUboOffsets, c.drawIndexed.uboOffsets);
+			vkCmdBindIndexBuffer(cmd, c.drawIndexed.ibuffer, c.drawIndexed.ioffset, (VkIndexType)c.drawIndexed.indexType);
+			VkDeviceSize voffset = c.drawIndexed.voffset;
+			vkCmdBindVertexBuffers(cmd, 0, 1, &c.drawIndexed.vbuffer, &voffset);
 			vkCmdDrawIndexed(cmd, c.drawIndexed.count, c.drawIndexed.instances, 0, 0, 0);
 			break;
+		}
 
 		case VKRRenderCommand::DRAW:
-			vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, c.draw.pipelineLayout, 0, 1, &c.draw.ds, c.draw.numUboOffsets, c.draw.uboOffsets);
+			vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &c.draw.ds, c.draw.numUboOffsets, c.draw.uboOffsets);
 			if (c.draw.vbuffer) {
 				vkCmdBindVertexBuffers(cmd, 0, 1, &c.draw.vbuffer, &c.draw.voffset);
 			}
@@ -1793,6 +1803,8 @@ void VulkanQueueRunner::CopyReadbackBuffer(int width, int height, Draw::DataForm
 		}
 	} else if (destFormat == Draw::DataFormat::D32F) {
 		ConvertToD32F(pixels, (const uint8_t *)mappedData, pixelStride, width, width, height, srcFormat);
+	} else if (destFormat == Draw::DataFormat::D16) {
+		ConvertToD16(pixels, (const uint8_t *)mappedData, pixelStride, width, width, height, srcFormat);
 	} else {
 		// TODO: Maybe a depth conversion or something?
 		ERROR_LOG(G3D, "CopyReadbackBuffer: Unknown format");

Common/GPU/Vulkan/VulkanQueueRunner.h

@@ -52,15 +52,17 @@ struct VkRenderData {
 	union {
 		struct {
 			VkPipeline pipeline;
+			VkPipelineLayout pipelineLayout;
 		} pipeline;
 		struct {
 			VKRGraphicsPipeline *pipeline;
+			VkPipelineLayout pipelineLayout;
 		} graphics_pipeline;
 		struct {
 			VKRComputePipeline *pipeline;
+			VkPipelineLayout pipelineLayout;
 		} compute_pipeline;
 		struct {
-			VkPipelineLayout pipelineLayout;
 			VkDescriptorSet ds;
 			int numUboOffsets;
 			uint32_t uboOffsets[3];
@@ -70,17 +72,16 @@ struct VkRenderData {
 			uint32_t offset;
 		} draw;
 		struct {
-			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;
+			uint32_t voffset;
+			uint32_t ioffset;
 			uint32_t count;
 			int16_t instances;
-			VkIndexType indexType;
+			int16_t indexType;
 		} drawIndexed;
 		struct {
 			uint32_t clearColor;
@@ -103,7 +104,6 @@ struct VkRenderData {
 			uint32_t color;
 		} blendColor;
 		struct {
-			VkPipelineLayout pipelineLayout;
 			VkShaderStageFlags stages;
 			uint8_t offset;
 			uint8_t size;
@@ -134,8 +134,8 @@ enum class VKRRenderPassStoreAction : uint8_t {
 };
 
 struct TransitionRequest {
-	VkImageAspectFlags aspect;  // COLOR or DEPTH
 	VKRFramebuffer *fb;
+	VkImageAspectFlags aspect;  // COLOR or DEPTH
 	VkImageLayout targetLayout;
 };
 
@@ -153,7 +153,7 @@ struct VKRStep {
 
 	VKRStepType stepType;
 	std::vector<VkRenderData> commands;
-	std::vector<TransitionRequest> preTransitions;
+	TinySet<TransitionRequest, 4> preTransitions;
 	TinySet<VKRFramebuffer *, 8> dependencies;
 	const char *tag;
 	union {

Common/GPU/Vulkan/VulkanRenderManager.cpp

@@ -836,6 +836,7 @@ bool VulkanRenderManager::CopyFramebufferToMemorySync(VKRFramebuffer *src, VkIma
 	} else {
 		_assert_(false);
 	}
+
 	// Need to call this after FlushSync so the pixels are guaranteed to be ready in CPU-accessible VRAM.
 	queueRunner_.CopyReadbackBuffer(w, h, srcFormat, destFormat, pixelStride, pixels);
 	return true;
@@ -1188,7 +1189,7 @@ VkImageView VulkanRenderManager::BindFramebufferAsTexture(VKRFramebuffer *fb, in
 		// We're done.
 		return aspectBit == VK_IMAGE_ASPECT_COLOR_BIT ? fb->color.imageView : fb->depth.depthSampleView;
 	} else {
-		curRenderStep_->preTransitions.push_back({ aspectBit, fb, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL });
+		curRenderStep_->preTransitions.push_back({ fb, aspectBit, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL });
 		return aspectBit == VK_IMAGE_ASPECT_COLOR_BIT ? fb->color.imageView : fb->depth.depthSampleView;
 	}
 }

Common/GPU/Vulkan/VulkanRenderManager.h

@@ -242,29 +242,32 @@ class VulkanRenderManager {
 		return pipeline;
 	}
 
-	void BindPipeline(VkPipeline pipeline, PipelineFlags flags) {
+	void BindPipeline(VkPipeline pipeline, PipelineFlags flags, VkPipelineLayout pipelineLayout) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER);
 		_dbg_assert_(pipeline != VK_NULL_HANDLE);
 		VkRenderData data{ VKRRenderCommand::BIND_PIPELINE };
 		data.pipeline.pipeline = pipeline;
+		data.pipeline.pipelineLayout = pipelineLayout;
 		curPipelineFlags_ |= flags;
 		curRenderStep_->commands.push_back(data);
 	}
 
-	void BindPipeline(VKRGraphicsPipeline *pipeline, PipelineFlags flags) {
+	void BindPipeline(VKRGraphicsPipeline *pipeline, PipelineFlags flags, VkPipelineLayout pipelineLayout) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER);
 		_dbg_assert_(pipeline != nullptr);
 		VkRenderData data{ VKRRenderCommand::BIND_GRAPHICS_PIPELINE };
 		data.graphics_pipeline.pipeline = pipeline;
+		data.graphics_pipeline.pipelineLayout = pipelineLayout;
 		curPipelineFlags_ |= flags;
 		curRenderStep_->commands.push_back(data);
 	}
 
-	void BindPipeline(VKRComputePipeline *pipeline, PipelineFlags flags) {
+	void BindPipeline(VKRComputePipeline *pipeline, PipelineFlags flags, VkPipelineLayout pipelineLayout) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER);
 		_dbg_assert_(pipeline != nullptr);
 		VkRenderData data{ VKRRenderCommand::BIND_COMPUTE_PIPELINE };
 		data.compute_pipeline.pipeline = pipeline;
+		data.compute_pipeline.pipelineLayout = pipelineLayout;
 		curPipelineFlags_ |= flags;
 		curRenderStep_->commands.push_back(data);
 	}
@@ -351,7 +354,6 @@ class VulkanRenderManager {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER);
 		_dbg_assert_(size + offset < 40);
 		VkRenderData data{ VKRRenderCommand::PUSH_CONSTANTS };
-		data.push.pipelineLayout = pipelineLayout;
 		data.push.stages = stages;
 		data.push.offset = offset;
 		data.push.size = size;
@@ -386,12 +388,11 @@ class VulkanRenderManager {
 			curRenderStep_->render.stencilStore = VKRRenderPassStoreAction::DONT_CARE;
 	}
 
-	void Draw(VkPipelineLayout layout, VkDescriptorSet descSet, int numUboOffsets, const uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, int count, int offset = 0) {
+	void Draw(VkDescriptorSet descSet, int numUboOffsets, const uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, int count, int offset = 0) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER && curStepHasViewport_ && curStepHasScissor_);
 		VkRenderData data{ VKRRenderCommand::DRAW };
 		data.draw.count = count;
 		data.draw.offset = offset;
-		data.draw.pipelineLayout = layout;
 		data.draw.ds = descSet;
 		data.draw.vbuffer = vbuffer;
 		data.draw.voffset = voffset;
@@ -403,12 +404,11 @@ class VulkanRenderManager {
 		curRenderStep_->render.numDraws++;
 	}
 
-	void DrawIndexed(VkPipelineLayout layout, VkDescriptorSet descSet, int numUboOffsets, const uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, VkBuffer ibuffer, int ioffset, int count, int numInstances, VkIndexType indexType) {
+	void DrawIndexed(VkDescriptorSet descSet, int numUboOffsets, const uint32_t *uboOffsets, VkBuffer vbuffer, int voffset, VkBuffer ibuffer, int ioffset, int count, int numInstances, VkIndexType indexType) {
 		_dbg_assert_(curRenderStep_ && curRenderStep_->stepType == VKRStepType::RENDER && curStepHasViewport_ && curStepHasScissor_);
 		VkRenderData data{ VKRRenderCommand::DRAW_INDEXED };
 		data.drawIndexed.count = count;
 		data.drawIndexed.instances = numInstances;
-		data.drawIndexed.pipelineLayout = layout;
 		data.drawIndexed.ds = descSet;
 		data.drawIndexed.vbuffer = vbuffer;
 		data.drawIndexed.voffset = voffset;