Wire up texture swizzles

src/Device/Sampler.cpp

@@ -61,10 +61,7 @@ namespace sw
 		highPrecisionFiltering = false;
 		border = 0;
 
-		swizzleR = SWIZZLE_RED;
-		swizzleG = SWIZZLE_GREEN;
-		swizzleB = SWIZZLE_BLUE;
-		swizzleA = SWIZZLE_ALPHA;
+		swizzle = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
 
 		compare = COMPARE_BYPASS;
 
@@ -92,10 +89,7 @@ namespace sw
 			state.addressingModeW = getAddressingModeW();
 			state.mipmapFilter = mipmapFilter();
 			state.sRGB = (sRGB && textureFormat.isSRGBreadable()) || textureFormat.isSRGBformat();
-			state.swizzleR = swizzleR;
-			state.swizzleG = swizzleG;
-			state.swizzleB = swizzleB;
-			state.swizzleA = swizzleA;
+			state.swizzle = swizzle;
 			state.highPrecisionFiltering = highPrecisionFiltering;
 			state.compare = getCompareFunc();
 
@@ -318,26 +312,6 @@ namespace sw
 		this->highPrecisionFiltering = highPrecisionFiltering;
 	}
 
-	void Sampler::setSwizzleR(SwizzleType swizzleR)
-	{
-		this->swizzleR = swizzleR;
-	}
-
-	void Sampler::setSwizzleG(SwizzleType swizzleG)
-	{
-		this->swizzleG = swizzleG;
-	}
-
-	void Sampler::setSwizzleB(SwizzleType swizzleB)
-	{
-		this->swizzleB = swizzleB;
-	}
-
-	void Sampler::setSwizzleA(SwizzleType swizzleA)
-	{
-		this->swizzleA = swizzleA;
-	}
-
 	void Sampler::setCompareFunc(CompareFunc compare)
 	{
 		this->compare = compare;

src/Device/Sampler.hpp

@@ -160,10 +160,7 @@ namespace sw
 			AddressingMode addressingModeW;
 			MipmapType mipmapFilter;
 			bool sRGB;
-			SwizzleType swizzleR;
-			SwizzleType swizzleG;
-			SwizzleType swizzleB;
-			SwizzleType swizzleA;
+			VkComponentMapping swizzle;
 			bool highPrecisionFiltering;
 			CompareFunc compare;
 
@@ -190,10 +187,6 @@ namespace sw
 		void setBorderColor(const Color<float> &borderColor);
 		void setMaxAnisotropy(float maxAnisotropy);
 		void setHighPrecisionFiltering(bool highPrecisionFiltering);
-		void setSwizzleR(SwizzleType swizzleR);
-		void setSwizzleG(SwizzleType swizzleG);
-		void setSwizzleB(SwizzleType swizzleB);
-		void setSwizzleA(SwizzleType swizzleA);
 		void setCompareFunc(CompareFunc compare);
 		void setMinLod(float minLod);
 		void setMaxLod(float maxLod);
@@ -231,10 +224,7 @@ namespace sw
 		bool highPrecisionFiltering;
 		int border;
 
-		SwizzleType swizzleR;
-		SwizzleType swizzleG;
-		SwizzleType swizzleB;
-		SwizzleType swizzleA;
+		VkComponentMapping swizzle;
 		CompareFunc compare;
 
 		Texture texture;

src/Pipeline/SamplerCore.cpp

@@ -20,16 +20,16 @@
 
 namespace
 {
-	void applySwizzle(sw::SwizzleType swizzle, sw::Float4& f, const sw::Vector4f& c)
+	void applySwizzle(VkComponentSwizzle swizzle, sw::Float4& f, const sw::Vector4f& c)
 	{
 		switch(swizzle)
 		{
-		case sw::SWIZZLE_RED:	f = c.x; break;
-		case sw::SWIZZLE_GREEN: f = c.y; break;
-		case sw::SWIZZLE_BLUE:  f = c.z; break;
-		case sw::SWIZZLE_ALPHA: f = c.w; break;
-		case sw::SWIZZLE_ZERO:  f = sw::Float4(0.0f, 0.0f, 0.0f, 0.0f); break;
-		case sw::SWIZZLE_ONE:   f = sw::Float4(1.0f, 1.0f, 1.0f, 1.0f); break;
+		case VK_COMPONENT_SWIZZLE_R:	f = c.x; break;
+		case VK_COMPONENT_SWIZZLE_G: f = c.y; break;
+		case VK_COMPONENT_SWIZZLE_B:  f = c.z; break;
+		case VK_COMPONENT_SWIZZLE_A: f = c.w; break;
+		case VK_COMPONENT_SWIZZLE_ZERO:  f = sw::Float4(0.0f, 0.0f, 0.0f, 0.0f); break;
+		case VK_COMPONENT_SWIZZLE_ONE:   f = sw::Float4(1.0f, 1.0f, 1.0f, 1.0f); break;
 		default: ASSERT(false);
 		}
 	}
@@ -196,16 +196,16 @@ namespace sw
 			}
 		}
 
-		if((state.swizzleR != SWIZZLE_RED) ||
-			(state.swizzleG != SWIZZLE_GREEN) ||
-			(state.swizzleB != SWIZZLE_BLUE) ||
-			(state.swizzleA != SWIZZLE_ALPHA))
+		if((state.swizzle.r != VK_COMPONENT_SWIZZLE_R) ||
+			(state.swizzle.g != VK_COMPONENT_SWIZZLE_G) ||
+			(state.swizzle.b != VK_COMPONENT_SWIZZLE_B) ||
+			(state.swizzle.a != VK_COMPONENT_SWIZZLE_A))
 		{
 			const Vector4f col(c);
-			applySwizzle(state.swizzleR, c.x, col);
-			applySwizzle(state.swizzleG, c.y, col);
-			applySwizzle(state.swizzleB, c.z, col);
-			applySwizzle(state.swizzleA, c.w, col);
+			applySwizzle(state.swizzle.r, c.x, col);
+			applySwizzle(state.swizzle.g, c.y, col);
+			applySwizzle(state.swizzle.b, c.z, col);
+			applySwizzle(state.swizzle.a, c.w, col);
 		}
 
 		return c;

src/Pipeline/SpirvShaderSampling.cpp

@@ -90,10 +90,7 @@ void SpirvShader::emitSamplerFunction(
 	samplerState.addressingModeW = convertAddressingMode(sampler->addressModeW);
 	samplerState.mipmapFilter = convertMipmapMode(sampler);
 	samplerState.sRGB = false;                              ASSERT(imageView->getFormat().isSRGBformat() == false);  // TODO(b/129523279)
-	samplerState.swizzleR = SWIZZLE_RED;                    ASSERT(imageView->getComponentMapping().r == VK_COMPONENT_SWIZZLE_R);  // TODO(b/129523279)
-	samplerState.swizzleG = SWIZZLE_GREEN;                  ASSERT(imageView->getComponentMapping().g == VK_COMPONENT_SWIZZLE_G);  // TODO(b/129523279)
-	samplerState.swizzleB = SWIZZLE_BLUE;                   ASSERT(imageView->getComponentMapping().b == VK_COMPONENT_SWIZZLE_B);  // TODO(b/129523279)
-	samplerState.swizzleA = SWIZZLE_ALPHA;                  ASSERT(imageView->getComponentMapping().a == VK_COMPONENT_SWIZZLE_A);  // TODO(b/129523279)
+	samplerState.swizzle = imageView->getComponentMapping();
 	samplerState.highPrecisionFiltering = false;
 	samplerState.compare = COMPARE_BYPASS;                  ASSERT(sampler->compareEnable == VK_FALSE);  // TODO(b/129523279)