diff --git a/src/Device/Blitter.cpp b/src/Device/Blitter.cpp
index f6b483e..198f108 100644
--- a/src/Device/Blitter.cpp
+++ b/src/Device/Blitter.cpp
@@ -257,9 +257,9 @@
 		return true;
 	}
 
-	bool Blitter::read(Float4 &c, Pointer<Byte> element, const State &state)
+	Float4 Blitter::readFloat4(Pointer<Byte> element, const State &state)
 	{
-		c = Float4(0.0f, 0.0f, 0.0f, 1.0f);
+		Float4 c(0.0f, 0.0f, 0.0f, 1.0f);
 
 		switch(state.sourceFormat)
 		{
@@ -448,13 +448,13 @@
 			c.x = Float(Int(*Pointer<Byte>(element)));
 			break;
 		default:
-			return false;
+			UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 		}
 
-		return true;
+		return c;
 	}
 
-	bool Blitter::write(Float4 &c, Pointer<Byte> element, const State &state)
+	void Blitter::write(Float4 &c, Pointer<Byte> element, const State &state)
 	{
 		bool writeR = state.writeRed;
 		bool writeG = state.writeGreen;
@@ -983,14 +983,14 @@
 			*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
 			break;
 		default:
-			return false;
+			UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
+			break;
 		}
-		return true;
 	}
 
-	bool Blitter::read(Int4 &c, Pointer<Byte> element, const State &state)
+	Int4 Blitter::readInt4(Pointer<Byte> element, const State &state)
 	{
-		c = Int4(0, 0, 0, 1);
+		Int4 c(0, 0, 0, 1);
 
 		switch(state.sourceFormat)
 		{
@@ -1046,13 +1046,13 @@
 			c = Insert(c, *Pointer<Int>(element), 0);
 			break;
 		default:
-			return false;
+			UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 		}
 
-		return true;
+		return c;
 	}
 
-	bool Blitter::write(Int4 &c, Pointer<Byte> element, const State &state)
+	void Blitter::write(Int4 &c, Pointer<Byte> element, const State &state)
 	{
 		bool writeR = state.writeRed;
 		bool writeG = state.writeGreen;
@@ -1273,15 +1273,14 @@
 			if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
 			break;
 		default:
-			return false;
+			UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
 		}
-
-		return true;
 	}
 
-	bool Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
+	void Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
 	{
 		float4 scale, unscale;
+
 		if(state.clearOperation &&
 		   state.sourceFormat.isNonNormalizedInteger() &&
 		   !state.destFormat.isNonNormalizedInteger())
@@ -1297,18 +1296,15 @@
 				unscale = replicate(static_cast<float>(0xFFFFFFFF));
 				break;
 			default:
-				return false;
+				UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 			}
 		}
-		else if(!state.sourceFormat.getScale(unscale))
+		else
 		{
-			return false;
+			unscale = state.sourceFormat.getScale();
 		}
 
-		if(!state.destFormat.getScale(scale))
-		{
-			return false;
-		}
+		scale = state.destFormat.getScale();
 
 		bool srcSRGB = state.sourceFormat.isSRGBformat();
 		bool dstSRGB = state.destFormat.isSRGBformat();
@@ -1334,8 +1330,6 @@
 			                          state.destFormat.isUnsignedComponent(2) ? 0.0f : -scale.z,
 			                          state.destFormat.isUnsignedComponent(3) ? 0.0f : -scale.w));
 		}
-
-		return true;
 	}
 
 	Int Blitter::ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout)
@@ -1416,24 +1410,15 @@
 			{
 				if(intBoth) // Integer types
 				{
-					if(!read(constantColorI, source, state))
-					{
-						return nullptr;
-					}
+					constantColorI = readInt4(source, state);
 					hasConstantColorI = true;
 				}
 				else
 				{
-					if(!read(constantColorF, source, state))
-					{
-						return nullptr;
-					}
+					constantColorF = readFloat4(source, state);
 					hasConstantColorF = true;
 
-					if(!ApplyScaleAndClamp(constantColorF, state))
-					{
-						return nullptr;
-					}
+					ApplyScaleAndClamp(constantColorF, state);
 				}
 			}
 
@@ -1449,26 +1434,19 @@
 
 					if(hasConstantColorI)
 					{
-						if(!write(constantColorI, d, state))
-						{
-							return nullptr;
-						}
+						write(constantColorI, d, state);
 					}
 					else if(hasConstantColorF)
 					{
 						for(int s = 0; s < state.destSamples; s++)
 						{
-							if(!write(constantColorF, d, state))
-							{
-								return nullptr;
-							}
+							write(constantColorF, d, state);
 
 							d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
 						}
 					}
 					else if(intBoth) // Integer types do not support filtering
 					{
-						Int4 color; // When both formats are true integer types, we don't go to float to avoid losing precision
 						Int X = Int(x);
 						Int Y = Int(y);
 
@@ -1480,15 +1458,9 @@
 
 						Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
 
-						if(!read(color, s, state))
-						{
-							return nullptr;
-						}
-
-						if(!write(color, d, state))
-						{
-							return nullptr;
-						}
+						// When both formats are true integer types, we don't go to float to avoid losing precision
+						Int4 color = readInt4(s, state);
+						write(color, d, state);
 					}
 					else
 					{
@@ -1508,29 +1480,24 @@
 
 							Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
 
-							if(!read(color, s, state))
-							{
-								return nullptr;
-							}
+							color = readFloat4(s, state);
 
 							if(state.srcSamples > 1) // Resolve multisampled source
 							{
 								if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
 								{
-									if(!ApplyScaleAndClamp(color, state)) return nullptr;
+									ApplyScaleAndClamp(color, state);
 									preScaled = true;
 								}
 								Float4 accum = color;
 								for(int sample = 1; sample < state.srcSamples; sample++)
 								{
 									s += *Pointer<Int>(blit + OFFSET(BlitData, sSliceB));
-									if(!read(color, s, state))
-									{
-										return nullptr;
-									}
+									color = readFloat4(s, state);
+
 									if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
 									{
-										if(!ApplyScaleAndClamp(color, state)) return nullptr;
+										ApplyScaleAndClamp(color, state);
 										preScaled = true;
 									}
 									accum += color;
@@ -1565,17 +1532,17 @@
 							Pointer<Byte> s10 = source + ComputeOffset(X0, Y1, sPitchB, srcBytes, srcQuadLayout);
 							Pointer<Byte> s11 = source + ComputeOffset(X1, Y1, sPitchB, srcBytes, srcQuadLayout);
 
-							Float4 c00; if(!read(c00, s00, state)) return nullptr;
-							Float4 c01; if(!read(c01, s01, state)) return nullptr;
-							Float4 c10; if(!read(c10, s10, state)) return nullptr;
-							Float4 c11; if(!read(c11, s11, state)) return nullptr;
+							Float4 c00 = readFloat4(s00, state);
+							Float4 c01 = readFloat4(s01, state);
+							Float4 c10 = readFloat4(s10, state);
+							Float4 c11 = readFloat4(s11, state);
 
 							if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
 							{
-								if(!ApplyScaleAndClamp(c00, state)) return nullptr;
-								if(!ApplyScaleAndClamp(c01, state)) return nullptr;
-								if(!ApplyScaleAndClamp(c10, state)) return nullptr;
-								if(!ApplyScaleAndClamp(c11, state)) return nullptr;
+								ApplyScaleAndClamp(c00, state);
+								ApplyScaleAndClamp(c01, state);
+								ApplyScaleAndClamp(c10, state);
+								ApplyScaleAndClamp(c11, state);
 								preScaled = true;
 							}
 
@@ -1588,17 +1555,11 @@
 							        (c10 * ix + c11 * fx) * fy;
 						}
 
-						if(!ApplyScaleAndClamp(color, state, preScaled))
-						{
-							return nullptr;
-						}
+						ApplyScaleAndClamp(color, state, preScaled);
 
 						for(int s = 0; s < state.destSamples; s++)
 						{
-							if(!write(color, d, state))
-							{
-								return nullptr;
-							}
+							write(color, d, state);
 
 							d += *Pointer<Int>(blit + OFFSET(BlitData,dSliceB));
 						}
@@ -1618,13 +1579,6 @@
 		if(!blitRoutine)
 		{
 			blitRoutine = generate(state);
-
-			if(!blitRoutine)
-			{
-				UNIMPLEMENTED("blitRoutine");
-				return nullptr;
-			}
-
 			blitCache.add(state, blitRoutine);
 		}
 
@@ -1639,13 +1593,6 @@
 		if(!cornerUpdateRoutine)
 		{
 			cornerUpdateRoutine = generateCornerUpdate(state);
-
-			if(!cornerUpdateRoutine)
-			{
-				UNIMPLEMENTED("cornerUpdateRoutine");
-				return nullptr;
-			}
-
 			cornerUpdateCache.add(state, cornerUpdateRoutine);
 		}
 
@@ -1918,15 +1865,13 @@
 		int bytes = state.sourceFormat.bytes();
 		bool quadLayout = state.sourceFormat.hasQuadLayout();
 
-		Float4 c0;
-		read(c0, layer + ComputeOffset(x0, y1, pitchB, bytes, quadLayout), state);
-		Float4 c1;
-		read(c1, layer + ComputeOffset(x1, y0, pitchB, bytes, quadLayout), state);
-		c0 += c1;
-		read(c1, layer + ComputeOffset(x1, y1, pitchB, bytes, quadLayout), state);
-		c0 += c1;
-		c0 *= Float4(1.0f / 3.0f);
-		write(c0, layer + ComputeOffset(x0, y0, pitchB, bytes, quadLayout), state);
+		Float4 c = readFloat4(layer + ComputeOffset(x0, y1, pitchB, bytes, quadLayout), state) +
+		           readFloat4(layer + ComputeOffset(x1, y0, pitchB, bytes, quadLayout), state) +
+		           readFloat4(layer + ComputeOffset(x1, y1, pitchB, bytes, quadLayout), state);
+
+		c *= Float4(1.0f / 3.0f);
+
+		write(c, layer + ComputeOffset(x0, y0, pitchB, bytes, quadLayout), state);
 	}
 
 	std::shared_ptr<Routine> Blitter::generateCornerUpdate(const State& state)
@@ -2082,7 +2027,7 @@
 		int h = extent.height;
 		if(w != h)
 		{
-			UNIMPLEMENTED("Cube doesn't have square faces : (%d, %d)", w, h);
+			UNSUPPORTED("Cube doesn't have square faces : (%d, %d)", w, h);
 		}
 
 		// Src is expressed in the regular [0, width-1], [0, height-1] space
diff --git a/src/Device/Blitter.hpp b/src/Device/Blitter.hpp
index c8cddf3..849bcc2 100644
--- a/src/Device/Blitter.hpp
+++ b/src/Device/Blitter.hpp
@@ -126,11 +126,11 @@
 
 		bool fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea);
 
-		bool read(Float4 &color, Pointer<Byte> element, const State &state);
-		bool write(Float4 &color, Pointer<Byte> element, const State &state);
-		bool read(Int4 &color, Pointer<Byte> element, const State &state);
-		bool write(Int4 &color, Pointer<Byte> element, const State &state);
-		static bool ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
+		Float4 readFloat4(Pointer<Byte> element, const State &state);
+		void write(Float4 &color, Pointer<Byte> element, const State &state);
+		Int4 readInt4(Pointer<Byte> element, const State &state);
+		void write(Int4 &color, Pointer<Byte> element, const State &state);
+		static void ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
 		static Int ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout);
 		static Float4 LinearToSRGB(Float4 &color);
 		static Float4 sRGBtoLinear(Float4 &color);
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index 7bf902e..9ada8ee 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -3508,6 +3508,18 @@
 		return T(Type_v2f32);
 	}
 
+	RValue<Float> Exp2(RValue<Float> v)
+	{
+		auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::exp2, { T(Float::getType()) } );
+		return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
+	}
+
+	RValue<Float> Log2(RValue<Float> v)
+	{
+		auto func = llvm::Intrinsic::getDeclaration(jit->module.get(), llvm::Intrinsic::log2, { T(Float::getType()) } );
+		return RValue<Float>(V(jit->builder->CreateCall(func, V(v.value))));
+	}
+
 	Float4::Float4(RValue<Float> rhs) : XYZW(this)
 	{
 		RR_DEBUG_INFO_UPDATE_LOC();
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index d6a2f4a..d269fec 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -2092,11 +2092,38 @@
 	RValue<Float> Rcp_pp(RValue<Float> val, bool exactAtPow2 = false);
 	RValue<Float> RcpSqrt_pp(RValue<Float> val);
 	RValue<Float> Sqrt(RValue<Float> x);
-	RValue<Float> Round(RValue<Float> val);
-	RValue<Float> Trunc(RValue<Float> val);
-	RValue<Float> Frac(RValue<Float> val);
-	RValue<Float> Floor(RValue<Float> val);
-	RValue<Float> Ceil(RValue<Float> val);
+
+//	RValue<Int4> IsInf(RValue<Float> x);
+//	RValue<Int4> IsNan(RValue<Float> x);
+	RValue<Float> Round(RValue<Float> x);
+	RValue<Float> Trunc(RValue<Float> x);
+	RValue<Float> Frac(RValue<Float> x);
+	RValue<Float> Floor(RValue<Float> x);
+	RValue<Float> Ceil(RValue<Float> x);
+
+	// Trigonometric functions
+	// TODO: Currently unimplemented for Subzero.
+//	RValue<Float> Sin(RValue<Float> x);
+//	RValue<Float> Cos(RValue<Float> x);
+//	RValue<Float> Tan(RValue<Float> x);
+//	RValue<Float> Asin(RValue<Float> x);
+//	RValue<Float> Acos(RValue<Float> x);
+//	RValue<Float> Atan(RValue<Float> x);
+//	RValue<Float> Sinh(RValue<Float> x);
+//	RValue<Float> Cosh(RValue<Float> x);
+//	RValue<Float> Tanh(RValue<Float> x);
+//	RValue<Float> Asinh(RValue<Float> x);
+//	RValue<Float> Acosh(RValue<Float> x);
+//	RValue<Float> Atanh(RValue<Float> x);
+//	RValue<Float> Atan2(RValue<Float> x, RValue<Float> y);
+
+	// Exponential functions
+	// TODO: Currently unimplemented for Subzero.
+//	RValue<Float> Pow(RValue<Float> x, RValue<Float> y);
+//	RValue<Float> Exp(RValue<Float> x);
+//	RValue<Float> Log(RValue<Float> x);
+	RValue<Float> Exp2(RValue<Float> x);
+	RValue<Float> Log2(RValue<Float> x);
 
 	class Float2 : public LValue<Float2>
 	{
@@ -2264,7 +2291,7 @@
 	RValue<Float4> Ceil(RValue<Float4> x);
 
 	// Trigonometric functions
-	// TODO: Currentlhy unimplemented for Subzero.
+	// TODO: Currently unimplemented for Subzero.
 	RValue<Float4> Sin(RValue<Float4> x);
 	RValue<Float4> Cos(RValue<Float4> x);
 	RValue<Float4> Tan(RValue<Float4> x);
@@ -2280,7 +2307,7 @@
 	RValue<Float4> Atan2(RValue<Float4> x, RValue<Float4> y);
 
 	// Exponential functions
-	// TODO: Currentlhy unimplemented for Subzero.
+	// TODO: Currently unimplemented for Subzero.
 	RValue<Float4> Pow(RValue<Float4> x, RValue<Float4> y);
 	RValue<Float4> Exp(RValue<Float4> x);
 	RValue<Float4> Log(RValue<Float4> x);
@@ -2288,7 +2315,7 @@
 	RValue<Float4> Log2(RValue<Float4> x);
 
 	// Bit Manipulation functions.
-	// TODO: Currentlhy unimplemented for Subzero.
+	// TODO: Currently unimplemented for Subzero.
 
 	// Count leading zeros.
 	// Returns 32 when: isZeroUndef && x == 0.
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index a1894ce..2099688 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -3522,6 +3522,8 @@
 	void Nucleus::createMaskedStore(Value *ptr, Value *val, Value *mask, unsigned int alignment) { UNIMPLEMENTED("Subzero createMaskedStore()"); }
 	Value *Nucleus::createGather(Value *base, Type *elTy, Value *offsets, Value *mask, unsigned int alignment, bool zeroMaskedLanes) { UNIMPLEMENTED("Subzero createGather()"); return nullptr; }
 	void Nucleus::createScatter(Value *base, Value *val, Value *offsets, Value *mask, unsigned int alignment) { UNIMPLEMENTED("Subzero createScatter()"); }
+	RValue<Float> Exp2(RValue<Float> x) { UNIMPLEMENTED("Subzero Exp2()"); return Float(0); }
+	RValue<Float> Log2(RValue<Float> x) { UNIMPLEMENTED("Subzero Log2()"); return Float(0); }
 	RValue<Float4> Sin(RValue<Float4> x) { UNIMPLEMENTED("Subzero Sin()"); return Float4(0); }
 	RValue<Float4> Cos(RValue<Float4> x) { UNIMPLEMENTED("Subzero Cos()"); return Float4(0); }
 	RValue<Float4> Tan(RValue<Float4> x) { UNIMPLEMENTED("Subzero Tan()"); return Float4(0); }
diff --git a/src/Vulkan/VkFormat.cpp b/src/Vulkan/VkFormat.cpp
index 9dad667..e980ea3 100644
--- a/src/Vulkan/VkFormat.cpp
+++ b/src/Vulkan/VkFormat.cpp
@@ -1724,15 +1724,14 @@
 	return sw::align<16>(sliceBUnpadded(width, height, border, target) + 15);
 }
 
-bool Format::getScale(sw::float4 &scale) const
+sw::float4 Format::getScale() const
 {
 	switch(format)
 	{
 	case VK_FORMAT_R4G4_UNORM_PACK8:
 	case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
 	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-		scale = sw::vector(0xF, 0xF, 0xF, 0xF);
-		break;
+		return sw::vector(0xF, 0xF, 0xF, 0xF);
 	case VK_FORMAT_R8_UNORM:
 	case VK_FORMAT_R8G8_UNORM:
 	case VK_FORMAT_R8G8B8_UNORM:
@@ -1747,8 +1746,7 @@
 	case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
 	case VK_FORMAT_R8G8B8A8_SRGB:
 	case VK_FORMAT_B8G8R8A8_SRGB:
-		scale = sw::vector(0xFF, 0xFF, 0xFF, 0xFF);
-		break;
+		return sw::vector(0xFF, 0xFF, 0xFF, 0xFF);
 	case VK_FORMAT_R8_SNORM:
 	case VK_FORMAT_R8G8_SNORM:
 	case VK_FORMAT_R8G8B8_SNORM:
@@ -1756,20 +1754,17 @@
 	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
 	case VK_FORMAT_R8G8B8A8_SNORM:
 	case VK_FORMAT_B8G8R8A8_SNORM:
-		scale = sw::vector(0x7F, 0x7F, 0x7F, 0x7F);
-		break;
+		return sw::vector(0x7F, 0x7F, 0x7F, 0x7F);
 	case VK_FORMAT_R16_UNORM:
 	case VK_FORMAT_R16G16_UNORM:
 	case VK_FORMAT_R16G16B16_UNORM:
 	case VK_FORMAT_R16G16B16A16_UNORM:
-		scale = sw::vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
-		break;
+		return sw::vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
 	case VK_FORMAT_R16_SNORM:
 	case VK_FORMAT_R16G16_SNORM:
 	case VK_FORMAT_R16G16B16_SNORM:
 	case VK_FORMAT_R16G16B16A16_SNORM:
-		scale = sw::vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
-		break;
+		return sw::vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
 	case VK_FORMAT_R8_SINT:
 	case VK_FORMAT_R8_UINT:
 	case VK_FORMAT_R8G8_SINT:
@@ -1838,42 +1833,35 @@
 	case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
 	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
 	case VK_FORMAT_A2B10G10R10_SINT_PACK32:
-		scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
-		break;
+		return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
 	case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
 	case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
 	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-		scale = sw::vector(0x1F, 0x1F, 0x1F, 0x01);
-		break;
+		return sw::vector(0x1F, 0x1F, 0x1F, 0x01);
 	case VK_FORMAT_R5G6B5_UNORM_PACK16:
 	case VK_FORMAT_B5G6R5_UNORM_PACK16:
-		scale = sw::vector(0x1F, 0x3F, 0x1F, 1.0f);
-		break;
+		return sw::vector(0x1F, 0x3F, 0x1F, 1.0f);
 	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
 	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
-		scale = sw::vector(0x3FF, 0x3FF, 0x3FF, 0x03);
-		break;
+		return sw::vector(0x3FF, 0x3FF, 0x3FF, 0x03);
 	case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
 	case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
-		scale = sw::vector(0x1FF, 0x1FF, 0x1FF, 0x01);
-		break;
+		return sw::vector(0x1FF, 0x1FF, 0x1FF, 0x01);
 	case VK_FORMAT_D16_UNORM:
-		scale = sw::vector(0xFFFF, 0.0f, 0.0f, 0.0f);
-		break;
+		return sw::vector(0xFFFF, 0.0f, 0.0f, 0.0f);
 	case VK_FORMAT_D24_UNORM_S8_UINT:
 	case VK_FORMAT_X8_D24_UNORM_PACK32:
-		scale = sw::vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
-		break;
+		return sw::vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
 	case VK_FORMAT_D32_SFLOAT:
 	case VK_FORMAT_D32_SFLOAT_S8_UINT:
 	case VK_FORMAT_S8_UINT:
-		scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
-		break;
+		return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
 	default:
-		return false;
+		UNSUPPORTED("format %d", int(format));
+		break;
 	}
 
-	return true;
+	return sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
 }
 
 bool Format::has16bitTextureFormat() const
diff --git a/src/Vulkan/VkFormat.h b/src/Vulkan/VkFormat.h
index 15385f4..8770c39 100644
--- a/src/Vulkan/VkFormat.h
+++ b/src/Vulkan/VkFormat.h
@@ -60,7 +60,7 @@
 	int pitchB(int width, int border, bool target) const;
 	int sliceB(int width, int height, int border, bool target) const;
 
-	bool getScale(sw::float4 &scale) const;
+	sw::float4 getScale() const;
 
 	// Texture sampling utilities
 	bool has16bitTextureFormat() const;