diff --git a/src/Device/Context.cpp b/src/Device/Context.cpp
index 8e35ff2..e5879d2 100644
--- a/src/Device/Context.cpp
+++ b/src/Device/Context.cpp
@@ -1,4 +1,4 @@
-// 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.
@@ -13,18 +13,513 @@
 // limitations under the License.
 
 #include "Context.hpp"
-
-#include "Primitive.hpp"
-#include "Pipeline/SpirvShader.hpp"
-#include "System/Debug.hpp"
-#include "System/Memory.hpp"
+#include "Vulkan/VkBuffer.hpp"
+#include "Vulkan/VkDevice.hpp"
 #include "Vulkan/VkImageView.hpp"
+#include "Vulkan/VkRenderPass.hpp"
+#include "Vulkan/VkStringify.hpp"
 
-#include <string.h>
+namespace {
 
-namespace sw {
+uint32_t ComputePrimitiveCount(VkPrimitiveTopology topology, uint32_t vertexCount)
+{
+	switch(topology)
+	{
+		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+			return vertexCount;
+		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+			return vertexCount / 2;
+		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+			return std::max<uint32_t>(vertexCount, 1) - 1;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+			return vertexCount / 3;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+			return std::max<uint32_t>(vertexCount, 2) - 2;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+			return std::max<uint32_t>(vertexCount, 2) - 2;
+		default:
+			UNSUPPORTED("VkPrimitiveTopology %d", int(topology));
+	}
 
-bool Context::isDrawPoint(bool polygonModeAware) const
+	return 0;
+}
+
+template<typename T>
+void ProcessPrimitiveRestart(T *indexBuffer,
+                             VkPrimitiveTopology topology,
+                             uint32_t count,
+                             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 = ComputePrimitiveCount(topology, 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 = ComputePrimitiveCount(topology, vertexCount);
+		if(primitiveCount > 0)
+		{
+			indexBuffers->push_back({ primitiveCount, indexBufferStart });
+		}
+	}
+}
+
+}  // namespace
+
+namespace vk {
+
+int IndexBuffer::bytesPerIndex() const
+{
+	return indexType == VK_INDEX_TYPE_UINT16 ? 2 : 4;
+}
+
+void IndexBuffer::setIndexBufferBinding(const VertexInputBinding &indexBufferBinding, VkIndexType type)
+{
+	binding = indexBufferBinding;
+	indexType = type;
+}
+
+void IndexBuffer::getIndexBuffers(VkPrimitiveTopology topology, uint32_t count, uint32_t first, bool indexed, bool hasPrimitiveRestartEnable, std::vector<std::pair<uint32_t, void *>> *indexBuffers) const
+{
+
+	if(indexed)
+	{
+		void *indexBuffer = binding.buffer->getOffsetPointer(binding.offset + first * bytesPerIndex());
+		if(hasPrimitiveRestartEnable)
+		{
+			switch(indexType)
+			{
+				case VK_INDEX_TYPE_UINT16:
+					ProcessPrimitiveRestart(static_cast<uint16_t *>(indexBuffer), topology, count, indexBuffers);
+					break;
+				case VK_INDEX_TYPE_UINT32:
+					ProcessPrimitiveRestart(static_cast<uint32_t *>(indexBuffer), topology, count, indexBuffers);
+					break;
+				default:
+					UNSUPPORTED("VkIndexType %d", int(indexType));
+			}
+		}
+		else
+		{
+			indexBuffers->push_back({ ComputePrimitiveCount(topology, count), indexBuffer });
+		}
+	}
+	else
+	{
+		indexBuffers->push_back({ ComputePrimitiveCount(topology, count), nullptr });
+	}
+}
+
+bool Attachments::isColorClamped(int index) const
+{
+	if(renderTarget[index] && renderTarget[index]->getFormat().isFloatFormat())
+	{
+		return false;
+	}
+
+	return true;
+}
+
+VkFormat Attachments::renderTargetInternalFormat(int index) const
+{
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
+
+	if(renderTarget[index])
+	{
+		return renderTarget[index]->getFormat();
+	}
+	else
+	{
+		return VK_FORMAT_UNDEFINED;
+	}
+}
+
+Inputs::Inputs(const VkPipelineVertexInputStateCreateInfo *vertexInputState)
+{
+	if(vertexInputState->flags != 0)
+	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("vertexInputState->flags");
+	}
+
+	// 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 vertexStrides[MAX_VERTEX_INPUT_BINDINGS];
+	uint32_t instanceStrides[MAX_VERTEX_INPUT_BINDINGS];
+	for(uint32_t i = 0; i < vertexInputState->vertexBindingDescriptionCount; i++)
+	{
+		auto const &desc = vertexInputState->pVertexBindingDescriptions[i];
+		vertexStrides[desc.binding] = desc.inputRate == VK_VERTEX_INPUT_RATE_VERTEX ? desc.stride : 0;
+		instanceStrides[desc.binding] = desc.inputRate == VK_VERTEX_INPUT_RATE_INSTANCE ? desc.stride : 0;
+	}
+
+	for(uint32_t i = 0; i < vertexInputState->vertexAttributeDescriptionCount; i++)
+	{
+		auto const &desc = vertexInputState->pVertexAttributeDescriptions[i];
+		sw::Stream &input = stream[desc.location];
+		input.format = desc.format;
+		input.offset = desc.offset;
+		input.binding = desc.binding;
+		input.vertexStride = vertexStrides[desc.binding];
+		input.instanceStride = instanceStrides[desc.binding];
+	}
+}
+
+void Inputs::updateDescriptorSets(const DescriptorSet::Array &dso,
+                                  const DescriptorSet::Bindings &ds,
+                                  const DescriptorSet::DynamicOffsets &ddo)
+{
+	descriptorSetObjects = dso;
+	descriptorSets = ds;
+	descriptorDynamicOffsets = ddo;
+}
+
+void Inputs::bindVertexInputs(int firstInstance)
+{
+	for(uint32_t i = 0; i < MAX_VERTEX_INPUT_BINDINGS; i++)
+	{
+		auto &attrib = stream[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 Inputs::setVertexInputBinding(const VertexInputBinding bindings[])
+{
+	for(uint32_t i = 0; i < MAX_VERTEX_INPUT_BINDINGS; ++i)
+	{
+		vertexInputBindings[i] = bindings[i];
+	}
+}
+
+// TODO(b/137740918): Optimize instancing to use a single draw call.
+void Inputs::advanceInstanceAttributes()
+{
+	for(uint32_t i = 0; i < vk::MAX_VERTEX_INPUT_BINDINGS; i++)
+	{
+		auto &attrib = stream[i];
+		if((attrib.format != VK_FORMAT_UNDEFINED) && attrib.instanceStride && (attrib.instanceStride < attrib.robustnessSize))
+		{
+			// Under the casts: attrib.buffer += attrib.instanceStride
+			attrib.buffer = (void const *)((uintptr_t)attrib.buffer + attrib.instanceStride);
+			attrib.robustnessSize -= attrib.instanceStride;
+		}
+	}
+}
+
+GraphicsState::GraphicsState(const Device *device, const VkGraphicsPipelineCreateInfo *pCreateInfo,
+                             const PipelineLayout *layout, bool robustBufferAccess)
+    : pipelineLayout(layout)
+    , robustBufferAccess(robustBufferAccess)
+{
+	if((pCreateInfo->flags &
+	    ~(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT |
+	      VK_PIPELINE_CREATE_DERIVATIVE_BIT |
+	      VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) != 0)
+	{
+		UNSUPPORTED("pCreateInfo->flags %d", int(pCreateInfo->flags));
+	}
+
+	if(pCreateInfo->pDynamicState)
+	{
+		if(pCreateInfo->pDynamicState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pDynamicState->flags %d", int(pCreateInfo->pDynamicState->flags));
+		}
+
+		for(uint32_t i = 0; i < pCreateInfo->pDynamicState->dynamicStateCount; i++)
+		{
+			VkDynamicState dynamicState = pCreateInfo->pDynamicState->pDynamicStates[i];
+			switch(dynamicState)
+			{
+				case VK_DYNAMIC_STATE_VIEWPORT:
+				case VK_DYNAMIC_STATE_SCISSOR:
+				case VK_DYNAMIC_STATE_LINE_WIDTH:
+				case VK_DYNAMIC_STATE_DEPTH_BIAS:
+				case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
+				case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
+				case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
+				case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
+				case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
+					ASSERT(dynamicState < (sizeof(dynamicStateFlags) * 8));
+					dynamicStateFlags |= (1 << dynamicState);
+					break;
+				default:
+					UNSUPPORTED("VkDynamicState %d", int(dynamicState));
+			}
+		}
+	}
+
+	const VkPipelineVertexInputStateCreateInfo *vertexInputState = pCreateInfo->pVertexInputState;
+
+	if(vertexInputState->flags != 0)
+	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("vertexInputState->flags");
+	}
+
+	const VkPipelineInputAssemblyStateCreateInfo *inputAssemblyState = pCreateInfo->pInputAssemblyState;
+
+	if(inputAssemblyState->flags != 0)
+	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("pCreateInfo->pInputAssemblyState->flags %d", int(pCreateInfo->pInputAssemblyState->flags));
+	}
+
+	primitiveRestartEnable = (inputAssemblyState->primitiveRestartEnable != VK_FALSE);
+	topology = inputAssemblyState->topology;
+
+	const VkPipelineRasterizationStateCreateInfo *rasterizationState = pCreateInfo->pRasterizationState;
+
+	if(rasterizationState->flags != 0)
+	{
+		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+		UNSUPPORTED("pCreateInfo->pRasterizationState->flags %d", int(pCreateInfo->pRasterizationState->flags));
+	}
+
+	if(rasterizationState->depthClampEnable != VK_FALSE)
+	{
+		UNSUPPORTED("VkPhysicalDeviceFeatures::depthClamp");
+	}
+
+	rasterizerDiscard = (rasterizationState->rasterizerDiscardEnable != VK_FALSE);
+	cullMode = rasterizationState->cullMode;
+	frontFace = rasterizationState->frontFace;
+	polygonMode = rasterizationState->polygonMode;
+	constantDepthBias = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasConstantFactor : 0.0f;
+	slopeDepthBias = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasSlopeFactor : 0.0f;
+	depthBiasClamp = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasClamp : 0.0f;
+	depthRangeUnrestricted = device->hasExtension(VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME);
+
+	// From the Vulkan spec for vkCmdSetDepthBias:
+	//    The bias value O for a polygon is:
+	//        O = dbclamp(...)
+	//    where dbclamp(x) =
+	//        * x                       depthBiasClamp = 0 or NaN
+	//        * min(x, depthBiasClamp)  depthBiasClamp > 0
+	//        * max(x, depthBiasClamp)  depthBiasClamp < 0
+	// So it should be safe to resolve NaNs to 0.0f.
+	if(std::isnan(depthBiasClamp))
+	{
+		depthBiasClamp = 0.0f;
+	}
+
+	lineWidth = rasterizationState->lineWidth;
+
+	const VkBaseInStructure *extensionCreateInfo = reinterpret_cast<const VkBaseInStructure *>(rasterizationState->pNext);
+	while(extensionCreateInfo)
+	{
+		// Casting to a long since some structures, such as
+		// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT
+		// are not enumerated in the official Vulkan header
+		switch((long)(extensionCreateInfo->sType))
+		{
+			case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
+			{
+				const VkPipelineRasterizationLineStateCreateInfoEXT *lineStateCreateInfo = reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>(extensionCreateInfo);
+				lineRasterizationMode = lineStateCreateInfo->lineRasterizationMode;
+			}
+			break;
+			case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
+			{
+				const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *provokingVertexModeCreateInfo =
+				    reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(extensionCreateInfo);
+				provokingVertexMode = provokingVertexModeCreateInfo->provokingVertexMode;
+			}
+			break;
+			default:
+				WARN("pCreateInfo->pRasterizationState->pNext sType = %s", vk::Stringify(extensionCreateInfo->sType).c_str());
+				break;
+		}
+
+		extensionCreateInfo = extensionCreateInfo->pNext;
+	}
+
+	// The sample count affects the batch size, so it needs initialization even if rasterization is disabled.
+	// TODO(b/147812380): Eliminate the dependency between multisampling and batch size.
+	sampleCount = 1;
+
+	// Only access rasterization state if rasterization is not disabled.
+	if(rasterizationState->rasterizerDiscardEnable == VK_FALSE)
+	{
+		const VkPipelineViewportStateCreateInfo *viewportState = pCreateInfo->pViewportState;
+		const VkPipelineMultisampleStateCreateInfo *multisampleState = pCreateInfo->pMultisampleState;
+		const VkPipelineDepthStencilStateCreateInfo *depthStencilState = pCreateInfo->pDepthStencilState;
+		const VkPipelineColorBlendStateCreateInfo *colorBlendState = pCreateInfo->pColorBlendState;
+
+		if(viewportState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pViewportState->flags %d", int(pCreateInfo->pViewportState->flags));
+		}
+
+		if((viewportState->viewportCount != 1) ||
+		   (viewportState->scissorCount != 1))
+		{
+			UNSUPPORTED("VkPhysicalDeviceFeatures::multiViewport");
+		}
+
+		if(!hasDynamicState(VK_DYNAMIC_STATE_SCISSOR))
+		{
+			scissor = viewportState->pScissors[0];
+		}
+
+		if(!hasDynamicState(VK_DYNAMIC_STATE_VIEWPORT))
+		{
+			viewport = viewportState->pViewports[0];
+		}
+
+		if(multisampleState->flags != 0)
+		{
+			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+			UNSUPPORTED("pCreateInfo->pMultisampleState->flags %d", int(pCreateInfo->pMultisampleState->flags));
+		}
+
+		if(multisampleState->sampleShadingEnable != VK_FALSE)
+		{
+			UNSUPPORTED("VkPhysicalDeviceFeatures::sampleRateShading");
+		}
+
+		if(multisampleState->alphaToOneEnable != VK_FALSE)
+		{
+			UNSUPPORTED("VkPhysicalDeviceFeatures::alphaToOne");
+		}
+
+		switch(multisampleState->rasterizationSamples)
+		{
+			case VK_SAMPLE_COUNT_1_BIT:
+				sampleCount = 1;
+				break;
+			case VK_SAMPLE_COUNT_4_BIT:
+				sampleCount = 4;
+				break;
+			default:
+				UNSUPPORTED("Unsupported sample count");
+		}
+
+		VkSampleMask sampleMask;
+		if(multisampleState->pSampleMask)
+		{
+			sampleMask = multisampleState->pSampleMask[0];
+		}
+		else  // "If pSampleMask is NULL, it is treated as if the mask has all bits set to 1."
+		{
+			sampleMask = ~0;
+		}
+
+		alphaToCoverage = (multisampleState->alphaToCoverageEnable != VK_FALSE);
+		multiSampleMask = sampleMask & ((unsigned)0xFFFFFFFF >> (32 - sampleCount));
+
+		const vk::RenderPass *renderPass = vk::Cast(pCreateInfo->renderPass);
+		const VkSubpassDescription &subpass = renderPass->getSubpass(pCreateInfo->subpass);
+
+		//  Ignore pDepthStencilState when "the subpass of the render pass the pipeline is created against does not use a depth/stencil attachment"
+		if(subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)
+		{
+			if(depthStencilState->flags != 0)
+			{
+				// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+				UNSUPPORTED("pCreateInfo->pDepthStencilState->flags %d", int(pCreateInfo->pDepthStencilState->flags));
+			}
+
+			if(depthStencilState->depthBoundsTestEnable != VK_FALSE)
+			{
+				UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
+			}
+
+			depthBoundsTestEnable = (depthStencilState->depthBoundsTestEnable != VK_FALSE);
+			depthBufferEnable = (depthStencilState->depthTestEnable != VK_FALSE);
+			depthWriteEnable = (depthStencilState->depthWriteEnable != VK_FALSE);
+			depthCompareMode = depthStencilState->depthCompareOp;
+
+			stencilEnable = (depthStencilState->stencilTestEnable != VK_FALSE);
+			if(stencilEnable)
+			{
+				frontStencil = depthStencilState->front;
+				backStencil = depthStencilState->back;
+			}
+		}
+
+		bool colorAttachmentUsed = false;
+		for(uint32_t i = 0; i < subpass.colorAttachmentCount; i++)
+		{
+			if(subpass.pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED)
+			{
+				colorAttachmentUsed = true;
+				break;
+			}
+		}
+
+		// Ignore pColorBlendState when "the subpass of the render pass the pipeline is created against does not use any color attachments"
+		if(colorAttachmentUsed)
+		{
+			if(colorBlendState->flags != 0)
+			{
+				// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
+				UNSUPPORTED("pCreateInfo->pColorBlendState->flags %d", int(pCreateInfo->pColorBlendState->flags));
+			}
+
+			if(colorBlendState->logicOpEnable != VK_FALSE)
+			{
+				UNSUPPORTED("VkPhysicalDeviceFeatures::logicOp");
+			}
+
+			if(!hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS))
+			{
+				blendConstants.x = colorBlendState->blendConstants[0];
+				blendConstants.y = colorBlendState->blendConstants[1];
+				blendConstants.z = colorBlendState->blendConstants[2];
+				blendConstants.w = colorBlendState->blendConstants[3];
+			}
+
+			ASSERT(colorBlendState->attachmentCount <= sw::RENDERTARGETS);
+			for(auto i = 0u; i < colorBlendState->attachmentCount; i++)
+			{
+				const VkPipelineColorBlendAttachmentState &attachment = colorBlendState->pAttachments[i];
+				colorWriteMask[i] = attachment.colorWriteMask;
+				blendState[i] = { (attachment.blendEnable != VK_FALSE),
+					              attachment.srcColorBlendFactor, attachment.dstColorBlendFactor, attachment.colorBlendOp,
+					              attachment.srcAlphaBlendFactor, attachment.dstAlphaBlendFactor, attachment.alphaBlendOp };
+			}
+		}
+	}
+}
+
+bool GraphicsState::isDrawPoint(bool polygonModeAware) const
 {
 	switch(topology)
 	{
@@ -43,7 +538,7 @@
 	return false;
 }
 
-bool Context::isDrawLine(bool polygonModeAware) const
+bool GraphicsState::isDrawLine(bool polygonModeAware) const
 {
 	switch(topology)
 	{
@@ -62,7 +557,7 @@
 	return false;
 }
 
-bool Context::isDrawTriangle(bool polygonModeAware) const
+bool GraphicsState::isDrawTriangle(bool polygonModeAware) const
 {
 	switch(topology)
 	{
@@ -80,78 +575,121 @@
 	return false;
 }
 
-bool Context::depthWriteActive() const
+bool GraphicsState::depthWriteActive(const Attachments &attachments) const
 {
-	if(!depthBufferActive()) return false;
+	if(!depthBufferActive(attachments)) return false;
 
 	return depthWriteEnable;
 }
 
-bool Context::depthBufferActive() const
+bool GraphicsState::depthBufferActive(const Attachments &attachments) const
 {
-	return depthBuffer && depthBufferEnable;
+	return attachments.depthBuffer && depthBufferEnable;
 }
 
-bool Context::stencilActive() const
+bool GraphicsState::stencilActive(const Attachments &attachments) const
 {
-	return stencilBuffer && stencilEnable;
+	return attachments.stencilBuffer && stencilEnable;
 }
 
-void Context::setBlendState(int index, BlendState state)
+const GraphicsState GraphicsState::combineStates(const DynamicState &dynamicState) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	GraphicsState combinedState = *this;
 
-	blendState[index] = state;
+	// Apply either pipeline state or dynamic state
+	if(hasDynamicState(VK_DYNAMIC_STATE_SCISSOR))
+	{
+		combinedState.scissor = dynamicState.scissor;
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_VIEWPORT))
+	{
+		combinedState.viewport = dynamicState.viewport;
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS))
+	{
+		combinedState.blendConstants = dynamicState.blendConstants;
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BIAS))
+	{
+		combinedState.constantDepthBias = dynamicState.depthBiasConstantFactor;
+		combinedState.slopeDepthBias = dynamicState.depthBiasSlopeFactor;
+		combinedState.depthBiasClamp = dynamicState.depthBiasClamp;
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_DEPTH_BOUNDS) && depthBoundsTestEnable)
+	{
+		// Unless the VK_EXT_depth_range_unrestricted extension is enabled,
+		// minDepthBounds and maxDepthBounds must be between 0.0 and 1.0, inclusive
+		ASSERT(dynamicState.minDepthBounds >= 0.0f && dynamicState.minDepthBounds <= 1.0f);
+		ASSERT(dynamicState.maxDepthBounds >= 0.0f && dynamicState.maxDepthBounds <= 1.0f);
+
+		UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK) && stencilEnable)
+	{
+		combinedState.frontStencil.compareMask = dynamicState.compareMask[0];
+		combinedState.backStencil.compareMask = dynamicState.compareMask[1];
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK) && stencilEnable)
+	{
+		combinedState.frontStencil.writeMask = dynamicState.writeMask[0];
+		combinedState.backStencil.writeMask = dynamicState.writeMask[1];
+	}
+
+	if(hasDynamicState(VK_DYNAMIC_STATE_STENCIL_REFERENCE) && stencilEnable)
+	{
+		combinedState.frontStencil.reference = dynamicState.reference[0];
+		combinedState.backStencil.reference = dynamicState.reference[1];
+	}
+
+	return combinedState;
 }
 
-BlendState Context::getBlendState(int index) const
+BlendState GraphicsState::getBlendState(int index, const Attachments &attachments, bool fragmentContainsKill) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	BlendState activeBlendState;
-	activeBlendState.alphaBlendEnable = alphaBlendActive(index);
+	activeBlendState.alphaBlendEnable = alphaBlendActive(index, attachments, fragmentContainsKill);
 	activeBlendState.sourceBlendFactor = sourceBlendFactor(index);
 	activeBlendState.destBlendFactor = destBlendFactor(index);
-	activeBlendState.blendOperation = blendOperation(index);
+	activeBlendState.blendOperation = blendOperation(index, attachments);
 	activeBlendState.sourceBlendFactorAlpha = sourceBlendFactorAlpha(index);
 	activeBlendState.destBlendFactorAlpha = destBlendFactorAlpha(index);
-	activeBlendState.blendOperationAlpha = blendOperationAlpha(index);
+	activeBlendState.blendOperationAlpha = blendOperationAlpha(index, attachments);
 	return activeBlendState;
 }
 
-bool Context::isColorClamped(int index) const
+bool GraphicsState::alphaBlendActive(int index, const Attachments &attachments, bool fragmentContainsKill) const
 {
-	if(renderTarget[index] && renderTarget[index]->getFormat().isFloatFormat())
-	{
-		return false;
-	}
-
-	return true;
-}
-
-bool Context::alphaBlendActive(int index) const
-{
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	if(!blendState[index].alphaBlendEnable)
 	{
 		return false;
 	}
 
-	if(!colorUsed())
+	if(!(colorWriteActive(attachments) || fragmentContainsKill))
 	{
 		return false;
 	}
 
-	bool colorBlend = !(blendOperation(index) == VK_BLEND_OP_SRC_EXT && sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE);
-	bool alphaBlend = !(blendOperationAlpha(index) == VK_BLEND_OP_SRC_EXT && sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE);
+	bool colorBlend = !(blendOperation(index, attachments) == VK_BLEND_OP_SRC_EXT &&
+	                    sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE);
+	bool alphaBlend = !(blendOperationAlpha(index, attachments) == VK_BLEND_OP_SRC_EXT &&
+	                    sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE);
 
 	return colorBlend || alphaBlend;
 }
 
-VkBlendFactor Context::sourceBlendFactor(int index) const
+VkBlendFactor GraphicsState::sourceBlendFactor(int index) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	if(!blendState[index].alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
@@ -172,9 +710,9 @@
 	return blendState[index].sourceBlendFactor;
 }
 
-VkBlendFactor Context::destBlendFactor(int index) const
+VkBlendFactor GraphicsState::destBlendFactor(int index) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	if(!blendState[index].alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
@@ -195,9 +733,9 @@
 	return blendState[index].destBlendFactor;
 }
 
-VkBlendOp Context::blendOperation(int index) const
+VkBlendOp GraphicsState::blendOperation(int index, const Attachments &attachments) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	if(!blendState[index].alphaBlendEnable) return VK_BLEND_OP_SRC_EXT;
 
@@ -238,7 +776,7 @@
 				}
 			}
 		case VK_BLEND_OP_SUBTRACT:
-			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 			{
 				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 			}
@@ -278,7 +816,7 @@
 			}
 			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
 			{
-				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 				{
 					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 				}
@@ -289,7 +827,7 @@
 			}
 			else
 			{
-				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 				{
 					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 				}
@@ -309,9 +847,9 @@
 	return blendState[index].blendOperation;
 }
 
-VkBlendFactor Context::sourceBlendFactorAlpha(int index) const
+VkBlendFactor GraphicsState::sourceBlendFactorAlpha(int index) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	switch(blendState[index].blendOperationAlpha)
 	{
@@ -330,9 +868,9 @@
 	return blendState[index].sourceBlendFactorAlpha;
 }
 
-VkBlendFactor Context::destBlendFactorAlpha(int index) const
+VkBlendFactor GraphicsState::destBlendFactorAlpha(int index) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	switch(blendState[index].blendOperationAlpha)
 	{
@@ -351,9 +889,9 @@
 	return blendState[index].destBlendFactorAlpha;
 }
 
-VkBlendOp Context::blendOperationAlpha(int index) const
+VkBlendOp GraphicsState::blendOperationAlpha(int index, const Attachments &attachments) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
 	switch(blendState[index].blendOperationAlpha)
 	{
@@ -392,7 +930,7 @@
 				}
 			}
 		case VK_BLEND_OP_SUBTRACT:
-			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 			{
 				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 			}
@@ -432,7 +970,7 @@
 			}
 			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
 			{
-				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 				{
 					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 				}
@@ -443,7 +981,7 @@
 			}
 			else
 			{
-				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && isColorClamped(index))
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && attachments.isColorClamped(index))
 				{
 					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
 				}
@@ -463,25 +1001,11 @@
 	return blendState[index].blendOperationAlpha;
 }
 
-VkFormat Context::renderTargetInternalFormat(int index) const
+bool GraphicsState::colorWriteActive(const Attachments &attachments) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
-
-	if(renderTarget[index])
+	for(int i = 0; i < sw::RENDERTARGETS; i++)
 	{
-		return renderTarget[index]->getFormat();
-	}
-	else
-	{
-		return VK_FORMAT_UNDEFINED;
-	}
-}
-
-bool Context::colorWriteActive() const
-{
-	for(int i = 0; i < RENDERTARGETS; i++)
-	{
-		if(colorWriteActive(i))
+		if(colorWriteActive(i, attachments))
 		{
 			return true;
 		}
@@ -490,17 +1014,17 @@
 	return false;
 }
 
-int Context::colorWriteActive(int index) const
+int GraphicsState::colorWriteActive(int index, const Attachments &attachments) const
 {
-	ASSERT((index >= 0) && (index < RENDERTARGETS));
+	ASSERT((index >= 0) && (index < sw::RENDERTARGETS));
 
-	if(!renderTarget[index] || renderTarget[index]->getFormat() == VK_FORMAT_UNDEFINED)
+	if(!attachments.renderTarget[index] || attachments.renderTarget[index]->getFormat() == VK_FORMAT_UNDEFINED)
 	{
 		return 0;
 	}
 
-	if(blendOperation(index) == VK_BLEND_OP_DST_EXT && destBlendFactor(index) == VK_BLEND_FACTOR_ONE &&
-	   (blendOperationAlpha(index) == VK_BLEND_OP_DST_EXT && destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE))
+	if(blendOperation(index, attachments) == VK_BLEND_OP_DST_EXT && destBlendFactor(index) == VK_BLEND_FACTOR_ONE &&
+	   (blendOperationAlpha(index, attachments) == VK_BLEND_OP_DST_EXT && destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE))
 	{
 		return 0;
 	}
@@ -508,9 +1032,4 @@
 	return colorWriteMask[index];
 }
 
-bool Context::colorUsed() const
-{
-	return colorWriteActive() || (pixelShader && pixelShader->getModes().ContainsKill);
-}
-
-}  // namespace sw
+}  // namespace vk
\ No newline at end of file
diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
index 60c36b5..637855e 100644
--- a/src/Device/Context.hpp
+++ b/src/Device/Context.hpp
@@ -1,4 +1,4 @@
-// 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
-
-namespace sw {
-
-class SpirvShader;
-
-struct PushConstantStorage
+struct VertexInputBinding
 {
-	unsigned char data[vk::MAX_PUSH_CONSTANT_SIZE];
+	Buffer *buffer;
+	VkDeviceSize offset;
 };
 
-struct BlendState : Memset<BlendState>
+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;
+
+	VertexInputBinding binding;
+	VkIndexType indexType;
+};
+
+struct Attachments
+{
+	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 : sw::Memset<BlendState>
 {
 	BlendState()
 	    : Memset(this, 0)
@@ -70,24 +115,93 @@
 	VkBlendOp blendOperationAlpha;
 };
 
-class Context
+struct DynamicState
 {
-public:
-	Context() = default;
+	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
+{
+	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 @@
 	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 @@
 
 	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 primitiveRestartEnable = false;
+	VkRect2D scissor;
+	VkViewport viewport;
+	sw::float4 blendConstants;
 
-	bool alphaBlendActive(int index) const;
-	VkBlendFactor sourceBlendFactor(int index) const;
-	VkBlendFactor destBlendFactor(int index) const;
-	VkBlendOp blendOperation(int index) const;
-
-	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
diff --git a/src/Device/PixelProcessor.cpp b/src/Device/PixelProcessor.cpp
index 4691a01..72a86f3 100644
--- a/src/Device/PixelProcessor.cpp
+++ b/src/Device/PixelProcessor.cpp
@@ -82,17 +82,17 @@
 	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 @@
 		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 @@
 }
 
 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);
diff --git a/src/Device/PixelProcessor.hpp b/src/Device/PixelProcessor.hpp
index 16b879c..328197e 100644
--- a/src/Device/PixelProcessor.hpp
+++ b/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 @@
 		bool occlusionEnabled;
 		bool perspective;
 
-		BlendState blendState[RENDERTARGETS];
+		vk::BlendState blendState[RENDERTARGETS];
 
 		unsigned int colorWriteMask;
 		vk::Format targetFormat[RENDERTARGETS];
@@ -153,9 +151,9 @@
 
 	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
diff --git a/src/Device/Rasterizer.hpp b/src/Device/Rasterizer.hpp
index 0c33857..a0c475a 100644
--- a/src/Device/Rasterizer.hpp
+++ b/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"
 
diff --git a/src/Device/Renderer.cpp b/src/Device/Renderer.cpp
index df22224..3cec3b2 100644
--- a/src/Device/Renderer.cpp
+++ b/src/Device/Renderer.cpp
@@ -180,9 +180,9 @@
 	vk::deallocate(mem, vk::DEVICE_MEMORY);
 }
 
-void Renderer::draw(const sw::Context *context, VkIndexType indexType, unsigned int count, int baseVertex,
+void Renderer::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)
+                    vk::Pipeline::PushConstantStorage const &pushConstants, bool update)
 {
 	if(count == 0) { return; }
 
@@ -196,28 +196,38 @@
 	}
 	draw->id = id;
 
+	const vk::GraphicsState &pipelineState = pipeline->getState(dynamicState);
+	pixelProcessor.setBlendConstant(pipelineState.getBlendConstants());
+
+	const vk::Inputs &inputs = pipeline->getInputs();
+
 	if(update)
 	{
 		MARL_SCOPED_EVENT("update");
-		vertexState = vertexProcessor.update(context);
-		setupState = setupProcessor.update(context);
-		pixelState = pixelProcessor.update(context);
 
-		vertexRoutine = vertexProcessor.routine(vertexState, context->pipelineLayout, context->vertexShader, context->descriptorSets);
+		const sw::SpirvShader *fragmentShader = pipeline->getShader(VK_SHADER_STAGE_FRAGMENT_BIT).get();
+		const sw::SpirvShader *vertexShader = pipeline->getShader(VK_SHADER_STAGE_VERTEX_BIT).get();
+
+		const vk::Attachments attachments = pipeline->getAttachments();
+
+		vertexState = vertexProcessor.update(pipelineState, vertexShader, inputs);
+		setupState = setupProcessor.update(pipelineState, fragmentShader, vertexShader, attachments);
+		pixelState = pixelProcessor.update(pipelineState, fragmentShader, vertexShader, attachments, hasOcclusionQuery());
+
+		vertexRoutine = vertexProcessor.routine(vertexState, pipelineState.getPipelineLayout(), vertexShader, inputs.getDescriptorSets());
 		setupRoutine = setupProcessor.routine(setupState);
-		pixelRoutine = pixelProcessor.routine(pixelState, context->pipelineLayout, context->pixelShader, context->descriptorSets);
+		pixelRoutine = pixelProcessor.routine(pixelState, pipelineState.getPipelineLayout(), fragmentShader, inputs.getDescriptorSets());
 	}
 
-	draw->containsImageWrite = (context->vertexShader && context->vertexShader->containsImageWrite()) ||
-	                           (context->pixelShader && context->pixelShader->containsImageWrite());
+	draw->containsImageWrite = pipeline->containsImageWrite();
 
 	DrawCall::SetupFunction setupPrimitives = nullptr;
-	int ms = context->sampleCount;
+	int ms = pipelineState.getSampleCount();
 	unsigned int numPrimitivesPerBatch = MaxBatchSize / ms;
 
-	if(context->isDrawTriangle(false))
+	if(pipelineState.isDrawTriangle(false))
 	{
-		switch(context->polygonMode)
+		switch(pipelineState.getPolygonMode())
 		{
 			case VK_POLYGON_MODE_FILL:
 				setupPrimitives = &DrawCall::setupSolidTriangles;
@@ -231,11 +241,11 @@
 				numPrimitivesPerBatch /= 3;
 				break;
 			default:
-				UNSUPPORTED("polygon mode: %d", int(context->polygonMode));
+				UNSUPPORTED("polygon mode: %d", int(pipelineState.getPolygonMode()));
 				return;
 		}
 	}
-	else if(context->isDrawLine(false))
+	else if(pipelineState.isDrawLine(false))
 	{
 		setupPrimitives = &DrawCall::setupLines;
 	}
@@ -251,12 +261,12 @@
 	draw->numPrimitives = count;
 	draw->numPrimitivesPerBatch = numPrimitivesPerBatch;
 	draw->numBatches = (count + draw->numPrimitivesPerBatch - 1) / draw->numPrimitivesPerBatch;
-	draw->topology = context->topology;
-	draw->provokingVertexMode = context->provokingVertexMode;
-	draw->indexType = indexType;
-	draw->lineRasterizationMode = context->lineRasterizationMode;
-	draw->descriptorSetObjects = context->descriptorSetObjects;
-	draw->pipelineLayout = context->pipelineLayout;
+	draw->topology = pipelineState.getTopology();
+	draw->provokingVertexMode = pipelineState.getProvokingVertexMode();
+	draw->indexType = pipeline->getIndexBuffer().getIndexType();
+	draw->lineRasterizationMode = pipelineState.getLineRasterizationMode();
+	draw->descriptorSetObjects = inputs.getDescriptorSetObjects();
+	draw->pipelineLayout = pipelineState.getPipelineLayout();
 
 	draw->vertexRoutine = vertexRoutine;
 	draw->setupRoutine = setupRoutine;
@@ -264,14 +274,15 @@
 	draw->setupPrimitives = setupPrimitives;
 	draw->setupState = setupState;
 
-	data->descriptorSets = context->descriptorSets;
-	data->descriptorDynamicOffsets = context->descriptorDynamicOffsets;
+	data->descriptorSets = inputs.getDescriptorSets();
+	data->descriptorDynamicOffsets = inputs.getDescriptorDynamicOffsets();
 
 	for(int i = 0; i < MAX_INTERFACE_COMPONENTS / 4; i++)
 	{
-		data->input[i] = context->input[i].buffer;
-		data->robustnessSize[i] = context->input[i].robustnessSize;
-		data->stride[i] = context->input[i].vertexStride;
+		const sw::Stream &stream = inputs.getStream(i);
+		data->input[i] = stream.buffer;
+		data->robustnessSize[i] = stream.robustnessSize;
+		data->stride[i] = stream.vertexStride;
 	}
 
 	data->indices = indexBuffer;
@@ -281,11 +292,11 @@
 
 	if(pixelState.stencilActive)
 	{
-		data->stencil[0].set(context->frontStencil.reference, context->frontStencil.compareMask, context->frontStencil.writeMask);
-		data->stencil[1].set(context->backStencil.reference, context->backStencil.compareMask, context->backStencil.writeMask);
+		data->stencil[0].set(pipelineState.getFrontStencil().reference, pipelineState.getFrontStencil().compareMask, pipelineState.getFrontStencil().writeMask);
+		data->stencil[1].set(pipelineState.getBackStencil().reference, pipelineState.getBackStencil().compareMask, pipelineState.getBackStencil().writeMask);
 	}
 
-	data->lineWidth = context->lineWidth;
+	data->lineWidth = pipelineState.getLineWidth();
 
 	data->factor = pixelProcessor.factor;
 
@@ -321,6 +332,8 @@
 
 	// Viewport
 	{
+		const VkViewport &viewport = pipelineState.getViewport();
+
 		float W = 0.5f * viewport.width;
 		float H = 0.5f * viewport.height;
 		float X0 = viewport.x + W;
@@ -339,13 +352,14 @@
 		data->viewportHeight = abs(viewport.height);
 		data->depthRange = Z;
 		data->depthNear = N;
-		data->constantDepthBias = context->constantDepthBias;
-		data->slopeDepthBias = context->slopeDepthBias;
-		data->depthBiasClamp = context->depthBiasClamp;
+		data->constantDepthBias = pipelineState.getConstantDepthBias();
+		data->slopeDepthBias = pipelineState.getSlopeDepthBias();
+		data->depthBiasClamp = pipelineState.getDepthBiasClamp();
 
-		if(context->depthBuffer)
+		const vk::Attachments attachments = pipeline->getAttachments();
+		if(attachments.depthBuffer)
 		{
-			switch(context->depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT))
+			switch(attachments.depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT))
 			{
 				case VK_FORMAT_D16_UNORM:
 					data->minimumResolvableDepthDifference = 1.0f / 0xFFFF;
@@ -355,45 +369,49 @@
 					// buffers. DrawData::minimumResolvableDepthDifference is unused.
 					break;
 				default:
-					UNSUPPORTED("Depth format: %d", int(context->depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT)));
+					UNSUPPORTED("Depth format: %d", int(attachments.depthBuffer->getFormat(VK_IMAGE_ASPECT_DEPTH_BIT)));
 			}
 		}
 	}
 
 	// Target
 	{
+		const vk::Attachments attachments = pipeline->getAttachments();
+
 		for(int index = 0; index < RENDERTARGETS; index++)
 		{
-			draw->renderTarget[index] = context->renderTarget[index];
+			draw->renderTarget[index] = attachments.renderTarget[index];
 
 			if(draw->renderTarget[index])
 			{
-				data->colorBuffer[index] = (unsigned int *)context->renderTarget[index]->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_COLOR_BIT, 0, data->viewID);
-				data->colorPitchB[index] = context->renderTarget[index]->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
-				data->colorSliceB[index] = context->renderTarget[index]->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
+				data->colorBuffer[index] = (unsigned int *)attachments.renderTarget[index]->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_COLOR_BIT, 0, data->viewID);
+				data->colorPitchB[index] = attachments.renderTarget[index]->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
+				data->colorSliceB[index] = attachments.renderTarget[index]->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
 			}
 		}
 
-		draw->depthBuffer = context->depthBuffer;
-		draw->stencilBuffer = context->stencilBuffer;
+		draw->depthBuffer = attachments.depthBuffer;
+		draw->stencilBuffer = attachments.stencilBuffer;
 
 		if(draw->depthBuffer)
 		{
-			data->depthBuffer = (float *)context->depthBuffer->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_DEPTH_BIT, 0, data->viewID);
-			data->depthPitchB = context->depthBuffer->rowPitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
-			data->depthSliceB = context->depthBuffer->slicePitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
+			data->depthBuffer = (float *)attachments.depthBuffer->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_DEPTH_BIT, 0, data->viewID);
+			data->depthPitchB = attachments.depthBuffer->rowPitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
+			data->depthSliceB = attachments.depthBuffer->slicePitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT, 0);
 		}
 
 		if(draw->stencilBuffer)
 		{
-			data->stencilBuffer = (unsigned char *)context->stencilBuffer->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_STENCIL_BIT, 0, data->viewID);
-			data->stencilPitchB = context->stencilBuffer->rowPitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
-			data->stencilSliceB = context->stencilBuffer->slicePitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
+			data->stencilBuffer = (unsigned char *)attachments.stencilBuffer->getOffsetPointer({ 0, 0, 0 }, VK_IMAGE_ASPECT_STENCIL_BIT, 0, data->viewID);
+			data->stencilPitchB = attachments.stencilBuffer->rowPitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
+			data->stencilSliceB = attachments.stencilBuffer->slicePitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT, 0);
 		}
 	}
 
 	// Scissor
 	{
+		const VkRect2D &scissor = pipelineState.getScissor();
+
 		data->scissorX0 = clamp<int>(scissor.offset.x, 0, framebufferExtent.width);
 		data->scissorX1 = clamp<int>(scissor.offset.x + scissor.extent.width, 0, framebufferExtent.width);
 		data->scissorY0 = clamp<int>(scissor.offset.y, 0, framebufferExtent.height);
@@ -1193,34 +1211,4 @@
 	occlusionQuery = nullptr;
 }
 
-// TODO(b/137740918): Optimize instancing to use a single draw call.
-void Renderer::advanceInstanceAttributes(Stream *inputs)
-{
-	for(uint32_t i = 0; i < vk::MAX_VERTEX_INPUT_BINDINGS; i++)
-	{
-		auto &attrib = inputs[i];
-		if((attrib.format != VK_FORMAT_UNDEFINED) && attrib.instanceStride && (attrib.instanceStride < attrib.robustnessSize))
-		{
-			// Under the casts: attrib.buffer += attrib.instanceStride
-			attrib.buffer = (void const *)((uintptr_t)attrib.buffer + attrib.instanceStride);
-			attrib.robustnessSize -= attrib.instanceStride;
-		}
-	}
-}
-
-void Renderer::setViewport(const VkViewport &viewport)
-{
-	this->viewport = viewport;
-}
-
-void Renderer::setScissor(const VkRect2D &scissor)
-{
-	this->scissor = scissor;
-}
-
-void Renderer::setBlendConstant(const float4 &blendConstant)
-{
-	pixelProcessor.setBlendConstant(blendConstant);
-}
-
 }  // namespace sw
diff --git a/src/Device/Renderer.hpp b/src/Device/Renderer.hpp
index 57eb7ba..2124e42 100644
--- a/src/Device/Renderer.hpp
+++ b/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 @@
 	float4 a2c2;
 	float4 a2c3;
 
-	PushConstantStorage pushConstants;
+	vk::Pipeline::PushConstantStorage pushConstants;
 };
 
 struct DrawCall
@@ -209,27 +209,16 @@
 
 	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;
 
diff --git a/src/Device/SetupProcessor.cpp b/src/Device/SetupProcessor.cpp
index b5ff120..de13fb4 100644
--- a/src/Device/SetupProcessor.cpp
+++ b/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 @@
 	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));
+	bool vPosZW = (fragmentShader && fragmentShader->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.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 = context->sampleCount;
+	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];
 		}
 	}
 
diff --git a/src/Device/SetupProcessor.hpp b/src/Device/SetupProcessor.hpp
index de3f886..8aeb216 100644
--- a/src/Device/SetupProcessor.hpp
+++ b/src/Device/SetupProcessor.hpp
@@ -76,7 +76,7 @@
 
 	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);
diff --git a/src/Device/VertexProcessor.cpp b/src/Device/VertexProcessor.cpp
index c7c403c..1650639 100644
--- a/src/Device/VertexProcessor.cpp
+++ b/src/Device/VertexProcessor.cpp
@@ -65,21 +65,21 @@
 	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();
diff --git a/src/Device/VertexProcessor.hpp b/src/Device/VertexProcessor.hpp
index c84dc70..aa1256e 100644
--- a/src/Device/VertexProcessor.hpp
+++ b/src/Device/VertexProcessor.hpp
@@ -94,7 +94,7 @@
 
 	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);
 
diff --git a/src/Pipeline/ComputeProgram.cpp b/src/Pipeline/ComputeProgram.cpp
index 92dad1f..b1cdb77 100644
--- a/src/Pipeline/ComputeProgram.cpp
+++ b/src/Pipeline/ComputeProgram.cpp
@@ -209,7 +209,7 @@
     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)
 {
diff --git a/src/Pipeline/ComputeProgram.hpp b/src/Pipeline/ComputeProgram.hpp
index c188546..839f494 100644
--- a/src/Pipeline/ComputeProgram.hpp
+++ b/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 @@
 	    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 @@
 		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;
 	};
 
diff --git a/src/Vulkan/VkCommandBuffer.cpp b/src/Vulkan/VkCommandBuffer.cpp
index f178d35..030487e 100644
--- a/src/Vulkan/VkCommandBuffer.cpp
+++ b/src/Vulkan/VkCommandBuffer.cpp
@@ -466,56 +466,6 @@
 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 @@
 
 		auto *pipeline = static_cast<vk::GraphicsPipeline *>(pipelineState.pipeline);
 
-		sw::Context context = pipeline->getContext();
+		vk::Attachments &attachments = pipeline->getAttachments();
+		executionState.bindAttachments(&attachments);
 
-		executionState.bindVertexInputs(context, firstInstance);
+		vk::Inputs &inputs = pipeline->getInputs();
+		inputs.updateDescriptorSets(pipelineState.descriptorSetObjects,
+		                            pipelineState.descriptorSets,
+		                            pipelineState.descriptorDynamicOffsets);
+		inputs.setVertexInputBinding(executionState.vertexInputBindings);
+		inputs.bindVertexInputs(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];
-		}
-
-		executionState.bindAttachments(context);
-
-		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 @@
 
 				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::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 @@
 		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 @@
 		auto attachment = renderPassFramebuffer->getAttachment(attachmentReference->attachment);
 		if(attachment->hasDepthAspect())
 		{
-			context.depthBuffer = attachment;
+			attachments->depthBuffer = attachment;
 		}
 		if(attachment->hasStencilAspect())
 		{
-			context.stencilBuffer = attachment;
+			attachments->stencilBuffer = attachment;
 		}
 	}
 }
diff --git a/src/Vulkan/VkCommandBuffer.hpp b/src/Vulkan/VkCommandBuffer.hpp
index e08f3ec..5671150 100644
--- a/src/Vulkan/VkCommandBuffer.hpp
+++ b/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 @@
 		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;
+		vk::DynamicState dynamicState;
 
-			uint32_t compareMask[2] = { 0 };
-			uint32_t writeMask[2] = { 0 };
-			uint32_t reference[2] = { 0 };
-		};
-		DynamicState dynamicState;
+		vk::Pipeline::PushConstantStorage pushConstants;
 
-		sw::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);
diff --git a/src/Vulkan/VkPipeline.cpp b/src/Vulkan/VkPipeline.cpp
index 81d9019..a7a6611 100644
--- a/src/Vulkan/VkPipeline.cpp
+++ b/src/Vulkan/VkPipeline.cpp
@@ -147,305 +147,9 @@
 
 GraphicsPipeline::GraphicsPipeline(const VkGraphicsPipelineCreateInfo *pCreateInfo, void *mem, Device *device)
     : Pipeline(vk::Cast(pCreateInfo->layout), device)
+    , state(device, pCreateInfo, layout, robustBufferAccess)
+    , inputs(pCreateInfo->pVertexInputState)
 {
-	context.robustBufferAccess = robustBufferAccess;
-
-	if((pCreateInfo->flags &
-	    ~(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT |
-	      VK_PIPELINE_CREATE_DERIVATIVE_BIT |
-	      VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) != 0)
-	{
-		UNSUPPORTED("pCreateInfo->flags %d", int(pCreateInfo->flags));
-	}
-
-	if(pCreateInfo->pDynamicState)
-	{
-		if(pCreateInfo->pDynamicState->flags != 0)
-		{
-			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-			UNSUPPORTED("pCreateInfo->pDynamicState->flags %d", int(pCreateInfo->pDynamicState->flags));
-		}
-
-		for(uint32_t i = 0; i < pCreateInfo->pDynamicState->dynamicStateCount; i++)
-		{
-			VkDynamicState dynamicState = pCreateInfo->pDynamicState->pDynamicStates[i];
-			switch(dynamicState)
-			{
-				case VK_DYNAMIC_STATE_VIEWPORT:
-				case VK_DYNAMIC_STATE_SCISSOR:
-				case VK_DYNAMIC_STATE_LINE_WIDTH:
-				case VK_DYNAMIC_STATE_DEPTH_BIAS:
-				case VK_DYNAMIC_STATE_BLEND_CONSTANTS:
-				case VK_DYNAMIC_STATE_DEPTH_BOUNDS:
-				case VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK:
-				case VK_DYNAMIC_STATE_STENCIL_WRITE_MASK:
-				case VK_DYNAMIC_STATE_STENCIL_REFERENCE:
-					ASSERT(dynamicState < (sizeof(dynamicStateFlags) * 8));
-					dynamicStateFlags |= (1 << dynamicState);
-					break;
-				default:
-					UNSUPPORTED("VkDynamicState %d", int(dynamicState));
-			}
-		}
-	}
-
-	const VkPipelineVertexInputStateCreateInfo *vertexInputState = pCreateInfo->pVertexInputState;
-
-	if(vertexInputState->flags != 0)
-	{
-		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-		UNSUPPORTED("vertexInputState->flags");
-	}
-
-	// 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 vertexStrides[MAX_VERTEX_INPUT_BINDINGS];
-	uint32_t instanceStrides[MAX_VERTEX_INPUT_BINDINGS];
-	for(uint32_t i = 0; i < vertexInputState->vertexBindingDescriptionCount; i++)
-	{
-		auto const &desc = vertexInputState->pVertexBindingDescriptions[i];
-		vertexStrides[desc.binding] = desc.inputRate == VK_VERTEX_INPUT_RATE_VERTEX ? desc.stride : 0;
-		instanceStrides[desc.binding] = desc.inputRate == VK_VERTEX_INPUT_RATE_INSTANCE ? desc.stride : 0;
-	}
-
-	for(uint32_t i = 0; i < vertexInputState->vertexAttributeDescriptionCount; i++)
-	{
-		auto const &desc = vertexInputState->pVertexAttributeDescriptions[i];
-		sw::Stream &input = context.input[desc.location];
-		input.format = desc.format;
-		input.offset = desc.offset;
-		input.binding = desc.binding;
-		input.vertexStride = vertexStrides[desc.binding];
-		input.instanceStride = instanceStrides[desc.binding];
-	}
-
-	const VkPipelineInputAssemblyStateCreateInfo *inputAssemblyState = pCreateInfo->pInputAssemblyState;
-
-	if(inputAssemblyState->flags != 0)
-	{
-		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-		UNSUPPORTED("pCreateInfo->pInputAssemblyState->flags %d", int(pCreateInfo->pInputAssemblyState->flags));
-	}
-
-	primitiveRestartEnable = (inputAssemblyState->primitiveRestartEnable != VK_FALSE);
-	context.topology = inputAssemblyState->topology;
-
-	const VkPipelineRasterizationStateCreateInfo *rasterizationState = pCreateInfo->pRasterizationState;
-
-	if(rasterizationState->flags != 0)
-	{
-		// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-		UNSUPPORTED("pCreateInfo->pRasterizationState->flags %d", int(pCreateInfo->pRasterizationState->flags));
-	}
-
-	if(rasterizationState->depthClampEnable != VK_FALSE)
-	{
-		UNSUPPORTED("VkPhysicalDeviceFeatures::depthClamp");
-	}
-
-	context.rasterizerDiscard = (rasterizationState->rasterizerDiscardEnable != VK_FALSE);
-	context.cullMode = rasterizationState->cullMode;
-	context.frontFace = rasterizationState->frontFace;
-	context.polygonMode = rasterizationState->polygonMode;
-	context.constantDepthBias = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasConstantFactor : 0.0f;
-	context.slopeDepthBias = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasSlopeFactor : 0.0f;
-	context.depthBiasClamp = (rasterizationState->depthBiasEnable != VK_FALSE) ? rasterizationState->depthBiasClamp : 0.0f;
-	context.depthRangeUnrestricted = device->hasExtension(VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME);
-
-	// From the Vulkan spec for vkCmdSetDepthBias:
-	//    The bias value O for a polygon is:
-	//        O = dbclamp(...)
-	//    where dbclamp(x) =
-	//        * x                       depthBiasClamp = 0 or NaN
-	//        * min(x, depthBiasClamp)  depthBiasClamp > 0
-	//        * max(x, depthBiasClamp)  depthBiasClamp < 0
-	// So it should be safe to resolve NaNs to 0.0f.
-	if(std::isnan(context.depthBiasClamp))
-	{
-		context.depthBiasClamp = 0.0f;
-	}
-
-	context.lineWidth = rasterizationState->lineWidth;
-
-	const VkBaseInStructure *extensionCreateInfo = reinterpret_cast<const VkBaseInStructure *>(rasterizationState->pNext);
-	while(extensionCreateInfo)
-	{
-		// Casting to a long since some structures, such as
-		// VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT
-		// are not enumerated in the official Vulkan header
-		switch((long)(extensionCreateInfo->sType))
-		{
-			case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
-			{
-				const VkPipelineRasterizationLineStateCreateInfoEXT *lineStateCreateInfo = reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>(extensionCreateInfo);
-				context.lineRasterizationMode = lineStateCreateInfo->lineRasterizationMode;
-			}
-			break;
-			case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT:
-			{
-				const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *provokingVertexModeCreateInfo =
-				    reinterpret_cast<const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>(extensionCreateInfo);
-				context.provokingVertexMode = provokingVertexModeCreateInfo->provokingVertexMode;
-			}
-			break;
-			default:
-				WARN("pCreateInfo->pRasterizationState->pNext sType = %s", vk::Stringify(extensionCreateInfo->sType).c_str());
-				break;
-		}
-
-		extensionCreateInfo = extensionCreateInfo->pNext;
-	}
-
-	// The sample count affects the batch size, so it needs initialization even if rasterization is disabled.
-	// TODO(b/147812380): Eliminate the dependency between multisampling and batch size.
-	context.sampleCount = 1;
-
-	// Only access rasterization state if rasterization is not disabled.
-	if(rasterizationState->rasterizerDiscardEnable == VK_FALSE)
-	{
-		const VkPipelineViewportStateCreateInfo *viewportState = pCreateInfo->pViewportState;
-		const VkPipelineMultisampleStateCreateInfo *multisampleState = pCreateInfo->pMultisampleState;
-		const VkPipelineDepthStencilStateCreateInfo *depthStencilState = pCreateInfo->pDepthStencilState;
-		const VkPipelineColorBlendStateCreateInfo *colorBlendState = pCreateInfo->pColorBlendState;
-
-		if(viewportState->flags != 0)
-		{
-			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-			UNSUPPORTED("pCreateInfo->pViewportState->flags %d", int(pCreateInfo->pViewportState->flags));
-		}
-
-		if((viewportState->viewportCount != 1) ||
-		   (viewportState->scissorCount != 1))
-		{
-			UNSUPPORTED("VkPhysicalDeviceFeatures::multiViewport");
-		}
-
-		if(!hasDynamicState(VK_DYNAMIC_STATE_SCISSOR))
-		{
-			scissor = viewportState->pScissors[0];
-		}
-
-		if(!hasDynamicState(VK_DYNAMIC_STATE_VIEWPORT))
-		{
-			viewport = viewportState->pViewports[0];
-		}
-
-		if(multisampleState->flags != 0)
-		{
-			// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-			UNSUPPORTED("pCreateInfo->pMultisampleState->flags %d", int(pCreateInfo->pMultisampleState->flags));
-		}
-
-		if(multisampleState->sampleShadingEnable != VK_FALSE)
-		{
-			UNSUPPORTED("VkPhysicalDeviceFeatures::sampleRateShading");
-		}
-
-		if(multisampleState->alphaToOneEnable != VK_FALSE)
-		{
-			UNSUPPORTED("VkPhysicalDeviceFeatures::alphaToOne");
-		}
-
-		switch(multisampleState->rasterizationSamples)
-		{
-			case VK_SAMPLE_COUNT_1_BIT:
-				context.sampleCount = 1;
-				break;
-			case VK_SAMPLE_COUNT_4_BIT:
-				context.sampleCount = 4;
-				break;
-			default:
-				UNSUPPORTED("Unsupported sample count");
-		}
-
-		if(multisampleState->pSampleMask)
-		{
-			context.sampleMask = multisampleState->pSampleMask[0];
-		}
-		else  // "If pSampleMask is NULL, it is treated as if the mask has all bits set to 1."
-		{
-			context.sampleMask = ~0;
-		}
-
-		context.alphaToCoverage = (multisampleState->alphaToCoverageEnable != VK_FALSE);
-		context.multiSampleMask = context.sampleMask & ((unsigned)0xFFFFFFFF >> (32 - context.sampleCount));
-
-		const vk::RenderPass *renderPass = vk::Cast(pCreateInfo->renderPass);
-		const VkSubpassDescription &subpass = renderPass->getSubpass(pCreateInfo->subpass);
-
-		//  Ignore pDepthStencilState when "the subpass of the render pass the pipeline is created against does not use a depth/stencil attachment"
-		if(subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED)
-		{
-			if(depthStencilState->flags != 0)
-			{
-				// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-				UNSUPPORTED("pCreateInfo->pDepthStencilState->flags %d", int(pCreateInfo->pDepthStencilState->flags));
-			}
-
-			if(depthStencilState->depthBoundsTestEnable != VK_FALSE)
-			{
-				UNSUPPORTED("VkPhysicalDeviceFeatures::depthBounds");
-			}
-
-			context.depthBoundsTestEnable = (depthStencilState->depthBoundsTestEnable != VK_FALSE);
-			context.depthBufferEnable = (depthStencilState->depthTestEnable != VK_FALSE);
-			context.depthWriteEnable = (depthStencilState->depthWriteEnable != VK_FALSE);
-			context.depthCompareMode = depthStencilState->depthCompareOp;
-
-			context.stencilEnable = (depthStencilState->stencilTestEnable != VK_FALSE);
-			if(context.stencilEnable)
-			{
-				context.frontStencil = depthStencilState->front;
-				context.backStencil = depthStencilState->back;
-			}
-		}
-
-		bool colorAttachmentUsed = false;
-		for(uint32_t i = 0; i < subpass.colorAttachmentCount; i++)
-		{
-			if(subpass.pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED)
-			{
-				colorAttachmentUsed = true;
-				break;
-			}
-		}
-
-		// Ignore pColorBlendState when "the subpass of the render pass the pipeline is created against does not use any color attachments"
-		if(colorAttachmentUsed)
-		{
-			if(colorBlendState->flags != 0)
-			{
-				// Vulkan 1.2: "flags is reserved for future use." "flags must be 0"
-				UNSUPPORTED("pCreateInfo->pColorBlendState->flags %d", int(pCreateInfo->pColorBlendState->flags));
-			}
-
-			if(colorBlendState->logicOpEnable != VK_FALSE)
-			{
-				UNSUPPORTED("VkPhysicalDeviceFeatures::logicOp");
-			}
-
-			if(!hasDynamicState(VK_DYNAMIC_STATE_BLEND_CONSTANTS))
-			{
-				blendConstants.x = colorBlendState->blendConstants[0];
-				blendConstants.y = colorBlendState->blendConstants[1];
-				blendConstants.z = colorBlendState->blendConstants[2];
-				blendConstants.w = colorBlendState->blendConstants[3];
-			}
-
-			for(auto i = 0u; i < colorBlendState->attachmentCount; i++)
-			{
-				const VkPipelineColorBlendAttachmentState &attachment = colorBlendState->pAttachments[i];
-				context.colorWriteMask[i] = attachment.colorWriteMask;
-
-				context.setBlendState(i, { (attachment.blendEnable != VK_FALSE),
-				                           attachment.srcColorBlendFactor, attachment.dstColorBlendFactor, attachment.colorBlendOp,
-				                           attachment.srcAlphaBlendFactor, attachment.dstAlphaBlendFactor, attachment.alphaBlendOp });
-			}
-		}
-	}
 }
 
 void GraphicsPipeline::destroyPipeline(const VkAllocationCallbacks *pAllocator)
@@ -459,6 +163,17 @@
 	return 0;
 }
 
+void GraphicsPipeline::getIndexBuffers(uint32_t count, uint32_t first, bool indexed, std::vector<std::pair<uint32_t, void *>> *indexBuffers) const
+{
+	indexBuffer.getIndexBuffers(state.getTopology(), count, first, indexed, state.hasPrimitiveRestartEnable(), indexBuffers);
+}
+
+bool GraphicsPipeline::containsImageWrite() const
+{
+	return (vertexShader.get() && vertexShader->containsImageWrite()) ||
+	       (fragmentShader.get() && fragmentShader->containsImageWrite());
+}
+
 void GraphicsPipeline::setShader(const VkShaderStageFlagBits &stage, const std::shared_ptr<sw::SpirvShader> spirvShader)
 {
 	switch(stage)
@@ -466,13 +181,11 @@
 		case VK_SHADER_STAGE_VERTEX_BIT:
 			ASSERT(vertexShader.get() == nullptr);
 			vertexShader = spirvShader;
-			context.vertexShader = vertexShader.get();
 			break;
 
 		case VK_SHADER_STAGE_FRAGMENT_BIT:
 			ASSERT(fragmentShader.get() == nullptr);
 			fragmentShader = spirvShader;
-			context.pixelShader = fragmentShader.get();
 			break;
 
 		default:
@@ -526,54 +239,6 @@
 	}
 }
 
-uint32_t GraphicsPipeline::computePrimitiveCount(uint32_t vertexCount) const
-{
-	switch(context.topology)
-	{
-		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-			return vertexCount;
-		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-			return vertexCount / 2;
-		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-			return std::max<uint32_t>(vertexCount, 1) - 1;
-		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-			return vertexCount / 3;
-		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
-			return std::max<uint32_t>(vertexCount, 2) - 2;
-		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-			return std::max<uint32_t>(vertexCount, 2) - 2;
-		default:
-			UNSUPPORTED("VkPrimitiveTopology %d", int(context.topology));
-	}
-
-	return 0;
-}
-
-const sw::Context &GraphicsPipeline::getContext() const
-{
-	return context;
-}
-
-const VkRect2D &GraphicsPipeline::getScissor() const
-{
-	return scissor;
-}
-
-const VkViewport &GraphicsPipeline::getViewport() const
-{
-	return viewport;
-}
-
-const sw::float4 &GraphicsPipeline::getBlendConstants() const
-{
-	return blendConstants;
-}
-
-bool GraphicsPipeline::hasDynamicState(VkDynamicState dynamicState) const
-{
-	return (dynamicStateFlags & (1 << dynamicState)) != 0;
-}
-
 ComputePipeline::ComputePipeline(const VkComputePipelineCreateInfo *pCreateInfo, void *mem, Device *device)
     : Pipeline(vk::Cast(pCreateInfo->layout), device)
 {
@@ -624,7 +289,7 @@
                           vk::DescriptorSet::Array const &descriptorSetObjects,
                           vk::DescriptorSet::Bindings const &descriptorSets,
                           vk::DescriptorSet::DynamicOffsets const &descriptorDynamicOffsets,
-                          sw::PushConstantStorage const &pushConstants)
+                          vk::Pipeline::PushConstantStorage const &pushConstants)
 {
 	ASSERT_OR_RETURN(program != nullptr);
 	program->run(
diff --git a/src/Vulkan/VkPipeline.hpp b/src/Vulkan/VkPipeline.hpp
index 401454f..2b13fcd 100644
--- a/src/Vulkan/VkPipeline.hpp
+++ b/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 @@
 class Context;
 }  // namespace dbg
 
-class PipelineCache;
-class PipelineLayout;
 class ShaderModule;
-class Device;
 
 class Pipeline
 {
@@ -67,6 +62,11 @@
 		return layout;
 	}
 
+	struct PushConstantStorage
+	{
+		unsigned char data[vk::MAX_PUSH_CONSTANT_SIZE];
+	};
+
 protected:
 	PipelineLayout *layout = nullptr;
 	Device *const device;
@@ -95,26 +95,31 @@
 
 	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 @@
 	         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;