Context refactor: from OpenGL-like state to Vulkan-like state

src/Device/Context.hpp

-// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+// Copyright 2020 The SwiftShader Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,33 +12,78 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef sw_Context_hpp
-#define sw_Context_hpp
+#ifndef vk_Context_hpp
+#define vk_Context_hpp
 
 #include "Config.hpp"
 #include "Memset.hpp"
 #include "Stream.hpp"
 #include "System/Types.hpp"
-#include "Vulkan/VkConfig.hpp"
 #include "Vulkan/VkDescriptorSet.hpp"
 
+#include <vector>
+
 namespace vk {
 
+class Buffer;
+class Device;
 class ImageView;
 class PipelineLayout;
 
-}  // namespace vk
+struct VertexInputBinding
+{
+	Buffer *buffer;
+	VkDeviceSize offset;
+};
 
-namespace sw {
+struct IndexBuffer
+{
+	inline VkIndexType getIndexType() const { return indexType; }
+	void setIndexBufferBinding(const VertexInputBinding &indexBufferBinding, VkIndexType type);
+	void getIndexBuffers(VkPrimitiveTopology topology, uint32_t count, uint32_t first, bool indexed, bool hasPrimitiveRestartEnable, std::vector<std::pair<uint32_t, void *>> *indexBuffers) const;
+
+private:
+	int bytesPerIndex() const;
 
-class SpirvShader;
+	VertexInputBinding binding;
+	VkIndexType indexType;
+};
 
-struct PushConstantStorage
+struct Attachments
 {
-	unsigned char data[vk::MAX_PUSH_CONSTANT_SIZE];
+	ImageView *renderTarget[sw::RENDERTARGETS] = {};
+	ImageView *depthBuffer = nullptr;
+	ImageView *stencilBuffer = nullptr;
+
+	bool isColorClamped(int index) const;
+	VkFormat renderTargetInternalFormat(int index) const;
+};
+
+struct Inputs
+{
+	Inputs(const VkPipelineVertexInputStateCreateInfo *vertexInputState);
+
+	void updateDescriptorSets(const DescriptorSet::Array &dso,
+	                          const DescriptorSet::Bindings &ds,
+	                          const DescriptorSet::DynamicOffsets &ddo);
+	inline const DescriptorSet::Array &getDescriptorSetObjects() const { return descriptorSetObjects; }
+	inline const DescriptorSet::Bindings &getDescriptorSets() const { return descriptorSets; }
+	inline const DescriptorSet::DynamicOffsets &getDescriptorDynamicOffsets() const { return descriptorDynamicOffsets; }
+	inline const sw::Stream &getStream(uint32_t i) const { return stream[i]; }
+
+	void bindVertexInputs(int firstInstance);
+	void setVertexInputBinding(const VertexInputBinding vertexInputBindings[]);
+	void advanceInstanceAttributes();
+
+private:
+	VertexInputBinding vertexInputBindings[MAX_VERTEX_INPUT_BINDINGS] = {};
+	DescriptorSet::Array descriptorSetObjects = {};
+	DescriptorSet::Bindings descriptorSets = {};
+	DescriptorSet::DynamicOffsets descriptorDynamicOffsets = {};
+	sw::Stream stream[sw::MAX_INTERFACE_COMPONENTS / 4];
 };
 
-struct BlendState : Memset<BlendState>
+struct BlendState : sw::Memset<BlendState>
 {
 	BlendState()
 	    : Memset(this, 0)
@@ -70,24 +115,93 @@ struct BlendState : Memset<BlendState>
 	VkBlendOp blendOperationAlpha;
 };
 
-class Context
+struct DynamicState
+{
+	VkViewport viewport;
+	VkRect2D scissor;
+	sw::float4 blendConstants;
+	float depthBiasConstantFactor = 0.0f;
+	float depthBiasClamp = 0.0f;
+	float depthBiasSlopeFactor = 0.0f;
+	float minDepthBounds = 0.0f;
+	float maxDepthBounds = 0.0f;
+
+	uint32_t compareMask[2] = { 0 };
+	uint32_t writeMask[2] = { 0 };
+	uint32_t reference[2] = { 0 };
+};
+
+struct GraphicsState
 {
-public:
-	Context() = default;
+	GraphicsState(const Device *device, const VkGraphicsPipelineCreateInfo *pCreateInfo, const PipelineLayout *layout, bool robustBufferAccess);
+
+	const GraphicsState combineStates(const DynamicState &dynamicState) const;
+
+	inline const PipelineLayout *getPipelineLayout() const { return pipelineLayout; }
+	inline bool getRobustBufferAccess() const { return robustBufferAccess; }
+	inline VkPrimitiveTopology getTopology() const { return topology; }
+
+	inline VkProvokingVertexModeEXT getProvokingVertexMode() const { return provokingVertexMode; }
+
+	inline VkStencilOpState getFrontStencil() const { return frontStencil; }
+	inline VkStencilOpState getBackStencil() const { return backStencil; }
+
+	// Pixel processor states
+	inline VkCullModeFlags getCullMode() const { return cullMode; }
+	inline VkFrontFace getFrontFace() const { return frontFace; }
+	inline VkPolygonMode getPolygonMode() const { return polygonMode; }
+	inline VkLineRasterizationModeEXT getLineRasterizationMode() const { return lineRasterizationMode; }
+
+	inline float getConstantDepthBias() const { return constantDepthBias; }
+	inline float getSlopeDepthBias() const { return slopeDepthBias; }
+	inline float getDepthBiasClamp() const { return depthBiasClamp; }
+	inline bool hasDepthRangeUnrestricted() const { return depthRangeUnrestricted; }
+
+	// Pixel processor states
+	inline bool hasRasterizerDiscard() const { return rasterizerDiscard; }
+	inline VkCompareOp getDepthCompareMode() const { return depthCompareMode; }
+
+	inline float getLineWidth() const { return lineWidth; }
+
+	inline unsigned int getMultiSampleMask() const { return multiSampleMask; }
+	inline int getSampleCount() const { return sampleCount; }
+	inline bool hasAlphaToCoverage() const { return alphaToCoverage; }
+
+	inline bool hasPrimitiveRestartEnable() const { return primitiveRestartEnable; }
+	inline const VkRect2D &getScissor() const { return scissor; }
+	inline const VkViewport &getViewport() const { return viewport; }
+	inline const sw::float4 &getBlendConstants() const { return blendConstants; }
 
 	bool isDrawPoint(bool polygonModeAware) const;
 	bool isDrawLine(bool polygonModeAware) const;
 	bool isDrawTriangle(bool polygonModeAware) const;
 
-	bool depthWriteActive() const;
-	bool depthBufferActive() const;
-	bool stencilActive() const;
+	BlendState getBlendState(int index, const Attachments &attachments, bool fragmentContainsKill) const;
 
-	void setBlendState(int index, BlendState state);
-	BlendState getBlendState(int index) const;
-	bool isColorClamped(int index) const;
+	int colorWriteActive(int index, const Attachments &attachments) const;
+	bool depthWriteActive(const Attachments &attachments) const;
+	bool depthBufferActive(const Attachments &attachments) const;
+	bool stencilActive(const Attachments &attachments) const;
 
+private:
+	inline bool hasDynamicState(VkDynamicState dynamicState) const { return (dynamicStateFlags & (1 << dynamicState)) != 0; }
+
+	VkBlendFactor sourceBlendFactor(int index) const;
+	VkBlendFactor destBlendFactor(int index) const;
+	VkBlendOp blendOperation(int index, const Attachments &attachments) const;
+
+	VkBlendFactor sourceBlendFactorAlpha(int index) const;
+	VkBlendFactor destBlendFactorAlpha(int index) const;
+	VkBlendOp blendOperationAlpha(int index, const Attachments &attachments) const;
+
+	bool alphaBlendActive(int index, const Attachments &attachments, bool fragmentContainsKill) const;
+	bool colorWriteActive(const Attachments &attachments) const;
+
+	const PipelineLayout *pipelineLayout;
+	const bool robustBufferAccess = true;
+	uint32_t dynamicStateFlags = 0;
 	VkPrimitiveTopology topology;
+
 	VkProvokingVertexModeEXT provokingVertexMode;
 
 	bool stencilEnable;
@@ -105,27 +219,6 @@ public:
 	float depthBiasClamp;
 	bool depthRangeUnrestricted;
 
-	VkFormat renderTargetInternalFormat(int index) const;
-	int colorWriteActive(int index) const;
-
-	vk::DescriptorSet::Array descriptorSetObjects = {};
-	vk::DescriptorSet::Bindings descriptorSets = {};
-	vk::DescriptorSet::DynamicOffsets descriptorDynamicOffsets = {};
-	Stream input[MAX_INTERFACE_COMPONENTS / 4];
-	bool robustBufferAccess;
-
-	vk::ImageView *renderTarget[RENDERTARGETS];
-	vk::ImageView *depthBuffer;
-	vk::ImageView *stencilBuffer;
-
-	vk::PipelineLayout const *pipelineLayout;
-
-	// Shaders
-	const SpirvShader *pixelShader;
-	const SpirvShader *vertexShader;
-
-	bool occlusionEnabled;
-
 	// Pixel processor states
 	bool rasterizerDiscard;
 	bool depthBoundsTestEnable;
@@ -135,28 +228,19 @@ public:
 
 	float lineWidth;
 
-	int colorWriteMask[RENDERTARGETS];  // RGBA
-	unsigned int sampleMask;
+	int colorWriteMask[sw::RENDERTARGETS];  // RGBA
 	unsigned int multiSampleMask;
 	int sampleCount;
 	bool alphaToCoverage;
 
-private:
-	bool colorWriteActive() const;
-	bool colorUsed() const;
-
-	bool alphaBlendActive(int index) const;
-	VkBlendFactor sourceBlendFactor(int index) const;
-	VkBlendFactor destBlendFactor(int index) const;
-	VkBlendOp blendOperation(int index) const;
+	bool primitiveRestartEnable = false;
+	VkRect2D scissor;
+	VkViewport viewport;
+	sw::float4 blendConstants;
 
-	VkBlendFactor sourceBlendFactorAlpha(int index) const;
-	VkBlendFactor destBlendFactorAlpha(int index) const;
-	VkBlendOp blendOperationAlpha(int index) const;
-
-	BlendState blendState[RENDERTARGETS];
+	BlendState blendState[sw::RENDERTARGETS];
 };
 
-}  // namespace sw
+}  // namespace vk
 
-#endif  // sw_Context_hpp
+#endif  // vk_Context_hpp

src/Device/PixelProcessor.cpp

@@ -82,17 +82,17 @@ void PixelProcessor::setRoutineCacheSize(int cacheSize)
 	routineCache = std::make_unique<RoutineCacheType>(clamp(cacheSize, 1, 65536));
 }
 
-const PixelProcessor::State PixelProcessor::update(const Context *context) const
+const PixelProcessor::State PixelProcessor::update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *fragmentShader, const sw::SpirvShader *vertexShader, const vk::Attachments &attachments, bool occlusionEnabled) const
 {
 	State state;
 
-	state.numClipDistances = context->vertexShader->getNumOutputClipDistances();
-	state.numCullDistances = context->vertexShader->getNumOutputCullDistances();
+	state.numClipDistances = vertexShader->getNumOutputClipDistances();
+	state.numCullDistances = vertexShader->getNumOutputCullDistances();
 
-	if(context->pixelShader)
+	if(fragmentShader)
 	{
-		state.shaderID = context->pixelShader->getSerialID();
-		state.pipelineLayoutIdentifier = context->pipelineLayout->identifier;
+		state.shaderID = fragmentShader->getSerialID();
+		state.pipelineLayoutIdentifier = pipelineState.getPipelineLayout()->identifier;
 	}
 	else
 	{
@@ -100,49 +100,50 @@ const PixelProcessor::State PixelProcessor::update(const Context *context) const
 		state.pipelineLayoutIdentifier = 0;
 	}
 
-	state.alphaToCoverage = context->alphaToCoverage;
-	state.depthWriteEnable = context->depthWriteActive();
+	state.alphaToCoverage = pipelineState.hasAlphaToCoverage();
+	state.depthWriteEnable = pipelineState.depthWriteActive(attachments);
 
-	if(context->stencilActive())
+	if(pipelineState.stencilActive(attachments))
 	{
 		state.stencilActive = true;
-		state.frontStencil = context->frontStencil;
-		state.backStencil = context->backStencil;
+		state.frontStencil = pipelineState.getFrontStencil();
+		state.backStencil = pipelineState.getBackStencil();
 	}
 
-	if(context->depthBufferActive())
+	if(pipelineState.depthBufferActive(attachments))
 	{
 		state.depthTestActive = true;
-		state.depthCompareMode = context->depthCompareMode;
-		state.depthFormat = context->depthBuffer->getFormat();
+		state.depthCompareMode = pipelineState.getDepthCompareMode();
+		state.depthFormat = attachments.depthBuffer->getFormat();
 
-		state.depthBias = (context->constantDepthBias != 0.0f) || (context->slopeDepthBias != 0.0f);
+		state.depthBias = (pipelineState.getConstantDepthBias() != 0.0f) || (pipelineState.getSlopeDepthBias() != 0.0f);
 
 		// "For fixed-point depth buffers, fragment depth values are always limited to the range [0,1] by clamping after depth bias addition is performed.
 		//  Unless the VK_EXT_depth_range_unrestricted extension is enabled, fragment depth values are clamped even when the depth buffer uses a floating-point representation."
-		state.depthClamp = !state.depthFormat.isFloatFormat() || !context->depthRangeUnrestricted;
+		state.depthClamp = !state.depthFormat.isFloatFormat() || !pipelineState.hasDepthRangeUnrestricted();
 	}
 
-	state.occlusionEnabled = context->occlusionEnabled;
+	state.occlusionEnabled = occlusionEnabled;
 
+	bool fragmentContainsKill = (fragmentShader && fragmentShader->getModes().ContainsKill);
 	for(int i = 0; i < RENDERTARGETS; i++)
 	{
-		state.colorWriteMask |= context->colorWriteActive(i) << (4 * i);
-		state.targetFormat[i] = context->renderTargetInternalFormat(i);
-		state.blendState[i] = context->getBlendState(i);
+		state.colorWriteMask |= pipelineState.colorWriteActive(i, attachments) << (4 * i);
+		state.targetFormat[i] = attachments.renderTargetInternalFormat(i);
+		state.blendState[i] = pipelineState.getBlendState(i, attachments, fragmentContainsKill);
 	}
 
-	state.multiSampleCount = static_cast<unsigned int>(context->sampleCount);
-	state.multiSampleMask = context->multiSampleMask;
+	state.multiSampleCount = static_cast<unsigned int>(pipelineState.getSampleCount());
+	state.multiSampleMask = pipelineState.getMultiSampleMask();
 	state.enableMultiSampling = (state.multiSampleCount > 1) &&
-	                            !(context->isDrawLine(true) && (context->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT));
+	                            !(pipelineState.isDrawLine(true) && (pipelineState.getLineRasterizationMode() == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT));
 
-	if(state.enableMultiSampling && context->pixelShader)
+	if(state.enableMultiSampling && fragmentShader)
 	{
-		state.centroid = context->pixelShader->getModes().NeedsCentroid;
+		state.centroid = fragmentShader->getModes().NeedsCentroid;
 	}
 
-	state.frontFace = context->frontFace;
+	state.frontFace = pipelineState.getFrontFace();
 
 	state.hash = state.computeHash();
 
@@ -150,8 +151,8 @@ const PixelProcessor::State PixelProcessor::update(const Context *context) const
 }
 
 PixelProcessor::RoutineType PixelProcessor::routine(const State &state,
-                                                    vk::PipelineLayout const *pipelineLayout,
-                                                    SpirvShader const *pixelShader,
+                                                    const vk::PipelineLayout *pipelineLayout,
+                                                    const SpirvShader *pixelShader,
                                                     const vk::DescriptorSet::Bindings &descriptorSets)
 {
 	auto routine = routineCache->lookup(state);

src/Device/PixelProcessor.hpp

@@ -24,11 +24,9 @@
 
 namespace sw {
 
-class PixelShader;
-class Rasterizer;
-struct Texture;
 struct DrawData;
 struct Primitive;
+class SpirvShader;
 
 using RasterizerFunction = FunctionT<void(const Primitive *primitive, int count, int cluster, int clusterCount, DrawData *draw)>;
 
@@ -82,7 +80,7 @@ public:
 		bool occlusionEnabled;
 		bool perspective;
 
-		BlendState blendState[RENDERTARGETS];
+		vk::BlendState blendState[RENDERTARGETS];
 
 		unsigned int colorWriteMask;
 		vk::Format targetFormat[RENDERTARGETS];
@@ -153,9 +151,9 @@ public:
 
 	void setBlendConstant(const float4 &blendConstant);
 
-	const State update(const Context *context) const;
-	RoutineType routine(const State &state, vk::PipelineLayout const *pipelineLayout,
-	                    SpirvShader const *pixelShader, const vk::DescriptorSet::Bindings &descriptorSets);
+	const State update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *fragmentShader, const sw::SpirvShader *vertexShader, const vk::Attachments &attachments, bool occlusionEnabled) const;
+	RoutineType routine(const State &state, const vk::PipelineLayout *pipelineLayout,
+	                    const SpirvShader *pixelShader, const vk::DescriptorSet::Bindings &descriptorSets);
 	void setRoutineCacheSize(int routineCacheSize);
 
 	// Other semi-constants

src/Device/Rasterizer.hpp

@@ -15,7 +15,6 @@
 #ifndef sw_Rasterizer_hpp
 #define sw_Rasterizer_hpp
 
-#include "Context.hpp"
 #include "PixelProcessor.hpp"
 #include "Device/Config.hpp"
 

src/Device/Renderer.hpp

@@ -20,8 +20,8 @@
 #include "Primitive.hpp"
 #include "SetupProcessor.hpp"
 #include "VertexProcessor.hpp"
-#include "Device/Config.hpp"
 #include "Vulkan/VkDescriptorSet.hpp"
+#include "Vulkan/VkPipeline.hpp"
 
 #include "marl/finally.h"
 #include "marl/pool.h"
@@ -114,7 +114,7 @@ struct DrawData
 	float4 a2c2;
 	float4 a2c3;
 
-	PushConstantStorage pushConstants;
+	vk::Pipeline::PushConstantStorage pushConstants;
 };
 
 struct DrawCall
@@ -209,27 +209,16 @@ public:
 
 	bool hasOcclusionQuery() const { return occlusionQuery != nullptr; }
 
-	void draw(const sw::Context *context, VkIndexType indexType, unsigned int count, int baseVertex,
+	void draw(const vk::GraphicsPipeline *pipeline, const vk::DynamicState &dynamicState, unsigned int count, int baseVertex,
 	          CountedEvent *events, int instanceID, int viewID, void *indexBuffer, const VkExtent3D &framebufferExtent,
-	          PushConstantStorage const &pushConstants, bool update = true);
-
-	// Viewport & Clipper
-	void setViewport(const VkViewport &viewport);
-	void setScissor(const VkRect2D &scissor);
-
-	void setBlendConstant(const float4 &blendConstant);
+	          vk::Pipeline::PushConstantStorage const &pushConstants, bool update = true);
 
 	void addQuery(vk::Query *query);
 	void removeQuery(vk::Query *query);
 
-	void advanceInstanceAttributes(Stream *inputs);
-
 	void synchronize();
 
 private:
-	VkViewport viewport;
-	VkRect2D scissor;
-
 	DrawCall::Pool drawCallPool;
 	DrawCall::BatchData::Pool batchDataPool;
 

src/Device/SetupProcessor.cpp

@@ -14,7 +14,6 @@
 
 #include "SetupProcessor.hpp"
 
-#include "Context.hpp"
 #include "Polygon.hpp"
 #include "Primitive.hpp"
 #include "Renderer.hpp"
@@ -56,37 +55,37 @@ SetupProcessor::SetupProcessor()
 	setRoutineCacheSize(1024);
 }
 
-SetupProcessor::State SetupProcessor::update(const sw::Context *context) const
+SetupProcessor::State SetupProcessor::update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *fragmentShader, const sw::SpirvShader *vertexShader, const vk::Attachments &attachments) const
 {
 	State state;
 
-	bool vPosZW = (context->pixelShader && context->pixelShader->hasBuiltinInput(spv::BuiltInFragCoord));
-
-	state.isDrawPoint = context->isDrawPoint(true);
-	state.isDrawLine = context->isDrawLine(true);
-	state.isDrawTriangle = context->isDrawTriangle(true);
-	state.fixedPointDepthBuffer = context->depthBuffer && !context->depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT).isFloatFormat();
-	state.applyConstantDepthBias = context->isDrawTriangle(false) && (context->constantDepthBias != 0.0f);
-	state.applySlopeDepthBias = context->isDrawTriangle(false) && (context->slopeDepthBias != 0.0f);
-	state.applyDepthBiasClamp = context->isDrawTriangle(false) && (context->depthBiasClamp != 0.0f);
-	state.interpolateZ = context->depthBufferActive() || vPosZW;
-	state.interpolateW = context->pixelShader != nullptr;
-	state.frontFace = context->frontFace;
-	state.cullMode = context->cullMode;
-
-	state.multiSampleCount = context->sampleCount;
+	bool vPosZW = (fragmentShader && fragmentShader->hasBuiltinInput(spv::BuiltInFragCoord));
+
+	state.isDrawPoint = pipelineState.isDrawPoint(true);
+	state.isDrawLine = pipelineState.isDrawLine(true);
+	state.isDrawTriangle = pipelineState.isDrawTriangle(true);
+	state.fixedPointDepthBuffer = attachments.depthBuffer && !attachments.depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT).isFloatFormat();
+	state.applyConstantDepthBias = pipelineState.isDrawTriangle(false) && (pipelineState.getConstantDepthBias() != 0.0f);
+	state.applySlopeDepthBias = pipelineState.isDrawTriangle(false) && (pipelineState.getSlopeDepthBias() != 0.0f);
+	state.applyDepthBiasClamp = pipelineState.isDrawTriangle(false) && (pipelineState.getDepthBiasClamp() != 0.0f);
+	state.interpolateZ = pipelineState.depthBufferActive(attachments) || vPosZW;
+	state.interpolateW = fragmentShader != nullptr;
+	state.frontFace = pipelineState.getFrontFace();
+	state.cullMode = pipelineState.getCullMode();
+
+	state.multiSampleCount = pipelineState.getSampleCount();
 	state.enableMultiSampling = (state.multiSampleCount > 1) &&
-	                            !(context->isDrawLine(true) && (context->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT));
-	state.rasterizerDiscard = context->rasterizerDiscard;
+	                            !(pipelineState.isDrawLine(true) && (pipelineState.getLineRasterizationMode() == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT));
+	state.rasterizerDiscard = pipelineState.hasRasterizerDiscard();
 
-	state.numClipDistances = context->vertexShader->getNumOutputClipDistances();
-	state.numCullDistances = context->vertexShader->getNumOutputCullDistances();
+	state.numClipDistances = vertexShader->getNumOutputClipDistances();
+	state.numCullDistances = vertexShader->getNumOutputCullDistances();
 
-	if(context->pixelShader)
+	if(fragmentShader)
 	{
 		for(int interpolant = 0; interpolant < MAX_INTERFACE_COMPONENTS; interpolant++)
 		{
-			state.gradient[interpolant] = context->pixelShader->inputs[interpolant];
+			state.gradient[interpolant] = fragmentShader->inputs[interpolant];
 		}
 	}
 

src/Device/SetupProcessor.hpp

@@ -76,7 +76,7 @@ public:
 
 	SetupProcessor();
 
-	State update(const sw::Context *context) const;
+	State update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *fragmentShader, const sw::SpirvShader *vertexShader, const vk::Attachments &attachments) const;
 	RoutineType routine(const State &state);
 
 	void setRoutineCacheSize(int cacheSize);

src/Device/VertexProcessor.cpp

@@ -65,21 +65,21 @@ void VertexProcessor::setRoutineCacheSize(int cacheSize)
 	routineCache = std::make_unique<RoutineCacheType>(clamp(cacheSize, 1, 65536));
 }
 
-const VertexProcessor::State VertexProcessor::update(const sw::Context *context)
+const VertexProcessor::State VertexProcessor::update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *vertexShader, const vk::Inputs &inputs)
 {
 	State state;
 
-	state.shaderID = context->vertexShader->getSerialID();
-	state.pipelineLayoutIdentifier = context->pipelineLayout->identifier;
-	state.robustBufferAccess = context->robustBufferAccess;
-	state.isPoint = context->topology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+	state.shaderID = vertexShader->getSerialID();
+	state.pipelineLayoutIdentifier = pipelineState.getPipelineLayout()->identifier;
+	state.robustBufferAccess = pipelineState.getRobustBufferAccess();
+	state.isPoint = pipelineState.getTopology() == VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
 
-	for(int i = 0; i < MAX_INTERFACE_COMPONENTS / 4; i++)
+	for(size_t i = 0; i < MAX_INTERFACE_COMPONENTS / 4; i++)
 	{
-		state.input[i].format = context->input[i].format;
+		state.input[i].format = inputs.getStream(i).format;
 		// TODO: get rid of attribType -- just keep the VK format all the way through, this fully determines
 		// how to handle the attribute.
-		state.input[i].attribType = context->vertexShader->inputs[i * 4].Type;
+		state.input[i].attribType = vertexShader->inputs[i * 4].Type;
 	}
 
 	state.hash = state.computeHash();

src/Device/VertexProcessor.hpp

@@ -94,7 +94,7 @@ public:
 
 	VertexProcessor();
 
-	const State update(const sw::Context *context);
+	const State update(const vk::GraphicsState &pipelineState, const sw::SpirvShader *vertexShader, const vk::Inputs &inputs);
 	RoutineType routine(const State &state, vk::PipelineLayout const *pipelineLayout,
 	                    SpirvShader const *vertexShader, const vk::DescriptorSet::Bindings &descriptorSets);
 

src/Pipeline/ComputeProgram.cpp

@@ -209,7 +209,7 @@ void ComputeProgram::run(
     vk::DescriptorSet::Array const &descriptorSetObjects,
     vk::DescriptorSet::Bindings const &descriptorSets,
     vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
-    PushConstantStorage const &pushConstants,
+    vk::Pipeline::PushConstantStorage const &pushConstants,
     uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
     uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {

src/Pipeline/ComputeProgram.hpp

@@ -17,9 +17,9 @@
 
 #include "SpirvShader.hpp"
 
-#include "Device/Context.hpp"
 #include "Reactor/Coroutine.hpp"
 #include "Vulkan/VkDescriptorSet.hpp"
+#include "Vulkan/VkPipeline.hpp"
 
 #include <functional>
 
@@ -58,7 +58,7 @@ public:
 	    vk::DescriptorSet::Array const &descriptorSetObjects,
 	    vk::DescriptorSet::Bindings const &descriptorSetBindings,
 	    vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
-	    PushConstantStorage const &pushConstants,
+	    vk::Pipeline::PushConstantStorage const &pushConstants,
 	    uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ,
 	    uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
 
@@ -76,7 +76,7 @@ protected:
 		uint32_t invocationsPerSubgroup;   // SPIR-V: "SubgroupSize"
 		uint32_t subgroupsPerWorkgroup;    // SPIR-V: "NumSubgroups"
 		uint32_t invocationsPerWorkgroup;  // Total number of invocations per workgroup.
-		PushConstantStorage pushConstants;
+		vk::Pipeline::PushConstantStorage pushConstants;
 		const Constants *constants;
 	};
 

src/Vulkan/VkCommandBuffer.cpp

@@ -466,56 +466,6 @@ private:
 class CmdDrawBase : public vk::CommandBuffer::Command
 {
 public:
-	int bytesPerIndex(vk::CommandBuffer::ExecutionState const &executionState)
-	{
-		return executionState.indexType == VK_INDEX_TYPE_UINT16 ? 2 : 4;
-	}
-
-	template<typename T>
-	void processPrimitiveRestart(T *indexBuffer,
-	                             uint32_t count,
-	                             vk::GraphicsPipeline *pipeline,
-	                             std::vector<std::pair<uint32_t, void *>> &indexBuffers)
-	{
-		static const T RestartIndex = static_cast<T>(-1);
-		T *indexBufferStart = indexBuffer;
-		uint32_t vertexCount = 0;
-		for(uint32_t i = 0; i < count; i++)
-		{
-			if(indexBuffer[i] == RestartIndex)
-			{
-				// Record previous segment
-				if(vertexCount > 0)
-				{
-					uint32_t primitiveCount = pipeline->computePrimitiveCount(vertexCount);
-					if(primitiveCount > 0)
-					{
-						indexBuffers.push_back({ primitiveCount, indexBufferStart });
-					}
-				}
-				vertexCount = 0;
-			}
-			else
-			{
-				if(vertexCount == 0)
-				{
-					indexBufferStart = indexBuffer + i;
-				}
-				vertexCount++;
-			}
-		}
-
-		// Record last segment
-		if(vertexCount > 0)
-		{
-			uint32_t primitiveCount = pipeline->computePrimitiveCount(vertexCount);
-			if(primitiveCount > 0)
-			{
-				indexBuffers.push_back({ primitiveCount, indexBufferStart });
-			}
-		}
-	}
-
 	void draw(vk::CommandBuffer::ExecutionState &executionState, bool indexed,
 	          uint32_t count, uint32_t instanceCount, uint32_t first, int32_t vertexOffset, uint32_t firstInstance)
 	{
@@ -523,87 +473,21 @@ public:
 
 		auto *pipeline = static_cast<vk::GraphicsPipeline *>(pipelineState.pipeline);
 
-		sw::Context context = pipeline->getContext();
-
-		executionState.bindVertexInputs(context, firstInstance);
-
-		context.descriptorSetObjects = pipelineState.descriptorSetObjects;
-		context.descriptorSets = pipelineState.descriptorSets;
-		context.descriptorDynamicOffsets = pipelineState.descriptorDynamicOffsets;
-
-		// Apply either pipeline state or dynamic state
-		executionState.renderer->setScissor(pipeline->hasDynamicState(VK_DYNAMIC_STATE_SCISSOR) ? executionState.dynamicState.scissor : pipeline->getScissor());
-		executionState.renderer->setViewport(pipeline->hasDynamicState(VK_DYNAMIC_STATE_VIEWPORT) ? executionState.dynamicState.viewport : pipeline->getViewport());
-		executionState.renderer->setBlendConstant(pipeline->hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS) ? executionState.dynamicState.blendConstants : pipeline->getBlendConstants());
-
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS))
-		{
-			context.constantDepthBias = executionState.dynamicState.depthBiasConstantFactor;
-			context.slopeDepthBias = executionState.dynamicState.depthBiasSlopeFactor;
-			context.depthBiasClamp = executionState.dynamicState.depthBiasClamp;
-		}
-
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BOUNDS) && context.depthBoundsTestEnable)
-		{
-			// Unless the VK_EXT_depth_range_unrestricted extension is enabled, minDepthBounds and maxDepthBounds must be between 0.0 and 1.0, inclusive
-			ASSERT(executionState.dynamicState.minDepthBounds >= 0.0f &&
-			       executionState.dynamicState.minDepthBounds <= 1.0f);
-			ASSERT(executionState.dynamicState.maxDepthBounds >= 0.0f &&
-			       executionState.dynamicState.maxDepthBounds <= 1.0f);
-
-			UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
-		}
-
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) && context.stencilEnable)
-		{
-			context.frontStencil.compareMask = executionState.dynamicState.compareMask[0];
-			context.backStencil.compareMask = executionState.dynamicState.compareMask[1];
-		}
-
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) && context.stencilEnable)
-		{
-			context.frontStencil.writeMask = executionState.dynamicState.writeMask[0];
-			context.backStencil.writeMask = executionState.dynamicState.writeMask[1];
-		}
-
-		if(pipeline->hasDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) && context.stencilEnable)
-		{
-			context.frontStencil.reference = executionState.dynamicState.reference[0];
-			context.backStencil.reference = executionState.dynamicState.reference[1];
-		}
+		vk::Attachments &attachments = pipeline->getAttachments();
+		executionState.bindAttachments(&attachments);
 
-		executionState.bindAttachments(context);
+		vk::Inputs &inputs = pipeline->getInputs();
+		inputs.updateDescriptorSets(pipelineState.descriptorSetObjects,
+		                            pipelineState.descriptorSets,
+		                            pipelineState.descriptorDynamicOffsets);
+		inputs.setVertexInputBinding(executionState.vertexInputBindings);
+		inputs.bindVertexInputs(firstInstance);
 
-		context.occlusionEnabled = executionState.renderer->hasOcclusionQuery();
+		vk::IndexBuffer &indexBuffer = pipeline->getIndexBuffer();
+		indexBuffer.setIndexBufferBinding(executionState.indexBufferBinding, executionState.indexType);
 
 		std::vector<std::pair<uint32_t, void *>> indexBuffers;
-		if(indexed)
-		{
-			void *indexBuffer = executionState.indexBufferBinding.buffer->getOffsetPointer(
-			    executionState.indexBufferBinding.offset + first * bytesPerIndex(executionState));
-			if(pipeline->hasPrimitiveRestartEnable())
-			{
-				switch(executionState.indexType)
-				{
-					case VK_INDEX_TYPE_UINT16:
-						processPrimitiveRestart(static_cast<uint16_t *>(indexBuffer), count, pipeline, indexBuffers);
-						break;
-					case VK_INDEX_TYPE_UINT32:
-						processPrimitiveRestart(static_cast<uint32_t *>(indexBuffer), count, pipeline, indexBuffers);
-						break;
-					default:
-						UNSUPPORTED("VkIndexType %d", int(executionState.indexType));
-				}
-			}
-			else
-			{
-				indexBuffers.push_back({ pipeline->computePrimitiveCount(count), indexBuffer });
-			}
-		}
-		else
-		{
-			indexBuffers.push_back({ pipeline->computePrimitiveCount(count), nullptr });
-		}
+		pipeline->getIndexBuffers(count, first, indexed, &indexBuffers);
 
 		for(uint32_t instance = firstInstance; instance != firstInstance + instanceCount; instance++)
 		{
@@ -616,14 +500,14 @@ public:
 
 				for(auto indexBuffer : indexBuffers)
 				{
-					executionState.renderer->draw(&context, executionState.indexType, indexBuffer.first, vertexOffset,
+					executionState.renderer->draw(pipeline, executionState.dynamicState, indexBuffer.first, vertexOffset,
 					                              executionState.events, instance, viewID, indexBuffer.second,
 					                              executionState.renderPassFramebuffer->getExtent(),
 					                              executionState.pushConstants);
 				}
 			}
 
-			executionState.renderer->advanceInstanceAttributes(context.input);
+			inputs.advanceInstanceAttributes();
 		}
 	}
 };
@@ -1840,25 +1724,7 @@ void CommandBuffer::submitSecondary(CommandBuffer::ExecutionState &executionStat
 	}
 }
 
-void CommandBuffer::ExecutionState::bindVertexInputs(sw::Context &context, int firstInstance)
-{
-	for(uint32_t i = 0; i < MAX_VERTEX_INPUT_BINDINGS; i++)
-	{
-		auto &attrib = context.input[i];
-		if(attrib.format != VK_FORMAT_UNDEFINED)
-		{
-			const auto &vertexInput = vertexInputBindings[attrib.binding];
-			VkDeviceSize offset = attrib.offset + vertexInput.offset +
-			                      attrib.instanceStride * firstInstance;
-			attrib.buffer = vertexInput.buffer ? vertexInput.buffer->getOffsetPointer(offset) : nullptr;
-
-			VkDeviceSize size = vertexInput.buffer ? vertexInput.buffer->getSize() : 0;
-			attrib.robustnessSize = (size > offset) ? size - offset : 0;
-		}
-	}
-}
-
-void CommandBuffer::ExecutionState::bindAttachments(sw::Context &context)
+void CommandBuffer::ExecutionState::bindAttachments(Attachments *attachments)
 {
 	// Binds all the attachments for the current subpass
 	// Ideally this would be performed by BeginRenderPass and NextSubpass, but
@@ -1872,7 +1738,7 @@ void CommandBuffer::ExecutionState::bindAttachments(sw::Context &context)
 		auto attachmentReference = subpass.pColorAttachments[i];
 		if(attachmentReference.attachment != VK_ATTACHMENT_UNUSED)
 		{
-			context.renderTarget[i] = renderPassFramebuffer->getAttachment(attachmentReference.attachment);
+			attachments->renderTarget[i] = renderPassFramebuffer->getAttachment(attachmentReference.attachment);
 		}
 	}
 
@@ -1882,11 +1748,11 @@ void CommandBuffer::ExecutionState::bindAttachments(sw::Context &context)
 		auto attachment = renderPassFramebuffer->getAttachment(attachmentReference->attachment);
 		if(attachment->hasDepthAspect())
 		{
-			context.depthBuffer = attachment;
+			attachments->depthBuffer = attachment;
 		}
 		if(attachment->hasStencilAspect())
 		{
-			context.stencilBuffer = attachment;
+			attachments->stencilBuffer = attachment;
 		}
 	}
 }

src/Vulkan/VkCommandBuffer.hpp

@@ -17,8 +17,7 @@
 
 #include "VkConfig.hpp"
 #include "VkDescriptorSet.hpp"
-#include "VkObject.hpp"
-#include "Device/Context.hpp"
+#include "VkPipeline.hpp"
 #include "System/Synchronization.hpp"
 
 #include <memory>
@@ -155,38 +154,17 @@ public:
 		Framebuffer *renderPassFramebuffer = nullptr;
 		std::array<PipelineState, vk::VK_PIPELINE_BIND_POINT_RANGE_SIZE> pipelineState;
 
-		struct DynamicState
-		{
-			VkViewport viewport;
-			VkRect2D scissor;
-			sw::float4 blendConstants;
-			float depthBiasConstantFactor = 0.0f;
-			float depthBiasClamp = 0.0f;
-			float depthBiasSlopeFactor = 0.0f;
-			float minDepthBounds = 0.0f;
-			float maxDepthBounds = 0.0f;
-
-			uint32_t compareMask[2] = { 0 };
-			uint32_t writeMask[2] = { 0 };
-			uint32_t reference[2] = { 0 };
-		};
-		DynamicState dynamicState;
+		vk::DynamicState dynamicState;
 
-		sw::PushConstantStorage pushConstants;
+		vk::Pipeline::PushConstantStorage pushConstants;
 
-		struct VertexInputBinding
-		{
-			Buffer *buffer;
-			VkDeviceSize offset;
-		};
 		VertexInputBinding vertexInputBindings[MAX_VERTEX_INPUT_BINDINGS] = {};
 		VertexInputBinding indexBufferBinding;
 		VkIndexType indexType;
 
 		uint32_t subpassIndex = 0;
 
-		void bindAttachments(sw::Context &context);
-		void bindVertexInputs(sw::Context &context, int firstInstance);
+		void bindAttachments(Attachments *attachments);
 	};
 
 	void submit(CommandBuffer::ExecutionState &executionState);

src/Vulkan/VkPipeline.hpp

@@ -15,9 +15,7 @@
 #ifndef VK_PIPELINE_HPP_
 #define VK_PIPELINE_HPP_
 
-#include "VkObject.hpp"
-#include "Device/Renderer.hpp"
-#include "Vulkan/VkDescriptorSet.hpp"
+#include "Device/Context.hpp"
 #include "Vulkan/VkPipelineCache.hpp"
 #include <memory>
 
@@ -34,10 +32,7 @@ namespace dbg {
 class Context;
 }  // namespace dbg
 
-class PipelineCache;
-class PipelineLayout;
 class ShaderModule;
-class Device;
 
 class Pipeline
 {
@@ -67,6 +62,11 @@ public:
 		return layout;
 	}
 
+	struct PushConstantStorage
+	{
+		unsigned char data[vk::MAX_PUSH_CONSTANT_SIZE];
+	};
+
 protected:
 	PipelineLayout *layout = nullptr;
 	Device *const device;
@@ -95,26 +95,31 @@ public:
 
 	void compileShaders(const VkAllocationCallbacks *pAllocator, const VkGraphicsPipelineCreateInfo *pCreateInfo, PipelineCache *pipelineCache);
 
-	uint32_t computePrimitiveCount(uint32_t vertexCount) const;
-	const sw::Context &getContext() const;
-	const VkRect2D &getScissor() const;
-	const VkViewport &getViewport() const;
-	const sw::float4 &getBlendConstants() const;
-	bool hasDynamicState(VkDynamicState dynamicState) const;
-	bool hasPrimitiveRestartEnable() const { return primitiveRestartEnable; }
+	const GraphicsState getState(const DynamicState &ds) const { return state.combineStates(ds); }
+
+	void getIndexBuffers(uint32_t count, uint32_t first, bool indexed, std::vector<std::pair<uint32_t, void *>> *indexBuffers) const;
+
+	IndexBuffer &getIndexBuffer() { return indexBuffer; }
+	const IndexBuffer &getIndexBuffer() const { return indexBuffer; }
+	Attachments &getAttachments() { return attachments; }
+	const Attachments &getAttachments() const { return attachments; }
+	Inputs &getInputs() { return inputs; }
+	const Inputs &getInputs() const { return inputs; }
+
+	bool containsImageWrite() const;
+
+	const std::shared_ptr<sw::SpirvShader> getShader(const VkShaderStageFlagBits &stage) const;
 
 private:
 	void setShader(const VkShaderStageFlagBits &stage, const std::shared_ptr<sw::SpirvShader> spirvShader);
-	const std::shared_ptr<sw::SpirvShader> getShader(const VkShaderStageFlagBits &stage) const;
 	std::shared_ptr<sw::SpirvShader> vertexShader;
 	std::shared_ptr<sw::SpirvShader> fragmentShader;
 
-	uint32_t dynamicStateFlags = 0;
-	bool primitiveRestartEnable = false;
-	sw::Context context;
-	VkRect2D scissor;
-	VkViewport viewport;
-	sw::float4 blendConstants;
+	const GraphicsState state;
+
+	IndexBuffer indexBuffer;
+	Attachments attachments;
+	Inputs inputs;
 };
 
 class ComputePipeline : public Pipeline, public ObjectBase<ComputePipeline, VkPipeline>
@@ -141,7 +146,7 @@ public:
 	         vk::DescriptorSet::Array const &descriptorSetObjects,
 	         vk::DescriptorSet::Bindings const &descriptorSets,
 	         vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
-	         sw::PushConstantStorage const &pushConstants);
+	         vk::Pipeline::PushConstantStorage const &pushConstants);
 
 protected:
 	std::shared_ptr<sw::SpirvShader> shader;