Removed SwiftShader's custom LogicalOperation enum

src/Device/Context.cpp

@@ -238,7 +238,7 @@ namespace sw
 		sampleMask = 0xFFFFFFFF;
 
 		colorLogicOpEnabled = false;
-		logicalOperation = LOGICALOP_COPY;
+		logicalOperation = VK_LOGIC_OP_COPY;
 	}
 
 	bool Context::setDepthBufferEnable(bool depthBufferEnable)
@@ -325,7 +325,7 @@ namespace sw
 		return modified;
 	}
 
-	bool Context::setLogicalOperation(LogicalOperation logicalOperation)
+	bool Context::setLogicalOperation(VkLogicOp logicalOperation)
 	{
 		bool modified = (Context::logicalOperation != logicalOperation);
 		Context::logicalOperation = logicalOperation;
@@ -377,9 +377,9 @@ namespace sw
 		return colorBlend || alphaBlend;
 	}
 
-	LogicalOperation Context::colorLogicOp()
+	VkLogicOp Context::colorLogicOp()
 	{
-		return colorLogicOpEnabled ? logicalOperation : LOGICALOP_COPY;
+		return colorLogicOpEnabled ? logicalOperation : VK_LOGIC_OP_COPY;
 	}
 
 	BlendFactor Context::sourceBlendFactor()

src/Device/Context.hpp

@@ -129,28 +129,6 @@ namespace sw
 		BLENDOP_LAST = BLENDOP_NULL
 	};
 
-	enum LogicalOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
-	{
-		LOGICALOP_CLEAR,
-		LOGICALOP_SET,
-		LOGICALOP_COPY,
-		LOGICALOP_COPY_INVERTED,
-		LOGICALOP_NOOP,
-		LOGICALOP_INVERT,
-		LOGICALOP_AND,
-		LOGICALOP_NAND,
-		LOGICALOP_OR,
-		LOGICALOP_NOR,
-		LOGICALOP_XOR,
-		LOGICALOP_EQUIV,
-		LOGICALOP_AND_REVERSE,
-		LOGICALOP_AND_INVERTED,
-		LOGICALOP_OR_REVERSE,
-		LOGICALOP_OR_INVERTED,
-
-		LOGICALOP_LAST = LOGICALOP_OR_INVERTED
-	};
-
 	enum TransparencyAntialiasing ENUM_UNDERLYING_TYPE_UNSIGNED_INT
 	{
 		TRANSPARENCY_NONE,
@@ -191,7 +169,7 @@ namespace sw
 		bool setWriteSRGB(bool sRGB);
 
 		bool setColorLogicOpEnabled(bool colorLogicOpEnabled);
-		bool setLogicalOperation(LogicalOperation logicalOperation);
+		bool setLogicalOperation(VkLogicOp logicalOperation);
 
 		bool depthWriteActive();
 		bool alphaTestActive();
@@ -209,7 +187,7 @@ namespace sw
 		BlendFactor destBlendFactorAlpha();
 		BlendOperation blendOperationAlpha();
 
-		LogicalOperation colorLogicOp();
+		VkLogicOp colorLogicOp();
 
 		unsigned short pixelShaderModel() const;
 		unsigned short vertexShaderModel() const;
@@ -300,7 +278,7 @@ namespace sw
 		unsigned int multiSampleMask;
 
 		bool colorLogicOpEnabled;
-		LogicalOperation logicalOperation;
+		VkLogicOp logicalOperation;
 	};
 }
 

src/Device/PixelProcessor.cpp

@@ -333,7 +333,7 @@ namespace sw
 		context->setColorLogicOpEnabled(colorLogicOpEnabled);
 	}
 
-	void PixelProcessor::setLogicalOperation(LogicalOperation logicalOperation)
+	void PixelProcessor::setLogicalOperation(VkLogicOp logicalOperation)
 	{
 		context->setLogicalOperation(logicalOperation);
 	}

src/Device/PixelProcessor.hpp

@@ -81,7 +81,7 @@ namespace sw
 			bool centroid                                     : 1;
 			bool frontFaceCCW                                 : 1;
 
-			LogicalOperation logicalOperation : BITS(LOGICALOP_LAST);
+			VkLogicOp logicalOperation : BITS(VK_LOGIC_OP_END_RANGE);
 
 			Sampler::State sampler[TEXTURE_IMAGE_UNITS];
 
@@ -217,7 +217,7 @@ namespace sw
 		void setColorWriteMask(int index, int rgbaMask);
 
 		void setColorLogicOpEnabled(bool colorLogicOpEnabled);
-		void setLogicalOperation(LogicalOperation logicalOperation);
+		void setLogicalOperation(VkLogicOp logicalOperation);
 
 		void setStencilEnable(bool stencilEnable);
 		void setStencilCompare(VkCompareOp stencilCompareMode);

src/Pipeline/PixelRoutine.cpp

@@ -1154,7 +1154,7 @@ namespace sw
 
 	void PixelRoutine::logicOperation(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x)
 	{
-		if(state.logicalOperation == LOGICALOP_COPY)
+		if(state.logicalOperation == VK_LOGIC_OP_COPY)
 		{
 			return;
 		}
@@ -1164,80 +1164,80 @@ namespace sw
 
 		switch(state.logicalOperation)
 		{
-		case LOGICALOP_CLEAR:
+		case VK_LOGIC_OP_CLEAR:
 			current.x = UShort4(0);
 			current.y = UShort4(0);
 			current.z = UShort4(0);
 			break;
-		case LOGICALOP_SET:
+		case VK_LOGIC_OP_SET:
 			current.x = UShort4(0xFFFFu);
 			current.y = UShort4(0xFFFFu);
 			current.z = UShort4(0xFFFFu);
 			break;
-		case LOGICALOP_COPY:
+		case VK_LOGIC_OP_COPY:
 			ASSERT(false);   // Optimized out
 			break;
-		case LOGICALOP_COPY_INVERTED:
+		case VK_LOGIC_OP_COPY_INVERTED:
 			current.x = ~current.x;
 			current.y = ~current.y;
 			current.z = ~current.z;
 			break;
-		case LOGICALOP_NOOP:
+		case VK_LOGIC_OP_NO_OP:
 			current.x = pixel.x;
 			current.y = pixel.y;
 			current.z = pixel.z;
 			break;
-		case LOGICALOP_INVERT:
+		case VK_LOGIC_OP_INVERT:
 			current.x = ~pixel.x;
 			current.y = ~pixel.y;
 			current.z = ~pixel.z;
 			break;
-		case LOGICALOP_AND:
+		case VK_LOGIC_OP_AND:
 			current.x = pixel.x & current.x;
 			current.y = pixel.y & current.y;
 			current.z = pixel.z & current.z;
 			break;
-		case LOGICALOP_NAND:
+		case VK_LOGIC_OP_NAND:
 			current.x = ~(pixel.x & current.x);
 			current.y = ~(pixel.y & current.y);
 			current.z = ~(pixel.z & current.z);
 			break;
-		case LOGICALOP_OR:
+		case VK_LOGIC_OP_OR:
 			current.x = pixel.x | current.x;
 			current.y = pixel.y | current.y;
 			current.z = pixel.z | current.z;
 			break;
-		case LOGICALOP_NOR:
+		case VK_LOGIC_OP_NOR:
 			current.x = ~(pixel.x | current.x);
 			current.y = ~(pixel.y | current.y);
 			current.z = ~(pixel.z | current.z);
 			break;
-		case LOGICALOP_XOR:
+		case VK_LOGIC_OP_XOR:
 			current.x = pixel.x ^ current.x;
 			current.y = pixel.y ^ current.y;
 			current.z = pixel.z ^ current.z;
 			break;
-		case LOGICALOP_EQUIV:
+		case VK_LOGIC_OP_EQUIVALENT:
 			current.x = ~(pixel.x ^ current.x);
 			current.y = ~(pixel.y ^ current.y);
 			current.z = ~(pixel.z ^ current.z);
 			break;
-		case LOGICALOP_AND_REVERSE:
+		case VK_LOGIC_OP_AND_REVERSE:
 			current.x = ~pixel.x & current.x;
 			current.y = ~pixel.y & current.y;
 			current.z = ~pixel.z & current.z;
 			break;
-		case LOGICALOP_AND_INVERTED:
+		case VK_LOGIC_OP_AND_INVERTED:
 			current.x = pixel.x & ~current.x;
 			current.y = pixel.y & ~current.y;
 			current.z = pixel.z & ~current.z;
 			break;
-		case LOGICALOP_OR_REVERSE:
+		case VK_LOGIC_OP_OR_REVERSE:
 			current.x = ~pixel.x | current.x;
 			current.y = ~pixel.y | current.y;
 			current.z = ~pixel.z | current.z;
 			break;
-		case LOGICALOP_OR_INVERTED:
+		case VK_LOGIC_OP_OR_INVERTED:
 			current.x = pixel.x | ~current.x;
 			current.y = pixel.y | ~current.y;
 			current.z = pixel.z | ~current.z;