Plumb PipelineLayouts down to SpirvRoutine

src/Device/Context.cpp

@@ -218,6 +218,8 @@ namespace sw
 			colorWriteMask[i] = 0x0000000F;
 		}
 
+		pipelineLayout = nullptr;
+
 		pixelShader = nullptr;
 		vertexShader = nullptr;
 

src/Device/Context.hpp

@@ -24,7 +24,8 @@
 namespace vk
 {
 	class ImageView;
-};
+	class PipelineLayout;
+} // namespace vk
 
 namespace sw
 {
@@ -198,6 +199,8 @@ namespace sw
 		vk::ImageView *stencilBuffer;
 		unsigned int stencilBufferLayer;
 
+		vk::PipelineLayout const *pipelineLayout;
+
 		// Shaders
 		const SpirvShader *pixelShader;
 		const SpirvShader *vertexShader;

src/Device/PixelProcessor.cpp

@@ -449,7 +449,7 @@ namespace sw
 
 		if(!routine)
 		{
-			QuadRasterizer *generator = new PixelProgram(state, context->pixelShader);
+			QuadRasterizer *generator = new PixelProgram(state, context->pipelineLayout, context->pixelShader);
 			generator->generate();
 			routine = (*generator)("PixelRoutine_%0.8X", state.shaderID);
 			delete generator;

src/Device/VertexProcessor.cpp

@@ -129,7 +129,7 @@ namespace sw
 
 		if(!routine)   // Create one
 		{
-			VertexRoutine *generator = new VertexProgram(state, context->vertexShader);
+			VertexRoutine *generator = new VertexProgram(state, context->pipelineLayout, context->vertexShader);
 			generator->generate();
 			routine = (*generator)("VertexRoutine_%0.8X", state.shaderID);
 			delete generator;

src/Pipeline/PixelProgram.hpp

@@ -23,8 +23,11 @@ namespace sw
 	class PixelProgram : public PixelRoutine
 	{
 	public:
-		PixelProgram(const PixelProcessor::State &state, SpirvShader const *spirvShader) :
-			PixelRoutine(state, spirvShader)
+		PixelProgram(
+				const PixelProcessor::State &state,
+				vk::PipelineLayout const *pipelineLayout,
+				SpirvShader const *spirvShader) :
+			PixelRoutine(state, pipelineLayout, spirvShader)
 		{
 		}
 

src/Pipeline/PixelRoutine.cpp

@@ -29,8 +29,12 @@ namespace sw
 	extern bool exactColorRounding;
 	extern bool forceClearRegisters;
 
-	PixelRoutine::PixelRoutine(const PixelProcessor::State &state, SpirvShader const *spirvShader)
-		: QuadRasterizer(state, spirvShader)	/* addressing */
+	PixelRoutine::PixelRoutine(
+			const PixelProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader)
+		: QuadRasterizer(state, spirvShader),
+		  routine(pipelineLayout)
 	{
 		spirvShader->emitProlog(&routine);
 

src/Pipeline/PixelRoutine.hpp

@@ -25,7 +25,9 @@ namespace sw
 	class PixelRoutine : public sw::QuadRasterizer, public ShaderCore
 	{
 	public:
-		PixelRoutine(const PixelProcessor::State &state, SpirvShader const *spirvShader);
+		PixelRoutine(const PixelProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader);
 
 		virtual ~PixelRoutine();
 

src/Pipeline/SpirvShader.cpp

@@ -16,6 +16,7 @@
 #include "SpirvShader.hpp"
 #include "System/Math.hpp"
 #include "Vulkan/VkDebug.hpp"
+#include "Vulkan/VkPipelineLayout.hpp"
 #include "Device/Config.hpp"
 
 namespace sw
@@ -1437,4 +1438,10 @@ namespace sw
 			}
 		}
 	}
+
+	SpirvRoutine::SpirvRoutine(vk::PipelineLayout const *pipelineLayout) :
+		pipelineLayout(pipelineLayout)
+	{
+	}
+
 }

src/Pipeline/SpirvShader.hpp

@@ -15,11 +15,13 @@
 #ifndef sw_SpirvShader_hpp
 #define sw_SpirvShader_hpp
 
-#include "System/Types.hpp"
-#include "Vulkan/VkDebug.hpp"
 #include "ShaderCore.hpp"
 #include "SpirvID.hpp"
+#include "System/Types.hpp"
+#include "Vulkan/VkDebug.hpp"
+#include "Vulkan/VkConfig.h"
 
+#include <array>
 #include <cstring>
 #include <string>
 #include <vector>
@@ -30,6 +32,11 @@
 #include <spirv/unified1/spirv.hpp>
 #include <Device/Config.hpp>
 
+namespace vk
+{
+	class PipelineLayout;
+} // namespace vk
+
 namespace sw
 {
 	// Forward declarations.
@@ -412,8 +419,12 @@ namespace sw
 	class SpirvRoutine
 	{
 	public:
+		SpirvRoutine(vk::PipelineLayout const *pipelineLayout);
+
 		using Value = Array<SIMD::Float>;
 
+		vk::PipelineLayout const * const pipelineLayout;
+
 		std::unordered_map<SpirvShader::ObjectID, Value> lvalues;
 
 		std::unordered_map<SpirvShader::ObjectID, Intermediate> intermediates;
@@ -421,6 +432,8 @@ namespace sw
 		Value inputs = Value{MAX_INTERFACE_COMPONENTS};
 		Value outputs = Value{MAX_INTERFACE_COMPONENTS};
 
+		std::array<Pointer<Byte>, vk::MAX_BOUND_DESCRIPTOR_SETS> descriptorSets;
+
 		void createLvalue(SpirvShader::ObjectID id, uint32_t size)
 		{
 			lvalues.emplace(id, Value(size));

src/Pipeline/VertexProgram.cpp

@@ -22,8 +22,11 @@
 
 namespace sw
 {
-	VertexProgram::VertexProgram(const VertexProcessor::State &state, SpirvShader const *spirvShader)
-		: VertexRoutine(state, spirvShader)
+	VertexProgram::VertexProgram(
+			const VertexProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader)
+		: VertexRoutine(state, pipelineLayout, spirvShader)
 	{
 		ifDepth = 0;
 		loopRepDepth = 0;

src/Pipeline/VertexProgram.hpp

@@ -29,7 +29,10 @@ namespace sw
 	class VertexProgram : public VertexRoutine, public ShaderCore
 	{
 	public:
-		VertexProgram(const VertexProcessor::State &state, SpirvShader const *spirvShader);
+		VertexProgram(
+			const VertexProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader);
 
 		virtual ~VertexProgram();
 

src/Pipeline/VertexRoutine.cpp

@@ -24,8 +24,12 @@
 
 namespace sw
 {
-	VertexRoutine::VertexRoutine(const VertexProcessor::State &state, SpirvShader const *spirvShader)
-		: state(state),
+	VertexRoutine::VertexRoutine(
+			const VertexProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader)
+		: routine(pipelineLayout),
+		  state(state),
 		  spirvShader(spirvShader)
 	{
 	  	spirvShader->emitProlog(&routine);

src/Pipeline/VertexRoutine.hpp

@@ -20,6 +20,11 @@
 #include "ShaderCore.hpp"
 #include "SpirvShader.hpp"
 
+namespace vk
+{
+	class PipelineLayout;
+} // namespace vk
+
 namespace sw
 {
 	class VertexRoutinePrototype : public Function<Void(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)>
@@ -38,7 +43,10 @@ namespace sw
 	class VertexRoutine : public VertexRoutinePrototype
 	{
 	public:
-		VertexRoutine(const VertexProcessor::State &state, SpirvShader const *spirvShader);
+		VertexRoutine(
+			const VertexProcessor::State &state,
+			vk::PipelineLayout const *pipelineLayout,
+			SpirvShader const *spirvShader);
 		virtual ~VertexRoutine();
 
 		void generate();

src/Vulkan/VkDescriptorSetLayout.cpp

@@ -13,6 +13,8 @@
 // limitations under the License.
 
 #include "VkDescriptorSetLayout.hpp"
+#include "System/Types.hpp"
+
 #include <algorithm>
 #include <cstring>
 
@@ -176,6 +178,12 @@ void DescriptorSetLayout::initialize(VkDescriptorSet vkDescriptorSet)
 	}
 }
 
+size_t DescriptorSetLayout::getBindingOffset(uint32_t binding) const
+{
+	uint32_t index = getBindingIndex(binding);
+	return bindingOffsets[index] + OFFSET(DescriptorSet, data[0]);
+}
+
 uint8_t* DescriptorSetLayout::getOffsetPointer(VkDescriptorSet descriptorSet, uint32_t binding, uint32_t arrayElement, uint32_t count, size_t* typeSize) const
 {
 	uint32_t index = getBindingIndex(binding);

src/Vulkan/VkDescriptorSetLayout.hpp

@@ -35,6 +35,7 @@ public:
 
 	void initialize(VkDescriptorSet descriptorSet);
 	size_t getSize() const;
+	size_t getBindingOffset(uint32_t binding) const;
 
 private:
 	uint32_t getBindingIndex(uint32_t binding) const;

src/Vulkan/VkPipeline.cpp

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "VkPipeline.hpp"
+#include "VkPipelineLayout.hpp"
 #include "VkShaderModule.hpp"
 #include "Pipeline/SpirvShader.hpp"
 
@@ -191,7 +192,10 @@ uint32_t getNumberOfChannels(VkFormat format)
 namespace vk
 {
 
+Pipeline::Pipeline(PipelineLayout const *layout) : layout(layout) {}
+
 GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, void* mem)
+	: Pipeline(Cast(pCreateInfo->layout))
 {
 	if((pCreateInfo->flags != 0) ||
 	   (pCreateInfo->stageCount != 2) ||
@@ -230,6 +234,9 @@ GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo* pCreateIn
 		UNIMPLEMENTED();
 	}
 
+	// Context must always have a PipelineLayout set.
+	context.pipelineLayout = layout;
+
 	// Temporary in-binding-order representation of buffer strides, to be consumed below
 	// when considering attributes. TODO: unfuse buffers from attributes in backend, is old GL model.
 	uint32_t bufferStrides[MAX_VERTEX_INPUT_BINDINGS];
@@ -499,6 +506,7 @@ const sw::Color<float>& GraphicsPipeline::getBlendConstants() const
 }
 
 ComputePipeline::ComputePipeline(const VkComputePipelineCreateInfo* pCreateInfo, void* mem)
+	: Pipeline(Cast(pCreateInfo->layout))
 {
 }
 

src/Vulkan/VkPipeline.hpp

@@ -23,9 +23,13 @@ namespace sw { class SpirvShader; }
 namespace vk
 {
 
+class PipelineLayout;
+
 class Pipeline
 {
 public:
+	Pipeline(PipelineLayout const *layout);
+
 	operator VkPipeline()
 	{
 		return reinterpret_cast<VkPipeline>(this);
@@ -40,6 +44,11 @@ public:
 #ifndef NDEBUG
 	virtual VkPipelineBindPoint bindPoint() const = 0;
 #endif
+
+	PipelineLayout const * getLayout() const { return layout; }
+
+protected:
+	PipelineLayout const *layout = nullptr;
 };
 
 class GraphicsPipeline : public Pipeline, public ObjectBase<GraphicsPipeline, VkPipeline>

src/Vulkan/VkPipelineLayout.cpp

@@ -44,4 +44,15 @@ size_t PipelineLayout::ComputeRequiredAllocationSize(const VkPipelineLayoutCreat
 	       (pCreateInfo->pushConstantRangeCount * sizeof(VkPushConstantRange));
 }
 
+size_t PipelineLayout::getNumDescriptorSets() const
+{
+	return setLayoutCount;
+}
+
+size_t PipelineLayout::getBindingOffset(size_t descriptorSet, size_t binding) const
+{
+	ASSERT(descriptorSet < setLayoutCount);
+	return setLayouts[descriptorSet]->getBindingOffset(binding);
+}
+
 } // namespace vk

src/Vulkan/VkPipelineLayout.hpp

@@ -29,6 +29,9 @@ public:
 
 	static size_t ComputeRequiredAllocationSize(const VkPipelineLayoutCreateInfo* pCreateInfo);
 
+	size_t getNumDescriptorSets() const;
+	size_t getBindingOffset(size_t descriptorSet, size_t binding) const;
+
 private:
 	uint32_t              setLayoutCount = 0;
 	DescriptorSetLayout** setLayouts = nullptr;