Removed SwiftShader's custom Blending enums

src/Device/Context.cpp

@@ -202,14 +202,14 @@ namespace sw
 		depthWriteEnable = true;
 
 		alphaBlendEnable = false;
-		sourceBlendFactorState = BLEND_ONE;
-		destBlendFactorState = BLEND_ZERO;
-		blendOperationState = BLENDOP_ADD;
+		sourceBlendFactorState = VK_BLEND_FACTOR_ONE;
+		destBlendFactorState = VK_BLEND_FACTOR_ZERO;
+		blendOperationState = VK_BLEND_OP_ADD;
 
 		separateAlphaBlendEnable = false;
-		sourceBlendFactorStateAlpha = BLEND_ONE;
-		destBlendFactorStateAlpha = BLEND_ZERO;
-		blendOperationStateAlpha = BLENDOP_ADD;
+		sourceBlendFactorStateAlpha = VK_BLEND_FACTOR_ONE;
+		destBlendFactorStateAlpha = VK_BLEND_FACTOR_ZERO;
+		blendOperationStateAlpha = VK_BLEND_OP_ADD;
 
 		cullMode = CULL_CLOCKWISE;
 		frontFacingCCW = true;
@@ -255,21 +255,21 @@ namespace sw
 		return modified;
 	}
 
-	bool Context::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+	bool Context::setSourceBlendFactor(VkBlendFactor sourceBlendFactor)
 	{
 		bool modified = (Context::sourceBlendFactorState != sourceBlendFactor);
 		Context::sourceBlendFactorState = sourceBlendFactor;
 		return modified;
 	}
 
-	bool Context::setDestBlendFactor(BlendFactor destBlendFactor)
+	bool Context::setDestBlendFactor(VkBlendFactor destBlendFactor)
 	{
 		bool modified = (Context::destBlendFactorState != destBlendFactor);
 		Context::destBlendFactorState = destBlendFactor;
 		return modified;
 	}
 
-	bool Context::setBlendOperation(BlendOperation blendOperation)
+	bool Context::setBlendOperation(VkBlendOp blendOperation)
 	{
 		bool modified = (Context::blendOperationState != blendOperation);
 		Context::blendOperationState = blendOperation;
@@ -283,21 +283,21 @@ namespace sw
 		return modified;
 	}
 
-	bool Context::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+	bool Context::setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha)
 	{
 		bool modified = (Context::sourceBlendFactorStateAlpha != sourceBlendFactorAlpha);
 		Context::sourceBlendFactorStateAlpha = sourceBlendFactorAlpha;
 		return modified;
 	}
 
-	bool Context::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+	bool Context::setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha)
 	{
 		bool modified = (Context::destBlendFactorStateAlpha != destBlendFactorAlpha);
 		Context::destBlendFactorStateAlpha = destBlendFactorAlpha;
 		return modified;
 	}
 
-	bool Context::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+	bool Context::setBlendOperationAlpha(VkBlendOp blendOperationAlpha)
 	{
 		bool modified = (Context::blendOperationStateAlpha != blendOperationAlpha);
 		Context::blendOperationStateAlpha = blendOperationAlpha;
@@ -371,8 +371,8 @@ namespace sw
 			return false;
 		}
 
-		bool colorBlend = !(blendOperation() == BLENDOP_SOURCE && sourceBlendFactor() == BLEND_ONE);
-		bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == BLENDOP_SOURCE && sourceBlendFactorAlpha() == BLEND_ONE) : colorBlend;
+		bool colorBlend = !(blendOperation() == VK_BLEND_OP_SRC_EXT && sourceBlendFactor() == VK_BLEND_FACTOR_ONE);
+		bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == VK_BLEND_OP_SRC_EXT && sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE) : colorBlend;
 
 		return colorBlend || alphaBlend;
 	}
@@ -382,20 +382,20 @@ namespace sw
 		return colorLogicOpEnabled ? logicalOperation : VK_LOGIC_OP_COPY;
 	}
 
-	BlendFactor Context::sourceBlendFactor()
+	VkBlendFactor Context::sourceBlendFactor()
 	{
-		if(!alphaBlendEnable) return BLEND_ONE;
+		if(!alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
 		switch(blendOperationState)
 		{
-		case BLENDOP_ADD:
-		case BLENDOP_SUB:
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			return sourceBlendFactorState;
-		case BLENDOP_MIN:
-			return BLEND_ONE;
-		case BLENDOP_MAX:
-			return BLEND_ONE;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
 		default:
 			ASSERT(false);
 		}
@@ -403,20 +403,20 @@ namespace sw
 		return sourceBlendFactorState;
 	}
 
-	BlendFactor Context::destBlendFactor()
+	VkBlendFactor Context::destBlendFactor()
 	{
-		if(!alphaBlendEnable) return BLEND_ZERO;
+		if(!alphaBlendEnable) return VK_BLEND_FACTOR_ONE;
 
 		switch(blendOperationState)
 		{
-		case BLENDOP_ADD:
-		case BLENDOP_SUB:
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			return destBlendFactorState;
-		case BLENDOP_MIN:
-			return BLEND_ONE;
-		case BLENDOP_MAX:
-			return BLEND_ONE;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
 		default:
 			ASSERT(false);
 		}
@@ -424,111 +424,111 @@ namespace sw
 		return destBlendFactorState;
 	}
 
-	BlendOperation Context::blendOperation()
+	VkBlendOp Context::blendOperation()
 	{
-		if(!alphaBlendEnable) return BLENDOP_SOURCE;
+		if(!alphaBlendEnable) return VK_BLEND_OP_SRC_EXT;
 
 		switch(blendOperationState)
 		{
-		case BLENDOP_ADD:
-			if(sourceBlendFactor() == BLEND_ZERO)
+		case VK_BLEND_OP_ADD:
+			if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_NULL;
+					return VK_BLEND_OP_ZERO_EXT;
 				}
 				else
 				{
-					return BLENDOP_DEST;
+					return VK_BLEND_OP_DST_EXT;
 				}
 			}
-			else if(sourceBlendFactor() == BLEND_ONE)
+			else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_SOURCE;
+					return VK_BLEND_OP_SRC_EXT;
 				}
 				else
 				{
-					return BLENDOP_ADD;
+					return VK_BLEND_OP_ADD;
 				}
 			}
 			else
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_SOURCE;
+					return VK_BLEND_OP_SRC_EXT;
 				}
 				else
 				{
-					return BLENDOP_ADD;
+					return VK_BLEND_OP_ADD;
 				}
 			}
-		case BLENDOP_SUB:
-			if(sourceBlendFactor() == BLEND_ZERO)
+		case VK_BLEND_OP_SUBTRACT:
+			if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
 			{
-				return BLENDOP_NULL;   // Negative, clamped to zero
+				return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 			}
-			else if(sourceBlendFactor() == BLEND_ONE)
+			else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_SOURCE;
+					return VK_BLEND_OP_SRC_EXT;
 				}
 				else
 				{
-					return BLENDOP_SUB;
+					return VK_BLEND_OP_SUBTRACT;
 				}
 			}
 			else
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_SOURCE;
+					return VK_BLEND_OP_SRC_EXT;
 				}
 				else
 				{
-					return BLENDOP_SUB;
+					return VK_BLEND_OP_SUBTRACT;
 				}
 			}
-		case BLENDOP_INVSUB:
-			if(sourceBlendFactor() == BLEND_ZERO)
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			if(sourceBlendFactor() == VK_BLEND_FACTOR_ZERO)
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_NULL;
+					return VK_BLEND_OP_ZERO_EXT;
 				}
 				else
 				{
-					return BLENDOP_DEST;
+					return VK_BLEND_OP_DST_EXT;
 				}
 			}
-			else if(sourceBlendFactor() == BLEND_ONE)
+			else if(sourceBlendFactor() == VK_BLEND_FACTOR_ONE)
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_NULL;   // Negative, clamped to zero
+					return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 				}
 				else
 				{
-					return BLENDOP_INVSUB;
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
 				}
 			}
 			else
 			{
-				if(destBlendFactor() == BLEND_ZERO)
+				if(destBlendFactor() == VK_BLEND_OP_ZERO_EXT)
 				{
-					return BLENDOP_NULL;   // Negative, clamped to zero
+					return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 				}
 				else
 				{
-					return BLENDOP_INVSUB;
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
 				}
 			}
-		case BLENDOP_MIN:
-			return BLENDOP_MIN;
-		case BLENDOP_MAX:
-			return BLENDOP_MAX;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_OP_MIN;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_OP_MAX;
 		default:
 			ASSERT(false);
 		}
@@ -536,7 +536,7 @@ namespace sw
 		return blendOperationState;
 	}
 
-	BlendFactor Context::sourceBlendFactorAlpha()
+	VkBlendFactor Context::sourceBlendFactorAlpha()
 	{
 		if(!separateAlphaBlendEnable)
 		{
@@ -546,14 +546,14 @@ namespace sw
 		{
 			switch(blendOperationStateAlpha)
 			{
-			case BLENDOP_ADD:
-			case BLENDOP_SUB:
-			case BLENDOP_INVSUB:
+			case VK_BLEND_OP_ADD:
+			case VK_BLEND_OP_SUBTRACT:
+			case VK_BLEND_OP_REVERSE_SUBTRACT:
 				return sourceBlendFactorStateAlpha;
-			case BLENDOP_MIN:
-				return BLEND_ONE;
-			case BLENDOP_MAX:
-				return BLEND_ONE;
+			case VK_BLEND_OP_MIN:
+				return VK_BLEND_FACTOR_ONE;
+			case VK_BLEND_OP_MAX:
+				return VK_BLEND_FACTOR_ONE;
 			default:
 				ASSERT(false);
 			}
@@ -562,7 +562,7 @@ namespace sw
 		}
 	}
 
-	BlendFactor Context::destBlendFactorAlpha()
+	VkBlendFactor Context::destBlendFactorAlpha()
 	{
 		if(!separateAlphaBlendEnable)
 		{
@@ -572,14 +572,14 @@ namespace sw
 		{
 			switch(blendOperationStateAlpha)
 			{
-			case BLENDOP_ADD:
-			case BLENDOP_SUB:
-			case BLENDOP_INVSUB:
+			case VK_BLEND_OP_ADD:
+			case VK_BLEND_OP_SUBTRACT:
+			case VK_BLEND_OP_REVERSE_SUBTRACT:
 				return destBlendFactorStateAlpha;
-			case BLENDOP_MIN:
-				return BLEND_ONE;
-			case BLENDOP_MAX:
-				return BLEND_ONE;
+			case VK_BLEND_OP_MIN:
+				return VK_BLEND_FACTOR_ONE;
+			case VK_BLEND_OP_MAX:
+				return VK_BLEND_FACTOR_ONE;
 			default:
 				ASSERT(false);
 			}
@@ -588,7 +588,7 @@ namespace sw
 		}
 	}
 
-	BlendOperation Context::blendOperationAlpha()
+	VkBlendOp Context::blendOperationAlpha()
 	{
 		if(!separateAlphaBlendEnable)
 		{
@@ -598,105 +598,105 @@ namespace sw
 		{
 			switch(blendOperationStateAlpha)
 			{
-			case BLENDOP_ADD:
-				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+			case VK_BLEND_OP_ADD:
+				if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_NULL;
+						return VK_BLEND_OP_ZERO_EXT;
 					}
 					else
 					{
-						return BLENDOP_DEST;
+						return VK_BLEND_OP_DST_EXT;
 					}
 				}
-				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_SOURCE;
+						return VK_BLEND_OP_SRC_EXT;
 					}
 					else
 					{
-						return BLENDOP_ADD;
+						return VK_BLEND_OP_ADD;
 					}
 				}
 				else
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_SOURCE;
+						return VK_BLEND_OP_SRC_EXT;
 					}
 					else
 					{
-						return BLENDOP_ADD;
+						return VK_BLEND_OP_ADD;
 					}
 				}
-			case BLENDOP_SUB:
-				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+			case VK_BLEND_OP_SUBTRACT:
+				if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 				{
-					return BLENDOP_NULL;   // Negative, clamped to zero
+					return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 				}
-				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_SOURCE;
+						return VK_BLEND_OP_SRC_EXT;
 					}
 					else
 					{
-						return BLENDOP_SUB;
+						return VK_BLEND_OP_SUBTRACT;
 					}
 				}
 				else
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_SOURCE;
+						return VK_BLEND_OP_SRC_EXT;
 					}
 					else
 					{
-						return BLENDOP_SUB;
+						return VK_BLEND_OP_SUBTRACT;
 					}
 				}
-			case BLENDOP_INVSUB:
-				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+			case VK_BLEND_OP_REVERSE_SUBTRACT:
+				if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_NULL;
+						return VK_BLEND_OP_ZERO_EXT;
 					}
 					else
 					{
-						return BLENDOP_DEST;
+						return VK_BLEND_OP_DST_EXT;
 					}
 				}
-				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				else if(sourceBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_FACTOR_ZERO)
 					{
-						return BLENDOP_NULL;   // Negative, clamped to zero
+						return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 					}
 					else
 					{
-						return BLENDOP_INVSUB;
+						return VK_BLEND_OP_REVERSE_SUBTRACT;
 					}
 				}
 				else
 				{
-					if(destBlendFactorAlpha() == BLEND_ZERO)
+					if(destBlendFactorAlpha() == VK_BLEND_OP_ZERO_EXT)
 					{
-						return BLENDOP_NULL;   // Negative, clamped to zero
+						return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
 					}
 					else
 					{
-						return BLENDOP_INVSUB;
+						return VK_BLEND_OP_ZERO_EXT;
 					}
 				}
-			case BLENDOP_MIN:
-				return BLENDOP_MIN;
-			case BLENDOP_MAX:
-				return BLENDOP_MAX;
+			case VK_BLEND_OP_MIN:
+				return VK_BLEND_OP_MIN;
+			case VK_BLEND_OP_MAX:
+				return VK_BLEND_OP_MAX;
 			default:
 				ASSERT(false);
 			}
@@ -764,8 +764,8 @@ namespace sw
 			return 0;
 		}
 
-		if(blendOperation() == BLENDOP_DEST && destBlendFactor() == BLEND_ONE &&
-		   (!separateAlphaBlendEnable || (blendOperationAlpha() == BLENDOP_DEST && destBlendFactorAlpha() == BLEND_ONE)))
+		if(blendOperation() == VK_BLEND_OP_DST_EXT && destBlendFactor() == VK_BLEND_FACTOR_ONE &&
+		   (!separateAlphaBlendEnable || (blendOperationAlpha() == VK_BLEND_OP_DST_EXT && destBlendFactorAlpha() == VK_BLEND_FACTOR_ONE)))
 		{
 			return 0;
 		}

src/Device/Context.hpp

@@ -93,42 +93,6 @@ namespace sw
 		CULL_LAST = CULL_COUNTERCLOCKWISE
 	};
 
-	enum BlendFactor ENUM_UNDERLYING_TYPE_UNSIGNED_INT
-	{
-		BLEND_ZERO,
-		BLEND_ONE,
-		BLEND_SOURCE,
-		BLEND_INVSOURCE,
-		BLEND_DEST,
-		BLEND_INVDEST,
-		BLEND_SOURCEALPHA,
-		BLEND_INVSOURCEALPHA,
-		BLEND_DESTALPHA,
-		BLEND_INVDESTALPHA,
-		BLEND_SRCALPHASAT,
-		BLEND_CONSTANT,
-		BLEND_INVCONSTANT,
-		BLEND_CONSTANTALPHA,
-		BLEND_INVCONSTANTALPHA,
-
-		BLEND_LAST = BLEND_INVCONSTANTALPHA
-	};
-
-	enum BlendOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
-	{
-		BLENDOP_ADD,
-		BLENDOP_SUB,
-		BLENDOP_INVSUB,
-		BLENDOP_MIN,
-		BLENDOP_MAX,
-
-		BLENDOP_SOURCE,   // Copy source
-		BLENDOP_DEST,     // Copy dest
-		BLENDOP_NULL,     // Nullify result
-
-		BLENDOP_LAST = BLENDOP_NULL
-	};
-
 	enum TransparencyAntialiasing ENUM_UNDERLYING_TYPE_UNSIGNED_INT
 	{
 		TRANSPARENCY_NONE,
@@ -156,14 +120,14 @@ namespace sw
 		bool setDepthBufferEnable(bool depthBufferEnable);
 
 		bool setAlphaBlendEnable(bool alphaBlendEnable);
-		bool setSourceBlendFactor(BlendFactor sourceBlendFactor);
-		bool setDestBlendFactor(BlendFactor destBlendFactor);
-		bool setBlendOperation(BlendOperation blendOperation);
+		bool setSourceBlendFactor(VkBlendFactor sourceBlendFactor);
+		bool setDestBlendFactor(VkBlendFactor destBlendFactor);
+		bool setBlendOperation(VkBlendOp blendOperation);
 
 		bool setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
-		bool setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
-		bool setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
-		bool setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+		bool setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha);
+		bool setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha);
+		bool setBlendOperationAlpha(VkBlendOp blendOperationAlpha);
 
 		bool setColorWriteMask(int index, int colorWriteMask);
 		bool setWriteSRGB(bool sRGB);
@@ -179,13 +143,13 @@ namespace sw
 		bool perspectiveActive();
 
 		bool alphaBlendActive();
-		BlendFactor sourceBlendFactor();
-		BlendFactor destBlendFactor();
-		BlendOperation blendOperation();
+		VkBlendFactor sourceBlendFactor();
+		VkBlendFactor destBlendFactor();
+		VkBlendOp blendOperation();
 
-		BlendFactor sourceBlendFactorAlpha();
-		BlendFactor destBlendFactorAlpha();
-		BlendOperation blendOperationAlpha();
+		VkBlendFactor sourceBlendFactorAlpha();
+		VkBlendFactor destBlendFactorAlpha();
+		VkBlendOp blendOperationAlpha();
 
 		VkLogicOp colorLogicOp();
 
@@ -261,14 +225,14 @@ namespace sw
 		bool depthWriteEnable;
 
 		bool alphaBlendEnable;
-		BlendFactor sourceBlendFactorState;
-		BlendFactor destBlendFactorState;
-		BlendOperation blendOperationState;
+		VkBlendFactor sourceBlendFactorState;
+		VkBlendFactor destBlendFactorState;
+		VkBlendOp blendOperationState;
 
 		bool separateAlphaBlendEnable;
-		BlendFactor sourceBlendFactorStateAlpha;
-		BlendFactor destBlendFactorStateAlpha;
-		BlendOperation blendOperationStateAlpha;
+		VkBlendFactor sourceBlendFactorStateAlpha;
+		VkBlendFactor destBlendFactorStateAlpha;
+		VkBlendOp blendOperationStateAlpha;
 
 		float lineWidth;
 

src/Device/PixelProcessor.cpp

@@ -560,17 +560,17 @@ namespace sw
 		context->setAlphaBlendEnable(alphaBlendEnable);
 	}
 
-	void PixelProcessor::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+	void PixelProcessor::setSourceBlendFactor(VkBlendFactor sourceBlendFactor)
 	{
 		context->setSourceBlendFactor(sourceBlendFactor);
 	}
 
-	void PixelProcessor::setDestBlendFactor(BlendFactor destBlendFactor)
+	void PixelProcessor::setDestBlendFactor(VkBlendFactor destBlendFactor)
 	{
 		context->setDestBlendFactor(destBlendFactor);
 	}
 
-	void PixelProcessor::setBlendOperation(BlendOperation blendOperation)
+	void PixelProcessor::setBlendOperation(VkBlendOp blendOperation)
 	{
 		context->setBlendOperation(blendOperation);
 	}
@@ -580,17 +580,17 @@ namespace sw
 		context->setSeparateAlphaBlendEnable(separateAlphaBlendEnable);
 	}
 
-	void PixelProcessor::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+	void PixelProcessor::setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha)
 	{
 		context->setSourceBlendFactorAlpha(sourceBlendFactorAlpha);
 	}
 
-	void PixelProcessor::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+	void PixelProcessor::setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha)
 	{
 		context->setDestBlendFactorAlpha(destBlendFactorAlpha);
 	}
 
-	void PixelProcessor::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+	void PixelProcessor::setBlendOperationAlpha(VkBlendOp blendOperationAlpha)
 	{
 		context->setBlendOperationAlpha(blendOperationAlpha);
 	}

src/Device/PixelProcessor.hpp

@@ -65,12 +65,12 @@ namespace sw
 			bool depthClamp                           : 1;
 
 			bool alphaBlendActive                     : 1;
-			BlendFactor sourceBlendFactor             : BITS(BLEND_LAST);
-			BlendFactor destBlendFactor               : BITS(BLEND_LAST);
-			BlendOperation blendOperation             : BITS(BLENDOP_LAST);
-			BlendFactor sourceBlendFactorAlpha        : BITS(BLEND_LAST);
-			BlendFactor destBlendFactorAlpha          : BITS(BLEND_LAST);
-			BlendOperation blendOperationAlpha        : BITS(BLENDOP_LAST);
+			VkBlendFactor sourceBlendFactor           : BITS(VK_BLEND_FACTOR_END_RANGE);
+			VkBlendFactor destBlendFactor             : BITS(VK_BLEND_FACTOR_END_RANGE);
+			VkBlendOp blendOperation                  : BITS(VK_BLEND_OP_BLUE_EXT);
+			VkBlendFactor sourceBlendFactorAlpha      : BITS(VK_BLEND_FACTOR_END_RANGE);
+			VkBlendFactor destBlendFactorAlpha        : BITS(VK_BLEND_FACTOR_END_RANGE);
+			VkBlendOp blendOperationAlpha             : BITS(VK_BLEND_OP_BLUE_EXT);
 
 			unsigned int colorWriteMask                       : RENDERTARGETS * 4;   // Four component bit masks
 			VkFormat targetFormat[RENDERTARGETS];
@@ -239,14 +239,14 @@ namespace sw
 		void setBlendConstant(const Color<float> &blendConstant);
 
 		void setAlphaBlendEnable(bool alphaBlendEnable);
-		void setSourceBlendFactor(BlendFactor sourceBlendFactor);
-		void setDestBlendFactor(BlendFactor destBlendFactor);
-		void setBlendOperation(BlendOperation blendOperation);
+		void setSourceBlendFactor(VkBlendFactor sourceBlendFactor);
+		void setDestBlendFactor(VkBlendFactor destBlendFactor);
+		void setBlendOperation(VkBlendOp blendOperation);
 
 		void setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
-		void setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
-		void setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
-		void setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+		void setSourceBlendFactorAlpha(VkBlendFactor sourceBlendFactorAlpha);
+		void setDestBlendFactorAlpha(VkBlendFactor destBlendFactorAlpha);
+		void setBlendOperationAlpha(VkBlendOp blendOperationAlpha);
 
 		void setAlphaReference(float alphaReference);
 

src/Pipeline/PixelRoutine.cpp

@@ -786,78 +786,78 @@ namespace sw
 		}
 	}
 
-	void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
+	void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorActive)
 	{
 		switch(blendFactorActive)
 		{
-		case BLEND_ZERO:
+		case VK_BLEND_FACTOR_ZERO:
 			// Optimized
 			break;
-		case BLEND_ONE:
+		case VK_BLEND_FACTOR_ONE:
 			// Optimized
 			break;
-		case BLEND_SOURCE:
+		case VK_BLEND_FACTOR_SRC_COLOR:
 			blendFactor.x = current.x;
 			blendFactor.y = current.y;
 			blendFactor.z = current.z;
 			break;
-		case BLEND_INVSOURCE:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
 			blendFactor.x = Short4(0xFFFFu) - current.x;
 			blendFactor.y = Short4(0xFFFFu) - current.y;
 			blendFactor.z = Short4(0xFFFFu) - current.z;
 			break;
-		case BLEND_DEST:
+		case VK_BLEND_FACTOR_DST_COLOR:
 			blendFactor.x = pixel.x;
 			blendFactor.y = pixel.y;
 			blendFactor.z = pixel.z;
 			break;
-		case BLEND_INVDEST:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
 			blendFactor.x = Short4(0xFFFFu) - pixel.x;
 			blendFactor.y = Short4(0xFFFFu) - pixel.y;
 			blendFactor.z = Short4(0xFFFFu) - pixel.z;
 			break;
-		case BLEND_SOURCEALPHA:
+		case VK_BLEND_FACTOR_SRC_ALPHA:
 			blendFactor.x = current.w;
 			blendFactor.y = current.w;
 			blendFactor.z = current.w;
 			break;
-		case BLEND_INVSOURCEALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
 			blendFactor.x = Short4(0xFFFFu) - current.w;
 			blendFactor.y = Short4(0xFFFFu) - current.w;
 			blendFactor.z = Short4(0xFFFFu) - current.w;
 			break;
-		case BLEND_DESTALPHA:
+		case VK_BLEND_FACTOR_DST_ALPHA:
 			blendFactor.x = pixel.w;
 			blendFactor.y = pixel.w;
 			blendFactor.z = pixel.w;
 			break;
-		case BLEND_INVDESTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
 			blendFactor.x = Short4(0xFFFFu) - pixel.w;
 			blendFactor.y = Short4(0xFFFFu) - pixel.w;
 			blendFactor.z = Short4(0xFFFFu) - pixel.w;
 			break;
-		case BLEND_SRCALPHASAT:
+		case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
 			blendFactor.x = Short4(0xFFFFu) - pixel.w;
 			blendFactor.x = Min(As<UShort4>(blendFactor.x), As<UShort4>(current.w));
 			blendFactor.y = blendFactor.x;
 			blendFactor.z = blendFactor.x;
 			break;
-		case BLEND_CONSTANT:
+		case VK_BLEND_FACTOR_CONSTANT_COLOR:
 			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[0]));
 			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[1]));
 			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[2]));
 			break;
-		case BLEND_INVCONSTANT:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
 			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[0]));
 			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[1]));
 			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[2]));
 			break;
-		case BLEND_CONSTANTALPHA:
+		case VK_BLEND_FACTOR_CONSTANT_ALPHA:
 			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
 			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
 			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
 			break;
-		case BLEND_INVCONSTANTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
 			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
 			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
 			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
@@ -867,49 +867,49 @@ namespace sw
 		}
 	}
 
-	void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
+	void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorAlphaActive)
 	{
 		switch(blendFactorAlphaActive)
 		{
-		case BLEND_ZERO:
+		case VK_BLEND_FACTOR_ZERO:
 			// Optimized
 			break;
-		case BLEND_ONE:
+		case VK_BLEND_FACTOR_ONE:
 			// Optimized
 			break;
-		case BLEND_SOURCE:
+		case VK_BLEND_FACTOR_SRC_COLOR:
 			blendFactor.w = current.w;
 			break;
-		case BLEND_INVSOURCE:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
 			blendFactor.w = Short4(0xFFFFu) - current.w;
 			break;
-		case BLEND_DEST:
+		case VK_BLEND_FACTOR_DST_COLOR:
 			blendFactor.w = pixel.w;
 			break;
-		case BLEND_INVDEST:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
 			blendFactor.w = Short4(0xFFFFu) - pixel.w;
 			break;
-		case BLEND_SOURCEALPHA:
+		case VK_BLEND_FACTOR_SRC_ALPHA:
 			blendFactor.w = current.w;
 			break;
-		case BLEND_INVSOURCEALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
 			blendFactor.w = Short4(0xFFFFu) - current.w;
 			break;
-		case BLEND_DESTALPHA:
+		case VK_BLEND_FACTOR_DST_ALPHA:
 			blendFactor.w = pixel.w;
 			break;
-		case BLEND_INVDESTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
 			blendFactor.w = Short4(0xFFFFu) - pixel.w;
 			break;
-		case BLEND_SRCALPHASAT:
+		case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
 			blendFactor.w = Short4(0xFFFFu);
 			break;
-		case BLEND_CONSTANT:
-		case BLEND_CONSTANTALPHA:
+		case VK_BLEND_FACTOR_CONSTANT_COLOR:
+		case VK_BLEND_FACTOR_CONSTANT_ALPHA:
 			blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
 			break;
-		case BLEND_INVCONSTANT:
-		case BLEND_INVCONSTANTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA:
 			blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
 			break;
 		default:
@@ -1050,14 +1050,14 @@ namespace sw
 		blendFactor(sourceFactor, current, pixel, state.sourceBlendFactor);
 		blendFactor(destFactor, current, pixel, state.destBlendFactor);
 
-		if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+		if(state.sourceBlendFactor != VK_BLEND_FACTOR_ONE && state.sourceBlendFactor != VK_BLEND_FACTOR_ZERO)
 		{
 			current.x = MulHigh(As<UShort4>(current.x), As<UShort4>(sourceFactor.x));
 			current.y = MulHigh(As<UShort4>(current.y), As<UShort4>(sourceFactor.y));
 			current.z = MulHigh(As<UShort4>(current.z), As<UShort4>(sourceFactor.z));
 		}
 
-		if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+		if(state.destBlendFactor != VK_BLEND_FACTOR_ONE && state.destBlendFactor != VK_BLEND_FACTOR_ZERO)
 		{
 			pixel.x = MulHigh(As<UShort4>(pixel.x), As<UShort4>(destFactor.x));
 			pixel.y = MulHigh(As<UShort4>(pixel.y), As<UShort4>(destFactor.y));
@@ -1066,40 +1066,40 @@ namespace sw
 
 		switch(state.blendOperation)
 		{
-		case BLENDOP_ADD:
+		case VK_BLEND_OP_ADD:
 			current.x = AddSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
 			current.y = AddSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
 			current.z = AddSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
 			break;
-		case BLENDOP_SUB:
+		case VK_BLEND_OP_SUBTRACT:
 			current.x = SubSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
 			current.y = SubSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
 			current.z = SubSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
 			break;
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			current.x = SubSat(As<UShort4>(pixel.x), As<UShort4>(current.x));
 			current.y = SubSat(As<UShort4>(pixel.y), As<UShort4>(current.y));
 			current.z = SubSat(As<UShort4>(pixel.z), As<UShort4>(current.z));
 			break;
-		case BLENDOP_MIN:
+		case VK_BLEND_OP_MIN:
 			current.x = Min(As<UShort4>(current.x), As<UShort4>(pixel.x));
 			current.y = Min(As<UShort4>(current.y), As<UShort4>(pixel.y));
 			current.z = Min(As<UShort4>(current.z), As<UShort4>(pixel.z));
 			break;
-		case BLENDOP_MAX:
+		case VK_BLEND_OP_MAX:
 			current.x = Max(As<UShort4>(current.x), As<UShort4>(pixel.x));
 			current.y = Max(As<UShort4>(current.y), As<UShort4>(pixel.y));
 			current.z = Max(As<UShort4>(current.z), As<UShort4>(pixel.z));
 			break;
-		case BLENDOP_SOURCE:
+		case VK_BLEND_OP_SRC_EXT:
 			// No operation
 			break;
-		case BLENDOP_DEST:
+		case VK_BLEND_OP_DST_EXT:
 			current.x = pixel.x;
 			current.y = pixel.y;
 			current.z = pixel.z;
 			break;
-		case BLENDOP_NULL:
+		case VK_BLEND_OP_ZERO_EXT:
 			current.x = Short4(0x0000);
 			current.y = Short4(0x0000);
 			current.z = Short4(0x0000);
@@ -1111,40 +1111,40 @@ namespace sw
 		blendFactorAlpha(sourceFactor, current, pixel, state.sourceBlendFactorAlpha);
 		blendFactorAlpha(destFactor, current, pixel, state.destBlendFactorAlpha);
 
-		if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+		if(state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
 		{
 			current.w = MulHigh(As<UShort4>(current.w), As<UShort4>(sourceFactor.w));
 		}
 
-		if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+		if(state.destBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.destBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
 		{
 			pixel.w = MulHigh(As<UShort4>(pixel.w), As<UShort4>(destFactor.w));
 		}
 
 		switch(state.blendOperationAlpha)
 		{
-		case BLENDOP_ADD:
+		case VK_BLEND_OP_ADD:
 			current.w = AddSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
 			break;
-		case BLENDOP_SUB:
+		case VK_BLEND_OP_SUBTRACT:
 			current.w = SubSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
 			break;
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			current.w = SubSat(As<UShort4>(pixel.w), As<UShort4>(current.w));
 			break;
-		case BLENDOP_MIN:
+		case VK_BLEND_OP_MIN:
 			current.w = Min(As<UShort4>(current.w), As<UShort4>(pixel.w));
 			break;
-		case BLENDOP_MAX:
+		case VK_BLEND_OP_MAX:
 			current.w = Max(As<UShort4>(current.w), As<UShort4>(pixel.w));
 			break;
-		case BLENDOP_SOURCE:
+		case VK_BLEND_OP_SRC_EXT:
 			// No operation
 			break;
-		case BLENDOP_DEST:
+		case VK_BLEND_OP_DST_EXT:
 			current.w = pixel.w;
 			break;
-		case BLENDOP_NULL:
+		case VK_BLEND_OP_ZERO_EXT:
 			current.w = Short4(0x0000);
 			break;
 		default:
@@ -1679,68 +1679,68 @@ namespace sw
 		}
 	}
 
-	void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
+	void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorActive)
 	{
 		switch(blendFactorActive)
 		{
-		case BLEND_ZERO:
+		case VK_BLEND_FACTOR_ZERO:
 			// Optimized
 			break;
-		case BLEND_ONE:
+		case VK_BLEND_FACTOR_ONE:
 			// Optimized
 			break;
-		case BLEND_SOURCE:
+		case VK_BLEND_FACTOR_SRC_COLOR:
 			blendFactor.x = oC.x;
 			blendFactor.y = oC.y;
 			blendFactor.z = oC.z;
 			break;
-		case BLEND_INVSOURCE:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
 			blendFactor.x = Float4(1.0f) - oC.x;
 			blendFactor.y = Float4(1.0f) - oC.y;
 			blendFactor.z = Float4(1.0f) - oC.z;
 			break;
-		case BLEND_DEST:
+		case VK_BLEND_FACTOR_DST_COLOR:
 			blendFactor.x = pixel.x;
 			blendFactor.y = pixel.y;
 			blendFactor.z = pixel.z;
 			break;
-		case BLEND_INVDEST:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
 			blendFactor.x = Float4(1.0f) - pixel.x;
 			blendFactor.y = Float4(1.0f) - pixel.y;
 			blendFactor.z = Float4(1.0f) - pixel.z;
 			break;
-		case BLEND_SOURCEALPHA:
+		case VK_BLEND_FACTOR_SRC_ALPHA:
 			blendFactor.x = oC.w;
 			blendFactor.y = oC.w;
 			blendFactor.z = oC.w;
 			break;
-		case BLEND_INVSOURCEALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
 			blendFactor.x = Float4(1.0f) - oC.w;
 			blendFactor.y = Float4(1.0f) - oC.w;
 			blendFactor.z = Float4(1.0f) - oC.w;
 			break;
-		case BLEND_DESTALPHA:
+		case VK_BLEND_FACTOR_DST_ALPHA:
 			blendFactor.x = pixel.w;
 			blendFactor.y = pixel.w;
 			blendFactor.z = pixel.w;
 			break;
-		case BLEND_INVDESTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
 			blendFactor.x = Float4(1.0f) - pixel.w;
 			blendFactor.y = Float4(1.0f) - pixel.w;
 			blendFactor.z = Float4(1.0f) - pixel.w;
 			break;
-		case BLEND_SRCALPHASAT:
+		case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
 			blendFactor.x = Float4(1.0f) - pixel.w;
 			blendFactor.x = Min(blendFactor.x, oC.w);
 			blendFactor.y = blendFactor.x;
 			blendFactor.z = blendFactor.x;
 			break;
-		case BLEND_CONSTANT:
+		case VK_BLEND_FACTOR_CONSTANT_COLOR:
 			blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[0]));
 			blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[1]));
 			blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[2]));
 			break;
-		case BLEND_INVCONSTANT:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
 			blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[0]));
 			blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[1]));
 			blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[2]));
@@ -1750,47 +1750,47 @@ namespace sw
 		}
 	}
 
-	void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
+	void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorAlphaActive)
 	{
 		switch(blendFactorAlphaActive)
 		{
-		case BLEND_ZERO:
+		case VK_BLEND_FACTOR_ZERO:
 			// Optimized
 			break;
-		case BLEND_ONE:
+		case VK_BLEND_FACTOR_ONE:
 			// Optimized
 			break;
-		case BLEND_SOURCE:
+		case VK_BLEND_FACTOR_SRC_COLOR:
 			blendFactor.w = oC.w;
 			break;
-		case BLEND_INVSOURCE:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR:
 			blendFactor.w = Float4(1.0f) - oC.w;
 			break;
-		case BLEND_DEST:
+		case VK_BLEND_FACTOR_DST_COLOR:
 			blendFactor.w = pixel.w;
 			break;
-		case BLEND_INVDEST:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR:
 			blendFactor.w = Float4(1.0f) - pixel.w;
 			break;
-		case BLEND_SOURCEALPHA:
+		case VK_BLEND_FACTOR_SRC_ALPHA:
 			blendFactor.w = oC.w;
 			break;
-		case BLEND_INVSOURCEALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA:
 			blendFactor.w = Float4(1.0f) - oC.w;
 			break;
-		case BLEND_DESTALPHA:
+		case VK_BLEND_FACTOR_DST_ALPHA:
 			blendFactor.w = pixel.w;
 			break;
-		case BLEND_INVDESTALPHA:
+		case VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA:
 			blendFactor.w = Float4(1.0f) - pixel.w;
 			break;
-		case BLEND_SRCALPHASAT:
+		case VK_BLEND_FACTOR_SRC_ALPHA_SATURATE:
 			blendFactor.w = Float4(1.0f);
 			break;
-		case BLEND_CONSTANT:
+		case VK_BLEND_FACTOR_CONSTANT_COLOR:
 			blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[3]));
 			break;
-		case BLEND_INVCONSTANT:
+		case VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR:
 			blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[3]));
 			break;
 		default:
@@ -1879,14 +1879,14 @@ namespace sw
 		blendFactor(sourceFactor, oC, pixel, state.sourceBlendFactor);
 		blendFactor(destFactor, oC, pixel, state.destBlendFactor);
 
-		if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+		if(state.sourceBlendFactor != VK_BLEND_FACTOR_ONE && state.sourceBlendFactor != VK_BLEND_FACTOR_ZERO)
 		{
 			oC.x *= sourceFactor.x;
 			oC.y *= sourceFactor.y;
 			oC.z *= sourceFactor.z;
 		}
 
-		if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+		if(state.destBlendFactor != VK_BLEND_FACTOR_ONE && state.destBlendFactor != VK_BLEND_FACTOR_ZERO)
 		{
 			pixel.x *= destFactor.x;
 			pixel.y *= destFactor.y;
@@ -1895,40 +1895,40 @@ namespace sw
 
 		switch(state.blendOperation)
 		{
-		case BLENDOP_ADD:
+		case VK_BLEND_OP_ADD:
 			oC.x += pixel.x;
 			oC.y += pixel.y;
 			oC.z += pixel.z;
 			break;
-		case BLENDOP_SUB:
+		case VK_BLEND_OP_SUBTRACT:
 			oC.x -= pixel.x;
 			oC.y -= pixel.y;
 			oC.z -= pixel.z;
 			break;
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			oC.x = pixel.x - oC.x;
 			oC.y = pixel.y - oC.y;
 			oC.z = pixel.z - oC.z;
 			break;
-		case BLENDOP_MIN:
+		case VK_BLEND_OP_MIN:
 			oC.x = Min(oC.x, pixel.x);
 			oC.y = Min(oC.y, pixel.y);
 			oC.z = Min(oC.z, pixel.z);
 			break;
-		case BLENDOP_MAX:
+		case VK_BLEND_OP_MAX:
 			oC.x = Max(oC.x, pixel.x);
 			oC.y = Max(oC.y, pixel.y);
 			oC.z = Max(oC.z, pixel.z);
 			break;
-		case BLENDOP_SOURCE:
+		case VK_BLEND_OP_SRC_EXT:
 			// No operation
 			break;
-		case BLENDOP_DEST:
+		case VK_BLEND_OP_DST_EXT:
 			oC.x = pixel.x;
 			oC.y = pixel.y;
 			oC.z = pixel.z;
 			break;
-		case BLENDOP_NULL:
+		case VK_BLEND_OP_ZERO_EXT:
 			oC.x = Float4(0.0f);
 			oC.y = Float4(0.0f);
 			oC.z = Float4(0.0f);
@@ -1940,41 +1940,41 @@ namespace sw
 		blendFactorAlpha(sourceFactor, oC, pixel, state.sourceBlendFactorAlpha);
 		blendFactorAlpha(destFactor, oC, pixel, state.destBlendFactorAlpha);
 
-		if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+		if(state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.sourceBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
 		{
 			oC.w *= sourceFactor.w;
 		}
 
-		if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+		if(state.destBlendFactorAlpha != VK_BLEND_FACTOR_ONE && state.destBlendFactorAlpha != VK_BLEND_FACTOR_ZERO)
 		{
 			pixel.w *= destFactor.w;
 		}
 
 		switch(state.blendOperationAlpha)
 		{
-		case BLENDOP_ADD:
+		case VK_BLEND_OP_ADD:
 			oC.w += pixel.w;
 			break;
-		case BLENDOP_SUB:
+		case VK_BLEND_OP_SUBTRACT:
 			oC.w -= pixel.w;
 			break;
-		case BLENDOP_INVSUB:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
 			pixel.w -= oC.w;
 			oC.w = pixel.w;
 			break;
-		case BLENDOP_MIN:
+		case VK_BLEND_OP_MIN:
 			oC.w = Min(oC.w, pixel.w);
 			break;
-		case BLENDOP_MAX:
+		case VK_BLEND_OP_MAX:
 			oC.w = Max(oC.w, pixel.w);
 			break;
-		case BLENDOP_SOURCE:
+		case VK_BLEND_OP_SRC_EXT:
 			// No operation
 			break;
-		case BLENDOP_DEST:
+		case VK_BLEND_OP_DST_EXT:
 			oC.w = pixel.w;
 			break;
-		case BLENDOP_NULL:
+		case VK_BLEND_OP_ZERO_EXT:
 			oC.w = Float4(0.0f);
 			break;
 		default:

src/Pipeline/PixelRoutine.hpp

@@ -72,11 +72,11 @@ namespace sw
 		Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
 
 		// Raster operations
-		void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
-		void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
+		void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, VkBlendFactor blendFactorAlphaActive);
 		void readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel);
-		void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
-		void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
+		void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, VkBlendFactor blendFactorAlphaActive);
 		void writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
 		void writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);