diff --git a/src/Device/BC_Decoder.cpp b/src/Device/BC_Decoder.cpp
index f14d871..f29b839 100644
--- a/src/Device/BC_Decoder.cpp
+++ b/src/Device/BC_Decoder.cpp
@@ -14,206 +14,205 @@
 
 #include "BC_Decoder.hpp"
 
-namespace
+namespace {
+static constexpr int BlockWidth = 4;
+static constexpr int BlockHeight = 4;
+
+struct BC_color
 {
-	static constexpr int BlockWidth = 4;
-	static constexpr int BlockHeight = 4;
-
-	struct BC_color
+	void decode(unsigned char *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, bool hasAlphaChannel, bool hasSeparateAlpha) const
 	{
-		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, bool hasAlphaChannel, bool hasSeparateAlpha) const
+		Color c[4];
+		c[0].extract565(c0);
+		c[1].extract565(c1);
+		if(hasSeparateAlpha || (c0 > c1))
 		{
-			Color c[4];
-			c[0].extract565(c0);
-			c[1].extract565(c1);
-			if(hasSeparateAlpha || (c0 > c1))
+			c[2] = ((c[0] * 2) + c[1]) / 3;
+			c[3] = ((c[1] * 2) + c[0]) / 3;
+		}
+		else
+		{
+			c[2] = (c[0] + c[1]) >> 1;
+			if(hasAlphaChannel)
 			{
-				c[2] = ((c[0] * 2) + c[1]) / 3;
-				c[3] = ((c[1] * 2) + c[0]) / 3;
+				c[3].clearAlpha();
 			}
-			else
-			{
-				c[2] = (c[0] + c[1]) >> 1;
-				if(hasAlphaChannel)
-				{
-					c[3].clearAlpha();
-				}
-			}
+		}
 
-			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
+		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
+		{
+			int dstOffset = j * dstPitch;
+			int idxOffset = j * BlockHeight;
+			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, idxOffset++, dstOffset += dstBpp)
 			{
-				int dstOffset = j * dstPitch;
-				int idxOffset = j * BlockHeight;
-				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, idxOffset++, dstOffset += dstBpp)
-				{
-					*reinterpret_cast<unsigned int*>(dst + dstOffset) = c[getIdx(idxOffset)].pack8888();
-				}
+				*reinterpret_cast<unsigned int *>(dst + dstOffset) = c[getIdx(idxOffset)].pack8888();
 			}
 		}
+	}
+
+private:
+	struct Color
+	{
+		Color()
+		{
+			c[0] = c[1] = c[2] = 0;
+			c[3] = 0xFF000000;
+		}
+
+		void extract565(const unsigned int c565)
+		{
+			c[0] = ((c565 & 0x0000001F) << 3) | ((c565 & 0x0000001C) >> 2);
+			c[1] = ((c565 & 0x000007E0) >> 3) | ((c565 & 0x00000600) >> 9);
+			c[2] = ((c565 & 0x0000F800) >> 8) | ((c565 & 0x0000E000) >> 13);
+		}
+
+		unsigned int pack8888() const
+		{
+			return ((c[2] & 0xFF) << 16) | ((c[1] & 0xFF) << 8) | (c[0] & 0xFF) | c[3];
+		}
+
+		void clearAlpha()
+		{
+			c[3] = 0;
+		}
+
+		Color operator*(int factor) const
+		{
+			Color res;
+			for(int i = 0; i < 4; ++i)
+			{
+				res.c[i] = c[i] * factor;
+			}
+			return res;
+		}
+
+		Color operator/(int factor) const
+		{
+			Color res;
+			for(int i = 0; i < 4; ++i)
+			{
+				res.c[i] = c[i] / factor;
+			}
+			return res;
+		}
+
+		Color operator>>(int shift) const
+		{
+			Color res;
+			for(int i = 0; i < 4; ++i)
+			{
+				res.c[i] = c[i] >> shift;
+			}
+			return res;
+		}
+
+		Color operator+(Color const &obj) const
+		{
+			Color res;
+			for(int i = 0; i < 4; ++i)
+			{
+				res.c[i] = c[i] + obj.c[i];
+			}
+			return res;
+		}
 
 	private:
-		struct Color
-		{
-			Color()
-			{
-				c[0] = c[1] = c[2] = 0;
-				c[3] = 0xFF000000;
-			}
-
-			void extract565(const unsigned int c565)
-			{
-				c[0] = ((c565 & 0x0000001F) << 3) | ((c565 & 0x0000001C) >> 2);
-				c[1] = ((c565 & 0x000007E0) >> 3) | ((c565 & 0x00000600) >> 9);
-				c[2] = ((c565 & 0x0000F800) >> 8) | ((c565 & 0x0000E000) >> 13);
-			}
-
-			unsigned int pack8888() const
-			{
-				return ((c[2] & 0xFF) << 16) | ((c[1] & 0xFF) << 8) | (c[0] & 0xFF) | c[3];
-			}
-
-			void clearAlpha()
-			{
-				c[3] = 0;
-			}
-
-			Color operator*(int factor) const
-			{
-				Color res;
-				for(int i = 0; i < 4; ++i)
-				{
-					res.c[i] = c[i] * factor;
-				}
-				return res;
-			}
-
-			Color operator/(int factor) const
-			{
-				Color res;
-				for(int i = 0; i < 4; ++i)
-				{
-					res.c[i] = c[i] / factor;
-				}
-				return res;
-			}
-
-			Color operator>>(int shift) const
-			{
-				Color res;
-				for(int i = 0; i < 4; ++i)
-				{
-					res.c[i] = c[i] >> shift;
-				}
-				return res;
-			}
-
-			Color operator+(Color const& obj) const
-			{
-				Color res;
-				for(int i = 0; i < 4; ++i)
-				{
-					res.c[i] = c[i] + obj.c[i];
-				}
-				return res;
-			}
-
-		private:
-			int c[4];
-		};
-
-		unsigned int getIdx(int i) const
-		{
-			int offset = i << 1; // 2 bytes per index
-			return (idx & (0x3 << offset)) >> offset;
-		}
-
-		unsigned short c0;
-		unsigned short c1;
-		unsigned int idx;
+		int c[4];
 	};
 
-	struct BC_channel
+	unsigned int getIdx(int i) const
 	{
-		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, int channel, bool isSigned) const
-		{
-			int c[8] = { 0 };
+		int offset = i << 1;  // 2 bytes per index
+		return (idx & (0x3 << offset)) >> offset;
+	}
 
-			if(isSigned)
-			{
-				c[0] = static_cast<signed char>(data & 0xFF);
-				c[1] = static_cast<signed char>((data & 0xFF00) >> 8);
-			}
-			else
-			{
-				c[0] = static_cast<unsigned char>(data & 0xFF);
-				c[1] = static_cast<unsigned char>((data & 0xFF00) >> 8);
-			}
+	unsigned short c0;
+	unsigned short c1;
+	unsigned int idx;
+};
 
-			if(c[0] > c[1])
-			{
-				for(int i = 2; i < 8; ++i)
-				{
-					c[i] = ((8 - i) * c[0] + (i - 1) * c[1]) / 7;
-				}
-			}
-			else
-			{
-				for(int i = 2; i < 6; ++i)
-				{
-					c[i] = ((6 - i) * c[0] + (i - 1) * c[1]) / 5;
-				}
-				c[6] = isSigned ? -128 : 0;
-				c[7] = isSigned ? 127 : 255;
-			}
-
-			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
-			{
-				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++)
-				{
-					dst[channel + (i * dstBpp) + (j * dstPitch)] = static_cast<unsigned char>(c[getIdx((j * BlockHeight) + i)]);
-				}
-			}
-		}
-
-	private:
-		unsigned char getIdx(int i) const
-		{
-			int offset = i * 3 + 16;
-			return static_cast<unsigned char>((data & (0x7ull << offset)) >> offset);
-		}
-
-		unsigned long long data;
-	};
-
-	struct BC_alpha
+struct BC_channel
+{
+	void decode(unsigned char *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, int channel, bool isSigned) const
 	{
-		void decode(unsigned char* dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp) const
+		int c[8] = { 0 };
+
+		if(isSigned)
 		{
-			dst += 3; // Write only to alpha (channel 3)
-			for(int j = 0; j < BlockHeight && (y + j) < dstH; j++, dst += dstPitch)
+			c[0] = static_cast<signed char>(data & 0xFF);
+			c[1] = static_cast<signed char>((data & 0xFF00) >> 8);
+		}
+		else
+		{
+			c[0] = static_cast<unsigned char>(data & 0xFF);
+			c[1] = static_cast<unsigned char>((data & 0xFF00) >> 8);
+		}
+
+		if(c[0] > c[1])
+		{
+			for(int i = 2; i < 8; ++i)
 			{
-				unsigned char* dstRow = dst;
-				for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, dstRow += dstBpp)
-				{
-					*dstRow = getAlpha(j * BlockHeight + i);
-				}
+				c[i] = ((8 - i) * c[0] + (i - 1) * c[1]) / 7;
 			}
 		}
-
-	private:
-		unsigned char getAlpha(int i) const
+		else
 		{
-			int offset = i << 2;
-			int alpha = (data & (0xFull << offset)) >> offset;
-			return static_cast<unsigned char>(alpha | (alpha << 4));
+			for(int i = 2; i < 6; ++i)
+			{
+				c[i] = ((6 - i) * c[0] + (i - 1) * c[1]) / 5;
+			}
+			c[6] = isSigned ? -128 : 0;
+			c[7] = isSigned ? 127 : 255;
 		}
 
-		unsigned long long data;
-	};
-} // end namespace
+		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
+		{
+			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++)
+			{
+				dst[channel + (i * dstBpp) + (j * dstPitch)] = static_cast<unsigned char>(c[getIdx((j * BlockHeight) + i)]);
+			}
+		}
+	}
+
+private:
+	unsigned char getIdx(int i) const
+	{
+		int offset = i * 3 + 16;
+		return static_cast<unsigned char>((data & (0x7ull << offset)) >> offset);
+	}
+
+	unsigned long long data;
+};
+
+struct BC_alpha
+{
+	void decode(unsigned char *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp) const
+	{
+		dst += 3;  // Write only to alpha (channel 3)
+		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++, dst += dstPitch)
+		{
+			unsigned char *dstRow = dst;
+			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, dstRow += dstBpp)
+			{
+				*dstRow = getAlpha(j * BlockHeight + i);
+			}
+		}
+	}
+
+private:
+	unsigned char getAlpha(int i) const
+	{
+		int offset = i << 2;
+		int alpha = (data & (0xFull << offset)) >> offset;
+		return static_cast<unsigned char>(alpha | (alpha << 4));
+	}
+
+	unsigned long long data;
+};
+}  // end namespace
 
 // Decodes 1 to 4 channel images to 8 bit output
-bool BC_Decoder::Decode(const unsigned char* src, unsigned char* dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, int n, bool isNoAlphaU)
+bool BC_Decoder::Decode(const unsigned char *src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, int n, bool isNoAlphaU)
 {
 	static_assert(sizeof(BC_color) == 8, "BC_color must be 8 bytes");
 	static_assert(sizeof(BC_channel) == 8, "BC_channel must be 8 bytes");
@@ -226,12 +225,12 @@
 
 	switch(n)
 	{
-	case 1: // BC1
+		case 1:  // BC1
 		{
-			const BC_color* color = reinterpret_cast<const BC_color*>(src);
+			const BC_color *color = reinterpret_cast<const BC_color *>(src);
 			for(int y = 0; y < h; y += BlockHeight, dst += dy)
 			{
-				unsigned char* dstRow = dst;
+				unsigned char *dstRow = dst;
 				for(int x = 0; x < w; x += BlockWidth, ++color, dstRow += dx)
 				{
 					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, false);
@@ -239,13 +238,13 @@
 			}
 		}
 		break;
-	case 2: // BC2
+		case 2:  // BC2
 		{
-			const BC_alpha* alpha = reinterpret_cast<const BC_alpha*>(src);
-			const BC_color* color = reinterpret_cast<const BC_color*>(src + 8);
+			const BC_alpha *alpha = reinterpret_cast<const BC_alpha *>(src);
+			const BC_color *color = reinterpret_cast<const BC_color *>(src + 8);
 			for(int y = 0; y < h; y += BlockHeight, dst += dy)
 			{
-				unsigned char* dstRow = dst;
+				unsigned char *dstRow = dst;
 				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
 				{
 					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, true);
@@ -254,13 +253,13 @@
 			}
 		}
 		break;
-	case 3: // BC3
+		case 3:  // BC3
 		{
-			const BC_channel* alpha = reinterpret_cast<const BC_channel*>(src);
-			const BC_color* color = reinterpret_cast<const BC_color*>(src + 8);
+			const BC_channel *alpha = reinterpret_cast<const BC_channel *>(src);
+			const BC_color *color = reinterpret_cast<const BC_color *>(src + 8);
 			for(int y = 0; y < h; y += BlockHeight, dst += dy)
 			{
-				unsigned char* dstRow = dst;
+				unsigned char *dstRow = dst;
 				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
 				{
 					color->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, isAlpha, true);
@@ -269,12 +268,12 @@
 			}
 		}
 		break;
-	case 4: // BC4
+		case 4:  // BC4
 		{
-			const BC_channel* red = reinterpret_cast<const BC_channel*>(src);
+			const BC_channel *red = reinterpret_cast<const BC_channel *>(src);
 			for(int y = 0; y < h; y += BlockHeight, dst += dy)
 			{
-				unsigned char* dstRow = dst;
+				unsigned char *dstRow = dst;
 				for(int x = 0; x < w; x += BlockWidth, ++red, dstRow += dx)
 				{
 					red->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 0, isSigned);
@@ -282,13 +281,13 @@
 			}
 		}
 		break;
-	case 5: // BC5
+		case 5:  // BC5
 		{
-			const BC_channel* red = reinterpret_cast<const BC_channel*>(src);
-			const BC_channel* green = reinterpret_cast<const BC_channel*>(src + 8);
+			const BC_channel *red = reinterpret_cast<const BC_channel *>(src);
+			const BC_channel *green = reinterpret_cast<const BC_channel *>(src + 8);
 			for(int y = 0; y < h; y += BlockHeight, dst += dy)
 			{
-				unsigned char* dstRow = dst;
+				unsigned char *dstRow = dst;
 				for(int x = 0; x < w; x += BlockWidth, red += 2, green += 2, dstRow += dx)
 				{
 					red->decode(dstRow, x, y, dstW, dstH, dstPitch, dstBpp, 0, isSigned);
@@ -297,8 +296,8 @@
 			}
 		}
 		break;
-	default:
-		return false;
+		default:
+			return false;
 	}
 
 	return true;
diff --git a/src/Device/BC_Decoder.hpp b/src/Device/BC_Decoder.hpp
index 28547bb..8ebbb60 100644
--- a/src/Device/BC_Decoder.hpp
+++ b/src/Device/BC_Decoder.hpp
@@ -15,7 +15,6 @@
 class BC_Decoder
 {
 public:
-
 	/// BCn_Decoder::Decode - Decodes 1 to 4 channel images to 8 bit output
 	/// @param src            Pointer to BCn encoded image
 	/// @param dst            Pointer to decoded output image
@@ -29,5 +28,5 @@
 	/// @param isNoAlphaU     BC1: true if RGB, BC2/BC3: unused, BC4/BC5: true if unsigned
 	/// @return               true if the decoding was performed
 
-	static bool Decode(const unsigned char* src, unsigned char* dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, int n, bool isNoAlphaU);
+	static bool Decode(const unsigned char *src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, int n, bool isNoAlphaU);
 };
diff --git a/src/Device/Blitter.cpp b/src/Device/Blitter.cpp
index 3103616..2394fb2 100644
--- a/src/Device/Blitter.cpp
+++ b/src/Device/Blitter.cpp
@@ -18,19 +18,19 @@
 #include "Reactor/Reactor.hpp"
 #include "System/Half.hpp"
 #include "System/Memory.hpp"
+#include "Vulkan/VkBuffer.hpp"
 #include "Vulkan/VkDebug.hpp"
 #include "Vulkan/VkImage.hpp"
-#include "Vulkan/VkBuffer.hpp"
 
 #include <utility>
 
 namespace sw {
 
-Blitter::Blitter() :
-	blitMutex(),
-	blitCache(1024),
-	cornerUpdateMutex(),
-	cornerUpdateCache(64) // We only need one of these per format
+Blitter::Blitter()
+    : blitMutex()
+    , blitCache(1024)
+    , cornerUpdateMutex()
+    , cornerUpdateCache(64)  // We only need one of these per format
 {
 }
 
@@ -38,7 +38,7 @@
 {
 }
 
-void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea)
+void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea)
 {
 	VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask);
 	vk::Format dstFormat = viewFormat.getAspectFormat(aspect);
@@ -75,8 +75,7 @@
 		return;
 	}
 
-	VkImageSubresourceLayers subresLayers =
-	{
+	VkImageSubresourceLayers subresLayers = {
 		subresourceRange.aspectMask,
 		subresourceRange.baseMipLevel,
 		subresourceRange.baseArrayLayer,
@@ -102,21 +101,20 @@
 			area.extent.height = extent.height;
 		}
 
-		BlitData data =
-		{
-			pixel, nullptr, // source, dest
+		BlitData data = {
+			pixel, nullptr,  // source, dest
 
-			format.bytes(),                                       // sPitchB
-			dest->rowPitchBytes(aspect, subresLayers.mipLevel),   // dPitchB
-			0,                                                    // sSliceB (unused in clear operations)
-			dest->slicePitchBytes(aspect, subresLayers.mipLevel), // dSliceB
+			format.bytes(),                                        // sPitchB
+			dest->rowPitchBytes(aspect, subresLayers.mipLevel),    // dPitchB
+			0,                                                     // sSliceB (unused in clear operations)
+			dest->slicePitchBytes(aspect, subresLayers.mipLevel),  // dSliceB
 
-			0.5f, 0.5f, 0.0f, 0.0f, // x0, y0, w, h
+			0.5f, 0.5f, 0.0f, 0.0f,  // x0, y0, w, h
 
-			area.offset.y, static_cast<int>(area.offset.y + area.extent.height), // y0d, y1d
-			area.offset.x, static_cast<int>(area.offset.x + area.extent.width),  // x0d, x1d
+			area.offset.y, static_cast<int>(area.offset.y + area.extent.height),  // y0d, y1d
+			area.offset.x, static_cast<int>(area.offset.x + area.extent.width),   // x0d, x1d
 
-			0, 0, // sWidth, sHeight
+			0, 0,  // sWidth, sHeight
 		};
 
 		if(renderArea && dest->is3DSlice())
@@ -126,7 +124,7 @@
 			subresLayers.layerCount = 1;
 			for(uint32_t depth = subresourceRange.baseArrayLayer; depth <= lastLayer; depth++)
 			{
-				data.dest = dest->getTexelPointer({0, 0, static_cast<int32_t>(depth)}, subresLayers);
+				data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subresLayers);
 				blitRoutine(&data);
 			}
 		}
@@ -145,14 +143,14 @@
 	}
 }
 
-bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea)
+bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea)
 {
 	if(format != VK_FORMAT_R32G32B32A32_SFLOAT)
 	{
 		return false;
 	}
 
-	float *color = (float*)pixel;
+	float *color = (float *)pixel;
 	float r = color[0];
 	float g = color[1];
 	float b = color[2];
@@ -163,42 +161,41 @@
 	VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask);
 	switch(viewFormat)
 	{
-	case VK_FORMAT_R5G6B5_UNORM_PACK16:
-		packed = ((uint16_t)(31 * b + 0.5f) << 0) |
-			        ((uint16_t)(63 * g + 0.5f) << 5) |
-			        ((uint16_t)(31 * r + 0.5f) << 11);
-		break;
-	case VK_FORMAT_B5G6R5_UNORM_PACK16:
-		packed = ((uint16_t)(31 * r + 0.5f) << 0) |
-			        ((uint16_t)(63 * g + 0.5f) << 5) |
-			        ((uint16_t)(31 * b + 0.5f) << 11);
-		break;
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
-	case VK_FORMAT_R8G8B8A8_UNORM:
-		packed = ((uint32_t)(255 * a + 0.5f) << 24) |
-		         ((uint32_t)(255 * b + 0.5f) << 16) |
-		         ((uint32_t)(255 * g + 0.5f) << 8) |
-		         ((uint32_t)(255 * r + 0.5f) << 0);
-		break;
-	case VK_FORMAT_B8G8R8A8_UNORM:
-		packed = ((uint32_t)(255 * a + 0.5f) << 24) |
-		         ((uint32_t)(255 * r + 0.5f) << 16) |
-		         ((uint32_t)(255 * g + 0.5f) << 8) |
-		         ((uint32_t)(255 * b + 0.5f) << 0);
-		break;
-	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
-		packed = R11G11B10F(color);
-		break;
-	case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
-		packed = RGB9E5(color);
-		break;
-	default:
-		return false;
+		case VK_FORMAT_R5G6B5_UNORM_PACK16:
+			packed = ((uint16_t)(31 * b + 0.5f) << 0) |
+			         ((uint16_t)(63 * g + 0.5f) << 5) |
+			         ((uint16_t)(31 * r + 0.5f) << 11);
+			break;
+		case VK_FORMAT_B5G6R5_UNORM_PACK16:
+			packed = ((uint16_t)(31 * r + 0.5f) << 0) |
+			         ((uint16_t)(63 * g + 0.5f) << 5) |
+			         ((uint16_t)(31 * b + 0.5f) << 11);
+			break;
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_UNORM:
+			packed = ((uint32_t)(255 * a + 0.5f) << 24) |
+			         ((uint32_t)(255 * b + 0.5f) << 16) |
+			         ((uint32_t)(255 * g + 0.5f) << 8) |
+			         ((uint32_t)(255 * r + 0.5f) << 0);
+			break;
+		case VK_FORMAT_B8G8R8A8_UNORM:
+			packed = ((uint32_t)(255 * a + 0.5f) << 24) |
+			         ((uint32_t)(255 * r + 0.5f) << 16) |
+			         ((uint32_t)(255 * g + 0.5f) << 8) |
+			         ((uint32_t)(255 * b + 0.5f) << 0);
+			break;
+		case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+			packed = R11G11B10F(color);
+			break;
+		case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+			packed = RGB9E5(color);
+			break;
+		default:
+			return false;
 	}
 
-	VkImageSubresourceLayers subresLayers =
-	{
+	VkImageSubresourceLayers subresLayers = {
 		subresourceRange.aspectMask,
 		subresourceRange.baseMipLevel,
 		subresourceRange.baseArrayLayer,
@@ -226,15 +223,15 @@
 		}
 		if(dest->is3DSlice())
 		{
-			extent.depth = 1; // The 3D image is instead interpreted as a 2D image with layers
+			extent.depth = 1;  // The 3D image is instead interpreted as a 2D image with layers
 		}
 
 		for(subresLayers.baseArrayLayer = subresourceRange.baseArrayLayer; subresLayers.baseArrayLayer <= lastLayer; subresLayers.baseArrayLayer++)
 		{
 			for(uint32_t depth = 0; depth < extent.depth; depth++)
 			{
-				uint8_t *slice = (uint8_t*)dest->getTexelPointer(
-					{ area.offset.x, area.offset.y, static_cast<int32_t>(depth) }, subresLayers);
+				uint8_t *slice = (uint8_t *)dest->getTexelPointer(
+				    { area.offset.x, area.offset.y, static_cast<int32_t>(depth) }, subresLayers);
 
 				for(int j = 0; j < dest->getSampleCountFlagBits(); j++)
 				{
@@ -242,24 +239,24 @@
 
 					switch(viewFormat.bytes())
 					{
-					case 2:
-						for(uint32_t i = 0; i < area.extent.height; i++)
-						{
-							ASSERT(d < dest->end());
-							sw::clear((uint16_t*)d, static_cast<uint16_t>(packed), area.extent.width);
-							d += rowPitchBytes;
-						}
-						break;
-					case 4:
-						for(uint32_t i = 0; i < area.extent.height; i++)
-						{
-							ASSERT(d < dest->end());
-							sw::clear((uint32_t*)d, packed, area.extent.width);
-							d += rowPitchBytes;
-						}
-						break;
-					default:
-						assert(false);
+						case 2:
+							for(uint32_t i = 0; i < area.extent.height; i++)
+							{
+								ASSERT(d < dest->end());
+								sw::clear((uint16_t *)d, static_cast<uint16_t>(packed), area.extent.width);
+								d += rowPitchBytes;
+							}
+							break;
+						case 4:
+							for(uint32_t i = 0; i < area.extent.height; i++)
+							{
+								ASSERT(d < dest->end());
+								sw::clear((uint32_t *)d, packed, area.extent.width);
+								d += rowPitchBytes;
+							}
+							break;
+						default:
+							assert(false);
 					}
 
 					slice += slicePitchBytes;
@@ -277,178 +274,178 @@
 
 	switch(state.sourceFormat)
 	{
-	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-		c.w = Float(Int(*Pointer<Byte>(element)) & Int(0xF));
-		c.x = Float((Int(*Pointer<Byte>(element)) >> 4) & Int(0xF));
-		c.y = Float(Int(*Pointer<Byte>(element + 1)) & Int(0xF));
-		c.z = Float((Int(*Pointer<Byte>(element + 1)) >> 4) & Int(0xF));
-		break;
-	case VK_FORMAT_R8_SINT:
-	case VK_FORMAT_R8_SNORM:
-		c.x = Float(Int(*Pointer<SByte>(element)));
-		c.w = float(0x7F);
-		break;
-	case VK_FORMAT_R8_UNORM:
-	case VK_FORMAT_R8_UINT:
-	case VK_FORMAT_R8_SRGB:
-		c.x = Float(Int(*Pointer<Byte>(element)));
-		c.w = float(0xFF);
-		break;
-	case VK_FORMAT_R16_SINT:
-	case VK_FORMAT_R16_SNORM:
-		c.x = Float(Int(*Pointer<Short>(element)));
-		c.w = float(0x7FFF);
-		break;
-	case VK_FORMAT_R16_UNORM:
-	case VK_FORMAT_R16_UINT:
-		c.x = Float(Int(*Pointer<UShort>(element)));
-		c.w = float(0xFFFF);
-		break;
-	case VK_FORMAT_R32_SINT:
-		c.x = Float(*Pointer<Int>(element));
-		c.w = float(0x7FFFFFFF);
-		break;
-	case VK_FORMAT_R32_UINT:
-		c.x = Float(*Pointer<UInt>(element));
-		c.w = float(0xFFFFFFFF);
-		break;
-	case VK_FORMAT_B8G8R8A8_SRGB:
-	case VK_FORMAT_B8G8R8A8_UNORM:
-		c = Float4(*Pointer<Byte4>(element)).zyxw;
-		break;
-	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_SINT:
-	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
-	case VK_FORMAT_R8G8B8A8_SNORM:
-		c = Float4(*Pointer<SByte4>(element));
-		break;
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
-	case VK_FORMAT_R8G8B8A8_UNORM:
-	case VK_FORMAT_R8G8B8A8_UINT:
-	case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
-	case VK_FORMAT_R8G8B8A8_SRGB:
-		c = Float4(*Pointer<Byte4>(element));
-		break;
-	case VK_FORMAT_R16G16B16A16_SINT:
-		c = Float4(*Pointer<Short4>(element));
-		break;
-	case VK_FORMAT_R16G16B16A16_UNORM:
-	case VK_FORMAT_R16G16B16A16_UINT:
-		c = Float4(*Pointer<UShort4>(element));
-		break;
-	case VK_FORMAT_R32G32B32A32_SINT:
-		c = Float4(*Pointer<Int4>(element));
-		break;
-	case VK_FORMAT_R32G32B32A32_UINT:
-		c = Float4(*Pointer<UInt4>(element));
-		break;
-	case VK_FORMAT_R8G8_SINT:
-	case VK_FORMAT_R8G8_SNORM:
-		c.x = Float(Int(*Pointer<SByte>(element + 0)));
-		c.y = Float(Int(*Pointer<SByte>(element + 1)));
-		c.w = float(0x7F);
-		break;
-	case VK_FORMAT_R8G8_UNORM:
-	case VK_FORMAT_R8G8_UINT:
-	case VK_FORMAT_R8G8_SRGB:
-		c.x = Float(Int(*Pointer<Byte>(element + 0)));
-		c.y = Float(Int(*Pointer<Byte>(element + 1)));
-		c.w = float(0xFF);
-		break;
-	case VK_FORMAT_R16G16_SINT:
-	case VK_FORMAT_R16G16_SNORM:
-		c.x = Float(Int(*Pointer<Short>(element + 0)));
-		c.y = Float(Int(*Pointer<Short>(element + 2)));
-		c.w = float(0x7FFF);
-		break;
-	case VK_FORMAT_R16G16_UNORM:
-	case VK_FORMAT_R16G16_UINT:
-		c.x = Float(Int(*Pointer<UShort>(element + 0)));
-		c.y = Float(Int(*Pointer<UShort>(element + 2)));
-		c.w = float(0xFFFF);
-		break;
-	case VK_FORMAT_R32G32_SINT:
-		c.x = Float(*Pointer<Int>(element + 0));
-		c.y = Float(*Pointer<Int>(element + 4));
-		c.w = float(0x7FFFFFFF);
-		break;
-	case VK_FORMAT_R32G32_UINT:
-		c.x = Float(*Pointer<UInt>(element + 0));
-		c.y = Float(*Pointer<UInt>(element + 4));
-		c.w = float(0xFFFFFFFF);
-		break;
-	case VK_FORMAT_R32G32B32A32_SFLOAT:
-		c = *Pointer<Float4>(element);
-		break;
-	case VK_FORMAT_R32G32_SFLOAT:
-		c.x = *Pointer<Float>(element + 0);
-		c.y = *Pointer<Float>(element + 4);
-		break;
-	case VK_FORMAT_R32_SFLOAT:
-		c.x = *Pointer<Float>(element);
-		break;
-	case VK_FORMAT_R16G16B16A16_SFLOAT:
-		c.w = Float(*Pointer<Half>(element + 6));
-	case VK_FORMAT_R16G16B16_SFLOAT:
-		c.z = Float(*Pointer<Half>(element + 4));
-	case VK_FORMAT_R16G16_SFLOAT:
-		c.y = Float(*Pointer<Half>(element + 2));
-	case VK_FORMAT_R16_SFLOAT:
-		c.x = Float(*Pointer<Half>(element));
-		break;
-	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
-		c = r11g11b10Unpack(*Pointer<UInt>(element));
-		break;
-	case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
-		// This type contains a common 5 bit exponent (E) and a 9 bit the mantissa for R, G and B.
-		c.x = Float(*Pointer<UInt>(element) & UInt(0x000001FF));         // R's mantissa (bits 0-8)
-		c.y = Float((*Pointer<UInt>(element) & UInt(0x0003FE00)) >> 9);  // G's mantissa (bits 9-17)
-		c.z = Float((*Pointer<UInt>(element) & UInt(0x07FC0000)) >> 18); // B's mantissa (bits 18-26)
-		c *= Float4(
-			// 2^E, using the exponent (bits 27-31) and treating it as an unsigned integer value
-			Float(UInt(1) << ((*Pointer<UInt>(element) & UInt(0xF8000000)) >> 27)) *
-			// Since the 9 bit mantissa values currently stored in RGB were converted straight
-			// from int to float (in the [0, 1<<9] range instead of the [0, 1] range), they
-			// are (1 << 9) times too high.
-			// Also, the exponent has 5 bits and we compute the exponent bias of floating point
-			// formats using "2^(k-1) - 1", so, in this case, the exponent bias is 2^(5-1)-1 = 15
-			// Exponent bias (15) + number of mantissa bits per component (9) = 24
-			Float(1.0f / (1 << 24)));
-		c.w = 1.0f;
-		break;
-	case VK_FORMAT_R5G6B5_UNORM_PACK16:
-		c.x = Float(Int((*Pointer<UShort>(element) & UShort(0xF800)) >> UShort(11)));
-		c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x07E0)) >> UShort(5)));
-		c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F)));
-		break;
-	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-		c.w = Float(Int((*Pointer<UShort>(element) & UShort(0x8000)) >> UShort(15)));
-		c.x = Float(Int((*Pointer<UShort>(element) & UShort(0x7C00)) >> UShort(10)));
-		c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x03E0)) >> UShort(5)));
-		c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F)));
-		break;
-	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
-	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-		c.x = Float(Int((*Pointer<UInt>(element) & UInt(0x000003FF))));
-		c.y = Float(Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10));
-		c.z = Float(Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20));
-		c.w = Float(Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30));
-		break;
-	case VK_FORMAT_D16_UNORM:
-		c.x = Float(Int((*Pointer<UShort>(element))));
-		break;
-	case VK_FORMAT_X8_D24_UNORM_PACK32:
-		c.x = Float(Int((*Pointer<UInt>(element) & UInt(0xFFFFFF00)) >> 8));
-		break;
-	case VK_FORMAT_D32_SFLOAT:
-		c.x = *Pointer<Float>(element);
-		break;
-	case VK_FORMAT_S8_UINT:
-		c.x = Float(Int(*Pointer<Byte>(element)));
-		break;
-	default:
-		UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
+		case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+			c.w = Float(Int(*Pointer<Byte>(element)) & Int(0xF));
+			c.x = Float((Int(*Pointer<Byte>(element)) >> 4) & Int(0xF));
+			c.y = Float(Int(*Pointer<Byte>(element + 1)) & Int(0xF));
+			c.z = Float((Int(*Pointer<Byte>(element + 1)) >> 4) & Int(0xF));
+			break;
+		case VK_FORMAT_R8_SINT:
+		case VK_FORMAT_R8_SNORM:
+			c.x = Float(Int(*Pointer<SByte>(element)));
+			c.w = float(0x7F);
+			break;
+		case VK_FORMAT_R8_UNORM:
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_R8_SRGB:
+			c.x = Float(Int(*Pointer<Byte>(element)));
+			c.w = float(0xFF);
+			break;
+		case VK_FORMAT_R16_SINT:
+		case VK_FORMAT_R16_SNORM:
+			c.x = Float(Int(*Pointer<Short>(element)));
+			c.w = float(0x7FFF);
+			break;
+		case VK_FORMAT_R16_UNORM:
+		case VK_FORMAT_R16_UINT:
+			c.x = Float(Int(*Pointer<UShort>(element)));
+			c.w = float(0xFFFF);
+			break;
+		case VK_FORMAT_R32_SINT:
+			c.x = Float(*Pointer<Int>(element));
+			c.w = float(0x7FFFFFFF);
+			break;
+		case VK_FORMAT_R32_UINT:
+			c.x = Float(*Pointer<UInt>(element));
+			c.w = float(0xFFFFFFFF);
+			break;
+		case VK_FORMAT_B8G8R8A8_SRGB:
+		case VK_FORMAT_B8G8R8A8_UNORM:
+			c = Float4(*Pointer<Byte4>(element)).zyxw;
+			break;
+		case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_SINT:
+		case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_SNORM:
+			c = Float4(*Pointer<SByte4>(element));
+			break;
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_UNORM:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+		case VK_FORMAT_R8G8B8A8_SRGB:
+			c = Float4(*Pointer<Byte4>(element));
+			break;
+		case VK_FORMAT_R16G16B16A16_SINT:
+			c = Float4(*Pointer<Short4>(element));
+			break;
+		case VK_FORMAT_R16G16B16A16_UNORM:
+		case VK_FORMAT_R16G16B16A16_UINT:
+			c = Float4(*Pointer<UShort4>(element));
+			break;
+		case VK_FORMAT_R32G32B32A32_SINT:
+			c = Float4(*Pointer<Int4>(element));
+			break;
+		case VK_FORMAT_R32G32B32A32_UINT:
+			c = Float4(*Pointer<UInt4>(element));
+			break;
+		case VK_FORMAT_R8G8_SINT:
+		case VK_FORMAT_R8G8_SNORM:
+			c.x = Float(Int(*Pointer<SByte>(element + 0)));
+			c.y = Float(Int(*Pointer<SByte>(element + 1)));
+			c.w = float(0x7F);
+			break;
+		case VK_FORMAT_R8G8_UNORM:
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R8G8_SRGB:
+			c.x = Float(Int(*Pointer<Byte>(element + 0)));
+			c.y = Float(Int(*Pointer<Byte>(element + 1)));
+			c.w = float(0xFF);
+			break;
+		case VK_FORMAT_R16G16_SINT:
+		case VK_FORMAT_R16G16_SNORM:
+			c.x = Float(Int(*Pointer<Short>(element + 0)));
+			c.y = Float(Int(*Pointer<Short>(element + 2)));
+			c.w = float(0x7FFF);
+			break;
+		case VK_FORMAT_R16G16_UNORM:
+		case VK_FORMAT_R16G16_UINT:
+			c.x = Float(Int(*Pointer<UShort>(element + 0)));
+			c.y = Float(Int(*Pointer<UShort>(element + 2)));
+			c.w = float(0xFFFF);
+			break;
+		case VK_FORMAT_R32G32_SINT:
+			c.x = Float(*Pointer<Int>(element + 0));
+			c.y = Float(*Pointer<Int>(element + 4));
+			c.w = float(0x7FFFFFFF);
+			break;
+		case VK_FORMAT_R32G32_UINT:
+			c.x = Float(*Pointer<UInt>(element + 0));
+			c.y = Float(*Pointer<UInt>(element + 4));
+			c.w = float(0xFFFFFFFF);
+			break;
+		case VK_FORMAT_R32G32B32A32_SFLOAT:
+			c = *Pointer<Float4>(element);
+			break;
+		case VK_FORMAT_R32G32_SFLOAT:
+			c.x = *Pointer<Float>(element + 0);
+			c.y = *Pointer<Float>(element + 4);
+			break;
+		case VK_FORMAT_R32_SFLOAT:
+			c.x = *Pointer<Float>(element);
+			break;
+		case VK_FORMAT_R16G16B16A16_SFLOAT:
+			c.w = Float(*Pointer<Half>(element + 6));
+		case VK_FORMAT_R16G16B16_SFLOAT:
+			c.z = Float(*Pointer<Half>(element + 4));
+		case VK_FORMAT_R16G16_SFLOAT:
+			c.y = Float(*Pointer<Half>(element + 2));
+		case VK_FORMAT_R16_SFLOAT:
+			c.x = Float(*Pointer<Half>(element));
+			break;
+		case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+			c = r11g11b10Unpack(*Pointer<UInt>(element));
+			break;
+		case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+			// This type contains a common 5 bit exponent (E) and a 9 bit the mantissa for R, G and B.
+			c.x = Float(*Pointer<UInt>(element) & UInt(0x000001FF));          // R's mantissa (bits 0-8)
+			c.y = Float((*Pointer<UInt>(element) & UInt(0x0003FE00)) >> 9);   // G's mantissa (bits 9-17)
+			c.z = Float((*Pointer<UInt>(element) & UInt(0x07FC0000)) >> 18);  // B's mantissa (bits 18-26)
+			c *= Float4(
+			    // 2^E, using the exponent (bits 27-31) and treating it as an unsigned integer value
+			    Float(UInt(1) << ((*Pointer<UInt>(element) & UInt(0xF8000000)) >> 27)) *
+			    // Since the 9 bit mantissa values currently stored in RGB were converted straight
+			    // from int to float (in the [0, 1<<9] range instead of the [0, 1] range), they
+			    // are (1 << 9) times too high.
+			    // Also, the exponent has 5 bits and we compute the exponent bias of floating point
+			    // formats using "2^(k-1) - 1", so, in this case, the exponent bias is 2^(5-1)-1 = 15
+			    // Exponent bias (15) + number of mantissa bits per component (9) = 24
+			    Float(1.0f / (1 << 24)));
+			c.w = 1.0f;
+			break;
+		case VK_FORMAT_R5G6B5_UNORM_PACK16:
+			c.x = Float(Int((*Pointer<UShort>(element) & UShort(0xF800)) >> UShort(11)));
+			c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x07E0)) >> UShort(5)));
+			c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F)));
+			break;
+		case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
+			c.w = Float(Int((*Pointer<UShort>(element) & UShort(0x8000)) >> UShort(15)));
+			c.x = Float(Int((*Pointer<UShort>(element) & UShort(0x7C00)) >> UShort(10)));
+			c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x03E0)) >> UShort(5)));
+			c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F)));
+			break;
+		case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+		case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+			c.x = Float(Int((*Pointer<UInt>(element) & UInt(0x000003FF))));
+			c.y = Float(Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10));
+			c.z = Float(Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20));
+			c.w = Float(Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30));
+			break;
+		case VK_FORMAT_D16_UNORM:
+			c.x = Float(Int((*Pointer<UShort>(element))));
+			break;
+		case VK_FORMAT_X8_D24_UNORM_PACK32:
+			c.x = Float(Int((*Pointer<UInt>(element) & UInt(0xFFFFFF00)) >> 8));
+			break;
+		case VK_FORMAT_D32_SFLOAT:
+			c.x = *Pointer<Float>(element);
+			break;
+		case VK_FORMAT_S8_UINT:
+			c.x = Float(Int(*Pointer<Byte>(element)));
+			break;
+		default:
+			UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 	}
 
 	return c;
@@ -464,150 +461,147 @@
 
 	switch(state.destFormat)
 	{
-	case VK_FORMAT_R4G4_UNORM_PACK8:
-		if(writeR | writeG)
-		{
-			if(!writeR)
+		case VK_FORMAT_R4G4_UNORM_PACK8:
+			if(writeR | writeG)
 			{
-				*Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) |
-			                              (*Pointer<Byte>(element) & Byte(0xF0));
+				if(!writeR)
+				{
+					*Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) |
+					                          (*Pointer<Byte>(element) & Byte(0xF0));
+				}
+				else if(!writeG)
+				{
+					*Pointer<Byte>(element) = (*Pointer<Byte>(element) & Byte(0xF)) |
+					                          (Byte(RoundInt(Float(c.x))) << Byte(4));
+				}
+				else
+				{
+					*Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) |
+					                          (Byte(RoundInt(Float(c.x))) << Byte(4));
+				}
 			}
-			else if(!writeG)
+			break;
+		case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
+			if(writeR || writeG || writeB || writeA)
 			{
-				*Pointer<Byte>(element) = (*Pointer<Byte>(element) & Byte(0xF)) |
-			                              (Byte(RoundInt(Float(c.x))) << Byte(4));
+				*Pointer<UShort>(element) = (writeR ? ((UShort(RoundInt(Float(c.x))) & UShort(0xF)) << UShort(12)) : (*Pointer<UShort>(element) & UShort(0x000F))) |
+				                            (writeG ? ((UShort(RoundInt(Float(c.y))) & UShort(0xF)) << UShort(8)) : (*Pointer<UShort>(element) & UShort(0x00F0))) |
+				                            (writeB ? ((UShort(RoundInt(Float(c.z))) & UShort(0xF)) << UShort(4)) : (*Pointer<UShort>(element) & UShort(0x0F00))) |
+				                            (writeA ? (UShort(RoundInt(Float(c.w))) & UShort(0xF)) : (*Pointer<UShort>(element) & UShort(0xF000)));
+			}
+			break;
+		case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
+			if(writeRGBA)
+			{
+				*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) & Int(0xF)) |
+				                            UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) |
+				                            UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) |
+				                            UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12);
 			}
 			else
 			{
-				*Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) |
-			                              (Byte(RoundInt(Float(c.x))) << Byte(4));
+				unsigned short mask = (writeA ? 0x000F : 0x0000) |
+				                      (writeR ? 0x00F0 : 0x0000) |
+				                      (writeG ? 0x0F00 : 0x0000) |
+				                      (writeB ? 0xF000 : 0x0000);
+				unsigned short unmask = ~mask;
+				*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
+				                            ((UShort(RoundInt(Float(c.w)) & Int(0xF)) |
+				                              UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) |
+				                              UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) |
+				                              UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12)) &
+				                             UShort(mask));
 			}
-		}
-		break;
-	case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
-		if(writeR || writeG || writeB || writeA)
-		{
-			*Pointer<UShort>(element) = (writeR ? ((UShort(RoundInt(Float(c.x))) & UShort(0xF)) << UShort(12)) :
-			                                      (*Pointer<UShort>(element) & UShort(0x000F))) |
-			                            (writeG ? ((UShort(RoundInt(Float(c.y))) & UShort(0xF)) << UShort(8)) :
-			                                      (*Pointer<UShort>(element) & UShort(0x00F0))) |
-			                            (writeB ? ((UShort(RoundInt(Float(c.z))) & UShort(0xF)) << UShort(4)) :
-		                                          (*Pointer<UShort>(element) & UShort(0x0F00))) |
-		                                (writeA ? (UShort(RoundInt(Float(c.w))) & UShort(0xF)) :
-		                                          (*Pointer<UShort>(element) & UShort(0xF000)));
-		}
-		break;
-	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-		if(writeRGBA)
-		{
-			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) & Int(0xF)) |
-			                            UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) |
-			                            UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) |
-			                            UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12);
-		}
-		else
-		{
-			unsigned short mask = (writeA ? 0x000F : 0x0000) |
-			                      (writeR ? 0x00F0 : 0x0000) |
-			                      (writeG ? 0x0F00 : 0x0000) |
-			                      (writeB ? 0xF000 : 0x0000);
-			unsigned short unmask = ~mask;
-			*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
-			                            ((UShort(RoundInt(Float(c.w)) & Int(0xF)) |
-			                              UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) |
-			                              UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) |
-			                              UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12)) & UShort(mask));
-		}
-		break;
-	case VK_FORMAT_B8G8R8A8_SRGB:
-	case VK_FORMAT_B8G8R8A8_UNORM:
-		if(writeRGBA)
-		{
-			Short4 c0 = RoundShort4(c.zyxw);
-			*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_B8G8R8A8_SRGB:
+		case VK_FORMAT_B8G8R8A8_UNORM:
+			if(writeRGBA)
+			{
+				Short4 c0 = RoundShort4(c.zyxw);
+				*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
+			}
+			else
+			{
+				if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); }
+				if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
+				if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); }
+				if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); }
+			}
+			break;
+		case VK_FORMAT_B8G8R8_SNORM:
+			if(writeB) { *Pointer<SByte>(element + 0) = SByte(RoundInt(Float(c.z))); }
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
+			if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); }
+			break;
+		case VK_FORMAT_B8G8R8_UNORM:
+		case VK_FORMAT_B8G8R8_SRGB:
 			if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); }
 			if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
 			if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); }
-			if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); }
-		}
-		break;
-	case VK_FORMAT_B8G8R8_SNORM:
-		if(writeB) { *Pointer<SByte>(element + 0) = SByte(RoundInt(Float(c.z))); }
-		if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
-		if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_B8G8R8_UNORM:
-	case VK_FORMAT_B8G8R8_SRGB:
-		if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); }
-		if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
-		if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
-	case VK_FORMAT_R8G8B8A8_UNORM:
-	case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
-	case VK_FORMAT_R8G8B8A8_SRGB:
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_UINT:
-	case VK_FORMAT_R8G8B8A8_USCALED:
-	case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
-		if(writeRGBA)
-		{
-			Short4 c0 = RoundShort4(c);
-			*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
-		}
-		else
-		{
-			if(writeR) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.x))); }
-			if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
-			if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); }
-			if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); }
-		}
-		break;
-	case VK_FORMAT_R32G32B32A32_SFLOAT:
-		if(writeRGBA)
-		{
-			*Pointer<Float4>(element) = c;
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_UNORM:
+		case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+		case VK_FORMAT_R8G8B8A8_SRGB:
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_R8G8B8A8_USCALED:
+		case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
+			if(writeRGBA)
+			{
+				Short4 c0 = RoundShort4(c);
+				*Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0));
+			}
+			else
+			{
+				if(writeR) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
+				if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); }
+				if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); }
+			}
+			break;
+		case VK_FORMAT_R32G32B32A32_SFLOAT:
+			if(writeRGBA)
+			{
+				*Pointer<Float4>(element) = c;
+			}
+			else
+			{
+				if(writeR) { *Pointer<Float>(element) = c.x; }
+				if(writeG) { *Pointer<Float>(element + 4) = c.y; }
+				if(writeB) { *Pointer<Float>(element + 8) = c.z; }
+				if(writeA) { *Pointer<Float>(element + 12) = c.w; }
+			}
+			break;
+		case VK_FORMAT_R32G32B32_SFLOAT:
 			if(writeR) { *Pointer<Float>(element) = c.x; }
 			if(writeG) { *Pointer<Float>(element + 4) = c.y; }
 			if(writeB) { *Pointer<Float>(element + 8) = c.z; }
-			if(writeA) { *Pointer<Float>(element + 12) = c.w; }
-		}
-		break;
-	case VK_FORMAT_R32G32B32_SFLOAT:
-		if(writeR) { *Pointer<Float>(element) = c.x; }
-		if(writeG) { *Pointer<Float>(element + 4) = c.y; }
-		if(writeB) { *Pointer<Float>(element + 8) = c.z; }
-		break;
-	case VK_FORMAT_R32G32_SFLOAT:
-		if(writeR && writeG)
-		{
-			*Pointer<Float2>(element) = Float2(c);
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_R32G32_SFLOAT:
+			if(writeR && writeG)
+			{
+				*Pointer<Float2>(element) = Float2(c);
+			}
+			else
+			{
+				if(writeR) { *Pointer<Float>(element) = c.x; }
+				if(writeG) { *Pointer<Float>(element + 4) = c.y; }
+			}
+			break;
+		case VK_FORMAT_R32_SFLOAT:
 			if(writeR) { *Pointer<Float>(element) = c.x; }
-			if(writeG) { *Pointer<Float>(element + 4) = c.y; }
-		}
-		break;
-	case VK_FORMAT_R32_SFLOAT:
-		if(writeR) { *Pointer<Float>(element) = c.x; }
-		break;
-	case VK_FORMAT_R16G16B16A16_SFLOAT:
-		if(writeA) { *Pointer<Half>(element + 6) = Half(c.w); }
-	case VK_FORMAT_R16G16B16_SFLOAT:
-		if(writeB) { *Pointer<Half>(element + 4) = Half(c.z); }
-	case VK_FORMAT_R16G16_SFLOAT:
-		if(writeG) { *Pointer<Half>(element + 2) = Half(c.y); }
-	case VK_FORMAT_R16_SFLOAT:
-		if(writeR) { *Pointer<Half>(element) = Half(c.x); }
-		break;
-	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
+			break;
+		case VK_FORMAT_R16G16B16A16_SFLOAT:
+			if(writeA) { *Pointer<Half>(element + 6) = Half(c.w); }
+		case VK_FORMAT_R16G16B16_SFLOAT:
+			if(writeB) { *Pointer<Half>(element + 4) = Half(c.z); }
+		case VK_FORMAT_R16G16_SFLOAT:
+			if(writeG) { *Pointer<Half>(element + 2) = Half(c.y); }
+		case VK_FORMAT_R16_SFLOAT:
+			if(writeR) { *Pointer<Half>(element) = Half(c.x); }
+			break;
+		case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
 		{
 			UInt rgb = r11g11b10Pack(c);
 
@@ -620,7 +614,7 @@
 			*Pointer<UInt>(element) = (rgb & mask) | (old & ~mask);
 		}
 		break;
-	case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
+		case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
 		{
 			ASSERT(writeRGBA);  // Can't sensibly write just part of this format.
 
@@ -634,9 +628,9 @@
 			constexpr float sharedexp_max = ((static_cast<float>(1 << N) - 1) / static_cast<float>(1 << N)) * static_cast<float>(1 << (E_max - B));
 
 			// Clamp components to valid range. NaN becomes 0.
-			Float red_c =   Min(IfThenElse(!(c.x > 0), Float(0), Float(c.x)), sharedexp_max);
+			Float red_c = Min(IfThenElse(!(c.x > 0), Float(0), Float(c.x)), sharedexp_max);
 			Float green_c = Min(IfThenElse(!(c.y > 0), Float(0), Float(c.y)), sharedexp_max);
-			Float blue_c =  Min(IfThenElse(!(c.z > 0), Float(0), Float(c.z)), sharedexp_max);
+			Float blue_c = Min(IfThenElse(!(c.z > 0), Float(0), Float(c.z)), sharedexp_max);
 
 			// We're reducing the mantissa to 9 bits, so we must round up if the next
 			// bit is 1. In other words add 0.5 to the new mantissa's position and
@@ -666,314 +660,320 @@
 			*Pointer<UInt>(element) = E5B9G9R9;
 		}
 		break;
-	case VK_FORMAT_B8G8R8A8_SNORM:
-		if(writeB) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.z))); }
-		if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
-		if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); }
-		if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); }
-		break;
-	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_SINT:
-	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
-	case VK_FORMAT_R8G8B8A8_SNORM:
-	case VK_FORMAT_R8G8B8A8_SSCALED:
-	case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
-		if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); }
-	case VK_FORMAT_R8G8B8_SINT:
-	case VK_FORMAT_R8G8B8_SNORM:
-	case VK_FORMAT_R8G8B8_SSCALED:
-		if(writeB) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.z))); }
-	case VK_FORMAT_R8G8_SINT:
-	case VK_FORMAT_R8G8_SNORM:
-	case VK_FORMAT_R8G8_SSCALED:
-		if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
-	case VK_FORMAT_R8_SINT:
-	case VK_FORMAT_R8_SNORM:
-	case VK_FORMAT_R8_SSCALED:
-		if(writeR) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_R8G8B8_UINT:
-	case VK_FORMAT_R8G8B8_UNORM:
-	case VK_FORMAT_R8G8B8_USCALED:
-	case VK_FORMAT_R8G8B8_SRGB:
-		if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); }
-	case VK_FORMAT_R8G8_UINT:
-	case VK_FORMAT_R8G8_UNORM:
-	case VK_FORMAT_R8G8_USCALED:
-	case VK_FORMAT_R8G8_SRGB:
-		if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
-	case VK_FORMAT_R8_UINT:
-	case VK_FORMAT_R8_UNORM:
-	case VK_FORMAT_R8_USCALED:
-	case VK_FORMAT_R8_SRGB:
-		if(writeR) { *Pointer<Byte>(element) = Byte(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_R16G16B16A16_SINT:
-	case VK_FORMAT_R16G16B16A16_SNORM:
-	case VK_FORMAT_R16G16B16A16_SSCALED:
-		if(writeRGBA)
-		{
-			*Pointer<Short4>(element) = Short4(RoundInt(c));
-		}
-		else
-		{
+		case VK_FORMAT_B8G8R8A8_SNORM:
+			if(writeB) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.z))); }
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
+			if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); }
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); }
+			break;
+		case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_SINT:
+		case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
+		case VK_FORMAT_R8G8B8A8_SNORM:
+		case VK_FORMAT_R8G8B8A8_SSCALED:
+		case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); }
+		case VK_FORMAT_R8G8B8_SINT:
+		case VK_FORMAT_R8G8B8_SNORM:
+		case VK_FORMAT_R8G8B8_SSCALED:
+			if(writeB) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.z))); }
+		case VK_FORMAT_R8G8_SINT:
+		case VK_FORMAT_R8G8_SNORM:
+		case VK_FORMAT_R8G8_SSCALED:
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
+		case VK_FORMAT_R8_SINT:
+		case VK_FORMAT_R8_SNORM:
+		case VK_FORMAT_R8_SSCALED:
+			if(writeR) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.x))); }
+			break;
+		case VK_FORMAT_R8G8B8_UINT:
+		case VK_FORMAT_R8G8B8_UNORM:
+		case VK_FORMAT_R8G8B8_USCALED:
+		case VK_FORMAT_R8G8B8_SRGB:
+			if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); }
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R8G8_UNORM:
+		case VK_FORMAT_R8G8_USCALED:
+		case VK_FORMAT_R8G8_SRGB:
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_R8_UNORM:
+		case VK_FORMAT_R8_USCALED:
+		case VK_FORMAT_R8_SRGB:
+			if(writeR) { *Pointer<Byte>(element) = Byte(RoundInt(Float(c.x))); }
+			break;
+		case VK_FORMAT_R16G16B16A16_SINT:
+		case VK_FORMAT_R16G16B16A16_SNORM:
+		case VK_FORMAT_R16G16B16A16_SSCALED:
+			if(writeRGBA)
+			{
+				*Pointer<Short4>(element) = Short4(RoundInt(c));
+			}
+			else
+			{
+				if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); }
+				if(writeB) { *Pointer<Short>(element + 4) = Short(RoundInt(Float(c.z))); }
+				if(writeA) { *Pointer<Short>(element + 6) = Short(RoundInt(Float(c.w))); }
+			}
+			break;
+		case VK_FORMAT_R16G16B16_SINT:
+		case VK_FORMAT_R16G16B16_SNORM:
+		case VK_FORMAT_R16G16B16_SSCALED:
 			if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
 			if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); }
 			if(writeB) { *Pointer<Short>(element + 4) = Short(RoundInt(Float(c.z))); }
-			if(writeA) { *Pointer<Short>(element + 6) = Short(RoundInt(Float(c.w))); }
-		}
-		break;
-	case VK_FORMAT_R16G16B16_SINT:
-	case VK_FORMAT_R16G16B16_SNORM:
-	case VK_FORMAT_R16G16B16_SSCALED:
-		if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
-		if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); }
-		if(writeB) { *Pointer<Short>(element + 4) = Short(RoundInt(Float(c.z))); }
-		break;
-	case VK_FORMAT_R16G16_SINT:
-	case VK_FORMAT_R16G16_SNORM:
-	case VK_FORMAT_R16G16_SSCALED:
-		if(writeR && writeG)
-		{
-			*Pointer<Short2>(element) = Short2(Short4(RoundInt(c)));
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_R16G16_SINT:
+		case VK_FORMAT_R16G16_SNORM:
+		case VK_FORMAT_R16G16_SSCALED:
+			if(writeR && writeG)
+			{
+				*Pointer<Short2>(element) = Short2(Short4(RoundInt(c)));
+			}
+			else
+			{
+				if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); }
+			}
+			break;
+		case VK_FORMAT_R16_SINT:
+		case VK_FORMAT_R16_SNORM:
+		case VK_FORMAT_R16_SSCALED:
 			if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
-			if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); }
-		}
-		break;
-	case VK_FORMAT_R16_SINT:
-	case VK_FORMAT_R16_SNORM:
-	case VK_FORMAT_R16_SSCALED:
-		if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_R16G16B16A16_UINT:
-	case VK_FORMAT_R16G16B16A16_UNORM:
-	case VK_FORMAT_R16G16B16A16_USCALED:
-		if(writeRGBA)
-		{
-			*Pointer<UShort4>(element) = UShort4(RoundInt(c));
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_R16G16B16A16_UINT:
+		case VK_FORMAT_R16G16B16A16_UNORM:
+		case VK_FORMAT_R16G16B16A16_USCALED:
+			if(writeRGBA)
+			{
+				*Pointer<UShort4>(element) = UShort4(RoundInt(c));
+			}
+			else
+			{
+				if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); }
+				if(writeB) { *Pointer<UShort>(element + 4) = UShort(RoundInt(Float(c.z))); }
+				if(writeA) { *Pointer<UShort>(element + 6) = UShort(RoundInt(Float(c.w))); }
+			}
+			break;
+		case VK_FORMAT_R16G16B16_UINT:
+		case VK_FORMAT_R16G16B16_UNORM:
+		case VK_FORMAT_R16G16B16_USCALED:
 			if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
 			if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); }
 			if(writeB) { *Pointer<UShort>(element + 4) = UShort(RoundInt(Float(c.z))); }
-			if(writeA) { *Pointer<UShort>(element + 6) = UShort(RoundInt(Float(c.w))); }
-		}
-		break;
-	case VK_FORMAT_R16G16B16_UINT:
-	case VK_FORMAT_R16G16B16_UNORM:
-	case VK_FORMAT_R16G16B16_USCALED:
-		if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
-		if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); }
-		if(writeB) { *Pointer<UShort>(element + 4) = UShort(RoundInt(Float(c.z))); }
-		break;
-	case VK_FORMAT_R16G16_UINT:
-	case VK_FORMAT_R16G16_UNORM:
-	case VK_FORMAT_R16G16_USCALED:
-		if(writeR && writeG)
-		{
-			*Pointer<UShort2>(element) = UShort2(UShort4(RoundInt(c)));
-		}
-		else
-		{
+			break;
+		case VK_FORMAT_R16G16_UINT:
+		case VK_FORMAT_R16G16_UNORM:
+		case VK_FORMAT_R16G16_USCALED:
+			if(writeR && writeG)
+			{
+				*Pointer<UShort2>(element) = UShort2(UShort4(RoundInt(c)));
+			}
+			else
+			{
+				if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); }
+			}
+			break;
+		case VK_FORMAT_R16_UINT:
+		case VK_FORMAT_R16_UNORM:
+		case VK_FORMAT_R16_USCALED:
 			if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
-			if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); }
-		}
-		break;
-	case VK_FORMAT_R16_UINT:
-	case VK_FORMAT_R16_UNORM:
-	case VK_FORMAT_R16_USCALED:
-		if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_R32G32B32A32_SINT:
-		if(writeRGBA)
-		{
-			*Pointer<Int4>(element) = RoundInt(c);
-		}
-		else
-		{
-			if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); }
-			if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); }
+			break;
+		case VK_FORMAT_R32G32B32A32_SINT:
+			if(writeRGBA)
+			{
+				*Pointer<Int4>(element) = RoundInt(c);
+			}
+			else
+			{
+				if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); }
+				if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); }
+				if(writeB) { *Pointer<Int>(element + 8) = RoundInt(Float(c.z)); }
+				if(writeA) { *Pointer<Int>(element + 12) = RoundInt(Float(c.w)); }
+			}
+			break;
+		case VK_FORMAT_R32G32B32_SINT:
 			if(writeB) { *Pointer<Int>(element + 8) = RoundInt(Float(c.z)); }
-			if(writeA) { *Pointer<Int>(element + 12) = RoundInt(Float(c.w)); }
-		}
-		break;
-	case VK_FORMAT_R32G32B32_SINT:
-		if(writeB) { *Pointer<Int>(element + 8) = RoundInt(Float(c.z)); }
-	case VK_FORMAT_R32G32_SINT:
-		if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); }
-	case VK_FORMAT_R32_SINT:
-		if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); }
-		break;
-	case VK_FORMAT_R32G32B32A32_UINT:
-		if(writeRGBA)
-		{
-			*Pointer<UInt4>(element) = UInt4(RoundInt(c));
-		}
-		else
-		{
-			if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); }
-			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); }
+		case VK_FORMAT_R32G32_SINT:
+			if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); }
+		case VK_FORMAT_R32_SINT:
+			if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); }
+			break;
+		case VK_FORMAT_R32G32B32A32_UINT:
+			if(writeRGBA)
+			{
+				*Pointer<UInt4>(element) = UInt4(RoundInt(c));
+			}
+			else
+			{
+				if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); }
+				if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); }
+				if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(RoundInt(Float(c.z))); }
+				if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(RoundInt(Float(c.w))); }
+			}
+			break;
+		case VK_FORMAT_R32G32B32_UINT:
 			if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(RoundInt(Float(c.z))); }
-			if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(RoundInt(Float(c.w))); }
-		}
-		break;
-	case VK_FORMAT_R32G32B32_UINT:
-		if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(RoundInt(Float(c.z))); }
-	case VK_FORMAT_R32G32_UINT:
-		if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); }
-	case VK_FORMAT_R32_UINT:
-		if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); }
-		break;
-	case VK_FORMAT_R5G6B5_UNORM_PACK16:
-		if(writeR && writeG && writeB)
-		{
-			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.z)) |
-			                                  (RoundInt(Float(c.y)) << Int(5)) |
-			                                  (RoundInt(Float(c.x)) << Int(11)));
-		}
-		else
-		{
-			unsigned short mask = (writeB ? 0x001F : 0x0000) | (writeG ? 0x07E0 : 0x0000) | (writeR ? 0xF800 : 0x0000);
-			unsigned short unmask = ~mask;
-			*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
-			                            (UShort(RoundInt(Float(c.z)) |
-			                                   (RoundInt(Float(c.y)) << Int(5)) |
-			                                   (RoundInt(Float(c.x)) << Int(11))) & UShort(mask));
-		}
-		break;
-	case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
-		if(writeRGBA)
-		{
-			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) |
-			                                  (RoundInt(Float(c.z)) << Int(1)) |
-			                                  (RoundInt(Float(c.y)) << Int(6)) |
-			                                  (RoundInt(Float(c.x)) << Int(11)));
-		}
-		else
-		{
-			unsigned short mask = (writeA ? 0x8000 : 0x0000) |
-			                      (writeR ? 0x7C00 : 0x0000) |
-			                      (writeG ? 0x03E0 : 0x0000) |
-			                      (writeB ? 0x001F : 0x0000);
-			unsigned short unmask = ~mask;
-			*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
-			                            (UShort(RoundInt(Float(c.w)) |
-			                                   (RoundInt(Float(c.z)) << Int(1)) |
-			                                   (RoundInt(Float(c.y)) << Int(6)) |
-			                                   (RoundInt(Float(c.x)) << Int(11))) & UShort(mask));
-		}
-		break;
-	case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
-		if(writeRGBA)
-		{
-			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) |
-			                                  (RoundInt(Float(c.x)) << Int(1)) |
-			                                  (RoundInt(Float(c.y)) << Int(6)) |
-			                                  (RoundInt(Float(c.z)) << Int(11)));
-		}
-		else
-		{
-			unsigned short mask = (writeA ? 0x8000 : 0x0000) |
-			                      (writeR ? 0x7C00 : 0x0000) |
-			                      (writeG ? 0x03E0 : 0x0000) |
-			                      (writeB ? 0x001F : 0x0000);
-			unsigned short unmask = ~mask;
-			*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
-			                            (UShort(RoundInt(Float(c.w)) |
-			                                   (RoundInt(Float(c.x)) << Int(1)) |
-			                                   (RoundInt(Float(c.y)) << Int(6)) |
-			                                   (RoundInt(Float(c.z)) << Int(11))) & UShort(mask));
-		}
-		break;
-	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
-		if(writeRGBA)
-		{
-			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.z)) |
-			                                  (RoundInt(Float(c.y)) << Int(5)) |
-			                                  (RoundInt(Float(c.x)) << Int(10)) |
-			                                  (RoundInt(Float(c.w)) << Int(15)));
-		}
-		else
-		{
-			unsigned short mask = (writeA ? 0x8000 : 0x0000) |
-			                      (writeR ? 0x7C00 : 0x0000) |
-			                      (writeG ? 0x03E0 : 0x0000) |
-			                      (writeB ? 0x001F : 0x0000);
-			unsigned short unmask = ~mask;
-			*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
-			                            (UShort(RoundInt(Float(c.z)) |
-			                                   (RoundInt(Float(c.y)) << Int(5)) |
-			                                   (RoundInt(Float(c.x)) << Int(10)) |
-			                                   (RoundInt(Float(c.w)) << Int(15))) & UShort(mask));
-		}
-		break;
-	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
-	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-	case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
-		if(writeRGBA)
-		{
-			*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) |
-			                              (RoundInt(Float(c.y)) << 10) |
-			                              (RoundInt(Float(c.z)) << 20) |
-			                              (RoundInt(Float(c.w)) << 30));
-		}
-		else
-		{
-			unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
-			                    (writeB ? 0x3FF00000 : 0x0000) |
-			                    (writeG ? 0x000FFC00 : 0x0000) |
-			                    (writeR ? 0x000003FF : 0x0000);
-			unsigned int unmask = ~mask;
-			*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
-			                            (UInt(RoundInt(Float(c.x)) |
-			                                 (RoundInt(Float(c.y)) << 10) |
-			                                 (RoundInt(Float(c.z)) << 20) |
-			                                 (RoundInt(Float(c.w)) << 30)) & UInt(mask));
-		}
-		break;
-	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
-	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
-	case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
-		if(writeRGBA)
-		{
-			*Pointer<UInt>(element) = UInt(RoundInt(Float(c.z)) |
-			                              (RoundInt(Float(c.y)) << 10) |
-			                              (RoundInt(Float(c.x)) << 20) |
-			                              (RoundInt(Float(c.w)) << 30));
-		}
-		else
-		{
-			unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
-			                    (writeR ? 0x3FF00000 : 0x0000) |
-			                    (writeG ? 0x000FFC00 : 0x0000) |
-			                    (writeB ? 0x000003FF : 0x0000);
-			unsigned int unmask = ~mask;
-			*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
-			                            (UInt(RoundInt(Float(c.z)) |
-			                                 (RoundInt(Float(c.y)) << 10) |
-			                                 (RoundInt(Float(c.x)) << 20) |
-			                                 (RoundInt(Float(c.w)) << 30)) & UInt(mask));
-		}
-		break;
-	case VK_FORMAT_D16_UNORM:
-		*Pointer<UShort>(element) = UShort(RoundInt(Float(c.x)));
-		break;
-	case VK_FORMAT_X8_D24_UNORM_PACK32:
-		*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) << 8);
-		break;
-	case VK_FORMAT_D32_SFLOAT:
-		*Pointer<Float>(element) = c.x;
-		break;
-	case VK_FORMAT_S8_UINT:
-		*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
-		break;
-	default:
-		UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
-		break;
+		case VK_FORMAT_R32G32_UINT:
+			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); }
+		case VK_FORMAT_R32_UINT:
+			if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); }
+			break;
+		case VK_FORMAT_R5G6B5_UNORM_PACK16:
+			if(writeR && writeG && writeB)
+			{
+				*Pointer<UShort>(element) = UShort(RoundInt(Float(c.z)) |
+				                                   (RoundInt(Float(c.y)) << Int(5)) |
+				                                   (RoundInt(Float(c.x)) << Int(11)));
+			}
+			else
+			{
+				unsigned short mask = (writeB ? 0x001F : 0x0000) | (writeG ? 0x07E0 : 0x0000) | (writeR ? 0xF800 : 0x0000);
+				unsigned short unmask = ~mask;
+				*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
+				                            (UShort(RoundInt(Float(c.z)) |
+				                                    (RoundInt(Float(c.y)) << Int(5)) |
+				                                    (RoundInt(Float(c.x)) << Int(11))) &
+				                             UShort(mask));
+			}
+			break;
+		case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
+			if(writeRGBA)
+			{
+				*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) |
+				                                   (RoundInt(Float(c.z)) << Int(1)) |
+				                                   (RoundInt(Float(c.y)) << Int(6)) |
+				                                   (RoundInt(Float(c.x)) << Int(11)));
+			}
+			else
+			{
+				unsigned short mask = (writeA ? 0x8000 : 0x0000) |
+				                      (writeR ? 0x7C00 : 0x0000) |
+				                      (writeG ? 0x03E0 : 0x0000) |
+				                      (writeB ? 0x001F : 0x0000);
+				unsigned short unmask = ~mask;
+				*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
+				                            (UShort(RoundInt(Float(c.w)) |
+				                                    (RoundInt(Float(c.z)) << Int(1)) |
+				                                    (RoundInt(Float(c.y)) << Int(6)) |
+				                                    (RoundInt(Float(c.x)) << Int(11))) &
+				                             UShort(mask));
+			}
+			break;
+		case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
+			if(writeRGBA)
+			{
+				*Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) |
+				                                   (RoundInt(Float(c.x)) << Int(1)) |
+				                                   (RoundInt(Float(c.y)) << Int(6)) |
+				                                   (RoundInt(Float(c.z)) << Int(11)));
+			}
+			else
+			{
+				unsigned short mask = (writeA ? 0x8000 : 0x0000) |
+				                      (writeR ? 0x7C00 : 0x0000) |
+				                      (writeG ? 0x03E0 : 0x0000) |
+				                      (writeB ? 0x001F : 0x0000);
+				unsigned short unmask = ~mask;
+				*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
+				                            (UShort(RoundInt(Float(c.w)) |
+				                                    (RoundInt(Float(c.x)) << Int(1)) |
+				                                    (RoundInt(Float(c.y)) << Int(6)) |
+				                                    (RoundInt(Float(c.z)) << Int(11))) &
+				                             UShort(mask));
+			}
+			break;
+		case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
+			if(writeRGBA)
+			{
+				*Pointer<UShort>(element) = UShort(RoundInt(Float(c.z)) |
+				                                   (RoundInt(Float(c.y)) << Int(5)) |
+				                                   (RoundInt(Float(c.x)) << Int(10)) |
+				                                   (RoundInt(Float(c.w)) << Int(15)));
+			}
+			else
+			{
+				unsigned short mask = (writeA ? 0x8000 : 0x0000) |
+				                      (writeR ? 0x7C00 : 0x0000) |
+				                      (writeG ? 0x03E0 : 0x0000) |
+				                      (writeB ? 0x001F : 0x0000);
+				unsigned short unmask = ~mask;
+				*Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) |
+				                            (UShort(RoundInt(Float(c.z)) |
+				                                    (RoundInt(Float(c.y)) << Int(5)) |
+				                                    (RoundInt(Float(c.x)) << Int(10)) |
+				                                    (RoundInt(Float(c.w)) << Int(15))) &
+				                             UShort(mask));
+			}
+			break;
+		case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+		case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+		case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
+			if(writeRGBA)
+			{
+				*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) |
+				                               (RoundInt(Float(c.y)) << 10) |
+				                               (RoundInt(Float(c.z)) << 20) |
+				                               (RoundInt(Float(c.w)) << 30));
+			}
+			else
+			{
+				unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
+				                    (writeB ? 0x3FF00000 : 0x0000) |
+				                    (writeG ? 0x000FFC00 : 0x0000) |
+				                    (writeR ? 0x000003FF : 0x0000);
+				unsigned int unmask = ~mask;
+				*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
+				                          (UInt(RoundInt(Float(c.x)) |
+				                                (RoundInt(Float(c.y)) << 10) |
+				                                (RoundInt(Float(c.z)) << 20) |
+				                                (RoundInt(Float(c.w)) << 30)) &
+				                           UInt(mask));
+			}
+			break;
+		case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+		case VK_FORMAT_A2R10G10B10_UINT_PACK32:
+		case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
+			if(writeRGBA)
+			{
+				*Pointer<UInt>(element) = UInt(RoundInt(Float(c.z)) |
+				                               (RoundInt(Float(c.y)) << 10) |
+				                               (RoundInt(Float(c.x)) << 20) |
+				                               (RoundInt(Float(c.w)) << 30));
+			}
+			else
+			{
+				unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
+				                    (writeR ? 0x3FF00000 : 0x0000) |
+				                    (writeG ? 0x000FFC00 : 0x0000) |
+				                    (writeB ? 0x000003FF : 0x0000);
+				unsigned int unmask = ~mask;
+				*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
+				                          (UInt(RoundInt(Float(c.z)) |
+				                                (RoundInt(Float(c.y)) << 10) |
+				                                (RoundInt(Float(c.x)) << 20) |
+				                                (RoundInt(Float(c.w)) << 30)) &
+				                           UInt(mask));
+			}
+			break;
+		case VK_FORMAT_D16_UNORM:
+			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.x)));
+			break;
+		case VK_FORMAT_X8_D24_UNORM_PACK32:
+			*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) << 8);
+			break;
+		case VK_FORMAT_D32_SFLOAT:
+			*Pointer<Float>(element) = c.x;
+			break;
+		case VK_FORMAT_S8_UINT:
+			*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
+			break;
+		default:
+			UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
+			break;
 	}
 }
 
@@ -983,60 +983,60 @@
 
 	switch(state.sourceFormat)
 	{
-	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_SINT:
-		c = Insert(c, Int(*Pointer<SByte>(element + 3)), 3);
-		c = Insert(c, Int(*Pointer<SByte>(element + 2)), 2);
-	case VK_FORMAT_R8G8_SINT:
-		c = Insert(c, Int(*Pointer<SByte>(element + 1)), 1);
-	case VK_FORMAT_R8_SINT:
-		c = Insert(c, Int(*Pointer<SByte>(element)), 0);
-		break;
-	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-		c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000003FF))), 0);
-		c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10), 1);
-		c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20), 2);
-		c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30), 3);
-		break;
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_UINT:
-		c = Insert(c, Int(*Pointer<Byte>(element + 3)), 3);
-		c = Insert(c, Int(*Pointer<Byte>(element + 2)), 2);
-	case VK_FORMAT_R8G8_UINT:
-		c = Insert(c, Int(*Pointer<Byte>(element + 1)), 1);
-	case VK_FORMAT_R8_UINT:
-	case VK_FORMAT_S8_UINT:
-		c = Insert(c, Int(*Pointer<Byte>(element)), 0);
-		break;
-	case VK_FORMAT_R16G16B16A16_SINT:
-		c = Insert(c, Int(*Pointer<Short>(element + 6)), 3);
-		c = Insert(c, Int(*Pointer<Short>(element + 4)), 2);
-	case VK_FORMAT_R16G16_SINT:
-		c = Insert(c, Int(*Pointer<Short>(element + 2)), 1);
-	case VK_FORMAT_R16_SINT:
-		c = Insert(c, Int(*Pointer<Short>(element)), 0);
-		break;
-	case VK_FORMAT_R16G16B16A16_UINT:
-		c = Insert(c, Int(*Pointer<UShort>(element + 6)), 3);
-		c = Insert(c, Int(*Pointer<UShort>(element + 4)), 2);
-	case VK_FORMAT_R16G16_UINT:
-		c = Insert(c, Int(*Pointer<UShort>(element + 2)), 1);
-	case VK_FORMAT_R16_UINT:
-		c = Insert(c, Int(*Pointer<UShort>(element)), 0);
-		break;
-	case VK_FORMAT_R32G32B32A32_SINT:
-	case VK_FORMAT_R32G32B32A32_UINT:
-		c = *Pointer<Int4>(element);
-		break;
-	case VK_FORMAT_R32G32_SINT:
-	case VK_FORMAT_R32G32_UINT:
-		c = Insert(c, *Pointer<Int>(element + 4), 1);
-	case VK_FORMAT_R32_SINT:
-	case VK_FORMAT_R32_UINT:
-		c = Insert(c, *Pointer<Int>(element), 0);
-		break;
-	default:
-		UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
+		case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_SINT:
+			c = Insert(c, Int(*Pointer<SByte>(element + 3)), 3);
+			c = Insert(c, Int(*Pointer<SByte>(element + 2)), 2);
+		case VK_FORMAT_R8G8_SINT:
+			c = Insert(c, Int(*Pointer<SByte>(element + 1)), 1);
+		case VK_FORMAT_R8_SINT:
+			c = Insert(c, Int(*Pointer<SByte>(element)), 0);
+			break;
+		case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+			c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000003FF))), 0);
+			c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10), 1);
+			c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20), 2);
+			c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30), 3);
+			break;
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_UINT:
+			c = Insert(c, Int(*Pointer<Byte>(element + 3)), 3);
+			c = Insert(c, Int(*Pointer<Byte>(element + 2)), 2);
+		case VK_FORMAT_R8G8_UINT:
+			c = Insert(c, Int(*Pointer<Byte>(element + 1)), 1);
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_S8_UINT:
+			c = Insert(c, Int(*Pointer<Byte>(element)), 0);
+			break;
+		case VK_FORMAT_R16G16B16A16_SINT:
+			c = Insert(c, Int(*Pointer<Short>(element + 6)), 3);
+			c = Insert(c, Int(*Pointer<Short>(element + 4)), 2);
+		case VK_FORMAT_R16G16_SINT:
+			c = Insert(c, Int(*Pointer<Short>(element + 2)), 1);
+		case VK_FORMAT_R16_SINT:
+			c = Insert(c, Int(*Pointer<Short>(element)), 0);
+			break;
+		case VK_FORMAT_R16G16B16A16_UINT:
+			c = Insert(c, Int(*Pointer<UShort>(element + 6)), 3);
+			c = Insert(c, Int(*Pointer<UShort>(element + 4)), 2);
+		case VK_FORMAT_R16G16_UINT:
+			c = Insert(c, Int(*Pointer<UShort>(element + 2)), 1);
+		case VK_FORMAT_R16_UINT:
+			c = Insert(c, Int(*Pointer<UShort>(element)), 0);
+			break;
+		case VK_FORMAT_R32G32B32A32_SINT:
+		case VK_FORMAT_R32G32B32A32_UINT:
+			c = *Pointer<Int4>(element);
+			break;
+		case VK_FORMAT_R32G32_SINT:
+		case VK_FORMAT_R32G32_UINT:
+			c = Insert(c, *Pointer<Int>(element + 4), 1);
+		case VK_FORMAT_R32_SINT:
+		case VK_FORMAT_R32_UINT:
+			c = Insert(c, *Pointer<Int>(element), 0);
+			break;
+		default:
+			UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 	}
 
 	return c;
@@ -1052,220 +1052,220 @@
 
 	switch(state.destFormat)
 	{
-	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-		c = Min(As<UInt4>(c), UInt4(0x03FF, 0x03FF, 0x03FF, 0x0003));
-		break;
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_UINT:
-	case VK_FORMAT_R8G8B8_UINT:
-	case VK_FORMAT_R8G8_UINT:
-	case VK_FORMAT_R8_UINT:
-	case VK_FORMAT_R8G8B8A8_USCALED:
-	case VK_FORMAT_R8G8B8_USCALED:
-	case VK_FORMAT_R8G8_USCALED:
-	case VK_FORMAT_R8_USCALED:
-	case VK_FORMAT_S8_UINT:
-		c = Min(As<UInt4>(c), UInt4(0xFF));
-		break;
-	case VK_FORMAT_R16G16B16A16_UINT:
-	case VK_FORMAT_R16G16B16_UINT:
-	case VK_FORMAT_R16G16_UINT:
-	case VK_FORMAT_R16_UINT:
-	case VK_FORMAT_R16G16B16A16_USCALED:
-	case VK_FORMAT_R16G16B16_USCALED:
-	case VK_FORMAT_R16G16_USCALED:
-	case VK_FORMAT_R16_USCALED:
-		c = Min(As<UInt4>(c), UInt4(0xFFFF));
-		break;
-	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_SINT:
-	case VK_FORMAT_R8G8_SINT:
-	case VK_FORMAT_R8_SINT:
-	case VK_FORMAT_R8G8B8A8_SSCALED:
-	case VK_FORMAT_R8G8B8_SSCALED:
-	case VK_FORMAT_R8G8_SSCALED:
-	case VK_FORMAT_R8_SSCALED:
-		c = Min(Max(c, Int4(-0x80)), Int4(0x7F));
-		break;
-	case VK_FORMAT_R16G16B16A16_SINT:
-	case VK_FORMAT_R16G16B16_SINT:
-	case VK_FORMAT_R16G16_SINT:
-	case VK_FORMAT_R16_SINT:
-	case VK_FORMAT_R16G16B16A16_SSCALED:
-	case VK_FORMAT_R16G16B16_SSCALED:
-	case VK_FORMAT_R16G16_SSCALED:
-	case VK_FORMAT_R16_SSCALED:
-		c = Min(Max(c, Int4(-0x8000)), Int4(0x7FFF));
-		break;
-	default:
-		break;
+		case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+			c = Min(As<UInt4>(c), UInt4(0x03FF, 0x03FF, 0x03FF, 0x0003));
+			break;
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_R8G8B8_UINT:
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_R8G8B8A8_USCALED:
+		case VK_FORMAT_R8G8B8_USCALED:
+		case VK_FORMAT_R8G8_USCALED:
+		case VK_FORMAT_R8_USCALED:
+		case VK_FORMAT_S8_UINT:
+			c = Min(As<UInt4>(c), UInt4(0xFF));
+			break;
+		case VK_FORMAT_R16G16B16A16_UINT:
+		case VK_FORMAT_R16G16B16_UINT:
+		case VK_FORMAT_R16G16_UINT:
+		case VK_FORMAT_R16_UINT:
+		case VK_FORMAT_R16G16B16A16_USCALED:
+		case VK_FORMAT_R16G16B16_USCALED:
+		case VK_FORMAT_R16G16_USCALED:
+		case VK_FORMAT_R16_USCALED:
+			c = Min(As<UInt4>(c), UInt4(0xFFFF));
+			break;
+		case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_SINT:
+		case VK_FORMAT_R8G8_SINT:
+		case VK_FORMAT_R8_SINT:
+		case VK_FORMAT_R8G8B8A8_SSCALED:
+		case VK_FORMAT_R8G8B8_SSCALED:
+		case VK_FORMAT_R8G8_SSCALED:
+		case VK_FORMAT_R8_SSCALED:
+			c = Min(Max(c, Int4(-0x80)), Int4(0x7F));
+			break;
+		case VK_FORMAT_R16G16B16A16_SINT:
+		case VK_FORMAT_R16G16B16_SINT:
+		case VK_FORMAT_R16G16_SINT:
+		case VK_FORMAT_R16_SINT:
+		case VK_FORMAT_R16G16B16A16_SSCALED:
+		case VK_FORMAT_R16G16B16_SSCALED:
+		case VK_FORMAT_R16G16_SSCALED:
+		case VK_FORMAT_R16_SSCALED:
+			c = Min(Max(c, Int4(-0x8000)), Int4(0x7FFF));
+			break;
+		default:
+			break;
 	}
 
 	switch(state.destFormat)
 	{
-	case VK_FORMAT_B8G8R8A8_SINT:
-	case VK_FORMAT_B8G8R8A8_SSCALED:
-		if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); }
-	case VK_FORMAT_B8G8R8_SINT:
-	case VK_FORMAT_B8G8R8_SSCALED:
-		if(writeB) { *Pointer<SByte>(element) = SByte(Extract(c, 2)); }
-		if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); }
-		if(writeR) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_SINT:
-	case VK_FORMAT_R8G8B8A8_SSCALED:
-	case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
-		if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); }
-	case VK_FORMAT_R8G8B8_SINT:
-	case VK_FORMAT_R8G8B8_SSCALED:
-		if(writeB) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 2)); }
-	case VK_FORMAT_R8G8_SINT:
-	case VK_FORMAT_R8G8_SSCALED:
-		if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); }
-	case VK_FORMAT_R8_SINT:
-	case VK_FORMAT_R8_SSCALED:
-		if(writeR) { *Pointer<SByte>(element) = SByte(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
-	case VK_FORMAT_A2B10G10R10_SINT_PACK32:
-	case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
-	case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
-		if(writeRGBA)
-		{
-			*Pointer<UInt>(element) =
-				UInt((Extract(c, 0)) | (Extract(c, 1) << 10) | (Extract(c, 2) << 20) | (Extract(c, 3) << 30));
-		}
-		else
-		{
-			unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
-			                    (writeB ? 0x3FF00000 : 0x0000) |
-			                    (writeG ? 0x000FFC00 : 0x0000) |
-			                    (writeR ? 0x000003FF : 0x0000);
-			unsigned int unmask = ~mask;
-			*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
-				(UInt(Extract(c, 0) | (Extract(c, 1) << 10) | (Extract(c, 2) << 20) | (Extract(c, 3) << 30)) & UInt(mask));
-		}
-		break;
-	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
-	case VK_FORMAT_A2R10G10B10_SINT_PACK32:
-	case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
-	case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
-		if(writeRGBA)
-		{
-			*Pointer<UInt>(element) =
-				UInt((Extract(c, 2)) | (Extract(c, 1) << 10) | (Extract(c, 0) << 20) | (Extract(c, 3) << 30));
-		}
-		else
-		{
-			unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
-			                    (writeR ? 0x3FF00000 : 0x0000) |
-			                    (writeG ? 0x000FFC00 : 0x0000) |
-			                    (writeB ? 0x000003FF : 0x0000);
-			unsigned int unmask = ~mask;
-			*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
-				(UInt(Extract(c, 2) | (Extract(c, 1) << 10) | (Extract(c, 0) << 20) | (Extract(c, 3) << 30)) & UInt(mask));
-		}
-		break;
-	case VK_FORMAT_B8G8R8A8_UINT:
-	case VK_FORMAT_B8G8R8A8_USCALED:
-		if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); }
-	case VK_FORMAT_B8G8R8_UINT:
-	case VK_FORMAT_B8G8R8_USCALED:
-	case VK_FORMAT_B8G8R8_SRGB:
-		if(writeB) { *Pointer<Byte>(element) = Byte(Extract(c, 2)); }
-		if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); }
-		if(writeR) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
-	case VK_FORMAT_R8G8B8A8_UINT:
-	case VK_FORMAT_R8G8B8A8_USCALED:
-	case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
-		if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); }
-	case VK_FORMAT_R8G8B8_UINT:
-	case VK_FORMAT_R8G8B8_USCALED:
-		if(writeB) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 2)); }
-	case VK_FORMAT_R8G8_UINT:
-	case VK_FORMAT_R8G8_USCALED:
-		if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); }
-	case VK_FORMAT_R8_UINT:
-	case VK_FORMAT_R8_USCALED:
-	case VK_FORMAT_S8_UINT:
-		if(writeR) { *Pointer<Byte>(element) = Byte(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_R16G16B16A16_SINT:
-	case VK_FORMAT_R16G16B16A16_SSCALED:
-		if(writeA) { *Pointer<Short>(element + 6) = Short(Extract(c, 3)); }
-	case VK_FORMAT_R16G16B16_SINT:
-	case VK_FORMAT_R16G16B16_SSCALED:
-		if(writeB) { *Pointer<Short>(element + 4) = Short(Extract(c, 2)); }
-	case VK_FORMAT_R16G16_SINT:
-	case VK_FORMAT_R16G16_SSCALED:
-		if(writeG) { *Pointer<Short>(element + 2) = Short(Extract(c, 1)); }
-	case VK_FORMAT_R16_SINT:
-	case VK_FORMAT_R16_SSCALED:
-		if(writeR) { *Pointer<Short>(element) = Short(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_R16G16B16A16_UINT:
-	case VK_FORMAT_R16G16B16A16_USCALED:
-		if(writeA) { *Pointer<UShort>(element + 6) = UShort(Extract(c, 3)); }
-	case VK_FORMAT_R16G16B16_UINT:
-	case VK_FORMAT_R16G16B16_USCALED:
-		if(writeB) { *Pointer<UShort>(element + 4) = UShort(Extract(c, 2)); }
-	case VK_FORMAT_R16G16_UINT:
-	case VK_FORMAT_R16G16_USCALED:
-		if(writeG) { *Pointer<UShort>(element + 2) = UShort(Extract(c, 1)); }
-	case VK_FORMAT_R16_UINT:
-	case VK_FORMAT_R16_USCALED:
-		if(writeR) { *Pointer<UShort>(element) = UShort(Extract(c, 0)); }
-		break;
-	case VK_FORMAT_R32G32B32A32_SINT:
-		if(writeRGBA)
-		{
-			*Pointer<Int4>(element) = c;
-		}
-		else
-		{
+		case VK_FORMAT_B8G8R8A8_SINT:
+		case VK_FORMAT_B8G8R8A8_SSCALED:
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); }
+		case VK_FORMAT_B8G8R8_SINT:
+		case VK_FORMAT_B8G8R8_SSCALED:
+			if(writeB) { *Pointer<SByte>(element) = SByte(Extract(c, 2)); }
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); }
+			if(writeR) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_SINT:
+		case VK_FORMAT_R8G8B8A8_SSCALED:
+		case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); }
+		case VK_FORMAT_R8G8B8_SINT:
+		case VK_FORMAT_R8G8B8_SSCALED:
+			if(writeB) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 2)); }
+		case VK_FORMAT_R8G8_SINT:
+		case VK_FORMAT_R8G8_SSCALED:
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); }
+		case VK_FORMAT_R8_SINT:
+		case VK_FORMAT_R8_SSCALED:
+			if(writeR) { *Pointer<SByte>(element) = SByte(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+		case VK_FORMAT_A2B10G10R10_SINT_PACK32:
+		case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
+		case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
+			if(writeRGBA)
+			{
+				*Pointer<UInt>(element) =
+				    UInt((Extract(c, 0)) | (Extract(c, 1) << 10) | (Extract(c, 2) << 20) | (Extract(c, 3) << 30));
+			}
+			else
+			{
+				unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
+				                    (writeB ? 0x3FF00000 : 0x0000) |
+				                    (writeG ? 0x000FFC00 : 0x0000) |
+				                    (writeR ? 0x000003FF : 0x0000);
+				unsigned int unmask = ~mask;
+				*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
+				                          (UInt(Extract(c, 0) | (Extract(c, 1) << 10) | (Extract(c, 2) << 20) | (Extract(c, 3) << 30)) & UInt(mask));
+			}
+			break;
+		case VK_FORMAT_A2R10G10B10_UINT_PACK32:
+		case VK_FORMAT_A2R10G10B10_SINT_PACK32:
+		case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
+		case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
+			if(writeRGBA)
+			{
+				*Pointer<UInt>(element) =
+				    UInt((Extract(c, 2)) | (Extract(c, 1) << 10) | (Extract(c, 0) << 20) | (Extract(c, 3) << 30));
+			}
+			else
+			{
+				unsigned int mask = (writeA ? 0xC0000000 : 0x0000) |
+				                    (writeR ? 0x3FF00000 : 0x0000) |
+				                    (writeG ? 0x000FFC00 : 0x0000) |
+				                    (writeB ? 0x000003FF : 0x0000);
+				unsigned int unmask = ~mask;
+				*Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) |
+				                          (UInt(Extract(c, 2) | (Extract(c, 1) << 10) | (Extract(c, 0) << 20) | (Extract(c, 3) << 30)) & UInt(mask));
+			}
+			break;
+		case VK_FORMAT_B8G8R8A8_UINT:
+		case VK_FORMAT_B8G8R8A8_USCALED:
+			if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); }
+		case VK_FORMAT_B8G8R8_UINT:
+		case VK_FORMAT_B8G8R8_USCALED:
+		case VK_FORMAT_B8G8R8_SRGB:
+			if(writeB) { *Pointer<Byte>(element) = Byte(Extract(c, 2)); }
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); }
+			if(writeR) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+		case VK_FORMAT_R8G8B8A8_UINT:
+		case VK_FORMAT_R8G8B8A8_USCALED:
+		case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
+			if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); }
+		case VK_FORMAT_R8G8B8_UINT:
+		case VK_FORMAT_R8G8B8_USCALED:
+			if(writeB) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 2)); }
+		case VK_FORMAT_R8G8_UINT:
+		case VK_FORMAT_R8G8_USCALED:
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); }
+		case VK_FORMAT_R8_UINT:
+		case VK_FORMAT_R8_USCALED:
+		case VK_FORMAT_S8_UINT:
+			if(writeR) { *Pointer<Byte>(element) = Byte(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_R16G16B16A16_SINT:
+		case VK_FORMAT_R16G16B16A16_SSCALED:
+			if(writeA) { *Pointer<Short>(element + 6) = Short(Extract(c, 3)); }
+		case VK_FORMAT_R16G16B16_SINT:
+		case VK_FORMAT_R16G16B16_SSCALED:
+			if(writeB) { *Pointer<Short>(element + 4) = Short(Extract(c, 2)); }
+		case VK_FORMAT_R16G16_SINT:
+		case VK_FORMAT_R16G16_SSCALED:
+			if(writeG) { *Pointer<Short>(element + 2) = Short(Extract(c, 1)); }
+		case VK_FORMAT_R16_SINT:
+		case VK_FORMAT_R16_SSCALED:
+			if(writeR) { *Pointer<Short>(element) = Short(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_R16G16B16A16_UINT:
+		case VK_FORMAT_R16G16B16A16_USCALED:
+			if(writeA) { *Pointer<UShort>(element + 6) = UShort(Extract(c, 3)); }
+		case VK_FORMAT_R16G16B16_UINT:
+		case VK_FORMAT_R16G16B16_USCALED:
+			if(writeB) { *Pointer<UShort>(element + 4) = UShort(Extract(c, 2)); }
+		case VK_FORMAT_R16G16_UINT:
+		case VK_FORMAT_R16G16_USCALED:
+			if(writeG) { *Pointer<UShort>(element + 2) = UShort(Extract(c, 1)); }
+		case VK_FORMAT_R16_UINT:
+		case VK_FORMAT_R16_USCALED:
+			if(writeR) { *Pointer<UShort>(element) = UShort(Extract(c, 0)); }
+			break;
+		case VK_FORMAT_R32G32B32A32_SINT:
+			if(writeRGBA)
+			{
+				*Pointer<Int4>(element) = c;
+			}
+			else
+			{
+				if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
+				if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
+				if(writeB) { *Pointer<Int>(element + 8) = Extract(c, 2); }
+				if(writeA) { *Pointer<Int>(element + 12) = Extract(c, 3); }
+			}
+			break;
+		case VK_FORMAT_R32G32B32_SINT:
 			if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
 			if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
 			if(writeB) { *Pointer<Int>(element + 8) = Extract(c, 2); }
-			if(writeA) { *Pointer<Int>(element + 12) = Extract(c, 3); }
-		}
-		break;
-	case VK_FORMAT_R32G32B32_SINT:
-		if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
-		if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
-		if(writeB) { *Pointer<Int>(element + 8) = Extract(c, 2); }
-		break;
-	case VK_FORMAT_R32G32_SINT:
-		if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
-		if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
-		break;
-	case VK_FORMAT_R32_SINT:
-		if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
-		break;
-	case VK_FORMAT_R32G32B32A32_UINT:
-		if(writeRGBA)
-		{
-			*Pointer<UInt4>(element) = As<UInt4>(c);
-		}
-		else
-		{
-			if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
-			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); }
+			break;
+		case VK_FORMAT_R32G32_SINT:
+			if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
+			if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
+			break;
+		case VK_FORMAT_R32_SINT:
+			if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
+			break;
+		case VK_FORMAT_R32G32B32A32_UINT:
+			if(writeRGBA)
+			{
+				*Pointer<UInt4>(element) = As<UInt4>(c);
+			}
+			else
+			{
+				if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
+				if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); }
+				if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(Extract(c, 2)); }
+				if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(Extract(c, 3)); }
+			}
+			break;
+		case VK_FORMAT_R32G32B32_UINT:
 			if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(Extract(c, 2)); }
-			if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(Extract(c, 3)); }
-		}
-		break;
-	case VK_FORMAT_R32G32B32_UINT:
-		if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(Extract(c, 2)); }
-	case VK_FORMAT_R32G32_UINT:
-		if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); }
-	case VK_FORMAT_R32_UINT:
-		if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
-		break;
-	default:
-		UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
+		case VK_FORMAT_R32G32_UINT:
+			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); }
+		case VK_FORMAT_R32_UINT:
+			if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
+			break;
+		default:
+			UNSUPPORTED("Blitter destination format %d", (int)state.destFormat);
 	}
 }
 
@@ -1281,14 +1281,14 @@
 		// then the whole range of the int or uint color must be scaled between 0 and 1.
 		switch(state.sourceFormat)
 		{
-		case VK_FORMAT_R32G32B32A32_SINT:
-			unscale = float4(static_cast<float>(0x7FFFFFFF));
-			break;
-		case VK_FORMAT_R32G32B32A32_UINT:
-			unscale = float4(static_cast<float>(0xFFFFFFFF));
-			break;
-		default:
-			UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
+			case VK_FORMAT_R32G32B32A32_SINT:
+				unscale = float4(static_cast<float>(0x7FFFFFFF));
+				break;
+			case VK_FORMAT_R32G32B32A32_UINT:
+				unscale = float4(static_cast<float>(0xFFFFFFFF));
+				break;
+			default:
+				UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat);
 		}
 	}
 	else
@@ -1301,12 +1301,12 @@
 	bool srcSRGB = state.sourceFormat.isSRGBformat();
 	bool dstSRGB = state.destFormat.isSRGBformat();
 
-	if(state.allowSRGBConversion && ((srcSRGB && !preScaled) || dstSRGB))   // One of the formats is sRGB encoded.
+	if(state.allowSRGBConversion && ((srcSRGB && !preScaled) || dstSRGB))  // One of the formats is sRGB encoded.
 	{
-		value *= preScaled ? Float4(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z, 1.0f / scale.w) : // Unapply scale
-		                     Float4(1.0f / unscale.x, 1.0f / unscale.y, 1.0f / unscale.z, 1.0f / unscale.w); // Apply unscale
+		value *= preScaled ? Float4(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z, 1.0f / scale.w) :  // Unapply scale
+		             Float4(1.0f / unscale.x, 1.0f / unscale.y, 1.0f / unscale.z, 1.0f / unscale.w);   // Apply unscale
 		value = (srcSRGB && !preScaled) ? sRGBtoLinear(value) : LinearToSRGB(value);
-		value *= Float4(scale.x, scale.y, scale.z, scale.w); // Apply scale
+		value *= Float4(scale.x, scale.y, scale.z, scale.w);  // Apply scale
 	}
 	else if(unscale != scale)
 	{
@@ -1348,7 +1348,7 @@
 	Int4 linear = CmpLT(c, Float4(0.04045f));
 
 	Float4 s = c;
-	s.xyz = As<Float4>((linear & As<Int4>(lc)) | (~linear & As<Int4>(ec)));   // TODO: IfThenElse()
+	s.xyz = As<Float4>((linear & As<Int4>(lc)) | (~linear & As<Int4>(ec)));  // TODO: IfThenElse()
 
 	return s;
 }
@@ -1359,23 +1359,23 @@
 	{
 		Pointer<Byte> blit(function.Arg<0>());
 
-		Pointer<Byte> source = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData,source));
-		Pointer<Byte> dest = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData,dest));
-		Int sPitchB = *Pointer<Int>(blit + OFFSET(BlitData,sPitchB));
-		Int dPitchB = *Pointer<Int>(blit + OFFSET(BlitData,dPitchB));
+		Pointer<Byte> source = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData, source));
+		Pointer<Byte> dest = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData, dest));
+		Int sPitchB = *Pointer<Int>(blit + OFFSET(BlitData, sPitchB));
+		Int dPitchB = *Pointer<Int>(blit + OFFSET(BlitData, dPitchB));
 
-		Float x0 = *Pointer<Float>(blit + OFFSET(BlitData,x0));
-		Float y0 = *Pointer<Float>(blit + OFFSET(BlitData,y0));
-		Float w = *Pointer<Float>(blit + OFFSET(BlitData,w));
-		Float h = *Pointer<Float>(blit + OFFSET(BlitData,h));
+		Float x0 = *Pointer<Float>(blit + OFFSET(BlitData, x0));
+		Float y0 = *Pointer<Float>(blit + OFFSET(BlitData, y0));
+		Float w = *Pointer<Float>(blit + OFFSET(BlitData, w));
+		Float h = *Pointer<Float>(blit + OFFSET(BlitData, h));
 
-		Int x0d = *Pointer<Int>(blit + OFFSET(BlitData,x0d));
-		Int x1d = *Pointer<Int>(blit + OFFSET(BlitData,x1d));
-		Int y0d = *Pointer<Int>(blit + OFFSET(BlitData,y0d));
-		Int y1d = *Pointer<Int>(blit + OFFSET(BlitData,y1d));
+		Int x0d = *Pointer<Int>(blit + OFFSET(BlitData, x0d));
+		Int x1d = *Pointer<Int>(blit + OFFSET(BlitData, x1d));
+		Int y0d = *Pointer<Int>(blit + OFFSET(BlitData, y0d));
+		Int y1d = *Pointer<Int>(blit + OFFSET(BlitData, y1d));
 
-		Int sWidth = *Pointer<Int>(blit + OFFSET(BlitData,sWidth));
-		Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData,sHeight));
+		Int sWidth = *Pointer<Int>(blit + OFFSET(BlitData, sWidth));
+		Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData, sHeight));
 
 		bool intSrc = state.sourceFormat.isNonNormalizedInteger();
 		bool intDst = state.destFormat.isNonNormalizedInteger();
@@ -1389,7 +1389,7 @@
 		Float4 constantColorF;
 		if(state.clearOperation)
 		{
-			if(intBoth) // Integer types
+			if(intBoth)  // Integer types
 			{
 				constantColorI = readInt4(source, state);
 				hasConstantColorI = true;
@@ -1431,7 +1431,7 @@
 						d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
 					}
 				}
-				else if(intBoth) // Integer types do not support filtering
+				else if(intBoth)  // Integer types do not support filtering
 				{
 					Int X = Int(x);
 					Int Y = Int(y);
@@ -1450,7 +1450,7 @@
 					{
 						write(color, d, state);
 
-						d += *Pointer<Int>(blit + OFFSET(BlitData,dSliceB));
+						d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
 					}
 				}
 				else
@@ -1473,9 +1473,9 @@
 
 						color = readFloat4(s, state);
 
-						if(state.srcSamples > 1) // Resolve multisampled source
+						if(state.srcSamples > 1)  // Resolve multisampled source
 						{
-							if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
+							if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat())  // sRGB -> RGB
 							{
 								ApplyScaleAndClamp(color, state);
 								preScaled = true;
@@ -1486,7 +1486,7 @@
 								s += *Pointer<Int>(blit + OFFSET(BlitData, sSliceB));
 								color = readFloat4(s, state);
 
-								if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
+								if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat())  // sRGB -> RGB
 								{
 									ApplyScaleAndClamp(color, state);
 									preScaled = true;
@@ -1496,7 +1496,7 @@
 							color = accum * Float4(1.0f / static_cast<float>(state.srcSamples));
 						}
 					}
-					else   // Bilinear filtering
+					else  // Bilinear filtering
 					{
 						Float X = x;
 						Float Y = y;
@@ -1528,7 +1528,7 @@
 						Float4 c10 = readFloat4(s10, state);
 						Float4 c11 = readFloat4(s11, state);
 
-						if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
+						if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat())  // sRGB -> RGB
 						{
 							ApplyScaleAndClamp(c00, state);
 							ApplyScaleAndClamp(c01, state);
@@ -1552,7 +1552,7 @@
 					{
 						write(color, d, state);
 
-						d += *Pointer<Int>(blit + OFFSET(BlitData,dSliceB));
+						d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
 					}
 				}
 			}
@@ -1594,7 +1594,7 @@
 {
 	auto aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask);
 	auto format = src->getFormat(aspect);
-	State state(format, format, VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_1_BIT, Options{false, false});
+	State state(format, format, VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_1_BIT, Options{ false, false });
 
 	auto blitRoutine = getBlitRoutine(state);
 	if(!blitRoutine)
@@ -1602,24 +1602,23 @@
 		return;
 	}
 
-	BlitData data =
-	{
-		nullptr, // source
-		dst, // dest
-		src->rowPitchBytes(aspect, subresource.mipLevel),   // sPitchB
-		bufferRowPitch,   // dPitchB
-		src->slicePitchBytes(aspect, subresource.mipLevel), // sSliceB
-		bufferSlicePitch, // dSliceB
+	BlitData data = {
+		nullptr,                                             // source
+		dst,                                                 // dest
+		src->rowPitchBytes(aspect, subresource.mipLevel),    // sPitchB
+		bufferRowPitch,                                      // dPitchB
+		src->slicePitchBytes(aspect, subresource.mipLevel),  // sSliceB
+		bufferSlicePitch,                                    // dSliceB
 
 		0, 0, 1, 1,
 
-		0, // y0d
-		static_cast<int>(extent.height), // y1d
-		0, // x0d
-		static_cast<int>(extent.width), // x1d
+		0,                                // y0d
+		static_cast<int>(extent.height),  // y1d
+		0,                                // x0d
+		static_cast<int>(extent.width),   // x1d
 
-		static_cast<int>(extent.width), // sWidth
-		static_cast<int>(extent.height) // sHeight;
+		static_cast<int>(extent.width),  // sWidth
+		static_cast<int>(extent.height)  // sHeight;
 	};
 
 	VkOffset3D srcOffset = { 0, 0, offset.z };
@@ -1627,8 +1626,7 @@
 	VkImageSubresourceLayers srcSubresLayers = subresource;
 	srcSubresLayers.layerCount = 1;
 
-	VkImageSubresourceRange srcSubresRange =
-	{
+	VkImageSubresourceRange srcSubresRange = {
 		subresource.aspectMask,
 		subresource.mipLevel,
 		1,
@@ -1657,7 +1655,7 @@
 {
 	auto aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask);
 	auto format = dst->getFormat(aspect);
-	State state(format, format, VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_1_BIT, Options{false, false});
+	State state(format, format, VK_SAMPLE_COUNT_1_BIT, VK_SAMPLE_COUNT_1_BIT, Options{ false, false });
 
 	auto blitRoutine = getBlitRoutine(state);
 	if(!blitRoutine)
@@ -1665,27 +1663,26 @@
 		return;
 	}
 
-	BlitData data =
-	{
-		src, // source
-		nullptr, // dest
-		bufferRowPitch,   // sPitchB
-		dst->rowPitchBytes(aspect, subresource.mipLevel),   // dPitchB
-		bufferSlicePitch, // sSliceB
-		dst->slicePitchBytes(aspect, subresource.mipLevel), // dSliceB
+	BlitData data = {
+		src,                                                 // source
+		nullptr,                                             // dest
+		bufferRowPitch,                                      // sPitchB
+		dst->rowPitchBytes(aspect, subresource.mipLevel),    // dPitchB
+		bufferSlicePitch,                                    // sSliceB
+		dst->slicePitchBytes(aspect, subresource.mipLevel),  // dSliceB
 
-		static_cast<float>(-offset.x), // x0
-		static_cast<float>(-offset.y), // y0
-		1.0f, // w
-		1.0f, // h
+		static_cast<float>(-offset.x),  // x0
+		static_cast<float>(-offset.y),  // y0
+		1.0f,                           // w
+		1.0f,                           // h
 
-		offset.y, // y0d
-		static_cast<int>(offset.y + extent.height), // y1d
-		offset.x, // x0d
-		static_cast<int>(offset.x + extent.width), // x1d
+		offset.y,                                    // y0d
+		static_cast<int>(offset.y + extent.height),  // y1d
+		offset.x,                                    // x0d
+		static_cast<int>(offset.x + extent.width),   // x1d
 
-		static_cast<int>(extent.width), // sWidth
-		static_cast<int>(extent.height) // sHeight;
+		static_cast<int>(extent.width),  // sWidth
+		static_cast<int>(extent.height)  // sHeight;
 	};
 
 	VkOffset3D dstOffset = { 0, 0, offset.z };
@@ -1693,8 +1690,7 @@
 	VkImageSubresourceLayers dstSubresLayers = subresource;
 	dstSubresLayers.layerCount = 1;
 
-	VkImageSubresourceRange dstSubresRange =
-	{
+	VkImageSubresourceRange dstSubresRange = {
 		subresource.aspectMask,
 		subresource.mipLevel,
 		1,
@@ -1763,9 +1759,9 @@
 
 	bool doFilter = (filter != VK_FILTER_NEAREST);
 	bool allowSRGBConversion =
-		doFilter ||
-		(src->getSampleCountFlagBits() > 1) ||
-		(srcFormat.isSRGBformat() != dstFormat.isSRGBformat());
+	    doFilter ||
+	    (src->getSampleCountFlagBits() > 1) ||
+	    (srcFormat.isSRGBformat() != dstFormat.isSRGBformat());
 
 	State state(src->getFormat(srcAspect), dst->getFormat(dstAspect), src->getSampleCountFlagBits(), dst->getSampleCountFlagBits(),
 	            Options{ doFilter, allowSRGBConversion });
@@ -1781,50 +1777,46 @@
 		return;
 	}
 
-	BlitData data =
-	{
-		nullptr, // source
-		nullptr, // dest
-		src->rowPitchBytes(srcAspect, region.srcSubresource.mipLevel),   // sPitchB
-		dst->rowPitchBytes(dstAspect, region.dstSubresource.mipLevel),   // dPitchB
-		src->slicePitchBytes(srcAspect, region.srcSubresource.mipLevel), // sSliceB
-		dst->slicePitchBytes(dstAspect, region.dstSubresource.mipLevel), // dSliceB
+	BlitData data = {
+		nullptr,                                                          // source
+		nullptr,                                                          // dest
+		src->rowPitchBytes(srcAspect, region.srcSubresource.mipLevel),    // sPitchB
+		dst->rowPitchBytes(dstAspect, region.dstSubresource.mipLevel),    // dPitchB
+		src->slicePitchBytes(srcAspect, region.srcSubresource.mipLevel),  // sSliceB
+		dst->slicePitchBytes(dstAspect, region.dstSubresource.mipLevel),  // dSliceB
 
 		x0,
 		y0,
 		widthRatio,
 		heightRatio,
 
-		region.dstOffsets[0].y, // y0d
-		region.dstOffsets[1].y, // y1d
-		region.dstOffsets[0].x, // x0d
-		region.dstOffsets[1].x, // x1d
+		region.dstOffsets[0].y,  // y0d
+		region.dstOffsets[1].y,  // y1d
+		region.dstOffsets[0].x,  // x0d
+		region.dstOffsets[1].x,  // x1d
 
-		static_cast<int>(srcExtent.width), // sWidth
-		static_cast<int>(srcExtent.height) // sHeight;
+		static_cast<int>(srcExtent.width),  // sWidth
+		static_cast<int>(srcExtent.height)  // sHeight;
 	};
 
 	VkOffset3D srcOffset = { 0, 0, region.srcOffsets[0].z };
 	VkOffset3D dstOffset = { 0, 0, region.dstOffsets[0].z };
 
-	VkImageSubresourceLayers srcSubresLayers =
-	{
+	VkImageSubresourceLayers srcSubresLayers = {
 		region.srcSubresource.aspectMask,
 		region.srcSubresource.mipLevel,
 		region.srcSubresource.baseArrayLayer,
 		1
 	};
 
-	VkImageSubresourceLayers dstSubresLayers =
-	{
+	VkImageSubresourceLayers dstSubresLayers = {
 		region.dstSubresource.aspectMask,
 		region.dstSubresource.mipLevel,
 		region.dstSubresource.baseArrayLayer,
 		1
 	};
 
-	VkImageSubresourceRange srcSubresRange =
-	{
+	VkImageSubresourceRange srcSubresRange = {
 		region.srcSubresource.aspectMask,
 		region.srcSubresource.mipLevel,
 		1,
@@ -1854,7 +1846,7 @@
 	}
 }
 
-void Blitter::computeCubeCorner(Pointer<Byte>& layer, Int& x0, Int& x1, Int& y0, Int& y1, Int& pitchB, const State& state)
+void Blitter::computeCubeCorner(Pointer<Byte> &layer, Int &x0, Int &x1, Int &y0, Int &y1, Int &pitchB, const State &state)
 {
 	int bytes = state.sourceFormat.bytes();
 
@@ -1867,7 +1859,7 @@
 	write(c, layer + ComputeOffset(x0, y0, pitchB, bytes), state);
 }
 
-Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State& state)
+Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State &state)
 {
 	// Reading and writing from/to the same image
 	ASSERT(state.sourceFormat == state.destFormat);
@@ -1888,7 +1880,7 @@
 		UInt dim = *Pointer<Int>(blit + OFFSET(CubeBorderData, dim));
 
 		// Low Border, Low Pixel, High Border, High Pixel
-		Int LB(-1), LP(0), HB(dim), HP(dim-1);
+		Int LB(-1), LP(0), HB(dim), HP(dim - 1);
 
 		for(int face = 0; face < 6; face++)
 		{
@@ -1903,7 +1895,7 @@
 	return function("BlitRoutine");
 }
 
-void Blitter::updateBorders(vk::Image* image, const VkImageSubresourceLayers& subresourceLayers)
+void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &subresourceLayers)
 {
 	if(image->getArrayLayers() < (subresourceLayers.baseArrayLayer + 6))
 	{
@@ -1975,8 +1967,7 @@
 	}
 
 	VkExtent3D extent = image->getMipLevelExtent(aspect, subresourceLayers.mipLevel);
-	CubeBorderData data =
-	{
+	CubeBorderData data = {
 		image->getTexelPointer({ 0, 0, 0 }, posX),
 		image->rowPitchBytes(aspect, subresourceLayers.mipLevel),
 		static_cast<uint32_t>(image->getLayerSize(aspect)),
@@ -1985,9 +1976,9 @@
 	cornerUpdateRoutine(&data);
 }
 
-void Blitter::copyCubeEdge(vk::Image* image,
-                           const VkImageSubresourceLayers& dstSubresourceLayers, Edge dstEdge,
-                           const VkImageSubresourceLayers& srcSubresourceLayers, Edge srcEdge)
+void Blitter::copyCubeEdge(vk::Image *image,
+                           const VkImageSubresourceLayers &dstSubresourceLayers, Edge dstEdge,
+                           const VkImageSubresourceLayers &srcSubresourceLayers, Edge srcEdge)
 {
 	ASSERT(srcSubresourceLayers.aspectMask == dstSubresourceLayers.aspectMask);
 	ASSERT(srcSubresourceLayers.mipLevel == dstSubresourceLayers.mipLevel);
@@ -2041,8 +2032,8 @@
 		dstOffset.y += reverse ? h : 1;
 	}
 
-	const uint8_t* src = static_cast<const uint8_t*>(image->getTexelPointer(srcOffset, srcSubresourceLayers));
-	uint8_t *dst = static_cast<uint8_t*>(image->getTexelPointer(dstOffset, dstSubresourceLayers));
+	const uint8_t *src = static_cast<const uint8_t *>(image->getTexelPointer(srcOffset, srcSubresourceLayers));
+	uint8_t *dst = static_cast<uint8_t *>(image->getTexelPointer(dstOffset, dstSubresourceLayers));
 	ASSERT((src < image->end()) && ((src + (w * srcDelta)) < image->end()));
 	ASSERT((dst < image->end()) && ((dst + (w * dstDelta)) < image->end()));
 
@@ -2052,4 +2043,4 @@
 	}
 }
 
-}  // namepspace sw
+}  // namespace sw
diff --git a/src/Device/Blitter.hpp b/src/Device/Blitter.hpp
index 317fdcc..ef8977e 100644
--- a/src/Device/Blitter.hpp
+++ b/src/Device/Blitter.hpp
@@ -20,8 +20,8 @@
 #include "Reactor/Reactor.hpp"
 #include "Vulkan/VkFormat.h"
 
-#include <mutex>
 #include <cstring>
+#include <mutex>
 
 namespace vk {
 
@@ -38,9 +38,19 @@
 	{
 		explicit Options() = default;
 		explicit Options(bool filter, bool allowSRGBConversion)
-			: writeMask(0xF), clearOperation(false), filter(filter), allowSRGBConversion(allowSRGBConversion), clampToEdge(false) {}
+		    : writeMask(0xF)
+		    , clearOperation(false)
+		    , filter(filter)
+		    , allowSRGBConversion(allowSRGBConversion)
+		    , clampToEdge(false)
+		{}
 		explicit Options(unsigned int writeMask)
-			: writeMask(writeMask), clearOperation(true), filter(false), allowSRGBConversion(true), clampToEdge(false) {}
+		    : writeMask(writeMask)
+		    , clearOperation(true)
+		    , filter(false)
+		    , allowSRGBConversion(true)
+		    , clampToEdge(false)
+		{}
 
 		union
 		{
@@ -63,10 +73,21 @@
 
 	struct State : Memset<State>, Options
 	{
-		State() : Memset(this, 0) {}
-		State(const Options &options) : Memset(this, 0), Options(options) {}
-		State(vk::Format sourceFormat, vk::Format destFormat, int srcSamples, int destSamples, const Options &options) :
-			Memset(this, 0), Options(options), sourceFormat(sourceFormat), destFormat(destFormat), srcSamples(srcSamples), destSamples(destSamples) {}
+		State()
+		    : Memset(this, 0)
+		{}
+		State(const Options &options)
+		    : Memset(this, 0)
+		    , Options(options)
+		{}
+		State(vk::Format sourceFormat, vk::Format destFormat, int srcSamples, int destSamples, const Options &options)
+		    : Memset(this, 0)
+		    , Options(options)
+		    , sourceFormat(sourceFormat)
+		    , destFormat(destFormat)
+		    , srcSamples(srcSamples)
+		    , destSamples(destSamples)
+		{}
 
 		bool operator==(const State &state) const
 		{
@@ -115,18 +136,24 @@
 	Blitter();
 	virtual ~Blitter();
 
-	void clear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea = nullptr);
+	void clear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea = nullptr);
 
 	void blit(const vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter);
 	void blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *dst, int bufferRowPitch, int bufferSlicePitch);
 	void blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *src, int bufferRowPitch, int bufferSlicePitch);
 
-	void updateBorders(vk::Image* image, const VkImageSubresourceLayers& subresourceLayers);
+	void updateBorders(vk::Image *image, const VkImageSubresourceLayers &subresourceLayers);
 
 private:
-	enum Edge { TOP, BOTTOM, RIGHT, LEFT };
+	enum Edge
+	{
+		TOP,
+		BOTTOM,
+		RIGHT,
+		LEFT
+	};
 
-	bool fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format& viewFormat, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea);
+	bool fastClear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea);
 
 	Float4 readFloat4(Pointer<Byte> element, const State &state);
 	void write(Float4 &color, Pointer<Byte> element, const State &state);
@@ -137,27 +164,27 @@
 	static Float4 LinearToSRGB(Float4 &color);
 	static Float4 sRGBtoLinear(Float4 &color);
 
-	using BlitFunction = FunctionT<void(const BlitData*)>;
+	using BlitFunction = FunctionT<void(const BlitData *)>;
 	using BlitRoutineType = BlitFunction::RoutineType;
 	BlitRoutineType getBlitRoutine(const State &state);
 	BlitRoutineType generate(const State &state);
 
-	using CornerUpdateFunction = FunctionT<void(const CubeBorderData*)>;
+	using CornerUpdateFunction = FunctionT<void(const CubeBorderData *)>;
 	using CornerUpdateRoutineType = CornerUpdateFunction::RoutineType;
 	CornerUpdateRoutineType getCornerUpdateRoutine(const State &state);
-	CornerUpdateRoutineType generateCornerUpdate(const State& state);
-	void computeCubeCorner(Pointer<Byte>& layer, Int& x0, Int& x1, Int& y0, Int& y1, Int& pitchB, const State& state);
+	CornerUpdateRoutineType generateCornerUpdate(const State &state);
+	void computeCubeCorner(Pointer<Byte> &layer, Int &x0, Int &x1, Int &y0, Int &y1, Int &pitchB, const State &state);
 
-	void copyCubeEdge(vk::Image* image,
-                      const VkImageSubresourceLayers& dstSubresourceLayers, Edge dstEdge,
-                      const VkImageSubresourceLayers& srcSubresourceLayers, Edge srcEdge);
+	void copyCubeEdge(vk::Image *image,
+	                  const VkImageSubresourceLayers &dstSubresourceLayers, Edge dstEdge,
+	                  const VkImageSubresourceLayers &srcSubresourceLayers, Edge srcEdge);
 
 	std::mutex blitMutex;
-	RoutineCacheT<State, BlitFunction::CFunctionType> blitCache; // guarded by blitMutex
+	RoutineCacheT<State, BlitFunction::CFunctionType> blitCache;  // guarded by blitMutex
 	std::mutex cornerUpdateMutex;
-	RoutineCacheT<State, CornerUpdateFunction::CFunctionType> cornerUpdateCache; // guarded by cornerUpdateMutex
+	RoutineCacheT<State, CornerUpdateFunction::CFunctionType> cornerUpdateCache;  // guarded by cornerUpdateMutex
 };
 
 }  // namespace sw
 
-#endif   // sw_Blitter_hpp
+#endif  // sw_Blitter_hpp
diff --git a/src/Device/Clipper.cpp b/src/Device/Clipper.cpp
index d36de8c..f5a75e5 100644
--- a/src/Device/Clipper.cpp
+++ b/src/Device/Clipper.cpp
@@ -263,31 +263,40 @@
 
 unsigned int Clipper::ComputeClipFlags(const float4 &v)
 {
-	return ((v.x > v.w)     ? CLIP_RIGHT  : 0) |
-	       ((v.y > v.w)     ? CLIP_TOP    : 0) |
-	       ((v.z > v.w)     ? CLIP_FAR    : 0) |
-	       ((v.x < -v.w)    ? CLIP_LEFT   : 0) |
-	       ((v.y < -v.w)    ? CLIP_BOTTOM : 0) |
-	       ((v.z < 0)       ? CLIP_NEAR   : 0) |
-	       Clipper::CLIP_FINITE;   // FIXME: xyz finite
+	return ((v.x > v.w) ? CLIP_RIGHT : 0) |
+	       ((v.y > v.w) ? CLIP_TOP : 0) |
+	       ((v.z > v.w) ? CLIP_FAR : 0) |
+	       ((v.x < -v.w) ? CLIP_LEFT : 0) |
+	       ((v.y < -v.w) ? CLIP_BOTTOM : 0) |
+	       ((v.z < 0) ? CLIP_NEAR : 0) |
+	       Clipper::CLIP_FINITE;  // FIXME: xyz finite
 }
 
 bool Clipper::Clip(Polygon &polygon, int clipFlagsOr, const DrawCall &draw)
 {
 	if(clipFlagsOr & CLIP_FRUSTUM)
 	{
-		if(clipFlagsOr & CLIP_NEAR)   clipNear(polygon);
-		if(polygon.n >= 3) {
-		if(clipFlagsOr & CLIP_FAR)    clipFar(polygon);
-		if(polygon.n >= 3) {
-		if(clipFlagsOr & CLIP_LEFT)   clipLeft(polygon);
-		if(polygon.n >= 3) {
-		if(clipFlagsOr & CLIP_RIGHT)  clipRight(polygon);
-		if(polygon.n >= 3) {
-		if(clipFlagsOr & CLIP_TOP)    clipTop(polygon);
-		if(polygon.n >= 3) {
-		if(clipFlagsOr & CLIP_BOTTOM) clipBottom(polygon);
-		}}}}}
+		if(clipFlagsOr & CLIP_NEAR) clipNear(polygon);
+		if(polygon.n >= 3)
+		{
+			if(clipFlagsOr & CLIP_FAR) clipFar(polygon);
+			if(polygon.n >= 3)
+			{
+				if(clipFlagsOr & CLIP_LEFT) clipLeft(polygon);
+				if(polygon.n >= 3)
+				{
+					if(clipFlagsOr & CLIP_RIGHT) clipRight(polygon);
+					if(polygon.n >= 3)
+					{
+						if(clipFlagsOr & CLIP_TOP) clipTop(polygon);
+						if(polygon.n >= 3)
+						{
+							if(clipFlagsOr & CLIP_BOTTOM) clipBottom(polygon);
+						}
+					}
+				}
+			}
+		}
 	}
 
 	return polygon.n >= 3;
diff --git a/src/Device/Clipper.hpp b/src/Device/Clipper.hpp
index 524a373..c696caf 100644
--- a/src/Device/Clipper.hpp
+++ b/src/Device/Clipper.hpp
@@ -27,16 +27,16 @@
 	enum ClipFlags
 	{
 		// Indicates the vertex is outside the respective frustum plane
-		CLIP_RIGHT  = 1 << 0,
-		CLIP_TOP    = 1 << 1,
-		CLIP_FAR    = 1 << 2,
-		CLIP_LEFT   = 1 << 3,
+		CLIP_RIGHT = 1 << 0,
+		CLIP_TOP = 1 << 1,
+		CLIP_FAR = 1 << 2,
+		CLIP_LEFT = 1 << 3,
 		CLIP_BOTTOM = 1 << 4,
-		CLIP_NEAR   = 1 << 5,
+		CLIP_NEAR = 1 << 5,
 
 		CLIP_FRUSTUM = 0x003F,
 
-		CLIP_FINITE = 1 << 7,   // All position coordinates are finite
+		CLIP_FINITE = 1 << 7,  // All position coordinates are finite
 	};
 
 	static unsigned int ComputeClipFlags(const float4 &v);
@@ -45,4 +45,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Clipper_hpp
+#endif  // sw_Clipper_hpp
diff --git a/src/Device/Color.hpp b/src/Device/Color.hpp
index 2b27e86..a7af805 100644
--- a/src/Device/Color.hpp
+++ b/src/Device/Color.hpp
@@ -15,8 +15,8 @@
 #ifndef sw_Color_hpp
 #define sw_Color_hpp
 
-#include "System/Types.hpp"
 #include "System/Math.hpp"
+#include "System/Types.hpp"
 
 namespace sw {
 
@@ -28,12 +28,12 @@
 	Color(const Color<byte> &c);
 	Color(const Color<short> &c);
 	Color(const Color<float> &c);
-	
+
 	Color(int c);
 	Color(unsigned short c);
 	Color(unsigned long c);
 	Color(unsigned int c);
-	
+
 	Color(T r, T g, T b, T a = 1);
 
 	operator unsigned int() const;
@@ -44,13 +44,13 @@
 	Color<T> operator+() const;
 	Color<T> operator-() const;
 
-	Color<T>& operator=(const Color<T>& c);
+	Color<T> &operator=(const Color<T> &c);
 
 	Color<T> &operator+=(const Color<T> &c);
 	Color<T> &operator*=(float l);
 
-	static Color<T> gradient(const Color<T> &c1, const Color<T>  &c2, float d);
-	static Color<T> shade(const Color<T> &c1, const Color<T>  &c2, float d);
+	static Color<T> gradient(const Color<T> &c1, const Color<T> &c2, float d);
+	static Color<T> shade(const Color<T> &c1, const Color<T> &c2, float d);
 
 	template<class S>
 	friend Color<S> operator+(const Color<S> &c1, const Color<S> &c2);
@@ -69,7 +69,7 @@
 	T b;
 	T a;
 };
-}
+}  // namespace sw
 
 #include "System/Math.hpp"
 
@@ -312,7 +312,7 @@
 	return (b << 0) +
 	       (g << 8) +
 	       (r << 16) +
-		   (a << 24);
+	       (a << 24);
 }
 
 template<class T>
@@ -340,7 +340,7 @@
 }
 
 template<class T>
-inline Color<T> &Color<T>::operator=(const Color& c)
+inline Color<T> &Color<T>::operator=(const Color &c)
 {
 	r = c.r;
 	g = c.g;
@@ -375,7 +375,7 @@
 	return Color<T>(c1.r + c2.r,
 	                c1.g + c2.g,
 	                c1.b + c2.b,
-	                c1.a + c2.a);	
+	                c1.a + c2.a);
 }
 
 template<class T>
@@ -384,7 +384,7 @@
 	return Color<T>(c1.r - c2.r,
 	                c1.g - c2.g,
 	                c1.b - c2.b,
-	                c1.a - c2.a);	
+	                c1.a - c2.a);
 }
 
 template<class T>
@@ -434,7 +434,7 @@
 template<class T>
 inline Color<T> operator/(const Color<T> &c, float l)
 {
-	l = 1.0f / l; 
+	l = 1.0f / l;
 
 	T r = (T)(l * c.r);
 	T g = (T)(l * c.g);
@@ -447,7 +447,7 @@
 template<class T>
 inline Color<T> Color<T>::gradient(const Color<T> &c1, const Color<T> &c2, float d)
 {
-	d = 1.0f / d; 
+	d = 1.0f / d;
 
 	T r = (c2.r - c1.r) * d;
 	T g = (c2.g - c1.g) * d;
@@ -458,7 +458,7 @@
 }
 
 template<class T>
-inline Color<T> Color<T>::shade(const Color<T> &c1, const Color<T>  &c2, float d)
+inline Color<T> Color<T>::shade(const Color<T> &c1, const Color<T> &c2, float d)
 {
 	T r = c1.r + (T)(d * (c2.r - c1.r));
 	T g = c1.g + (T)(d * (c2.g - c1.g));
@@ -470,4 +470,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Color_hpp
+#endif  // sw_Color_hpp
diff --git a/src/Device/Config.hpp b/src/Device/Config.hpp
index 7584f07..1e4947f 100644
--- a/src/Device/Config.hpp
+++ b/src/Device/Config.hpp
@@ -47,7 +47,7 @@
 
 enum
 {
-	OUTLINE_RESOLUTION = 8192,   // Maximum vertical resolution of the render target
+	OUTLINE_RESOLUTION = 8192,  // Maximum vertical resolution of the render target
 	MIPMAP_LEVELS = 14,
 	MAX_UNIFORM_BLOCK_SIZE = 16384,
 	MAX_CLIP_DISTANCES = 8,
@@ -56,11 +56,11 @@
 	MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 64,
 	MIN_TEXEL_OFFSET = -8,
 	MAX_TEXEL_OFFSET = 7,
-	MAX_TEXTURE_LOD = MIPMAP_LEVELS - 2,   // Trilinear accesses lod+1
+	MAX_TEXTURE_LOD = MIPMAP_LEVELS - 2,  // Trilinear accesses lod+1
 	RENDERTARGETS = 8,
 	MAX_INTERFACE_COMPONENTS = 32 * 4,  // Must be multiple of 4 for 16-byte alignment.
 };
 
 }  // namespace sw
 
-#endif   // sw_Config_hpp
+#endif  // sw_Config_hpp
diff --git a/src/Device/Context.cpp b/src/Device/Context.cpp
index 03987f4..5275e67 100644
--- a/src/Device/Context.cpp
+++ b/src/Device/Context.cpp
@@ -15,10 +15,10 @@
 #include "Context.hpp"
 
 #include "Primitive.hpp"
+#include "Pipeline/SpirvShader.hpp"
 #include "System/Memory.hpp"
 #include "Vulkan/VkDebug.hpp"
 #include "Vulkan/VkImageView.hpp"
-#include "Pipeline/SpirvShader.hpp"
 
 #include <string.h>
 
@@ -33,17 +33,17 @@
 {
 	switch(topology)
 	{
-	case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-		return true;
-	case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-		return false;
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-		return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_POINT) : false;
-	default:
-		UNIMPLEMENTED("topology %d", int(topology));
+		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+			return true;
+		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+			return false;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_POINT) : false;
+		default:
+			UNIMPLEMENTED("topology %d", int(topology));
 	}
 	return false;
 }
@@ -52,17 +52,17 @@
 {
 	switch(topology)
 	{
-	case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-		return false;
-	case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-		return true;
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-		return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_LINE) : false;
-	default:
-		UNIMPLEMENTED("topology %d", int(topology));
+		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+			return false;
+		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+			return true;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_LINE) : false;
+		default:
+			UNIMPLEMENTED("topology %d", int(topology));
 	}
 	return false;
 }
@@ -71,16 +71,16 @@
 {
 	switch(topology)
 	{
-	case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-		return false;
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-		return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_FILL) : true;
-	default:
-		UNIMPLEMENTED("topology %d", int(topology));
+		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+			return false;
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+			return polygonModeAware ? (polygonMode == VK_POLYGON_MODE_FILL) : true;
+		default:
+			UNIMPLEMENTED("topology %d", int(topology));
 	}
 	return false;
 }
@@ -201,16 +201,16 @@
 
 	switch(blendState[index].blendOperation)
 	{
-	case VK_BLEND_OP_ADD:
-	case VK_BLEND_OP_SUBTRACT:
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		return blendState[index].sourceBlendFactor;
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_FACTOR_ONE;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			return blendState[index].sourceBlendFactor;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].sourceBlendFactor;
@@ -224,16 +224,16 @@
 
 	switch(blendState[index].blendOperation)
 	{
-	case VK_BLEND_OP_ADD:
-	case VK_BLEND_OP_SUBTRACT:
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		return blendState[index].destBlendFactor;
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_FACTOR_ONE;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			return blendState[index].destBlendFactor;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].destBlendFactor;
@@ -261,107 +261,107 @@
 
 	switch(blendState[index].blendOperation)
 	{
-	case VK_BLEND_OP_ADD:
-		if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_ADD:
+			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
 			{
-				return VK_BLEND_OP_ZERO_EXT;
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_ZERO_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_DST_EXT;
+				}
+			}
+			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_ADD;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_DST_EXT;
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_ADD;
+				}
 			}
-		}
-		else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_SUBTRACT:
+			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
 			{
-				return VK_BLEND_OP_SRC_EXT;
+				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+			}
+			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_SUBTRACT;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_ADD;
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_SUBTRACT;
+				}
 			}
-		}
-		else
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
 			{
-				return VK_BLEND_OP_SRC_EXT;
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_ZERO_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_DST_EXT;
+				}
+			}
+			else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
+				{
+					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+				}
+				else
+				{
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_ADD;
+				if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
+				{
+					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+				}
+				else
+				{
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
+				}
 			}
-		}
-	case VK_BLEND_OP_SUBTRACT:
-		if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-		{
-			return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-		}
-		else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_SRC_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_SUBTRACT;
-			}
-		}
-		else
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_SRC_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_SUBTRACT;
-			}
-		}
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_ZERO_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_DST_EXT;
-			}
-		}
-		else if(sourceBlendFactor(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-			{
-				return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-			}
-			else
-			{
-				return VK_BLEND_OP_REVERSE_SUBTRACT;
-			}
-		}
-		else
-		{
-			if(destBlendFactor(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-			{
-				return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-			}
-			else
-			{
-				return VK_BLEND_OP_REVERSE_SUBTRACT;
-			}
-		}
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_OP_MIN;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_OP_MAX;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_OP_MIN;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_OP_MAX;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].blendOperation;
@@ -373,16 +373,16 @@
 
 	switch(blendState[index].blendOperationAlpha)
 	{
-	case VK_BLEND_OP_ADD:
-	case VK_BLEND_OP_SUBTRACT:
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		return blendState[index].sourceBlendFactorAlpha;
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_FACTOR_ONE;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			return blendState[index].sourceBlendFactorAlpha;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].sourceBlendFactorAlpha;
@@ -394,16 +394,16 @@
 
 	switch(blendState[index].blendOperationAlpha)
 	{
-	case VK_BLEND_OP_ADD:
-	case VK_BLEND_OP_SUBTRACT:
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		return blendState[index].destBlendFactorAlpha;
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_FACTOR_ONE;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_FACTOR_ONE;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_ADD:
+		case VK_BLEND_OP_SUBTRACT:
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			return blendState[index].destBlendFactorAlpha;
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_FACTOR_ONE;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_FACTOR_ONE;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].destBlendFactorAlpha;
@@ -415,107 +415,107 @@
 
 	switch(blendState[index].blendOperationAlpha)
 	{
-	case VK_BLEND_OP_ADD:
-		if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_ADD:
+			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
 			{
-				return VK_BLEND_OP_ZERO_EXT;
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_ZERO_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_DST_EXT;
+				}
+			}
+			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_ADD;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_DST_EXT;
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_ADD;
+				}
 			}
-		}
-		else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_SUBTRACT:
+			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
 			{
-				return VK_BLEND_OP_SRC_EXT;
+				return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+			}
+			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_SUBTRACT;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_ADD;
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_SRC_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_SUBTRACT;
+				}
 			}
-		}
-		else
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+		case VK_BLEND_OP_REVERSE_SUBTRACT:
+			if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
 			{
-				return VK_BLEND_OP_SRC_EXT;
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
+				{
+					return VK_BLEND_OP_ZERO_EXT;
+				}
+				else
+				{
+					return VK_BLEND_OP_DST_EXT;
+				}
+			}
+			else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
+			{
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
+				{
+					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+				}
+				else
+				{
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
+				}
 			}
 			else
 			{
-				return VK_BLEND_OP_ADD;
+				if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
+				{
+					return VK_BLEND_OP_ZERO_EXT;  // Negative, clamped to zero
+				}
+				else
+				{
+					return VK_BLEND_OP_REVERSE_SUBTRACT;
+				}
 			}
-		}
-	case VK_BLEND_OP_SUBTRACT:
-		if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-		{
-			return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-		}
-		else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_SRC_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_SUBTRACT;
-			}
-		}
-		else
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_SRC_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_SUBTRACT;
-			}
-		}
-	case VK_BLEND_OP_REVERSE_SUBTRACT:
-		if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO)
-			{
-				return VK_BLEND_OP_ZERO_EXT;
-			}
-			else
-			{
-				return VK_BLEND_OP_DST_EXT;
-			}
-		}
-		else if(sourceBlendFactorAlpha(index) == VK_BLEND_FACTOR_ONE)
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-			{
-				return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-			}
-			else
-			{
-				return VK_BLEND_OP_REVERSE_SUBTRACT;
-			}
-		}
-		else
-		{
-			if(destBlendFactorAlpha(index) == VK_BLEND_FACTOR_ZERO && allTargetsColorClamp())
-			{
-				return VK_BLEND_OP_ZERO_EXT;   // Negative, clamped to zero
-			}
-			else
-			{
-				return VK_BLEND_OP_REVERSE_SUBTRACT;
-			}
-		}
-	case VK_BLEND_OP_MIN:
-		return VK_BLEND_OP_MIN;
-	case VK_BLEND_OP_MAX:
-		return VK_BLEND_OP_MAX;
-	default:
-		ASSERT(false);
+		case VK_BLEND_OP_MIN:
+			return VK_BLEND_OP_MIN;
+		case VK_BLEND_OP_MAX:
+			return VK_BLEND_OP_MAX;
+		default:
+			ASSERT(false);
 	}
 
 	return blendState[index].blendOperationAlpha;
diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
index 20bc089..4aec203 100644
--- a/src/Device/Context.hpp
+++ b/src/Device/Context.hpp
@@ -15,12 +15,12 @@
 #ifndef sw_Context_hpp
 #define sw_Context_hpp
 
-#include "Vulkan/VkConfig.h"
-#include "Vulkan/VkDescriptorSet.hpp"
 #include "Config.hpp"
 #include "Memset.hpp"
 #include "Stream.hpp"
 #include "System/Types.hpp"
+#include "Vulkan/VkConfig.h"
+#include "Vulkan/VkDescriptorSet.hpp"
 
 namespace vk {
 
@@ -40,7 +40,9 @@
 
 struct BlendState : Memset<BlendState>
 {
-	BlendState() : Memset(this, 0) {}
+	BlendState()
+	    : Memset(this, 0)
+	{}
 
 	BlendState(bool alphaBlendEnable,
 	           VkBlendFactor sourceBlendFactor,
@@ -48,15 +50,15 @@
 	           VkBlendOp blendOperation,
 	           VkBlendFactor sourceBlendFactorAlpha,
 	           VkBlendFactor destBlendFactorAlpha,
-	           VkBlendOp blendOperationAlpha) :
-		Memset(this, 0),
-		alphaBlendEnable(alphaBlendEnable),
-		sourceBlendFactor(sourceBlendFactor),
-		destBlendFactor(destBlendFactor),
-		blendOperation(blendOperation),
-		sourceBlendFactorAlpha(sourceBlendFactorAlpha),
-		destBlendFactorAlpha(destBlendFactorAlpha),
-		blendOperationAlpha(blendOperationAlpha)
+	           VkBlendOp blendOperationAlpha)
+	    : Memset(this, 0)
+	    , alphaBlendEnable(alphaBlendEnable)
+	    , sourceBlendFactor(sourceBlendFactor)
+	    , destBlendFactor(destBlendFactor)
+	    , blendOperation(blendOperation)
+	    , sourceBlendFactorAlpha(sourceBlendFactorAlpha)
+	    , destBlendFactorAlpha(destBlendFactorAlpha)
+	    , blendOperationAlpha(blendOperationAlpha)
 	{}
 
 	bool alphaBlendEnable;
@@ -133,7 +135,7 @@
 
 	float lineWidth;
 
-	int colorWriteMask[RENDERTARGETS];   // RGBA
+	int colorWriteMask[RENDERTARGETS];  // RGBA
 	unsigned int sampleMask;
 	unsigned int multiSampleMask;
 	int sampleCount;
@@ -157,4 +159,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Context_hpp
+#endif  // sw_Context_hpp
diff --git a/src/Device/ETC_Decoder.cpp b/src/Device/ETC_Decoder.cpp
index aba807f..d3fcf6e 100644
--- a/src/Device/ETC_Decoder.cpp
+++ b/src/Device/ETC_Decoder.cpp
@@ -14,622 +14,615 @@
 
 #include "ETC_Decoder.hpp"
 
-namespace
+namespace {
+inline unsigned char clampByte(int value)
 {
-	inline unsigned char clampByte(int value)
+	return static_cast<unsigned char>((value < 0) ? 0 : ((value > 255) ? 255 : value));
+}
+
+inline signed char clampSByte(int value)
+{
+	return static_cast<signed char>((value < -128) ? -128 : ((value > 127) ? 127 : value));
+}
+
+inline short clampEAC(int value, bool isSigned)
+{
+	short min = isSigned ? -1023 : 0;
+	short max = isSigned ? 1023 : 2047;
+	return static_cast<short>(((value < min) ? min : ((value > max) ? max : value)) << 5);
+}
+
+struct bgra8
+{
+	unsigned char b;
+	unsigned char g;
+	unsigned char r;
+	unsigned char a;
+
+	inline bgra8()
 	{
-		return static_cast<unsigned char>((value < 0) ? 0 : ((value > 255) ? 255 : value));
 	}
 
-	inline signed char clampSByte(int value)
+	inline void set(int red, int green, int blue)
 	{
-		return static_cast<signed char>((value < -128) ? -128 : ((value > 127) ? 127 : value));
+		r = clampByte(red);
+		g = clampByte(green);
+		b = clampByte(blue);
 	}
 
-	inline short clampEAC(int value, bool isSigned)
+	inline void set(int red, int green, int blue, int alpha)
 	{
-		short min = isSigned ? -1023 : 0;
-		short max = isSigned ? 1023 : 2047;
-		return static_cast<short>(((value < min) ? min : ((value > max) ? max : value)) << 5);
+		r = clampByte(red);
+		g = clampByte(green);
+		b = clampByte(blue);
+		a = clampByte(alpha);
 	}
 
-	struct bgra8
+	const bgra8 &addA(unsigned char alpha)
 	{
-		unsigned char b;
-		unsigned char g;
-		unsigned char r;
-		unsigned char a;
+		a = alpha;
+		return *this;
+	}
+};
 
-		inline bgra8()
+inline int extend_4to8bits(int x)
+{
+	return (x << 4) | x;
+}
+
+inline int extend_5to8bits(int x)
+{
+	return (x << 3) | (x >> 2);
+}
+
+inline int extend_6to8bits(int x)
+{
+	return (x << 2) | (x >> 4);
+}
+
+inline int extend_7to8bits(int x)
+{
+	return (x << 1) | (x >> 6);
+}
+
+struct ETC2
+{
+	// Decodes unsigned single or dual channel block to bytes
+	static void DecodeBlock(const ETC2 **sources, unsigned char *dest, int nbChannels, int x, int y, int w, int h, int pitch, bool isSigned, bool isEAC)
+	{
+		if(isEAC)
 		{
-		}
-
-		inline void set(int red, int green, int blue)
-		{
-			r = clampByte(red);
-			g = clampByte(green);
-			b = clampByte(blue);
-		}
-
-		inline void set(int red, int green, int blue, int alpha)
-		{
-			r = clampByte(red);
-			g = clampByte(green);
-			b = clampByte(blue);
-			a = clampByte(alpha);
-		}
-
-		const bgra8& addA(unsigned char alpha)
-		{
-			a = alpha;
-			return *this;
-		}
-	};
-
-	inline int extend_4to8bits(int x)
-	{
-		return (x << 4) | x;
-	}
-
-	inline int extend_5to8bits(int x)
-	{
-		return (x << 3) | (x >> 2);
-	}
-
-	inline int extend_6to8bits(int x)
-	{
-		return (x << 2) | (x >> 4);
-	}
-
-	inline int extend_7to8bits(int x)
-	{
-		return (x << 1) | (x >> 6);
-	}
-
-	struct ETC2
-	{
-		// Decodes unsigned single or dual channel block to bytes
-		static void DecodeBlock(const ETC2** sources, unsigned char *dest, int nbChannels, int x, int y, int w, int h, int pitch, bool isSigned, bool isEAC)
-		{
-			if(isEAC)
+			for(int j = 0; j < 4 && (y + j) < h; j++)
 			{
+				short *sDst = reinterpret_cast<short *>(dest);
+				for(int i = 0; i < 4 && (x + i) < w; i++)
+				{
+					for(int c = nbChannels - 1; c >= 0; c--)
+					{
+						sDst[i * nbChannels + c] = clampEAC(sources[c]->getSingleChannel(i, j, isSigned, true), isSigned);
+					}
+				}
+				dest += pitch;
+			}
+		}
+		else
+		{
+			if(isSigned)
+			{
+				signed char *sDst = reinterpret_cast<signed char *>(dest);
 				for(int j = 0; j < 4 && (y + j) < h; j++)
 				{
-					short* sDst = reinterpret_cast<short*>(dest);
 					for(int i = 0; i < 4 && (x + i) < w; i++)
 					{
 						for(int c = nbChannels - 1; c >= 0; c--)
 						{
-							sDst[i * nbChannels + c] = clampEAC(sources[c]->getSingleChannel(i, j, isSigned, true), isSigned);
+							sDst[i * nbChannels + c] = clampSByte(sources[c]->getSingleChannel(i, j, isSigned, false));
 						}
 					}
-					dest += pitch;
-				}
-			}
-			else
-			{
-				if(isSigned)
-				{
-					signed char* sDst = reinterpret_cast<signed char*>(dest);
-					for(int j = 0; j < 4 && (y + j) < h; j++)
-					{
-						for(int i = 0; i < 4 && (x + i) < w; i++)
-						{
-							for(int c = nbChannels - 1; c >= 0; c--)
-							{
-								sDst[i * nbChannels + c] = clampSByte(sources[c]->getSingleChannel(i, j, isSigned, false));
-							}
-						}
-						sDst += pitch;
-					}
-				}
-				else
-				{
-					for(int j = 0; j < 4 && (y + j) < h; j++)
-					{
-						for(int i = 0; i < 4 && (x + i) < w; i++)
-						{
-							for(int c = nbChannels - 1; c >= 0; c--)
-							{
-								dest[i * nbChannels + c] = clampByte(sources[c]->getSingleChannel(i, j, isSigned, false));
-							}
-						}
-						dest += pitch;
-					}
-				}
-			}
-		}
-
-		// Decodes RGB block to bgra8
-		void decodeBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool punchThroughAlpha) const
-		{
-			bool opaqueBit = diffbit;
-			bool nonOpaquePunchThroughAlpha = punchThroughAlpha && !opaqueBit;
-
-			// Select mode
-			if(diffbit || punchThroughAlpha)
-			{
-				int r = (R + dR);
-				int g = (G + dG);
-				int b = (B + dB);
-				if(r < 0 || r > 31)
-				{
-					decodeTBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
-				}
-				else if(g < 0 || g > 31)
-				{
-					decodeHBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
-				}
-				else if(b < 0 || b > 31)
-				{
-					decodePlanarBlock(dest, x, y, w, h, pitch, alphaValues);
-				}
-				else
-				{
-					decodeDifferentialBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
-				}
-			}
-			else
-			{
-				decodeIndividualBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
-			}
-		}
-
-	private:
-		struct
-		{
-			union
-			{
-				// Individual, differential, H and T modes
-				struct
-				{
-					union
-					{
-						// Individual and differential modes
-						struct
-						{
-							union
-							{
-								struct   // Individual colors
-								{
-									unsigned char R2 : 4;
-									unsigned char R1 : 4;
-									unsigned char G2 : 4;
-									unsigned char G1 : 4;
-									unsigned char B2 : 4;
-									unsigned char B1 : 4;
-								};
-
-								struct   // Differential colors
-								{
-									signed char dR : 3;
-									unsigned char R : 5;
-									signed char dG : 3;
-									unsigned char G : 5;
-									signed char dB : 3;
-									unsigned char B : 5;
-								};
-							};
-
-							bool flipbit : 1;
-							bool diffbit : 1;
-							unsigned char cw2 : 3;
-							unsigned char cw1 : 3;
-						};
-
-						// T mode
-						struct
-						{
-							// Byte 1
-							unsigned char TR1b : 2;
-							unsigned char TdummyB : 1;
-							unsigned char TR1a : 2;
-							unsigned char TdummyA : 3;
-
-							// Byte 2
-							unsigned char TB1 : 4;
-							unsigned char TG1 : 4;
-
-							// Byte 3
-							unsigned char TG2 : 4;
-							unsigned char TR2 : 4;
-
-							// Byte 4
-							unsigned char Tdb : 1;
-							bool Tflipbit : 1;
-							unsigned char Tda : 2;
-							unsigned char TB2 : 4;
-						};
-
-						// H mode
-						struct
-						{
-							// Byte 1
-							unsigned char HG1a : 3;
-							unsigned char HR1 : 4;
-							unsigned char HdummyA : 1;
-
-							// Byte 2
-							unsigned char HB1b : 2;
-							unsigned char HdummyC : 1;
-							unsigned char HB1a : 1;
-							unsigned char HG1b : 1;
-							unsigned char HdummyB : 3;
-
-							// Byte 3
-							unsigned char HG2a : 3;
-							unsigned char HR2 : 4;
-							unsigned char HB1c : 1;
-
-							// Byte 4
-							unsigned char Hdb : 1;
-							bool Hflipbit : 1;
-							unsigned char Hda : 1;
-							unsigned char HB2 : 4;
-							unsigned char HG2b : 1;
-						};
-					};
-
-					unsigned char pixelIndexMSB[2];
-					unsigned char pixelIndexLSB[2];
-				};
-
-				// planar mode
-				struct
-				{
-					// Byte 1
-					unsigned char GO1 : 1;
-					unsigned char RO : 6;
-					unsigned char PdummyA : 1;
-
-					// Byte 2
-					unsigned char BO1 : 1;
-					unsigned char GO2 : 6;
-					unsigned char PdummyB : 1;
-
-					// Byte 3
-					unsigned char BO3a : 2;
-					unsigned char PdummyD : 1;
-					unsigned char BO2 : 2;
-					unsigned char PdummyC : 3;
-
-					// Byte 4
-					unsigned char RH2 : 1;
-					bool Pflipbit : 1;
-					unsigned char RH1 : 5;
-					unsigned char BO3b : 1;
-
-					// Byte 5
-					unsigned char BHa : 1;
-					unsigned char GH : 7;
-
-					// Byte 6
-					unsigned char RVa : 3;
-					unsigned char BHb : 5;
-
-					// Byte 7
-					unsigned char GVa : 5;
-					unsigned char RVb : 3;
-
-					// Byte 8
-					unsigned char BV : 6;
-					unsigned char GVb : 2;
-				};
-
-				// Single channel block
-				struct
-				{
-					union
-					{
-						unsigned char base_codeword;
-						signed char signed_base_codeword;
-					};
-
-					unsigned char table_index : 4;
-					unsigned char multiplier : 4;
-
-					unsigned char mc1 : 2;
-					unsigned char mb : 3;
-					unsigned char ma : 3;
-
-					unsigned char mf1 : 1;
-					unsigned char me : 3;
-					unsigned char md : 3;
-					unsigned char mc2 : 1;
-
-					unsigned char mh : 3;
-					unsigned char mg : 3;
-					unsigned char mf2 : 2;
-
-					unsigned char mk1 : 2;
-					unsigned char mj : 3;
-					unsigned char mi : 3;
-
-					unsigned char mn1 : 1;
-					unsigned char mm : 3;
-					unsigned char ml : 3;
-					unsigned char mk2 : 1;
-
-					unsigned char mp : 3;
-					unsigned char mo : 3;
-					unsigned char mn2 : 2;
-				};
-			};
-		};
-
-		void decodeIndividualBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
-		{
-			int r1 = extend_4to8bits(R1);
-			int g1 = extend_4to8bits(G1);
-			int b1 = extend_4to8bits(B1);
-
-			int r2 = extend_4to8bits(R2);
-			int g2 = extend_4to8bits(G2);
-			int b2 = extend_4to8bits(B2);
-
-			decodeIndividualOrDifferentialBlock(dest, x, y, w, h, pitch, r1, g1, b1, r2, g2, b2, alphaValues, nonOpaquePunchThroughAlpha);
-		}
-
-		void decodeDifferentialBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
-		{
-			int b1 = extend_5to8bits(B);
-			int g1 = extend_5to8bits(G);
-			int r1 = extend_5to8bits(R);
-
-			int r2 = extend_5to8bits(R + dR);
-			int g2 = extend_5to8bits(G + dG);
-			int b2 = extend_5to8bits(B + dB);
-
-			decodeIndividualOrDifferentialBlock(dest, x, y, w, h, pitch, r1, g1, b1, r2, g2, b2, alphaValues, nonOpaquePunchThroughAlpha);
-		}
-
-		void decodeIndividualOrDifferentialBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, int r1, int g1, int b1, int r2, int g2, int b2, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
-		{
-			// Table 3.17.2 sorted according to table 3.17.3
-			static const int intensityModifierDefault[8][4] =
-			{
-				{ 2, 8, -2, -8 },
-				{ 5, 17, -5, -17 },
-				{ 9, 29, -9, -29 },
-				{ 13, 42, -13, -42 },
-				{ 18, 60, -18, -60 },
-				{ 24, 80, -24, -80 },
-				{ 33, 106, -33, -106 },
-				{ 47, 183, -47, -183 }
-			};
-
-			// Table C.12, intensity modifier for non opaque punchthrough alpha
-			static const int intensityModifierNonOpaque[8][4] =
-			{
-				{ 0, 8, 0, -8 },
-				{ 0, 17, 0, -17 },
-				{ 0, 29, 0, -29 },
-				{ 0, 42, 0, -42 },
-				{ 0, 60, 0, -60 },
-				{ 0, 80, 0, -80 },
-				{ 0, 106, 0, -106 },
-				{ 0, 183, 0, -183 }
-			};
-
-			const int(&intensityModifier)[8][4] = nonOpaquePunchThroughAlpha ? intensityModifierNonOpaque : intensityModifierDefault;
-
-			bgra8 subblockColors0[4];
-			bgra8 subblockColors1[4];
-
-			const int i10 = intensityModifier[cw1][0];
-			const int i11 = intensityModifier[cw1][1];
-			const int i12 = intensityModifier[cw1][2];
-			const int i13 = intensityModifier[cw1][3];
-
-			subblockColors0[0].set(r1 + i10, g1 + i10, b1 + i10);
-			subblockColors0[1].set(r1 + i11, g1 + i11, b1 + i11);
-			subblockColors0[2].set(r1 + i12, g1 + i12, b1 + i12);
-			subblockColors0[3].set(r1 + i13, g1 + i13, b1 + i13);
-
-			const int i20 = intensityModifier[cw2][0];
-			const int i21 = intensityModifier[cw2][1];
-			const int i22 = intensityModifier[cw2][2];
-			const int i23 = intensityModifier[cw2][3];
-
-			subblockColors1[0].set(r2 + i20, g2 + i20, b2 + i20);
-			subblockColors1[1].set(r2 + i21, g2 + i21, b2 + i21);
-			subblockColors1[2].set(r2 + i22, g2 + i22, b2 + i22);
-			subblockColors1[3].set(r2 + i23, g2 + i23, b2 + i23);
-
-			unsigned char* destStart = dest;
-
-			if(flipbit)
-			{
-				for(int j = 0; j < 2 && (y + j) < h; j++)
-				{
-					bgra8* color = (bgra8*)dest;
-					if((x + 0) < w) color[0] = subblockColors0[getIndex(0, j)].addA(alphaValues[j][0]);
-					if((x + 1) < w) color[1] = subblockColors0[getIndex(1, j)].addA(alphaValues[j][1]);
-					if((x + 2) < w) color[2] = subblockColors0[getIndex(2, j)].addA(alphaValues[j][2]);
-					if((x + 3) < w) color[3] = subblockColors0[getIndex(3, j)].addA(alphaValues[j][3]);
-					dest += pitch;
-				}
-
-				for(int j = 2; j < 4 && (y + j) < h; j++)
-				{
-					bgra8* color = (bgra8*)dest;
-					if((x + 0) < w) color[0] = subblockColors1[getIndex(0, j)].addA(alphaValues[j][0]);
-					if((x + 1) < w) color[1] = subblockColors1[getIndex(1, j)].addA(alphaValues[j][1]);
-					if((x + 2) < w) color[2] = subblockColors1[getIndex(2, j)].addA(alphaValues[j][2]);
-					if((x + 3) < w) color[3] = subblockColors1[getIndex(3, j)].addA(alphaValues[j][3]);
-					dest += pitch;
+					sDst += pitch;
 				}
 			}
 			else
 			{
 				for(int j = 0; j < 4 && (y + j) < h; j++)
 				{
-					bgra8* color = (bgra8*)dest;
-					if((x + 0) < w) color[0] = subblockColors0[getIndex(0, j)].addA(alphaValues[j][0]);
-					if((x + 1) < w) color[1] = subblockColors0[getIndex(1, j)].addA(alphaValues[j][1]);
-					if((x + 2) < w) color[2] = subblockColors1[getIndex(2, j)].addA(alphaValues[j][2]);
-					if((x + 3) < w) color[3] = subblockColors1[getIndex(3, j)].addA(alphaValues[j][3]);
+					for(int i = 0; i < 4 && (x + i) < w; i++)
+					{
+						for(int c = nbChannels - 1; c >= 0; c--)
+						{
+							dest[i * nbChannels + c] = clampByte(sources[c]->getSingleChannel(i, j, isSigned, false));
+						}
+					}
 					dest += pitch;
 				}
 			}
+		}
+	}
 
-			if(nonOpaquePunchThroughAlpha)
+	// Decodes RGB block to bgra8
+	void decodeBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool punchThroughAlpha) const
+	{
+		bool opaqueBit = diffbit;
+		bool nonOpaquePunchThroughAlpha = punchThroughAlpha && !opaqueBit;
+
+		// Select mode
+		if(diffbit || punchThroughAlpha)
+		{
+			int r = (R + dR);
+			int g = (G + dG);
+			int b = (B + dB);
+			if(r < 0 || r > 31)
 			{
-				decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
+				decodeTBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
+			}
+			else if(g < 0 || g > 31)
+			{
+				decodeHBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
+			}
+			else if(b < 0 || b > 31)
+			{
+				decodePlanarBlock(dest, x, y, w, h, pitch, alphaValues);
+			}
+			else
+			{
+				decodeDifferentialBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
 			}
 		}
-
-		void decodeTBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+		else
 		{
-			// Table C.8, distance index fot T and H modes
-			static const int distance[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
-
-			bgra8 paintColors[4];
-
-			int r1 = extend_4to8bits(TR1a << 2 | TR1b);
-			int g1 = extend_4to8bits(TG1);
-			int b1 = extend_4to8bits(TB1);
-
-			int r2 = extend_4to8bits(TR2);
-			int g2 = extend_4to8bits(TG2);
-			int b2 = extend_4to8bits(TB2);
-
-			const int d = distance[Tda << 1 | Tdb];
-
-			paintColors[0].set(r1, g1, b1);
-			paintColors[1].set(r2 + d, g2 + d, b2 + d);
-			paintColors[2].set(r2, g2, b2);
-			paintColors[3].set(r2 - d, g2 - d, b2 - d);
-
-			unsigned char* destStart = dest;
-
-			for(int j = 0; j < 4 && (y + j) < h; j++)
-			{
-				bgra8* color = (bgra8*)dest;
-				if((x + 0) < w) color[0] = paintColors[getIndex(0, j)].addA(alphaValues[j][0]);
-				if((x + 1) < w) color[1] = paintColors[getIndex(1, j)].addA(alphaValues[j][1]);
-				if((x + 2) < w) color[2] = paintColors[getIndex(2, j)].addA(alphaValues[j][2]);
-				if((x + 3) < w) color[3] = paintColors[getIndex(3, j)].addA(alphaValues[j][3]);
-				dest += pitch;
-			}
-
-			if(nonOpaquePunchThroughAlpha)
-			{
-				decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
-			}
+			decodeIndividualBlock(dest, x, y, w, h, pitch, alphaValues, nonOpaquePunchThroughAlpha);
 		}
+	}
 
-		void decodeHBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+private:
+	struct
+	{
+		union
 		{
-			// Table C.8, distance index fot T and H modes
-			static const int distance[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
-
-			bgra8 paintColors[4];
-
-			int r1 = extend_4to8bits(HR1);
-			int g1 = extend_4to8bits(HG1a << 1 | HG1b);
-			int b1 = extend_4to8bits(HB1a << 3 | HB1b << 1 | HB1c);
-
-			int r2 = extend_4to8bits(HR2);
-			int g2 = extend_4to8bits(HG2a << 1 | HG2b);
-			int b2 = extend_4to8bits(HB2);
-
-			const int d = distance[(Hda << 2) | (Hdb << 1) | ((r1 << 16 | g1 << 8 | b1) >= (r2 << 16 | g2 << 8 | b2) ? 1 : 0)];
-
-			paintColors[0].set(r1 + d, g1 + d, b1 + d);
-			paintColors[1].set(r1 - d, g1 - d, b1 - d);
-			paintColors[2].set(r2 + d, g2 + d, b2 + d);
-			paintColors[3].set(r2 - d, g2 - d, b2 - d);
-
-			unsigned char* destStart = dest;
-
-			for(int j = 0; j < 4 && (y + j) < h; j++)
+			// Individual, differential, H and T modes
+			struct
 			{
-				bgra8* color = (bgra8*)dest;
-				if((x + 0) < w) color[0] = paintColors[getIndex(0, j)].addA(alphaValues[j][0]);
-				if((x + 1) < w) color[1] = paintColors[getIndex(1, j)].addA(alphaValues[j][1]);
-				if((x + 2) < w) color[2] = paintColors[getIndex(2, j)].addA(alphaValues[j][2]);
-				if((x + 3) < w) color[3] = paintColors[getIndex(3, j)].addA(alphaValues[j][3]);
-				dest += pitch;
-			}
-
-			if(nonOpaquePunchThroughAlpha)
-			{
-				decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
-			}
-		}
-
-		void decodePlanarBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4]) const
-		{
-			int ro = extend_6to8bits(RO);
-			int go = extend_7to8bits(GO1 << 6 | GO2);
-			int bo = extend_6to8bits(BO1 << 5 | BO2 << 3 | BO3a << 1 | BO3b);
-
-			int rh = extend_6to8bits(RH1 << 1 | RH2);
-			int gh = extend_7to8bits(GH);
-			int bh = extend_6to8bits(BHa << 5 | BHb);
-
-			int rv = extend_6to8bits(RVa << 3 | RVb);
-			int gv = extend_7to8bits(GVa << 2 | GVb);
-			int bv = extend_6to8bits(BV);
-
-			for(int j = 0; j < 4 && (y + j) < h; j++)
-			{
-				int ry = j * (rv - ro) + 2;
-				int gy = j * (gv - go) + 2;
-				int by = j * (bv - bo) + 2;
-				for(int i = 0; i < 4 && (x + i) < w; i++)
+				union
 				{
-					((bgra8*)(dest))[i].set(((i * (rh - ro) + ry) >> 2) + ro,
-						((i * (gh - go) + gy) >> 2) + go,
-						((i * (bh - bo) + by) >> 2) + bo,
-						alphaValues[j][i]);
-				}
-				dest += pitch;
-			}
-		}
-
-		// Index for individual, differential, H and T modes
-		inline int getIndex(int x, int y) const
-		{
-			int bitIndex = x * 4 + y;
-			int bitOffset = bitIndex & 7;
-			int lsb = (pixelIndexLSB[1 - (bitIndex >> 3)] >> bitOffset) & 1;
-			int msb = (pixelIndexMSB[1 - (bitIndex >> 3)] >> bitOffset) & 1;
-
-			return (msb << 1) | lsb;
-		}
-
-		void decodePunchThroughAlphaBlock(unsigned char *dest, int x, int y, int w, int h, int pitch) const
-		{
-			for(int j = 0; j < 4 && (y + j) < h; j++)
-			{
-				for(int i = 0; i < 4 && (x + i) < w; i++)
-				{
-					if(getIndex(i, j) == 2) //  msb == 1 && lsb == 0
+					// Individual and differential modes
+					struct
 					{
-						((bgra8*)dest)[i].set(0, 0, 0, 0);
-					}
-				}
+						union
+						{
+							struct  // Individual colors
+							{
+								unsigned char R2 : 4;
+								unsigned char R1 : 4;
+								unsigned char G2 : 4;
+								unsigned char G1 : 4;
+								unsigned char B2 : 4;
+								unsigned char B1 : 4;
+							};
+
+							struct  // Differential colors
+							{
+								signed char dR : 3;
+								unsigned char R : 5;
+								signed char dG : 3;
+								unsigned char G : 5;
+								signed char dB : 3;
+								unsigned char B : 5;
+							};
+						};
+
+						bool flipbit : 1;
+						bool diffbit : 1;
+						unsigned char cw2 : 3;
+						unsigned char cw1 : 3;
+					};
+
+					// T mode
+					struct
+					{
+						// Byte 1
+						unsigned char TR1b : 2;
+						unsigned char TdummyB : 1;
+						unsigned char TR1a : 2;
+						unsigned char TdummyA : 3;
+
+						// Byte 2
+						unsigned char TB1 : 4;
+						unsigned char TG1 : 4;
+
+						// Byte 3
+						unsigned char TG2 : 4;
+						unsigned char TR2 : 4;
+
+						// Byte 4
+						unsigned char Tdb : 1;
+						bool Tflipbit : 1;
+						unsigned char Tda : 2;
+						unsigned char TB2 : 4;
+					};
+
+					// H mode
+					struct
+					{
+						// Byte 1
+						unsigned char HG1a : 3;
+						unsigned char HR1 : 4;
+						unsigned char HdummyA : 1;
+
+						// Byte 2
+						unsigned char HB1b : 2;
+						unsigned char HdummyC : 1;
+						unsigned char HB1a : 1;
+						unsigned char HG1b : 1;
+						unsigned char HdummyB : 3;
+
+						// Byte 3
+						unsigned char HG2a : 3;
+						unsigned char HR2 : 4;
+						unsigned char HB1c : 1;
+
+						// Byte 4
+						unsigned char Hdb : 1;
+						bool Hflipbit : 1;
+						unsigned char Hda : 1;
+						unsigned char HB2 : 4;
+						unsigned char HG2b : 1;
+					};
+				};
+
+				unsigned char pixelIndexMSB[2];
+				unsigned char pixelIndexLSB[2];
+			};
+
+			// planar mode
+			struct
+			{
+				// Byte 1
+				unsigned char GO1 : 1;
+				unsigned char RO : 6;
+				unsigned char PdummyA : 1;
+
+				// Byte 2
+				unsigned char BO1 : 1;
+				unsigned char GO2 : 6;
+				unsigned char PdummyB : 1;
+
+				// Byte 3
+				unsigned char BO3a : 2;
+				unsigned char PdummyD : 1;
+				unsigned char BO2 : 2;
+				unsigned char PdummyC : 3;
+
+				// Byte 4
+				unsigned char RH2 : 1;
+				bool Pflipbit : 1;
+				unsigned char RH1 : 5;
+				unsigned char BO3b : 1;
+
+				// Byte 5
+				unsigned char BHa : 1;
+				unsigned char GH : 7;
+
+				// Byte 6
+				unsigned char RVa : 3;
+				unsigned char BHb : 5;
+
+				// Byte 7
+				unsigned char GVa : 5;
+				unsigned char RVb : 3;
+
+				// Byte 8
+				unsigned char BV : 6;
+				unsigned char GVb : 2;
+			};
+
+			// Single channel block
+			struct
+			{
+				union
+				{
+					unsigned char base_codeword;
+					signed char signed_base_codeword;
+				};
+
+				unsigned char table_index : 4;
+				unsigned char multiplier : 4;
+
+				unsigned char mc1 : 2;
+				unsigned char mb : 3;
+				unsigned char ma : 3;
+
+				unsigned char mf1 : 1;
+				unsigned char me : 3;
+				unsigned char md : 3;
+				unsigned char mc2 : 1;
+
+				unsigned char mh : 3;
+				unsigned char mg : 3;
+				unsigned char mf2 : 2;
+
+				unsigned char mk1 : 2;
+				unsigned char mj : 3;
+				unsigned char mi : 3;
+
+				unsigned char mn1 : 1;
+				unsigned char mm : 3;
+				unsigned char ml : 3;
+				unsigned char mk2 : 1;
+
+				unsigned char mp : 3;
+				unsigned char mo : 3;
+				unsigned char mn2 : 2;
+			};
+		};
+	};
+
+	void decodeIndividualBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+	{
+		int r1 = extend_4to8bits(R1);
+		int g1 = extend_4to8bits(G1);
+		int b1 = extend_4to8bits(B1);
+
+		int r2 = extend_4to8bits(R2);
+		int g2 = extend_4to8bits(G2);
+		int b2 = extend_4to8bits(B2);
+
+		decodeIndividualOrDifferentialBlock(dest, x, y, w, h, pitch, r1, g1, b1, r2, g2, b2, alphaValues, nonOpaquePunchThroughAlpha);
+	}
+
+	void decodeDifferentialBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+	{
+		int b1 = extend_5to8bits(B);
+		int g1 = extend_5to8bits(G);
+		int r1 = extend_5to8bits(R);
+
+		int r2 = extend_5to8bits(R + dR);
+		int g2 = extend_5to8bits(G + dG);
+		int b2 = extend_5to8bits(B + dB);
+
+		decodeIndividualOrDifferentialBlock(dest, x, y, w, h, pitch, r1, g1, b1, r2, g2, b2, alphaValues, nonOpaquePunchThroughAlpha);
+	}
+
+	void decodeIndividualOrDifferentialBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, int r1, int g1, int b1, int r2, int g2, int b2, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+	{
+		// Table 3.17.2 sorted according to table 3.17.3
+		static const int intensityModifierDefault[8][4] = {
+			{ 2, 8, -2, -8 },
+			{ 5, 17, -5, -17 },
+			{ 9, 29, -9, -29 },
+			{ 13, 42, -13, -42 },
+			{ 18, 60, -18, -60 },
+			{ 24, 80, -24, -80 },
+			{ 33, 106, -33, -106 },
+			{ 47, 183, -47, -183 }
+		};
+
+		// Table C.12, intensity modifier for non opaque punchthrough alpha
+		static const int intensityModifierNonOpaque[8][4] = {
+			{ 0, 8, 0, -8 },
+			{ 0, 17, 0, -17 },
+			{ 0, 29, 0, -29 },
+			{ 0, 42, 0, -42 },
+			{ 0, 60, 0, -60 },
+			{ 0, 80, 0, -80 },
+			{ 0, 106, 0, -106 },
+			{ 0, 183, 0, -183 }
+		};
+
+		const int(&intensityModifier)[8][4] = nonOpaquePunchThroughAlpha ? intensityModifierNonOpaque : intensityModifierDefault;
+
+		bgra8 subblockColors0[4];
+		bgra8 subblockColors1[4];
+
+		const int i10 = intensityModifier[cw1][0];
+		const int i11 = intensityModifier[cw1][1];
+		const int i12 = intensityModifier[cw1][2];
+		const int i13 = intensityModifier[cw1][3];
+
+		subblockColors0[0].set(r1 + i10, g1 + i10, b1 + i10);
+		subblockColors0[1].set(r1 + i11, g1 + i11, b1 + i11);
+		subblockColors0[2].set(r1 + i12, g1 + i12, b1 + i12);
+		subblockColors0[3].set(r1 + i13, g1 + i13, b1 + i13);
+
+		const int i20 = intensityModifier[cw2][0];
+		const int i21 = intensityModifier[cw2][1];
+		const int i22 = intensityModifier[cw2][2];
+		const int i23 = intensityModifier[cw2][3];
+
+		subblockColors1[0].set(r2 + i20, g2 + i20, b2 + i20);
+		subblockColors1[1].set(r2 + i21, g2 + i21, b2 + i21);
+		subblockColors1[2].set(r2 + i22, g2 + i22, b2 + i22);
+		subblockColors1[3].set(r2 + i23, g2 + i23, b2 + i23);
+
+		unsigned char *destStart = dest;
+
+		if(flipbit)
+		{
+			for(int j = 0; j < 2 && (y + j) < h; j++)
+			{
+				bgra8 *color = (bgra8 *)dest;
+				if((x + 0) < w) color[0] = subblockColors0[getIndex(0, j)].addA(alphaValues[j][0]);
+				if((x + 1) < w) color[1] = subblockColors0[getIndex(1, j)].addA(alphaValues[j][1]);
+				if((x + 2) < w) color[2] = subblockColors0[getIndex(2, j)].addA(alphaValues[j][2]);
+				if((x + 3) < w) color[3] = subblockColors0[getIndex(3, j)].addA(alphaValues[j][3]);
+				dest += pitch;
+			}
+
+			for(int j = 2; j < 4 && (y + j) < h; j++)
+			{
+				bgra8 *color = (bgra8 *)dest;
+				if((x + 0) < w) color[0] = subblockColors1[getIndex(0, j)].addA(alphaValues[j][0]);
+				if((x + 1) < w) color[1] = subblockColors1[getIndex(1, j)].addA(alphaValues[j][1]);
+				if((x + 2) < w) color[2] = subblockColors1[getIndex(2, j)].addA(alphaValues[j][2]);
+				if((x + 3) < w) color[3] = subblockColors1[getIndex(3, j)].addA(alphaValues[j][3]);
+				dest += pitch;
+			}
+		}
+		else
+		{
+			for(int j = 0; j < 4 && (y + j) < h; j++)
+			{
+				bgra8 *color = (bgra8 *)dest;
+				if((x + 0) < w) color[0] = subblockColors0[getIndex(0, j)].addA(alphaValues[j][0]);
+				if((x + 1) < w) color[1] = subblockColors0[getIndex(1, j)].addA(alphaValues[j][1]);
+				if((x + 2) < w) color[2] = subblockColors1[getIndex(2, j)].addA(alphaValues[j][2]);
+				if((x + 3) < w) color[3] = subblockColors1[getIndex(3, j)].addA(alphaValues[j][3]);
 				dest += pitch;
 			}
 		}
 
-		// Single channel utility functions
-		inline int getSingleChannel(int x, int y, bool isSigned, bool isEAC) const
+		if(nonOpaquePunchThroughAlpha)
 		{
-			int codeword = isSigned ? signed_base_codeword : base_codeword;
-			return isEAC ?
-			       ((multiplier == 0) ?
-			        (codeword * 8 + 4 + getSingleChannelModifier(x, y)) :
-			        (codeword * 8 + 4 + getSingleChannelModifier(x, y) * multiplier * 8)) :
-			       codeword + getSingleChannelModifier(x, y) * multiplier;
+			decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
+		}
+	}
+
+	void decodeTBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+	{
+		// Table C.8, distance index fot T and H modes
+		static const int distance[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
+
+		bgra8 paintColors[4];
+
+		int r1 = extend_4to8bits(TR1a << 2 | TR1b);
+		int g1 = extend_4to8bits(TG1);
+		int b1 = extend_4to8bits(TB1);
+
+		int r2 = extend_4to8bits(TR2);
+		int g2 = extend_4to8bits(TG2);
+		int b2 = extend_4to8bits(TB2);
+
+		const int d = distance[Tda << 1 | Tdb];
+
+		paintColors[0].set(r1, g1, b1);
+		paintColors[1].set(r2 + d, g2 + d, b2 + d);
+		paintColors[2].set(r2, g2, b2);
+		paintColors[3].set(r2 - d, g2 - d, b2 - d);
+
+		unsigned char *destStart = dest;
+
+		for(int j = 0; j < 4 && (y + j) < h; j++)
+		{
+			bgra8 *color = (bgra8 *)dest;
+			if((x + 0) < w) color[0] = paintColors[getIndex(0, j)].addA(alphaValues[j][0]);
+			if((x + 1) < w) color[1] = paintColors[getIndex(1, j)].addA(alphaValues[j][1]);
+			if((x + 2) < w) color[2] = paintColors[getIndex(2, j)].addA(alphaValues[j][2]);
+			if((x + 3) < w) color[3] = paintColors[getIndex(3, j)].addA(alphaValues[j][3]);
+			dest += pitch;
 		}
 
-		inline int getSingleChannelIndex(int x, int y) const
+		if(nonOpaquePunchThroughAlpha)
 		{
-			switch(x * 4 + y)
+			decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
+		}
+	}
+
+	void decodeHBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4], bool nonOpaquePunchThroughAlpha) const
+	{
+		// Table C.8, distance index fot T and H modes
+		static const int distance[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
+
+		bgra8 paintColors[4];
+
+		int r1 = extend_4to8bits(HR1);
+		int g1 = extend_4to8bits(HG1a << 1 | HG1b);
+		int b1 = extend_4to8bits(HB1a << 3 | HB1b << 1 | HB1c);
+
+		int r2 = extend_4to8bits(HR2);
+		int g2 = extend_4to8bits(HG2a << 1 | HG2b);
+		int b2 = extend_4to8bits(HB2);
+
+		const int d = distance[(Hda << 2) | (Hdb << 1) | ((r1 << 16 | g1 << 8 | b1) >= (r2 << 16 | g2 << 8 | b2) ? 1 : 0)];
+
+		paintColors[0].set(r1 + d, g1 + d, b1 + d);
+		paintColors[1].set(r1 - d, g1 - d, b1 - d);
+		paintColors[2].set(r2 + d, g2 + d, b2 + d);
+		paintColors[3].set(r2 - d, g2 - d, b2 - d);
+
+		unsigned char *destStart = dest;
+
+		for(int j = 0; j < 4 && (y + j) < h; j++)
+		{
+			bgra8 *color = (bgra8 *)dest;
+			if((x + 0) < w) color[0] = paintColors[getIndex(0, j)].addA(alphaValues[j][0]);
+			if((x + 1) < w) color[1] = paintColors[getIndex(1, j)].addA(alphaValues[j][1]);
+			if((x + 2) < w) color[2] = paintColors[getIndex(2, j)].addA(alphaValues[j][2]);
+			if((x + 3) < w) color[3] = paintColors[getIndex(3, j)].addA(alphaValues[j][3]);
+			dest += pitch;
+		}
+
+		if(nonOpaquePunchThroughAlpha)
+		{
+			decodePunchThroughAlphaBlock(destStart, x, y, w, h, pitch);
+		}
+	}
+
+	void decodePlanarBlock(unsigned char *dest, int x, int y, int w, int h, int pitch, unsigned char alphaValues[4][4]) const
+	{
+		int ro = extend_6to8bits(RO);
+		int go = extend_7to8bits(GO1 << 6 | GO2);
+		int bo = extend_6to8bits(BO1 << 5 | BO2 << 3 | BO3a << 1 | BO3b);
+
+		int rh = extend_6to8bits(RH1 << 1 | RH2);
+		int gh = extend_7to8bits(GH);
+		int bh = extend_6to8bits(BHa << 5 | BHb);
+
+		int rv = extend_6to8bits(RVa << 3 | RVb);
+		int gv = extend_7to8bits(GVa << 2 | GVb);
+		int bv = extend_6to8bits(BV);
+
+		for(int j = 0; j < 4 && (y + j) < h; j++)
+		{
+			int ry = j * (rv - ro) + 2;
+			int gy = j * (gv - go) + 2;
+			int by = j * (bv - bo) + 2;
+			for(int i = 0; i < 4 && (x + i) < w; i++)
 			{
+				((bgra8 *)(dest))[i].set(((i * (rh - ro) + ry) >> 2) + ro,
+				                         ((i * (gh - go) + gy) >> 2) + go,
+				                         ((i * (bh - bo) + by) >> 2) + bo,
+				                         alphaValues[j][i]);
+			}
+			dest += pitch;
+		}
+	}
+
+	// Index for individual, differential, H and T modes
+	inline int getIndex(int x, int y) const
+	{
+		int bitIndex = x * 4 + y;
+		int bitOffset = bitIndex & 7;
+		int lsb = (pixelIndexLSB[1 - (bitIndex >> 3)] >> bitOffset) & 1;
+		int msb = (pixelIndexMSB[1 - (bitIndex >> 3)] >> bitOffset) & 1;
+
+		return (msb << 1) | lsb;
+	}
+
+	void decodePunchThroughAlphaBlock(unsigned char *dest, int x, int y, int w, int h, int pitch) const
+	{
+		for(int j = 0; j < 4 && (y + j) < h; j++)
+		{
+			for(int i = 0; i < 4 && (x + i) < w; i++)
+			{
+				if(getIndex(i, j) == 2)  //  msb == 1 && lsb == 0
+				{
+					((bgra8 *)dest)[i].set(0, 0, 0, 0);
+				}
+			}
+			dest += pitch;
+		}
+	}
+
+	// Single channel utility functions
+	inline int getSingleChannel(int x, int y, bool isSigned, bool isEAC) const
+	{
+		int codeword = isSigned ? signed_base_codeword : base_codeword;
+		return isEAC ? ((multiplier == 0) ? (codeword * 8 + 4 + getSingleChannelModifier(x, y)) : (codeword * 8 + 4 + getSingleChannelModifier(x, y) * multiplier * 8)) : codeword + getSingleChannelModifier(x, y) * multiplier;
+	}
+
+	inline int getSingleChannelIndex(int x, int y) const
+	{
+		switch(x * 4 + y)
+		{
 			case 0: return ma;
 			case 1: return mb;
 			case 2: return mc1 << 1 | mc2;
@@ -645,96 +638,96 @@
 			case 12: return mm;
 			case 13: return mn1 << 2 | mn2;
 			case 14: return mo;
-			default: return mp; // 15
-			}
+			default: return mp;  // 15
 		}
+	}
 
-		inline int getSingleChannelModifier(int x, int y) const
-		{
-			static const int modifierTable[16][8] = { { -3, -6, -9, -15, 2, 5, 8, 14 },
-			{ -3, -7, -10, -13, 2, 6, 9, 12 },
-			{ -2, -5, -8, -13, 1, 4, 7, 12 },
-			{ -2, -4, -6, -13, 1, 3, 5, 12 },
-			{ -3, -6, -8, -12, 2, 5, 7, 11 },
-			{ -3, -7, -9, -11, 2, 6, 8, 10 },
-			{ -4, -7, -8, -11, 3, 6, 7, 10 },
-			{ -3, -5, -8, -11, 2, 4, 7, 10 },
-			{ -2, -6, -8, -10, 1, 5, 7, 9 },
-			{ -2, -5, -8, -10, 1, 4, 7, 9 },
-			{ -2, -4, -8, -10, 1, 3, 7, 9 },
-			{ -2, -5, -7, -10, 1, 4, 6, 9 },
-			{ -3, -4, -7, -10, 2, 3, 6, 9 },
-			{ -1, -2, -3, -10, 0, 1, 2, 9 },
-			{ -4, -6, -8, -9, 3, 5, 7, 8 },
-			{ -3, -5, -7, -9, 2, 4, 6, 8 } };
+	inline int getSingleChannelModifier(int x, int y) const
+	{
+		static const int modifierTable[16][8] = { { -3, -6, -9, -15, 2, 5, 8, 14 },
+			                                      { -3, -7, -10, -13, 2, 6, 9, 12 },
+			                                      { -2, -5, -8, -13, 1, 4, 7, 12 },
+			                                      { -2, -4, -6, -13, 1, 3, 5, 12 },
+			                                      { -3, -6, -8, -12, 2, 5, 7, 11 },
+			                                      { -3, -7, -9, -11, 2, 6, 8, 10 },
+			                                      { -4, -7, -8, -11, 3, 6, 7, 10 },
+			                                      { -3, -5, -8, -11, 2, 4, 7, 10 },
+			                                      { -2, -6, -8, -10, 1, 5, 7, 9 },
+			                                      { -2, -5, -8, -10, 1, 4, 7, 9 },
+			                                      { -2, -4, -8, -10, 1, 3, 7, 9 },
+			                                      { -2, -5, -7, -10, 1, 4, 6, 9 },
+			                                      { -3, -4, -7, -10, 2, 3, 6, 9 },
+			                                      { -1, -2, -3, -10, 0, 1, 2, 9 },
+			                                      { -4, -6, -8, -9, 3, 5, 7, 8 },
+			                                      { -3, -5, -7, -9, 2, 4, 6, 8 } };
 
-			return modifierTable[table_index][getSingleChannelIndex(x, y)];
-		}
-	};
-}
+		return modifierTable[table_index][getSingleChannelIndex(x, y)];
+	}
+};
+}  // namespace
 
 // Decodes 1 to 4 channel images to 8 bit output
-bool ETC_Decoder::Decode(const unsigned char* src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, InputType inputType)
+bool ETC_Decoder::Decode(const unsigned char *src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, InputType inputType)
 {
-	const ETC2* sources[2];
-	sources[0] = (const ETC2*)src;
+	const ETC2 *sources[2];
+	sources[0] = (const ETC2 *)src;
 
 	unsigned char alphaValues[4][4] = { { 255, 255, 255, 255 }, { 255, 255, 255, 255 }, { 255, 255, 255, 255 }, { 255, 255, 255, 255 } };
 
 	switch(inputType)
 	{
-	case ETC_R_SIGNED:
-	case ETC_R_UNSIGNED:
-		for(int y = 0; y < h; y += 4)
-		{
-			unsigned char *dstRow = dst + (y * dstPitch);
-			for(int x = 0; x < w; x += 4, sources[0]++)
+		case ETC_R_SIGNED:
+		case ETC_R_UNSIGNED:
+			for(int y = 0; y < h; y += 4)
 			{
-				ETC2::DecodeBlock(sources, dstRow + (x * dstBpp), 1, x, y, dstW, dstH, dstPitch, inputType == ETC_R_SIGNED, true);
+				unsigned char *dstRow = dst + (y * dstPitch);
+				for(int x = 0; x < w; x += 4, sources[0]++)
+				{
+					ETC2::DecodeBlock(sources, dstRow + (x * dstBpp), 1, x, y, dstW, dstH, dstPitch, inputType == ETC_R_SIGNED, true);
+				}
 			}
-		}
-		break;
-	case ETC_RG_SIGNED:
-	case ETC_RG_UNSIGNED:
-		sources[1] = sources[0] + 1;
-		for(int y = 0; y < h; y += 4)
-		{
-			unsigned char *dstRow = dst + (y * dstPitch);
-			for(int x = 0; x < w; x += 4, sources[0] += 2, sources[1] += 2)
+			break;
+		case ETC_RG_SIGNED:
+		case ETC_RG_UNSIGNED:
+			sources[1] = sources[0] + 1;
+			for(int y = 0; y < h; y += 4)
 			{
-				ETC2::DecodeBlock(sources, dstRow + (x * dstBpp), 2, x, y, dstW, dstH, dstPitch, inputType == ETC_RG_SIGNED, true);
+				unsigned char *dstRow = dst + (y * dstPitch);
+				for(int x = 0; x < w; x += 4, sources[0] += 2, sources[1] += 2)
+				{
+					ETC2::DecodeBlock(sources, dstRow + (x * dstBpp), 2, x, y, dstW, dstH, dstPitch, inputType == ETC_RG_SIGNED, true);
+				}
 			}
-		}
-		break;
-	case ETC_RGB:
-	case ETC_RGB_PUNCHTHROUGH_ALPHA:
-		for(int y = 0; y < h; y += 4)
-		{
-			unsigned char *dstRow = dst + (y * dstPitch);
-			for(int x = 0; x < w; x += 4, sources[0]++)
+			break;
+		case ETC_RGB:
+		case ETC_RGB_PUNCHTHROUGH_ALPHA:
+			for(int y = 0; y < h; y += 4)
 			{
-				sources[0]->decodeBlock(dstRow + (x * dstBpp), x, y, dstW, dstH, dstPitch, alphaValues, inputType == ETC_RGB_PUNCHTHROUGH_ALPHA);
+				unsigned char *dstRow = dst + (y * dstPitch);
+				for(int x = 0; x < w; x += 4, sources[0]++)
+				{
+					sources[0]->decodeBlock(dstRow + (x * dstBpp), x, y, dstW, dstH, dstPitch, alphaValues, inputType == ETC_RGB_PUNCHTHROUGH_ALPHA);
+				}
 			}
-		}
-		break;
-	case ETC_RGBA:
-		for(int y = 0; y < h; y += 4)
-		{
-			unsigned char *dstRow = dst + (y * dstPitch);
-			for(int x = 0; x < w; x += 4)
+			break;
+		case ETC_RGBA:
+			for(int y = 0; y < h; y += 4)
 			{
-				// Decode Alpha
-				ETC2::DecodeBlock(&sources[0], &(alphaValues[0][0]), 1, x, y, dstW, dstH, 4, false, false);
-				sources[0]++; // RGBA packets are 128 bits, so move on to the next 64 bit packet to decode the RGB color
+				unsigned char *dstRow = dst + (y * dstPitch);
+				for(int x = 0; x < w; x += 4)
+				{
+					// Decode Alpha
+					ETC2::DecodeBlock(&sources[0], &(alphaValues[0][0]), 1, x, y, dstW, dstH, 4, false, false);
+					sources[0]++;  // RGBA packets are 128 bits, so move on to the next 64 bit packet to decode the RGB color
 
-				// Decode RGB
-				sources[0]->decodeBlock(dstRow + (x * dstBpp), x, y, dstW, dstH, dstPitch, alphaValues, false);
-				sources[0]++;
+					// Decode RGB
+					sources[0]->decodeBlock(dstRow + (x * dstBpp), x, y, dstW, dstH, dstPitch, alphaValues, false);
+					sources[0]++;
+				}
 			}
-		}
-		break;
-	default:
-		return false;
+			break;
+		default:
+			return false;
 	}
 
 	return true;
diff --git a/src/Device/ETC_Decoder.hpp b/src/Device/ETC_Decoder.hpp
index 1039b37..f202bec 100644
--- a/src/Device/ETC_Decoder.hpp
+++ b/src/Device/ETC_Decoder.hpp
@@ -37,5 +37,5 @@
 	/// @param dstBpp         dst image bytes per pixel
 	/// @param inputType      src's format
 	/// @return               true if the decoding was performed
-	static bool Decode(const unsigned char* src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, InputType inputType);
+	static bool Decode(const unsigned char *src, unsigned char *dst, int w, int h, int dstW, int dstH, int dstPitch, int dstBpp, InputType inputType);
 };
diff --git a/src/Device/LRUCache.hpp b/src/Device/LRUCache.hpp
index f549769..d4d2bdb 100644
--- a/src/Device/LRUCache.hpp
+++ b/src/Device/LRUCache.hpp
@@ -33,8 +33,8 @@
 	Data query(const Key &key) const;
 	virtual Data add(const Key &key, const Data &data);
 
-	int getSize() {return size;}
-	Key &getKey(int i) {return key[i];}
+	int getSize() { return size; }
+	Key &getKey(int i) { return key[i]; }
 
 protected:
 	int size;
@@ -51,18 +51,21 @@
 class LRUConstCache : public LRUCache<Key, Data>
 {
 	using LRUBase = LRUCache<Key, Data>;
+
 public:
-	LRUConstCache(int n) : LRUBase(n) {}
+	LRUConstCache(int n)
+	    : LRUBase(n)
+	{}
 	~LRUConstCache() { clearConstCache(); }
 
-	Data add(const Key &key, const Data& data) override
+	Data add(const Key &key, const Data &data) override
 	{
 		constCacheNeedsUpdate = true;
 		return LRUBase::add(key, data);
 	}
 
 	void updateConstCache();
-	const Data& queryConstCache(const Key &key) const;
+	const Data &queryConstCache(const Key &key) const;
 
 private:
 	void clearConstCache();
@@ -75,15 +78,15 @@
 template<typename T>
 struct is_memcmparable
 {
-	// std::is_trivially_copyable is not available in older GCC versions.
-	#if !defined(__GNUC__) || __GNUC__ > 5
-		static const bool value = std::is_trivially_copyable<T>::value;
-	#else
-		// At least check it doesn't have virtual methods.
-		static const bool value = !std::is_polymorphic<T>::value;
-	#endif
+// std::is_trivially_copyable is not available in older GCC versions.
+#if !defined(__GNUC__) || __GNUC__ > 5
+	static const bool value = std::is_trivially_copyable<T>::value;
+#else
+	// At least check it doesn't have virtual methods.
+	static const bool value = !std::is_polymorphic<T>::value;
+#endif
 };
-}
+}  // namespace sw
 
 namespace sw {
 
@@ -96,7 +99,7 @@
 	fill = 0;
 
 	key = new Key[size];
-	ref = new Key*[size];
+	ref = new Key *[size];
 	data = new Data[size];
 
 	for(int i = 0; i < size; i++)
@@ -147,7 +150,7 @@
 		}
 	}
 
-	return {};   // Not found
+	return {};  // Not found
 }
 
 template<class Key, class Data>
@@ -188,7 +191,7 @@
 }
 
 template<class Key, class Data, class Hasher>
-const Data& LRUConstCache<Key, Data, Hasher>::queryConstCache(const Key &key) const
+const Data &LRUConstCache<Key, Data, Hasher>::queryConstCache(const Key &key) const
 {
 	auto it = constCache.find(key);
 	static Data null = {};
@@ -197,4 +200,4 @@
 
 }  // namespace sw
 
-#endif   // sw_LRUCache_hpp
+#endif  // sw_LRUCache_hpp
diff --git a/src/Device/Matrix.cpp b/src/Device/Matrix.cpp
index 006ca1b..b45facf 100644
--- a/src/Device/Matrix.cpp
+++ b/src/Device/Matrix.cpp
@@ -21,13 +21,13 @@
 
 Matrix Matrix::diag(float m11, float m22, float m33, float m44)
 {
-	return Matrix(m11, 0,   0,   0,
-	              0,   m22, 0,   0,
-	              0,   0,   m33, 0,
-	              0,   0,   0,   m44);
+	return Matrix(m11, 0, 0, 0,
+	              0, m22, 0, 0,
+	              0, 0, m33, 0,
+	              0, 0, 0, m44);
 }
 
-Matrix::operator float*()
+Matrix::operator float *()
 {
 	return &(*this)(1, 1);
 }
@@ -41,9 +41,9 @@
 {
 	const Matrix &M = *this;
 
-	return Matrix(-M(1, 1), -M(1, 2), -M(1, 3), -M(1, 4), 
-	              -M(2, 1), -M(2, 2), -M(2, 3), -M(2, 4), 
-	              -M(3, 1), -M(3, 2), -M(3, 3), -M(3, 4), 
+	return Matrix(-M(1, 1), -M(1, 2), -M(1, 3), -M(1, 4),
+	              -M(2, 1), -M(2, 2), -M(2, 3), -M(2, 4),
+	              -M(3, 1), -M(3, 2), -M(3, 3), -M(3, 4),
 	              -M(4, 1), -M(4, 2), -M(4, 3), -M(4, 4));
 }
 
@@ -72,25 +72,25 @@
 	float M1223 = M(1, 2) * M(2, 3) - M(2, 2) * M(1, 3);
 
 	// Adjoint Matrix
-	I(1, 1) =  M(2, 2) * M3344 - M(3, 2) * M2344 + M(4, 2) * M2334;
+	I(1, 1) = M(2, 2) * M3344 - M(3, 2) * M2344 + M(4, 2) * M2334;
 	I(2, 1) = -M(2, 1) * M3344 + M(3, 1) * M2344 - M(4, 1) * M2334;
-	I(3, 1) =  M(2, 1) * M3244 - M(3, 1) * M2244 + M(4, 1) * M2234;
+	I(3, 1) = M(2, 1) * M3244 - M(3, 1) * M2244 + M(4, 1) * M2234;
 	I(4, 1) = -M(2, 1) * M3243 + M(3, 1) * M2243 - M(4, 1) * M2233;
 
 	I(1, 2) = -M(1, 2) * M3344 + M(3, 2) * M1344 - M(4, 2) * M1334;
-	I(2, 2) =  M(1, 1) * M3344 - M(3, 1) * M1344 + M(4, 1) * M1334;
+	I(2, 2) = M(1, 1) * M3344 - M(3, 1) * M1344 + M(4, 1) * M1334;
 	I(3, 2) = -M(1, 1) * M3244 + M(3, 1) * M1244 - M(4, 1) * M1234;
-	I(4, 2) =  M(1, 1) * M3243 - M(3, 1) * M1243 + M(4, 1) * M1233;
+	I(4, 2) = M(1, 1) * M3243 - M(3, 1) * M1243 + M(4, 1) * M1233;
 
-	I(1, 3) =  M(1, 2) * M2344 - M(2, 2) * M1344 + M(4, 2) * M1324;
+	I(1, 3) = M(1, 2) * M2344 - M(2, 2) * M1344 + M(4, 2) * M1324;
 	I(2, 3) = -M(1, 1) * M2344 + M(2, 1) * M1344 - M(4, 1) * M1324;
-	I(3, 3) =  M(1, 1) * M2244 - M(2, 1) * M1244 + M(4, 1) * M1224;
+	I(3, 3) = M(1, 1) * M2244 - M(2, 1) * M1244 + M(4, 1) * M1224;
 	I(4, 3) = -M(1, 1) * M2243 + M(2, 1) * M1243 - M(4, 1) * M1223;
 
 	I(1, 4) = -M(1, 2) * M2334 + M(2, 2) * M1334 - M(3, 2) * M1324;
-	I(2, 4) =  M(1, 1) * M2334 - M(2, 1) * M1334 + M(3, 1) * M1324;
+	I(2, 4) = M(1, 1) * M2334 - M(2, 1) * M1334 + M(3, 1) * M1324;
 	I(3, 4) = -M(1, 1) * M2234 + M(2, 1) * M1234 - M(3, 1) * M1224;
-	I(4, 4) =  M(1, 1) * M2233 - M(2, 1) * M1233 + M(3, 1) * M1223;
+	I(4, 4) = M(1, 1) * M2233 - M(2, 1) * M1233 + M(3, 1) * M1223;
 
 	// Division by determinant
 	I /= M(1, 1) * I(1, 1) +
@@ -105,9 +105,9 @@
 {
 	const Matrix &M = *this;
 
-	return Matrix(M(1, 1), M(2, 1), M(3, 1), M(4, 1), 
-	              M(1, 2), M(2, 2), M(3, 2), M(4, 2), 
-	              M(1, 3), M(2, 3), M(3, 3), M(4, 3), 
+	return Matrix(M(1, 1), M(2, 1), M(3, 1), M(4, 1),
+	              M(1, 2), M(2, 2), M(3, 2), M(4, 2),
+	              M(1, 3), M(2, 3), M(3, 3), M(4, 3),
 	              M(1, 4), M(2, 4), M(3, 4), M(4, 4));
 }
 
@@ -115,10 +115,22 @@
 {
 	Matrix &M = *this;
 
-	M(1, 1) += N(1, 1); M(1, 2) += N(1, 2); M(1, 3) += N(1, 3); M(1, 4) += N(1, 4);
-	M(2, 1) += N(2, 1); M(2, 2) += N(2, 2); M(2, 3) += N(2, 3); M(2, 4) += N(2, 4);
-	M(3, 1) += N(3, 1); M(3, 2) += N(3, 2); M(3, 3) += N(3, 3); M(3, 4) += N(3, 4);
-	M(4, 1) += N(4, 1); M(4, 2) += N(4, 2); M(4, 3) += N(4, 3); M(4, 4) += N(4, 4);
+	M(1, 1) += N(1, 1);
+	M(1, 2) += N(1, 2);
+	M(1, 3) += N(1, 3);
+	M(1, 4) += N(1, 4);
+	M(2, 1) += N(2, 1);
+	M(2, 2) += N(2, 2);
+	M(2, 3) += N(2, 3);
+	M(2, 4) += N(2, 4);
+	M(3, 1) += N(3, 1);
+	M(3, 2) += N(3, 2);
+	M(3, 3) += N(3, 3);
+	M(3, 4) += N(3, 4);
+	M(4, 1) += N(4, 1);
+	M(4, 2) += N(4, 2);
+	M(4, 3) += N(4, 3);
+	M(4, 4) += N(4, 4);
 
 	return M;
 }
@@ -127,10 +139,22 @@
 {
 	Matrix &M = *this;
 
-	M(1, 1) -= N(1, 1); M(1, 2) -= N(1, 2); M(1, 3) -= N(1, 3); M(1, 4) -= N(1, 4);
-	M(2, 1) -= N(2, 1); M(2, 2) -= N(2, 2); M(2, 3) -= N(2, 3); M(2, 4) -= N(2, 4);
-	M(3, 1) -= N(3, 1); M(3, 2) -= N(3, 2); M(3, 3) -= N(3, 3); M(3, 4) -= N(3, 4);
-	M(4, 1) -= N(4, 1); M(4, 2) -= N(4, 2); M(4, 3) -= N(4, 3); M(4, 4) -= N(4, 4);
+	M(1, 1) -= N(1, 1);
+	M(1, 2) -= N(1, 2);
+	M(1, 3) -= N(1, 3);
+	M(1, 4) -= N(1, 4);
+	M(2, 1) -= N(2, 1);
+	M(2, 2) -= N(2, 2);
+	M(2, 3) -= N(2, 3);
+	M(2, 4) -= N(2, 4);
+	M(3, 1) -= N(3, 1);
+	M(3, 2) -= N(3, 2);
+	M(3, 3) -= N(3, 3);
+	M(3, 4) -= N(3, 4);
+	M(4, 1) -= N(4, 1);
+	M(4, 2) -= N(4, 2);
+	M(4, 3) -= N(4, 3);
+	M(4, 4) -= N(4, 4);
 
 	return M;
 }
@@ -139,10 +163,22 @@
 {
 	Matrix &M = *this;
 
-	M(1, 1) *= s; M(1, 2) *= s; M(1, 3) *= s; M(1, 4) *= s;
-	M(2, 1) *= s; M(2, 2) *= s; M(2, 3) *= s; M(2, 4) *= s;
-	M(3, 1) *= s; M(3, 2) *= s; M(3, 3) *= s; M(3, 4) *= s;
-	M(4, 1) *= s; M(4, 2) *= s; M(4, 3) *= s; M(4, 4) *= s;
+	M(1, 1) *= s;
+	M(1, 2) *= s;
+	M(1, 3) *= s;
+	M(1, 4) *= s;
+	M(2, 1) *= s;
+	M(2, 2) *= s;
+	M(2, 3) *= s;
+	M(2, 4) *= s;
+	M(3, 1) *= s;
+	M(3, 2) *= s;
+	M(3, 3) *= s;
+	M(3, 4) *= s;
+	M(4, 1) *= s;
+	M(4, 2) *= s;
+	M(4, 3) *= s;
+	M(4, 4) *= s;
 
 	return M;
 }
@@ -183,41 +219,41 @@
 
 Matrix operator+(const Matrix &M, const Matrix &N)
 {
-	return Matrix(M(1, 1) + N(1, 1), M(1, 2) + N(1, 2), M(1, 3) + N(1, 3), M(1, 4) + N(1, 4), 
-	              M(2, 1) + N(2, 1), M(2, 2) + N(2, 2), M(2, 3) + N(2, 3), M(2, 4) + N(2, 4), 
-	              M(3, 1) + N(3, 1), M(3, 2) + N(3, 2), M(3, 3) + N(3, 3), M(3, 4) + N(3, 4), 
+	return Matrix(M(1, 1) + N(1, 1), M(1, 2) + N(1, 2), M(1, 3) + N(1, 3), M(1, 4) + N(1, 4),
+	              M(2, 1) + N(2, 1), M(2, 2) + N(2, 2), M(2, 3) + N(2, 3), M(2, 4) + N(2, 4),
+	              M(3, 1) + N(3, 1), M(3, 2) + N(3, 2), M(3, 3) + N(3, 3), M(3, 4) + N(3, 4),
 	              M(4, 1) + N(4, 1), M(4, 2) + N(4, 2), M(4, 3) + N(4, 3), M(4, 4) + N(4, 4));
 }
 
 Matrix operator-(const Matrix &M, const Matrix &N)
 {
-	return Matrix(M(1, 1) - N(1, 1), M(1, 2) - N(1, 2), M(1, 3) - N(1, 3), M(1, 4) - N(1, 4), 
-	              M(2, 1) - N(2, 1), M(2, 2) - N(2, 2), M(2, 3) - N(2, 3), M(2, 4) - N(2, 4), 
-	              M(3, 1) - N(3, 1), M(3, 2) - N(3, 2), M(3, 3) - N(3, 3), M(3, 4) - N(3, 4), 
+	return Matrix(M(1, 1) - N(1, 1), M(1, 2) - N(1, 2), M(1, 3) - N(1, 3), M(1, 4) - N(1, 4),
+	              M(2, 1) - N(2, 1), M(2, 2) - N(2, 2), M(2, 3) - N(2, 3), M(2, 4) - N(2, 4),
+	              M(3, 1) - N(3, 1), M(3, 2) - N(3, 2), M(3, 3) - N(3, 3), M(3, 4) - N(3, 4),
 	              M(4, 1) - N(4, 1), M(4, 2) - N(4, 2), M(4, 3) - N(4, 3), M(4, 4) - N(4, 4));
 }
 
 Matrix operator*(float s, const Matrix &M)
 {
-	return Matrix(s * M(1, 1), s * M(1, 2), s * M(1, 3), s * M(1, 4), 
-	              s * M(2, 1), s * M(2, 2), s * M(2, 3), s * M(2, 4), 
-	              s * M(3, 1), s * M(3, 2), s * M(3, 3), s * M(3, 4), 
+	return Matrix(s * M(1, 1), s * M(1, 2), s * M(1, 3), s * M(1, 4),
+	              s * M(2, 1), s * M(2, 2), s * M(2, 3), s * M(2, 4),
+	              s * M(3, 1), s * M(3, 2), s * M(3, 3), s * M(3, 4),
 	              s * M(4, 1), s * M(4, 2), s * M(4, 3), s * M(4, 4));
 }
 
 Matrix operator*(const Matrix &M, float s)
 {
-	return Matrix(M(1, 1) * s, M(1, 2) * s, M(1, 3) * s, M(1, 4) * s, 
-	              M(2, 1) * s, M(2, 2) * s, M(2, 3) * s, M(2, 4) * s, 
-	              M(3, 1) * s, M(3, 2) * s, M(3, 3) * s, M(3, 4) * s, 
+	return Matrix(M(1, 1) * s, M(1, 2) * s, M(1, 3) * s, M(1, 4) * s,
+	              M(2, 1) * s, M(2, 2) * s, M(2, 3) * s, M(2, 4) * s,
+	              M(3, 1) * s, M(3, 2) * s, M(3, 3) * s, M(3, 4) * s,
 	              M(4, 1) * s, M(4, 2) * s, M(4, 3) * s, M(4, 4) * s);
 }
 
 Matrix operator*(const Matrix &M, const Matrix &N)
 {
-	return Matrix(M(1, 1) * N(1, 1) + M(1, 2) * N(2, 1) + M(1, 3) * N(3, 1) + M(1, 4) * N(4, 1), M(1, 1) * N(1, 2) + M(1, 2) * N(2, 2) + M(1, 3) * N(3, 2) + M(1, 4) * N(4, 2), M(1, 1) * N(1, 3) + M(1, 2) * N(2, 3) + M(1, 3) * N(3, 3) + M(1, 4) * N(4, 3), M(1, 1) * N(1, 4) + M(1, 2) * N(2, 4) + M(1, 3) * N(3, 4) + M(1, 4) * N(4, 4), 
-	              M(2, 1) * N(1, 1) + M(2, 2) * N(2, 1) + M(2, 3) * N(3, 1) + M(2, 4) * N(4, 1), M(2, 1) * N(1, 2) + M(2, 2) * N(2, 2) + M(2, 3) * N(3, 2) + M(2, 4) * N(4, 2), M(2, 1) * N(1, 3) + M(2, 2) * N(2, 3) + M(2, 3) * N(3, 3) + M(2, 4) * N(4, 3), M(2, 1) * N(1, 4) + M(2, 2) * N(2, 4) + M(2, 3) * N(3, 4) + M(2, 4) * N(4, 4), 
-	              M(3, 1) * N(1, 1) + M(3, 2) * N(2, 1) + M(3, 3) * N(3, 1) + M(3, 4) * N(4, 1), M(3, 1) * N(1, 2) + M(3, 2) * N(2, 2) + M(3, 3) * N(3, 2) + M(3, 4) * N(4, 2), M(3, 1) * N(1, 3) + M(3, 2) * N(2, 3) + M(3, 3) * N(3, 3) + M(3, 4) * N(4, 3), M(3, 1) * N(1, 4) + M(3, 2) * N(2, 4) + M(3, 3) * N(3, 4) + M(3, 4) * N(4, 4), 
+	return Matrix(M(1, 1) * N(1, 1) + M(1, 2) * N(2, 1) + M(1, 3) * N(3, 1) + M(1, 4) * N(4, 1), M(1, 1) * N(1, 2) + M(1, 2) * N(2, 2) + M(1, 3) * N(3, 2) + M(1, 4) * N(4, 2), M(1, 1) * N(1, 3) + M(1, 2) * N(2, 3) + M(1, 3) * N(3, 3) + M(1, 4) * N(4, 3), M(1, 1) * N(1, 4) + M(1, 2) * N(2, 4) + M(1, 3) * N(3, 4) + M(1, 4) * N(4, 4),
+	              M(2, 1) * N(1, 1) + M(2, 2) * N(2, 1) + M(2, 3) * N(3, 1) + M(2, 4) * N(4, 1), M(2, 1) * N(1, 2) + M(2, 2) * N(2, 2) + M(2, 3) * N(3, 2) + M(2, 4) * N(4, 2), M(2, 1) * N(1, 3) + M(2, 2) * N(2, 3) + M(2, 3) * N(3, 3) + M(2, 4) * N(4, 3), M(2, 1) * N(1, 4) + M(2, 2) * N(2, 4) + M(2, 3) * N(3, 4) + M(2, 4) * N(4, 4),
+	              M(3, 1) * N(1, 1) + M(3, 2) * N(2, 1) + M(3, 3) * N(3, 1) + M(3, 4) * N(4, 1), M(3, 1) * N(1, 2) + M(3, 2) * N(2, 2) + M(3, 3) * N(3, 2) + M(3, 4) * N(4, 2), M(3, 1) * N(1, 3) + M(3, 2) * N(2, 3) + M(3, 3) * N(3, 3) + M(3, 4) * N(4, 3), M(3, 1) * N(1, 4) + M(3, 2) * N(2, 4) + M(3, 3) * N(3, 4) + M(3, 4) * N(4, 4),
 	              M(4, 1) * N(1, 1) + M(4, 2) * N(2, 1) + M(4, 3) * N(3, 1) + M(4, 4) * N(4, 1), M(4, 1) * N(1, 2) + M(4, 2) * N(2, 2) + M(4, 3) * N(3, 2) + M(4, 4) * N(4, 2), M(4, 1) * N(1, 3) + M(4, 2) * N(2, 3) + M(4, 3) * N(3, 3) + M(4, 4) * N(4, 3), M(4, 1) * N(1, 4) + M(4, 2) * N(2, 4) + M(4, 3) * N(3, 4) + M(4, 4) * N(4, 4));
 }
 
@@ -236,7 +272,7 @@
 	float Mz = M(3, 1) * v.x + M(3, 2) * v.y + M(3, 3) * v.z + M(3, 4) * v.w;
 	float Mw = M(4, 1) * v.x + M(4, 2) * v.y + M(4, 3) * v.z + M(4, 4) * v.w;
 
-	return {Mx, My, Mz, Mw};
+	return { Mx, My, Mz, Mw };
 }
 
 float Matrix::det(const Matrix &M)
@@ -259,14 +295,14 @@
 	return m11;
 }
 
-float Matrix::det(float m11, float m12, 
+float Matrix::det(float m11, float m12,
                   float m21, float m22)
 {
-	return m11 * m22 - m12 * m21; 
+	return m11 * m22 - m12 * m21;
 }
 
-float Matrix::det(float m11, float m12, float m13, 
-                  float m21, float m22, float m23, 
+float Matrix::det(float m11, float m12, float m13,
+                  float m21, float m22, float m23,
                   float m31, float m32, float m33)
 {
 	return m11 * (m22 * m33 - m32 * m23) -
@@ -274,9 +310,9 @@
 	       m31 * (m12 * m23 - m22 * m13);
 }
 
-float Matrix::det(float m11, float m12, float m13, float m14, 
-                  float m21, float m22, float m23, float m24, 
-                  float m31, float m32, float m33, float m34, 
+float Matrix::det(float m11, float m12, float m13, float m14,
+                  float m21, float m22, float m23, float m24,
+                  float m31, float m32, float m33, float m34,
                   float m41, float m42, float m43, float m44)
 {
 	float M3344 = m33 * m44 - m43 * m34;
@@ -327,9 +363,15 @@
 	v2 /= Vector::N(v2);
 	v3 /= Vector::N(v3);
 
-	M(1, 1) = v1.x;  M(1, 2) = v2.x;  M(1, 3) = v3.x;
-	M(2, 1) = v1.y;  M(2, 2) = v2.y;  M(2, 3) = v3.y;
-	M(3, 1) = v1.z;  M(3, 2) = v2.z;  M(3, 3) = v3.z;
+	M(1, 1) = v1.x;
+	M(1, 2) = v2.x;
+	M(1, 3) = v3.x;
+	M(2, 1) = v1.y;
+	M(2, 2) = v2.y;
+	M(2, 3) = v3.y;
+	M(3, 1) = v1.z;
+	M(3, 2) = v2.z;
+	M(3, 3) = v3.z;
 
 	return *this;
 }
@@ -347,8 +389,8 @@
 	float sxcy = sx * cy;
 
 	return Matrix(cy * cz - sxsy * sz, -cy * sz - sxsy * cz, -sy * cx,
-	              cx * sz,              cx * cz,             -sx,
-	              sy * cz + sxcy * sz, -sy * sz + sxcy * cz,  cy * cx);
+	              cx * sz, cx * cz, -sx,
+	              sy * cz + sxcy * sz, -sy * sz + sxcy * cz, cy * cx);
 }
 
 Matrix Matrix::eulerRotate(float x, float y, float z)
@@ -371,9 +413,9 @@
 
 Matrix Matrix::scale(const Vector &v)
 {
-	return Matrix(v.x, 0,   0,
-	              0,   v.y, 0,
-	              0,   0,   v.z);
+	return Matrix(v.x, 0, 0,
+	              0, v.y, 0,
+	              0, 0, v.z);
 }
 
 Matrix Matrix::scale(float x, float y, float z)
diff --git a/src/Device/Matrix.hpp b/src/Device/Matrix.hpp
index 2dd4e3c..d5a525a 100644
--- a/src/Device/Matrix.hpp
+++ b/src/Device/Matrix.hpp
@@ -35,7 +35,7 @@
 	       float m21, float m22, float m23, float m24,
 	       float m31, float m32, float m33, float m34,
 	       float m41, float m42, float m43, float m44);
-	Matrix(const Vector &v1, const Vector &v2, const Vector &v3);   // Column vectors
+	Matrix(const Vector &v1, const Vector &v2, const Vector &v3);  // Column vectors
 
 	Matrix &operator=(const Matrix &N);
 
@@ -44,13 +44,13 @@
 
 	static Matrix diag(float m11, float m22, float m33, float m44);
 
-	operator float*();
+	operator float *();
 
 	Matrix operator+() const;
 	Matrix operator-() const;
 
-	Matrix operator!() const;   // Inverse
-	Matrix operator~() const;   // Transpose
+	Matrix operator!() const;  // Inverse
+	Matrix operator~() const;  // Transpose
 
 	Matrix &operator+=(const Matrix &N);
 	Matrix &operator-=(const Matrix &N);
@@ -58,10 +58,10 @@
 	Matrix &operator*=(const Matrix &N);
 	Matrix &operator/=(float s);
 
-	float *operator[](int i);   // Access element [row][col], starting with [0][0]
+	float *operator[](int i);  // Access element [row][col], starting with [0][0]
 	const float *operator[](int i) const;
 
-	float &operator()(int i, int j);   // Access element (row, col), starting with (1, 1)
+	float &operator()(int i, int j);  // Access element (row, col), starting with (1, 1)
 	const float &operator()(int i, int j) const;
 
 	friend bool operator==(const Matrix &M, const Matrix &N);
@@ -91,21 +91,21 @@
 
 	static float tr(const Matrix &M);
 
-	Matrix &orthogonalise();   // Gram-Schmidt orthogonalisation of 3x3 submatrix
+	Matrix &orthogonalise();  // Gram-Schmidt orthogonalisation of 3x3 submatrix
 
 	static Matrix eulerRotate(const Vector &v);
 	static Matrix eulerRotate(float x, float y, float z);
 
 	static Matrix translate(const Vector &v);
 	static Matrix translate(float x, float y, float z);
-	
+
 	static Matrix scale(const Vector &v);
 	static Matrix scale(float x, float y, float z);
 
 	static Matrix lookAt(const Vector &v);
 	static Matrix lookAt(float x, float y, float z);
 };
-}
+}  // namespace sw
 
 #include "Vector.hpp"
 
@@ -121,75 +121,159 @@
 
 	Matrix &M = *this;
 
-	M(1, 1) = s; M(1, 2) = 0; M(1, 3) = 0; M(1, 4) = 0;
-	M(2, 1) = 0; M(2, 2) = s; M(2, 3) = 0; M(2, 4) = 0;
-	M(3, 1) = 0; M(3, 2) = 0; M(3, 3) = s; M(3, 4) = 0;
-	M(4, 1) = 0; M(4, 2) = 0; M(4, 3) = 0; M(4, 4) = s;
+	M(1, 1) = s;
+	M(1, 2) = 0;
+	M(1, 3) = 0;
+	M(1, 4) = 0;
+	M(2, 1) = 0;
+	M(2, 2) = s;
+	M(2, 3) = 0;
+	M(2, 4) = 0;
+	M(3, 1) = 0;
+	M(3, 2) = 0;
+	M(3, 3) = s;
+	M(3, 4) = 0;
+	M(4, 1) = 0;
+	M(4, 2) = 0;
+	M(4, 3) = 0;
+	M(4, 4) = s;
 }
 
 inline Matrix::Matrix(const float m[16])
 {
 	Matrix &M = *this;
 
-	M(1, 1) = m[0];  M(1, 2) = m[1];  M(1, 3) = m[2];  M(1, 4) = m[3];
-	M(2, 1) = m[4];  M(2, 2) = m[5];  M(2, 3) = m[6];  M(2, 4) = m[7];
-	M(3, 1) = m[8];  M(3, 2) = m[8];  M(3, 3) = m[10]; M(3, 4) = m[11];
-	M(4, 1) = m[12]; M(4, 2) = m[13]; M(4, 3) = m[14]; M(4, 4) = m[15];
+	M(1, 1) = m[0];
+	M(1, 2) = m[1];
+	M(1, 3) = m[2];
+	M(1, 4) = m[3];
+	M(2, 1) = m[4];
+	M(2, 2) = m[5];
+	M(2, 3) = m[6];
+	M(2, 4) = m[7];
+	M(3, 1) = m[8];
+	M(3, 2) = m[8];
+	M(3, 3) = m[10];
+	M(3, 4) = m[11];
+	M(4, 1) = m[12];
+	M(4, 2) = m[13];
+	M(4, 3) = m[14];
+	M(4, 4) = m[15];
 }
 
 inline Matrix::Matrix(const float m[4][4])
 {
 	Matrix &M = *this;
 
-	M[0][0] = m[0][0];  M[0][1] = m[0][1];  M[0][2] = m[0][2];  M[0][3] = m[0][3];
-	M[1][0] = m[1][0];  M[1][1] = m[1][1];  M[1][2] = m[1][2];  M[1][3] = m[1][3];
-	M[2][0] = m[2][0];  M[2][1] = m[2][1];  M[2][2] = m[2][2];  M[2][3] = m[2][3];
-	M[3][0] = m[3][0];  M[3][1] = m[3][1];  M[3][2] = m[3][2];  M[3][3] = m[3][3];
+	M[0][0] = m[0][0];
+	M[0][1] = m[0][1];
+	M[0][2] = m[0][2];
+	M[0][3] = m[0][3];
+	M[1][0] = m[1][0];
+	M[1][1] = m[1][1];
+	M[1][2] = m[1][2];
+	M[1][3] = m[1][3];
+	M[2][0] = m[2][0];
+	M[2][1] = m[2][1];
+	M[2][2] = m[2][2];
+	M[2][3] = m[2][3];
+	M[3][0] = m[3][0];
+	M[3][1] = m[3][1];
+	M[3][2] = m[3][2];
+	M[3][3] = m[3][3];
 }
 
-inline Matrix::Matrix(float m11, float m12, float m13, 
-                      float m21, float m22, float m23, 
+inline Matrix::Matrix(float m11, float m12, float m13,
+                      float m21, float m22, float m23,
                       float m31, float m32, float m33)
 {
 	Matrix &M = *this;
 
-	M(1, 1) = m11; M(1, 2) = m12; M(1, 3) = m13; M(1, 4) = 0;
-	M(2, 1) = m21; M(2, 2) = m22; M(2, 3) = m23; M(2, 4) = 0;
-	M(3, 1) = m31; M(3, 2) = m32; M(3, 3) = m33; M(3, 4) = 0;
-	M(4, 1) = 0;   M(4, 2) = 0;   M(4, 3) = 0;   M(4, 4) = 1;
+	M(1, 1) = m11;
+	M(1, 2) = m12;
+	M(1, 3) = m13;
+	M(1, 4) = 0;
+	M(2, 1) = m21;
+	M(2, 2) = m22;
+	M(2, 3) = m23;
+	M(2, 4) = 0;
+	M(3, 1) = m31;
+	M(3, 2) = m32;
+	M(3, 3) = m33;
+	M(3, 4) = 0;
+	M(4, 1) = 0;
+	M(4, 2) = 0;
+	M(4, 3) = 0;
+	M(4, 4) = 1;
 }
 
-inline Matrix::Matrix(float m11, float m12, float m13, float m14, 
-                      float m21, float m22, float m23, float m24, 
-                      float m31, float m32, float m33, float m34, 
+inline Matrix::Matrix(float m11, float m12, float m13, float m14,
+                      float m21, float m22, float m23, float m24,
+                      float m31, float m32, float m33, float m34,
                       float m41, float m42, float m43, float m44)
 {
 	Matrix &M = *this;
 
-	M(1, 1) = m11; M(1, 2) = m12; M(1, 3) = m13; M(1, 4) = m14;
-	M(2, 1) = m21; M(2, 2) = m22; M(2, 3) = m23; M(2, 4) = m24;
-	M(3, 1) = m31; M(3, 2) = m32; M(3, 3) = m33; M(3, 4) = m34;
-	M(4, 1) = m41; M(4, 2) = m42; M(4, 3) = m43; M(4, 4) = m44;
+	M(1, 1) = m11;
+	M(1, 2) = m12;
+	M(1, 3) = m13;
+	M(1, 4) = m14;
+	M(2, 1) = m21;
+	M(2, 2) = m22;
+	M(2, 3) = m23;
+	M(2, 4) = m24;
+	M(3, 1) = m31;
+	M(3, 2) = m32;
+	M(3, 3) = m33;
+	M(3, 4) = m34;
+	M(4, 1) = m41;
+	M(4, 2) = m42;
+	M(4, 3) = m43;
+	M(4, 4) = m44;
 }
 
 inline Matrix::Matrix(const Vector &v1, const Vector &v2, const Vector &v3)
 {
 	Matrix &M = *this;
 
-	M(1, 1) = v1.x; M(1, 2) = v2.x; M(1, 3) = v3.x; M(1, 4) = 0;
-	M(2, 1) = v1.y; M(2, 2) = v2.y; M(2, 3) = v3.y; M(2, 4) = 0;
-	M(3, 1) = v1.z; M(3, 2) = v2.z; M(3, 3) = v3.z; M(3, 4) = 0;
-	M(4, 1) = 0;    M(4, 2) = 0;    M(4, 3) = 0;    M(4, 4) = 1;
+	M(1, 1) = v1.x;
+	M(1, 2) = v2.x;
+	M(1, 3) = v3.x;
+	M(1, 4) = 0;
+	M(2, 1) = v1.y;
+	M(2, 2) = v2.y;
+	M(2, 3) = v3.y;
+	M(2, 4) = 0;
+	M(3, 1) = v1.z;
+	M(3, 2) = v2.z;
+	M(3, 3) = v3.z;
+	M(3, 4) = 0;
+	M(4, 1) = 0;
+	M(4, 2) = 0;
+	M(4, 3) = 0;
+	M(4, 4) = 1;
 }
 
 inline Matrix &Matrix::operator=(const Matrix &N)
 {
 	Matrix &M = *this;
 
-	M(1, 1) = N(1, 1); M(1, 2) = N(1, 2); M(1, 3) = N(1, 3); M(1, 4) = N(1, 4);
-	M(2, 1) = N(2, 1); M(2, 2) = N(2, 2); M(2, 3) = N(2, 3); M(2, 4) = N(2, 4);
-	M(3, 1) = N(3, 1); M(3, 2) = N(3, 2); M(3, 3) = N(3, 3); M(3, 4) = N(3, 4);
-	M(4, 1) = N(4, 1); M(4, 2) = N(4, 2); M(4, 3) = N(4, 3); M(4, 4) = N(4, 4);
+	M(1, 1) = N(1, 1);
+	M(1, 2) = N(1, 2);
+	M(1, 3) = N(1, 3);
+	M(1, 4) = N(1, 4);
+	M(2, 1) = N(2, 1);
+	M(2, 2) = N(2, 2);
+	M(2, 3) = N(2, 3);
+	M(2, 4) = N(2, 4);
+	M(3, 1) = N(3, 1);
+	M(3, 2) = N(3, 2);
+	M(3, 3) = N(3, 3);
+	M(3, 4) = N(3, 4);
+	M(4, 1) = N(4, 1);
+	M(4, 2) = N(4, 2);
+	M(4, 3) = N(4, 3);
+	M(4, 4) = N(4, 4);
 
 	return M;
 }
@@ -216,4 +300,4 @@
 
 }  // namespace sw
 
-#endif   // Matrix_hpp
+#endif  // Matrix_hpp
diff --git a/src/Device/Memset.hpp b/src/Device/Memset.hpp
index 9db5d47..6ce53ae 100644
--- a/src/Device/Memset.hpp
+++ b/src/Device/Memset.hpp
@@ -30,23 +30,23 @@
 	{
 		static_assert(std::is_base_of<Memset<T>, T>::value, "Memset<T> must only clear the memory of a type of which it is a base class");
 
-		// GCC 8+ warns that
-		// "‘void* memset(void*, int, size_t)’ clearing an object of non-trivial type ‘T’;
-		//  use assignment or value-initialization instead [-Werror=class-memaccess]"
-		// This is benign iff it happens before any of the base or member constructrs are called.
-		#if defined(__GNUC__) && (__GNUC__ >= 8)
-		#pragma GCC diagnostic push
-		#pragma GCC diagnostic ignored "-Wclass-memaccess"
-		#endif
+// GCC 8+ warns that
+// "‘void* memset(void*, int, size_t)’ clearing an object of non-trivial type ‘T’;
+//  use assignment or value-initialization instead [-Werror=class-memaccess]"
+// This is benign iff it happens before any of the base or member constructrs are called.
+#if defined(__GNUC__) && (__GNUC__ >= 8)
+#	pragma GCC diagnostic push
+#	pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
 
 		memset(object, 0, sizeof(T));
 
-		#if defined(__GNUC__) && (__GNUC__ >= 8)
-		#pragma GCC diagnostic pop
-		#endif
+#if defined(__GNUC__) && (__GNUC__ >= 8)
+#	pragma GCC diagnostic pop
+#endif
 	}
 };
 
 }  // namespace sw
 
-#endif   // sw_Memset_hpp
\ No newline at end of file
+#endif  // sw_Memset_hpp
\ No newline at end of file
diff --git a/src/Device/PixelProcessor.cpp b/src/Device/PixelProcessor.cpp
index 1c81a24..91644a1 100644
--- a/src/Device/PixelProcessor.cpp
+++ b/src/Device/PixelProcessor.cpp
@@ -15,8 +15,8 @@
 #include "PixelProcessor.hpp"
 
 #include "Primitive.hpp"
-#include "Pipeline/PixelProgram.hpp"
 #include "Pipeline/Constants.hpp"
+#include "Pipeline/PixelProgram.hpp"
 #include "Vulkan/VkDebug.hpp"
 #include "Vulkan/VkImageView.hpp"
 
@@ -26,7 +26,7 @@
 
 uint32_t PixelProcessor::States::computeHash()
 {
-	uint32_t *state = reinterpret_cast<uint32_t*>(this);
+	uint32_t *state = reinterpret_cast<uint32_t *>(this);
 	uint32_t hash = 0;
 
 	for(unsigned int i = 0; i < sizeof(States) / sizeof(uint32_t); i++)
@@ -45,7 +45,7 @@
 	}
 
 	static_assert(is_memcmparable<State>::value, "Cannot memcmp State");
-	return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	return memcmp(static_cast<const States *>(this), static_cast<const States *>(&state), sizeof(States)) == 0;
 }
 
 PixelProcessor::PixelProcessor()
@@ -90,7 +90,7 @@
 	routineCache = new RoutineCacheType(clamp(cacheSize, 1, 65536));
 }
 
-const PixelProcessor::State PixelProcessor::update(const Context* context) const
+const PixelProcessor::State PixelProcessor::update(const Context *context) const
 {
 	State state;
 
@@ -151,9 +151,9 @@
 }
 
 PixelProcessor::RoutineType PixelProcessor::routine(const State &state,
-	vk::PipelineLayout const *pipelineLayout,
-	SpirvShader const *pixelShader,
-	const vk::DescriptorSet::Bindings &descriptorSets)
+                                                    vk::PipelineLayout const *pipelineLayout,
+                                                    SpirvShader const *pixelShader,
+                                                    const vk::DescriptorSet::Bindings &descriptorSets)
 {
 	auto routine = routineCache->query(state);
 
diff --git a/src/Device/PixelProcessor.hpp b/src/Device/PixelProcessor.hpp
index 8bc19ab..4679b16 100644
--- a/src/Device/PixelProcessor.hpp
+++ b/src/Device/PixelProcessor.hpp
@@ -28,7 +28,7 @@
 struct DrawData;
 struct Primitive;
 
-using RasterizerFunction = FunctionT<void(const Primitive* primitive, int count, int cluster, int clusterCount, DrawData* draw)>;
+using RasterizerFunction = FunctionT<void(const Primitive *primitive, int count, int cluster, int clusterCount, DrawData *draw)>;
 
 class PixelProcessor
 {
@@ -39,25 +39,27 @@
 		// (it doesn't require a different program to be generated)
 		struct StencilOpState
 		{
-			VkStencilOp    failOp;
-			VkStencilOp    passOp;
-			VkStencilOp    depthFailOp;
-			VkCompareOp    compareOp;
-			uint32_t       compareMask;
-			uint32_t       writeMask;
+			VkStencilOp failOp;
+			VkStencilOp passOp;
+			VkStencilOp depthFailOp;
+			VkCompareOp compareOp;
+			uint32_t compareMask;
+			uint32_t writeMask;
 
 			void operator=(const VkStencilOpState &rhs)
 			{
-				failOp = rhs.failOp;
-				passOp = rhs.passOp;
-				depthFailOp = rhs.depthFailOp;
-				compareOp = rhs.compareOp;
-				compareMask = rhs.compareMask;
+				failOp = rhs.failOp;
+				passOp = rhs.passOp;
+				depthFailOp = rhs.depthFailOp;
+				compareOp = rhs.compareOp;
+				compareMask = rhs.compareMask;
 				writeMask = rhs.writeMask;
 			}
 		};
 
-		States() : Memset(this, 0) {}
+		States()
+		    : Memset(this, 0)
+		{}
 
 		uint32_t computeHash();
 
@@ -150,7 +152,7 @@
 	void setBlendConstant(const Color<float> &blendConstant);
 
 protected:
-	const State update(const Context* context) const;
+	const State update(const Context *context) const;
 	RoutineType routine(const State &state, vk::PipelineLayout const *pipelineLayout,
 	                    SpirvShader const *pixelShader, const vk::DescriptorSet::Bindings &descriptorSets);
 	void setRoutineCacheSize(int routineCacheSize);
@@ -165,4 +167,4 @@
 
 }  // namespace sw
 
-#endif   // sw_PixelProcessor_hpp
+#endif  // sw_PixelProcessor_hpp
diff --git a/src/Device/Plane.hpp b/src/Device/Plane.hpp
index dcce294..13da81a 100644
--- a/src/Device/Plane.hpp
+++ b/src/Device/Plane.hpp
@@ -29,13 +29,13 @@
 	float D;
 
 	Plane();
-	Plane(float A, float B, float C, float D);   // Plane equation 
+	Plane(float A, float B, float C, float D);  // Plane equation
 	Plane(const float ABCD[4]);
 
-	friend Plane operator*(const Plane &p, const Matrix &A);   // Transform plane by matrix (post-multiply)
-	friend Plane operator*(const Matrix &A, const Plane &p);   // Transform plane by matrix (pre-multiply)
+	friend Plane operator*(const Plane &p, const Matrix &A);  // Transform plane by matrix (post-multiply)
+	friend Plane operator*(const Matrix &A, const Plane &p);  // Transform plane by matrix (pre-multiply)
 };
 
 }  // namespace sw
 
-#endif   // Plane_hpp
+#endif  // Plane_hpp
diff --git a/src/Device/Point.hpp b/src/Device/Point.hpp
index 5602209..318b5c4 100644
--- a/src/Device/Point.hpp
+++ b/src/Device/Point.hpp
@@ -35,7 +35,7 @@
 		float p[3];
 
 		struct
-		{	
+		{
 			float x;
 			float y;
 			float z;
@@ -56,15 +56,15 @@
 
 	friend Vector operator-(const Point &P, const Point &Q);
 
-	friend Point operator*(const Matrix &M, const Point& P);
+	friend Point operator*(const Matrix &M, const Point &P);
 	friend Point operator*(const Point &P, const Matrix &M);
 	friend Point &operator*=(Point &P, const Matrix &M);
 
 	float d(const Point &P) const;   // Distance between two points
-	float d2(const Point &P) const;   // Squared distance between two points
+	float d2(const Point &P) const;  // Squared distance between two points
 
 	static float d(const Point &P, const Point &Q);   // Distance between two points
-	static float d2(const Point &P, const Point &Q);   // Squared distance between two points
+	static float d2(const Point &P, const Point &Q);  // Squared distance between two points
 };
 
 }  // namespace sw
@@ -138,4 +138,4 @@
 
 }  // namespace sw
 
-#endif   // Point_hpp
+#endif  // Point_hpp
diff --git a/src/Device/Polygon.hpp b/src/Device/Polygon.hpp
index 5412128..c4152f9 100644
--- a/src/Device/Polygon.hpp
+++ b/src/Device/Polygon.hpp
@@ -44,14 +44,14 @@
 		this->b = 0;
 	}
 
-	float4 B[16];              // Buffer for clipped vertices
-	const float4 *P[16][16];   // Pointers to clipped polygon's vertices
+	float4 B[16];             // Buffer for clipped vertices
+	const float4 *P[16][16];  // Pointers to clipped polygon's vertices
 
-	int n;   // Number of vertices
-	int i;   // Level of P to use
-	int b;   // Next available new vertex
+	int n;  // Number of vertices
+	int i;  // Level of P to use
+	int b;  // Next available new vertex
 };
 
 }  // namespace sw
 
-#endif   // sw_Polygon_hpp
+#endif  // sw_Polygon_hpp
diff --git a/src/Device/Primitive.hpp b/src/Device/Primitive.hpp
index 85a9db4..591b974 100644
--- a/src/Device/Primitive.hpp
+++ b/src/Device/Primitive.hpp
@@ -22,35 +22,41 @@
 
 namespace sw {
 
-struct Triangle MEMORY_SANITIZER_ONLY(: Memset<Triangle>)
+struct Triangle MEMORY_SANITIZER_ONLY(
+    : Memset<Triangle>)
 {
 #if MEMORY_SANITIZER_ENABLED
 	// Memory sanitizer cannot 'see' writes from JIT'd code, and can raise
 	// false-positives when read. By clearing the struct in the constructor,
 	// we can avoid triggering these false-positives.
-	inline Triangle() : Memset<Triangle>(this, 0) {}
-#endif // MEMORY_SANITIZER_ENABLED
+	inline Triangle()
+	    : Memset<Triangle>(this, 0)
+	{}
+#endif  // MEMORY_SANITIZER_ENABLED
 
 	Vertex v0;
 	Vertex v1;
 	Vertex v2;
 };
 
-struct PlaneEquation   // z = A * x + B * y + C
+struct PlaneEquation  // z = A * x + B * y + C
 {
 	float4 A;
 	float4 B;
 	float4 C;
 };
 
-struct Primitive MEMORY_SANITIZER_ONLY(: Memset<Primitive>)
+struct Primitive MEMORY_SANITIZER_ONLY(
+    : Memset<Primitive>)
 {
 #if MEMORY_SANITIZER_ENABLED
 	// Memory sanitizer cannot 'see' writes from JIT'd code, and can raise
 	// false-positives when read. By clearing the struct in the constructor,
 	// we can avoid triggering these false-positives.
-	inline Primitive() : Memset<Primitive>(this, 0) {}
-#endif // MEMORY_SANITIZER_ENABLED
+	inline Primitive()
+	    : Memset<Primitive>(this, 0)
+	{}
+#endif  // MEMORY_SANITIZER_ENABLED
 
 	int yMin;
 	int yMax;
@@ -87,4 +93,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Primitive_hpp
+#endif  // sw_Primitive_hpp
diff --git a/src/Device/QuadRasterizer.cpp b/src/Device/QuadRasterizer.cpp
index e589e15..36db635 100644
--- a/src/Device/QuadRasterizer.cpp
+++ b/src/Device/QuadRasterizer.cpp
@@ -22,7 +22,9 @@
 
 namespace sw {
 
-QuadRasterizer::QuadRasterizer(const PixelProcessor::State &state, SpirvShader const *spirvShader) : state(state), spirvShader{spirvShader}
+QuadRasterizer::QuadRasterizer(const PixelProcessor::State &state, SpirvShader const *spirvShader)
+    : state(state)
+    , spirvShader{ spirvShader }
 {
 }
 
@@ -32,13 +34,13 @@
 
 void QuadRasterizer::generate()
 {
-	constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
+	constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, constants));
 	occlusion = 0;
 
 	Do
 	{
-		Int yMin = *Pointer<Int>(primitive + OFFSET(Primitive,yMin));
-		Int yMax = *Pointer<Int>(primitive + OFFSET(Primitive,yMax));
+		Int yMin = *Pointer<Int>(primitive + OFFSET(Primitive, yMin));
+		Int yMax = *Pointer<Int>(primitive + OFFSET(Primitive, yMax));
 
 		Int cluster2 = cluster + cluster;
 		yMin += clusterCount * 2 - 2 - cluster2;
@@ -57,9 +59,9 @@
 
 	if(state.occlusionEnabled)
 	{
-		UInt clusterOcclusion = *Pointer<UInt>(data + OFFSET(DrawData,occlusion) + 4 * cluster);
+		UInt clusterOcclusion = *Pointer<UInt>(data + OFFSET(DrawData, occlusion) + 4 * cluster);
 		clusterOcclusion += occlusion;
-		*Pointer<UInt>(data + OFFSET(DrawData,occlusion) + 4 * cluster) = clusterOcclusion;
+		*Pointer<UInt>(data + OFFSET(DrawData, occlusion) + 4 * cluster) = clusterOcclusion;
 	}
 
 	Return();
@@ -77,49 +79,49 @@
 	{
 		if(state.colorWriteActive(index))
 		{
-			cBuffer[index] = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,colorBuffer[index])) + yMin * *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+			cBuffer[index] = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, colorBuffer[index])) + yMin * *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
 		}
 	}
 
 	if(state.depthTestActive)
 	{
-		zBuffer = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,depthBuffer)) + yMin * *Pointer<Int>(data + OFFSET(DrawData,depthPitchB));
+		zBuffer = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, depthBuffer)) + yMin * *Pointer<Int>(data + OFFSET(DrawData, depthPitchB));
 	}
 
 	if(state.stencilActive)
 	{
-		sBuffer = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,stencilBuffer)) + yMin * *Pointer<Int>(data + OFFSET(DrawData,stencilPitchB));
+		sBuffer = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, stencilBuffer)) + yMin * *Pointer<Int>(data + OFFSET(DrawData, stencilPitchB));
 	}
 
 	Int y = yMin;
 
 	Do
 	{
-		Int x0a = Int(*Pointer<Short>(primitive + OFFSET(Primitive,outline->left) + (y + 0) * sizeof(Primitive::Span)));
-		Int x0b = Int(*Pointer<Short>(primitive + OFFSET(Primitive,outline->left) + (y + 1) * sizeof(Primitive::Span)));
+		Int x0a = Int(*Pointer<Short>(primitive + OFFSET(Primitive, outline->left) + (y + 0) * sizeof(Primitive::Span)));
+		Int x0b = Int(*Pointer<Short>(primitive + OFFSET(Primitive, outline->left) + (y + 1) * sizeof(Primitive::Span)));
 		Int x0 = Min(x0a, x0b);
 
 		for(unsigned int q = 1; q < state.multiSample; q++)
 		{
-			x0a = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left) + (y + 0) * sizeof(Primitive::Span)));
-			x0b = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left) + (y + 1) * sizeof(Primitive::Span)));
+			x0a = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive, outline->left) + (y + 0) * sizeof(Primitive::Span)));
+			x0b = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive, outline->left) + (y + 1) * sizeof(Primitive::Span)));
 			x0 = Min(x0, Min(x0a, x0b));
 		}
 
 		x0 &= 0xFFFFFFFE;
 
-		Int x1a = Int(*Pointer<Short>(primitive + OFFSET(Primitive,outline->right) + (y + 0) * sizeof(Primitive::Span)));
-		Int x1b = Int(*Pointer<Short>(primitive + OFFSET(Primitive,outline->right) + (y + 1) * sizeof(Primitive::Span)));
+		Int x1a = Int(*Pointer<Short>(primitive + OFFSET(Primitive, outline->right) + (y + 0) * sizeof(Primitive::Span)));
+		Int x1b = Int(*Pointer<Short>(primitive + OFFSET(Primitive, outline->right) + (y + 1) * sizeof(Primitive::Span)));
 		Int x1 = Max(x1a, x1b);
 
 		for(unsigned int q = 1; q < state.multiSample; q++)
 		{
-			x1a = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right) + (y + 0) * sizeof(Primitive::Span)));
-			x1b = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right) + (y + 1) * sizeof(Primitive::Span)));
+			x1a = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive, outline->right) + (y + 0) * sizeof(Primitive::Span)));
+			x1b = Int(*Pointer<Short>(primitive + q * sizeof(Primitive) + OFFSET(Primitive, outline->right) + (y + 1) * sizeof(Primitive::Span)));
 			x1 = Max(x1, Max(x1a, x1b));
 		}
 
-		Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16);
+		Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive, yQuad), 16);
 
 		if(interpolateZ())
 		{
@@ -129,10 +131,10 @@
 
 				if(state.multiSample > 1)
 				{
-					y -= *Pointer<Float4>(constants + OFFSET(Constants,Y) + q * sizeof(float4));
+					y -= *Pointer<Float4>(constants + OFFSET(Constants, Y) + q * sizeof(float4));
 				}
 
-				Dz[q] = *Pointer<Float4>(primitive + OFFSET(Primitive,z.C), 16) + y * *Pointer<Float4>(primitive + OFFSET(Primitive,z.B), 16);
+				Dz[q] = *Pointer<Float4>(primitive + OFFSET(Primitive, z.C), 16) + y * *Pointer<Float4>(primitive + OFFSET(Primitive, z.B), 16);
 			}
 		}
 
@@ -140,7 +142,7 @@
 		{
 			if(interpolateW())
 			{
-				Dw = *Pointer<Float4>(primitive + OFFSET(Primitive,w.C), 16) + yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive,w.B), 16);
+				Dw = *Pointer<Float4>(primitive + OFFSET(Primitive, w.C), 16) + yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, w.B), 16);
 			}
 
 			if(spirvShader)
@@ -154,20 +156,20 @@
 					if(!spirvShader->inputs[interpolant].Flat)
 					{
 						Dv[interpolant] +=
-								yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, V[interpolant].B), 16);
+						    yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, V[interpolant].B), 16);
 					}
 				}
 
 				for(unsigned int i = 0; i < state.numClipDistances; i++)
 				{
 					DclipDistance[i] = *Pointer<Float4>(primitive + OFFSET(Primitive, clipDistance[i].C), 16) +
-								yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, clipDistance[i].B), 16);
+					                   yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, clipDistance[i].B), 16);
 				}
 
 				for(unsigned int i = 0; i < state.numCullDistances; i++)
 				{
 					DcullDistance[i] = *Pointer<Float4>(primitive + OFFSET(Primitive, cullDistance[i].C), 16) +
-								yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, cullDistance[i].B), 16);
+					                   yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive, cullDistance[i].B), 16);
 				}
 			}
 
@@ -176,7 +178,7 @@
 
 			for(unsigned int q = 0; q < state.multiSample; q++)
 			{
-				xLeft[q] = *Pointer<Short4>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline) + y * sizeof(Primitive::Span));
+				xLeft[q] = *Pointer<Short4>(primitive + q * sizeof(Primitive) + OFFSET(Primitive, outline) + y * sizeof(Primitive::Span));
 				xRight[q] = xLeft[q];
 
 				xLeft[q] = Swizzle(xLeft[q], 0x0022) - Short4(1, 2, 1, 2);
@@ -190,7 +192,7 @@
 
 				for(unsigned int q = 0; q < state.multiSample; q++)
 				{
-					if(state.multiSampleMask & (1<<q))
+					if(state.multiSampleMask & (1 << q))
 					{
 						unsigned int i = state.multiSampledBresenham ? 0 : q;
 						Short4 mask = CmpGT(xxxx, xLeft[i]) & CmpGT(xRight[i], xxxx);
@@ -210,18 +212,18 @@
 		{
 			if(state.colorWriteActive(index))
 			{
-				cBuffer[index] += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index])) << (1 + clusterCountLog2);   // FIXME: Precompute
+				cBuffer[index] += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index])) << (1 + clusterCountLog2);  // FIXME: Precompute
 			}
 		}
 
 		if(state.depthTestActive)
 		{
-			zBuffer += *Pointer<Int>(data + OFFSET(DrawData,depthPitchB)) << (1 + clusterCountLog2);   // FIXME: Precompute
+			zBuffer += *Pointer<Int>(data + OFFSET(DrawData, depthPitchB)) << (1 + clusterCountLog2);  // FIXME: Precompute
 		}
 
 		if(state.stencilActive)
 		{
-			sBuffer += *Pointer<Int>(data + OFFSET(DrawData,stencilPitchB)) << (1 + clusterCountLog2);   // FIXME: Precompute
+			sBuffer += *Pointer<Int>(data + OFFSET(DrawData, stencilPitchB)) << (1 + clusterCountLog2);  // FIXME: Precompute
 		}
 
 		y += 2 * clusterCount;
diff --git a/src/Device/QuadRasterizer.hpp b/src/Device/QuadRasterizer.hpp
index 0311d8a..f24e80e 100644
--- a/src/Device/QuadRasterizer.hpp
+++ b/src/Device/QuadRasterizer.hpp
@@ -57,4 +57,4 @@
 
 }  // namespace sw
 
-#endif   // sw_QuadRasterizer_hpp
+#endif  // sw_QuadRasterizer_hpp
diff --git a/src/Device/Rasterizer.hpp b/src/Device/Rasterizer.hpp
index cf229e6..0c33857 100644
--- a/src/Device/Rasterizer.hpp
+++ b/src/Device/Rasterizer.hpp
@@ -24,7 +24,13 @@
 class Rasterizer : public RasterizerFunction
 {
 public:
-	Rasterizer() : primitive(Arg<0>()), count(Arg<1>()), cluster(Arg<2>()), clusterCount(Arg<3>()), data(Arg<4>()) {}
+	Rasterizer()
+	    : primitive(Arg<0>())
+	    , count(Arg<1>())
+	    , cluster(Arg<2>())
+	    , clusterCount(Arg<3>())
+	    , data(Arg<4>())
+	{}
 	virtual ~Rasterizer() {}
 
 protected:
@@ -37,4 +43,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Rasterizer_hpp
+#endif  // sw_Rasterizer_hpp
diff --git a/src/Device/Renderer.cpp b/src/Device/Renderer.cpp
index 80a2662..966d9e5 100644
--- a/src/Device/Renderer.cpp
+++ b/src/Device/Renderer.cpp
@@ -15,13 +15,15 @@
 #include "Renderer.hpp"
 
 #include "Clipper.hpp"
-#include "Primitive.hpp"
 #include "Polygon.hpp"
-#include "Reactor/Reactor.hpp"
+#include "Primitive.hpp"
+#include "Vertex.hpp"
 #include "Pipeline/Constants.hpp"
-#include "System/Memory.hpp"
+#include "Pipeline/SpirvShader.hpp"
+#include "Reactor/Reactor.hpp"
 #include "System/Half.hpp"
 #include "System/Math.hpp"
+#include "System/Memory.hpp"
 #include "System/Timer.hpp"
 #include "Vulkan/VkConfig.h"
 #include "Vulkan/VkDebug.hpp"
@@ -29,8 +31,6 @@
 #include "Vulkan/VkFence.hpp"
 #include "Vulkan/VkImageView.hpp"
 #include "Vulkan/VkQueryPool.hpp"
-#include "Pipeline/SpirvShader.hpp"
-#include "Vertex.hpp"
 
 #include "marl/containers.h"
 #include "marl/defer.h"
@@ -52,91 +52,91 @@
 
 	switch(topology)
 	{
-	case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
-	{
-		auto index = start;
-		auto pointBatch = &(batch[0][0]);
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
 		{
-			*pointBatch++ = indices[index++];
-		}
+			auto index = start;
+			auto pointBatch = &(batch[0][0]);
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				*pointBatch++ = indices[index++];
+			}
 
-		// Repeat the last index to allow for SIMD width overrun.
-		index--;
-		for(unsigned int i = 0; i < 3; i++)
-		{
-			*pointBatch++ = indices[index];
+			// Repeat the last index to allow for SIMD width overrun.
+			index--;
+			for(unsigned int i = 0; i < 3; i++)
+			{
+				*pointBatch++ = indices[index];
+			}
+			break;
 		}
-		break;
-	}
-	case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-	{
-		auto index = 2 * start;
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
 		{
-			batch[i][0] = indices[index + (provokeFirst ? 0 : 1)];
-			batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
-			batch[i][2] = indices[index + 1];
+			auto index = 2 * start;
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				batch[i][0] = indices[index + (provokeFirst ? 0 : 1)];
+				batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
+				batch[i][2] = indices[index + 1];
 
-			index += 2;
+				index += 2;
+			}
+			break;
 		}
-		break;
-	}
-	case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
-	{
-		auto index = start;
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
 		{
-			batch[i][0] = indices[index + (provokeFirst ? 0 : 1)];
-			batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
-			batch[i][2] = indices[index + 1];
+			auto index = start;
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				batch[i][0] = indices[index + (provokeFirst ? 0 : 1)];
+				batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
+				batch[i][2] = indices[index + 1];
 
-			index += 1;
+				index += 1;
+			}
+			break;
 		}
-		break;
-	}
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
-	{
-		auto index = 3 * start;
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
 		{
-			batch[i][0] = indices[index + (provokeFirst ? 0 : 2)];
-			batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
-			batch[i][2] = indices[index + (provokeFirst ? 2 : 1)];
+			auto index = 3 * start;
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				batch[i][0] = indices[index + (provokeFirst ? 0 : 2)];
+				batch[i][1] = indices[index + (provokeFirst ? 1 : 0)];
+				batch[i][2] = indices[index + (provokeFirst ? 2 : 1)];
 
-			index += 3;
+				index += 3;
+			}
+			break;
 		}
-		break;
-	}
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
-	{
-		auto index = start;
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP:
 		{
-			batch[i][0] = indices[index + (provokeFirst ? 0 : 2)];
-			batch[i][1] = indices[index + ((start + i) & 1) + (provokeFirst ? 1 : 0)];
-			batch[i][2] = indices[index + (~(start + i) & 1) + (provokeFirst ? 1 : 0)];
+			auto index = start;
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				batch[i][0] = indices[index + (provokeFirst ? 0 : 2)];
+				batch[i][1] = indices[index + ((start + i) & 1) + (provokeFirst ? 1 : 0)];
+				batch[i][2] = indices[index + (~(start + i) & 1) + (provokeFirst ? 1 : 0)];
 
-			index += 1;
+				index += 1;
+			}
+			break;
 		}
-		break;
-	}
-	case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
-	{
-		auto index = start + 1;
-		for(unsigned int i = 0; i < triangleCount; i++)
+		case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
 		{
-			batch[i][provokeFirst ? 0 : 2] = indices[index + 0];
-			batch[i][provokeFirst ? 1 : 0] = indices[index + 1];
-			batch[i][provokeFirst ? 2 : 1] = indices[0];
+			auto index = start + 1;
+			for(unsigned int i = 0; i < triangleCount; i++)
+			{
+				batch[i][provokeFirst ? 0 : 2] = indices[index + 0];
+				batch[i][provokeFirst ? 1 : 0] = indices[index + 1];
+				batch[i][provokeFirst ? 2 : 1] = indices[0];
 
-			index += 1;
+				index += 1;
+			}
+			break;
 		}
-		break;
-	}
-	default:
-		ASSERT(false);
-		return false;
+		default:
+			ASSERT(false);
+			return false;
 	}
 
 	return true;
@@ -144,7 +144,7 @@
 
 DrawCall::DrawCall()
 {
-	data = (DrawData*)allocate(sizeof(DrawData));
+	data = (DrawData *)allocate(sizeof(DrawData));
 	data->constants = &constants;
 }
 
@@ -153,7 +153,8 @@
 	deallocate(data);
 }
 
-Renderer::Renderer(vk::Device* device) : device(device)
+Renderer::Renderer(vk::Device *device)
+    : device(device)
 {
 	VertexProcessor::setRoutineCacheSize(1024);
 	PixelProcessor::setRoutineCacheSize(1024);
@@ -166,27 +167,27 @@
 }
 
 // Renderer objects have to be mem aligned to the alignment provided in the class declaration
-void* Renderer::operator new(size_t size)
+void *Renderer::operator new(size_t size)
 {
 	ASSERT(size == sizeof(Renderer));  // This operator can't be called from a derived class
 	return vk::allocate(sizeof(Renderer), alignof(Renderer), vk::DEVICE_MEMORY, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
 }
 
-void Renderer::operator delete(void* mem)
+void Renderer::operator delete(void *mem)
 {
 	vk::deallocate(mem, vk::DEVICE_MEMORY);
 }
 
-void Renderer::draw(const sw::Context* context, VkIndexType indexType, unsigned int count, int baseVertex,
-		TaskEvents *events, int instanceID, int viewID, void *indexBuffer, const VkExtent3D& framebufferExtent,
-		PushConstantStorage const & pushConstants, bool update)
+void Renderer::draw(const sw::Context *context, VkIndexType indexType, unsigned int count, int baseVertex,
+                    TaskEvents *events, int instanceID, int viewID, void *indexBuffer, const VkExtent3D &framebufferExtent,
+                    PushConstantStorage const &pushConstants, bool update)
 {
 	if(count == 0) { return; }
 
 	auto id = nextDrawID++;
 	MARL_SCOPED_EVENT("draw %d", id);
 
-	#ifndef NDEBUG
+#ifndef NDEBUG
 	{
 		unsigned int minPrimitives = 1;
 		unsigned int maxPrimitives = 1 << 21;
@@ -195,7 +196,7 @@
 			return;
 		}
 	}
-	#endif
+#endif
 
 	int ms = context->sampleCount;
 
@@ -230,20 +231,20 @@
 	{
 		switch(context->polygonMode)
 		{
-		case VK_POLYGON_MODE_FILL:
-			setupPrimitives = &DrawCall::setupSolidTriangles;
-			break;
-		case VK_POLYGON_MODE_LINE:
-			setupPrimitives = &DrawCall::setupWireframeTriangles;
-			numPrimitivesPerBatch /= 3;
-			break;
-		case VK_POLYGON_MODE_POINT:
-			setupPrimitives = &DrawCall::setupPointTriangles;
-			numPrimitivesPerBatch /= 3;
-			break;
-		default:
-			UNSUPPORTED("polygon mode: %d", int(context->polygonMode));
-			return;
+			case VK_POLYGON_MODE_FILL:
+				setupPrimitives = &DrawCall::setupSolidTriangles;
+				break;
+			case VK_POLYGON_MODE_LINE:
+				setupPrimitives = &DrawCall::setupWireframeTriangles;
+				numPrimitivesPerBatch /= 3;
+				break;
+			case VK_POLYGON_MODE_POINT:
+				setupPrimitives = &DrawCall::setupPointTriangles;
+				numPrimitivesPerBatch /= 3;
+				break;
+			default:
+				UNSUPPORTED("polygon mode: %d", int(context->polygonMode));
+				return;
 		}
 	}
 	else if(context->isDrawLine(false))
@@ -275,7 +276,7 @@
 	data->descriptorSets = context->descriptorSets;
 	data->descriptorDynamicOffsets = context->descriptorDynamicOffsets;
 
-	for(int i = 0; i < MAX_INTERFACE_COMPONENTS/4; i++)
+	for(int i = 0; i < MAX_INTERFACE_COMPONENTS / 4; i++)
 	{
 		data->input[i] = context->input[i].buffer;
 		data->robustnessSize[i] = context->input[i].robustnessSize;
@@ -311,7 +312,8 @@
 			data->a2c0 = float4(0.25f);
 			data->a2c1 = float4(0.75f);
 		}
-		else ASSERT(false);
+		else
+			ASSERT(false);
 	}
 
 	if(pixelState.occlusionEnabled)
@@ -358,7 +360,7 @@
 
 			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->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);
 			}
@@ -369,14 +371,14 @@
 
 		if(draw->depthBuffer)
 		{
-			data->depthBuffer = (float*)context->depthBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_DEPTH_BIT, 0, data->viewID);
+			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);
 		}
 
 		if(draw->stencilBuffer)
 		{
-			data->stencilBuffer = (unsigned char*)context->stencilBuffer->getOffsetPointer({0, 0, 0}, VK_IMAGE_ASPECT_STENCIL_BIT, 0, data->viewID);
+			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);
 		}
@@ -435,7 +437,7 @@
 	pixelRoutine = {};
 }
 
-void DrawCall::run(const marl::Loan<DrawCall>& draw, marl::Ticket::Queue* tickets, marl::Ticket::Queue clusterQueues[MaxClusterCount])
+void DrawCall::run(const marl::Loan<DrawCall> &draw, marl::Ticket::Queue *tickets, marl::Ticket::Queue clusterQueues[MaxClusterCount])
 {
 	draw->setup();
 
@@ -463,7 +465,6 @@
 		}
 
 		marl::schedule([draw, batch, finally] {
-
 			processVertices(draw.get(), batch.get());
 
 			if(!draw->setupState.rasterizerDiscard)
@@ -485,7 +486,7 @@
 	}
 }
 
-void DrawCall::processVertices(DrawCall* draw, BatchData* batch)
+void DrawCall::processVertices(DrawCall *draw, BatchData *batch)
 {
 	MARL_SCOPED_EVENT("VERTEX draw %d, batch %d", draw->id, batch->id);
 
@@ -493,16 +494,16 @@
 	{
 		MARL_SCOPED_EVENT("processPrimitiveVertices");
 		processPrimitiveVertices(
-			triangleIndices,
-			draw->data->indices,
-			draw->indexType,
-			batch->firstPrimitive,
-			batch->numPrimitives,
-			draw->topology,
-			draw->provokingVertexMode);
+		    triangleIndices,
+		    draw->data->indices,
+		    draw->indexType,
+		    batch->firstPrimitive,
+		    batch->numPrimitives,
+		    draw->topology,
+		    draw->provokingVertexMode);
 	}
 
-	auto& vertexTask = batch->vertexTask;
+	auto &vertexTask = batch->vertexTask;
 	vertexTask.primitiveStart = batch->firstPrimitive;
 	// We're only using batch compaction for points, not lines
 	vertexTask.vertexCount = batch->numPrimitives * ((draw->topology == VK_PRIMITIVE_TOPOLOGY_POINT_LIST) ? 1 : 3);
@@ -515,7 +516,7 @@
 	draw->vertexRoutine(&batch->triangles.front().v0, &triangleIndices[0][0], &vertexTask, draw->data);
 }
 
-void DrawCall::processPrimitives(DrawCall* draw, BatchData* batch)
+void DrawCall::processPrimitives(DrawCall *draw, BatchData *batch)
 {
 	MARL_SCOPED_EVENT("PRIMITIVES draw %d batch %d", draw->id, batch->id);
 	auto triangles = &batch->triangles[0];
@@ -523,12 +524,15 @@
 	batch->numVisible = draw->setupPrimitives(triangles, primitives, draw, batch->numPrimitives);
 }
 
-void DrawCall::processPixels(const marl::Loan<DrawCall>& draw, const marl::Loan<BatchData>& batch, const std::shared_ptr<marl::Finally>& finally)
+void DrawCall::processPixels(const marl::Loan<DrawCall> &draw, const marl::Loan<BatchData> &batch, const std::shared_ptr<marl::Finally> &finally)
 {
 	struct Data
 	{
-		Data(const marl::Loan<DrawCall>& draw, const marl::Loan<BatchData>& batch, const std::shared_ptr<marl::Finally>& finally)
-			: draw(draw), batch(batch), finally(finally) {}
+		Data(const marl::Loan<DrawCall> &draw, const marl::Loan<BatchData> &batch, const std::shared_ptr<marl::Finally> &finally)
+		    : draw(draw)
+		    , batch(batch)
+		    , finally(finally)
+		{}
 		marl::Loan<DrawCall> draw;
 		marl::Loan<BatchData> batch;
 		std::shared_ptr<marl::Finally> finally;
@@ -536,10 +540,9 @@
 	auto data = std::make_shared<Data>(draw, batch, finally);
 	for(int cluster = 0; cluster < MaxClusterCount; cluster++)
 	{
-		batch->clusterTickets[cluster].onCall([data, cluster]
-		{
-			auto& draw = data->draw;
-			auto& batch = data->batch;
+		batch->clusterTickets[cluster].onCall([data, cluster] {
+			auto &draw = data->draw;
+			auto &batch = data->batch;
 			MARL_SCOPED_EVENT("PIXEL draw %d, batch %d, cluster %d", draw->id, batch->id, cluster);
 			draw->pixelRoutine(&batch->primitives.front(), batch->numVisible, cluster, MaxClusterCount, draw->data);
 			batch->clusterTickets[cluster].done();
@@ -557,13 +560,13 @@
 }
 
 void DrawCall::processPrimitiveVertices(
-	unsigned int triangleIndicesOut[MaxBatchSize + 1][3],
-	const void *primitiveIndices,
-	VkIndexType indexType,
-	unsigned int start,
-	unsigned int triangleCount,
-	VkPrimitiveTopology topology,
-	VkProvokingVertexModeEXT provokingVertexMode)
+    unsigned int triangleIndicesOut[MaxBatchSize + 1][3],
+    const void *primitiveIndices,
+    VkIndexType indexType,
+    unsigned int start,
+    unsigned int triangleCount,
+    VkPrimitiveTopology topology,
+    VkProvokingVertexModeEXT provokingVertexMode)
 {
 	if(!primitiveIndices)
 	{
@@ -581,22 +584,22 @@
 	{
 		switch(indexType)
 		{
-		case VK_INDEX_TYPE_UINT16:
-			if(!setBatchIndices(triangleIndicesOut, topology, provokingVertexMode, static_cast<const uint16_t*>(primitiveIndices), start, triangleCount))
-			{
+			case VK_INDEX_TYPE_UINT16:
+				if(!setBatchIndices(triangleIndicesOut, topology, provokingVertexMode, static_cast<const uint16_t *>(primitiveIndices), start, triangleCount))
+				{
+					return;
+				}
+				break;
+			case VK_INDEX_TYPE_UINT32:
+				if(!setBatchIndices(triangleIndicesOut, topology, provokingVertexMode, static_cast<const uint32_t *>(primitiveIndices), start, triangleCount))
+				{
+					return;
+				}
+				break;
+				break;
+			default:
+				ASSERT(false);
 				return;
-			}
-			break;
-		case VK_INDEX_TYPE_UINT32:
-			if(!setBatchIndices(triangleIndicesOut, topology, provokingVertexMode, static_cast<const uint32_t*>(primitiveIndices), start, triangleCount))
-			{
-				return;
-			}
-			break;
-		break;
-		default:
-			ASSERT(false);
-			return;
 		}
 	}
 
@@ -626,7 +629,6 @@
 
 		Polygon polygon(&v0.position, &v1.position, &v2.position);
 
-
 		if((v0.cullMask | v1.cullMask | v2.cullMask) == 0)
 		{
 			continue;
@@ -658,7 +660,7 @@
 
 int DrawCall::setupWireframeTriangles(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count)
 {
-	auto& state = drawCall->setupState;
+	auto &state = drawCall->setupState;
 
 	int ms = state.multiSample;
 	int visible = 0;
@@ -706,7 +708,7 @@
 
 int DrawCall::setupPointTriangles(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count)
 {
-	auto& state = drawCall->setupState;
+	auto &state = drawCall->setupState;
 
 	int ms = state.multiSample;
 	int visible = 0;
@@ -838,7 +840,7 @@
 		P[2] = P1;
 		P[3] = P0;
 
-		float scale = lineWidth * 0.5f / sqrt(dx*dx + dy*dy);
+		float scale = lineWidth * 0.5f / sqrt(dx * dx + dy * dy);
 
 		dx *= scale;
 		dy *= scale;
@@ -937,7 +939,7 @@
 
 			if(dx > -dy)
 			{
-				if(dx > dy)   // Right
+				if(dx > dy)  // Right
 				{
 					L[0] = P[0];
 					L[1] = P[1];
@@ -946,7 +948,7 @@
 					L[4] = P[7];
 					L[5] = P[3];
 				}
-				else   // Down
+				else  // Down
 				{
 					L[0] = P[0];
 					L[1] = P[4];
@@ -958,7 +960,7 @@
 			}
 			else
 			{
-				if(dx > dy)   // Up
+				if(dx > dy)  // Up
 				{
 					L[0] = P[0];
 					L[1] = P[1];
@@ -967,7 +969,7 @@
 					L[4] = P[7];
 					L[5] = P[4];
 				}
-				else   // Left
+				else  // Left
 				{
 					L[0] = P[1];
 					L[1] = P[2];
@@ -1029,14 +1031,14 @@
 
 		if(dx > -dy)
 		{
-			if(dx > dy)   // Right
+			if(dx > dy)  // Right
 			{
 				L[0] = P[1];
 				L[1] = P[5];
 				L[2] = P[7];
 				L[3] = P[3];
 			}
-			else   // Down
+			else  // Down
 			{
 				L[0] = P[0];
 				L[1] = P[4];
@@ -1046,14 +1048,14 @@
 		}
 		else
 		{
-			if(dx > dy)   // Up
+			if(dx > dy)  // Up
 			{
 				L[0] = P[0];
 				L[1] = P[2];
 				L[2] = P[6];
 				L[3] = P[4];
 			}
-			else   // Left
+			else  // Left
 			{
 				L[0] = P[1];
 				L[1] = P[3];
@@ -1150,7 +1152,7 @@
 		constexpr float subPixF = vk::SUBPIXEL_PRECISION_FACTOR;
 
 		triangle.v1.projected.x += iround(subPixF * 0.5f * pSize);
-		triangle.v2.projected.y -= iround(subPixF * 0.5f * pSize) * (data.HxF[0] > 0.0f ? 1 : -1);   // Both Direct3D and OpenGL expect (0, 0) in the top-left corner
+		triangle.v2.projected.y -= iround(subPixF * 0.5f * pSize) * (data.HxF[0] > 0.0f ? 1 : -1);  // Both Direct3D and OpenGL expect (0, 0) in the top-left corner
 		return draw.setupRoutine(&primitive, &triangle, &polygon, &data);
 	}
 
@@ -1173,7 +1175,7 @@
 	occlusionQuery = nullptr;
 }
 
-void Renderer::advanceInstanceAttributes(Stream* inputs)
+void Renderer::advanceInstanceAttributes(Stream *inputs)
 {
 	for(uint32_t i = 0; i < vk::MAX_VERTEX_INPUT_BINDINGS; i++)
 	{
diff --git a/src/Device/Renderer.hpp b/src/Device/Renderer.hpp
index 1598c11..8723fbc 100644
--- a/src/Device/Renderer.hpp
+++ b/src/Device/Renderer.hpp
@@ -15,17 +15,17 @@
 #ifndef sw_Renderer_hpp
 #define sw_Renderer_hpp
 
-#include "VertexProcessor.hpp"
+#include "Blitter.hpp"
 #include "PixelProcessor.hpp"
-#include "SetupProcessor.hpp"
 #include "Plane.hpp"
 #include "Primitive.hpp"
-#include "Blitter.hpp"
+#include "SetupProcessor.hpp"
+#include "VertexProcessor.hpp"
 #include "Device/Config.hpp"
 #include "Vulkan/VkDescriptorSet.hpp"
 
-#include "marl/pool.h"
 #include "marl/finally.h"
+#include "marl/pool.h"
 #include "marl/ticket.h"
 
 #include <atomic>
@@ -76,9 +76,9 @@
 	float lineWidth;
 	int viewID;
 
-	PixelProcessor::Stencil stencil[2];   // clockwise, counterclockwise
+	PixelProcessor::Stencil stencil[2];  // clockwise, counterclockwise
 	PixelProcessor::Factor factor;
-	unsigned int occlusion[MaxClusterCount];   // Number of pixels passing depth test
+	unsigned int occlusion[MaxClusterCount];  // Number of pixels passing depth test
 
 	float4 WxF;
 	float4 HxF;
@@ -131,15 +131,15 @@
 	};
 
 	using Pool = marl::BoundedPool<DrawCall, MaxDrawCount, marl::PoolPolicy::Preserve>;
-	using SetupFunction = int(*)(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
+	using SetupFunction = int (*)(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
 
 	DrawCall();
 	~DrawCall();
 
-	static void run(const marl::Loan<DrawCall>& draw, marl::Ticket::Queue* tickets, marl::Ticket::Queue clusterQueues[MaxClusterCount]);
-	static void processVertices(DrawCall* draw, BatchData* batch);
-	static void processPrimitives(DrawCall* draw, BatchData* batch);
-	static void processPixels(const marl::Loan<DrawCall>& draw, const marl::Loan<BatchData>& batch, const std::shared_ptr<marl::Finally>& finally);
+	static void run(const marl::Loan<DrawCall> &draw, marl::Ticket::Queue *tickets, marl::Ticket::Queue clusterQueues[MaxClusterCount]);
+	static void processVertices(DrawCall *draw, BatchData *batch);
+	static void processPrimitives(DrawCall *draw, BatchData *batch);
+	static void processPixels(const marl::Loan<DrawCall> &draw, const marl::Loan<BatchData> &batch, const std::shared_ptr<marl::Finally> &finally);
 	void setup();
 	void teardown();
 
@@ -167,22 +167,22 @@
 	vk::ImageView *stencilBuffer;
 	TaskEvents *events;
 
-	vk::Query* occlusionQuery;
+	vk::Query *occlusionQuery;
 
 	DrawData *data;
 
 	static void processPrimitiveVertices(
-			unsigned int triangleIndicesOut[MaxBatchSize + 1][3],
-			const void *primitiveIndices,
-			VkIndexType indexType,
-			unsigned int start,
-			unsigned int triangleCount,
-			VkPrimitiveTopology topology,
-			VkProvokingVertexModeEXT provokingVertexMode);
+	    unsigned int triangleIndicesOut[MaxBatchSize + 1][3],
+	    const void *primitiveIndices,
+	    VkIndexType indexType,
+	    unsigned int start,
+	    unsigned int triangleCount,
+	    VkPrimitiveTopology topology,
+	    VkProvokingVertexModeEXT provokingVertexMode);
 
-	static int setupSolidTriangles(Triangle* triangles, Primitive* primitives, const DrawCall* drawCall, int count);
-	static int setupWireframeTriangles(Triangle* triangles, Primitive* primitives, const DrawCall* drawCall, int count);
-	static int setupPointTriangles(Triangle* triangles, Primitive* primitives, const DrawCall* drawCall, int count);
+	static int setupSolidTriangles(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
+	static int setupWireframeTriangles(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
+	static int setupPointTriangles(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
 	static int setupLines(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
 	static int setupPoints(Triangle *triangles, Primitive *primitives, const DrawCall *drawCall, int count);
 
@@ -193,18 +193,18 @@
 class alignas(16) Renderer : public VertexProcessor, public PixelProcessor, public SetupProcessor
 {
 public:
-	Renderer(vk::Device* device);
+	Renderer(vk::Device *device);
 
 	virtual ~Renderer();
 
-	void* operator new(size_t size);
-	void operator delete(void* mem);
+	void *operator new(size_t size);
+	void operator delete(void *mem);
 
 	bool hasOcclusionQuery() const { return occlusionQuery != nullptr; }
 
-	void draw(const sw::Context* context, VkIndexType indexType, unsigned int count, int baseVertex,
-			TaskEvents *events, int instanceID, int viewID, void *indexBuffer, const VkExtent3D& framebufferExtent,
-			PushConstantStorage const & pushConstants, bool update = true);
+	void draw(const sw::Context *context, VkIndexType indexType, unsigned int count, int baseVertex,
+	          TaskEvents *events, int instanceID, int viewID, void *indexBuffer, const VkExtent3D &framebufferExtent,
+	          PushConstantStorage const &pushConstants, bool update = true);
 
 	// Viewport & Clipper
 	void setViewport(const VkViewport &viewport);
@@ -213,7 +213,7 @@
 	void addQuery(vk::Query *query);
 	void removeQuery(vk::Query *query);
 
-	void advanceInstanceAttributes(Stream* inputs);
+	void advanceInstanceAttributes(Stream *inputs);
 
 	void synchronize();
 
@@ -224,7 +224,7 @@
 	DrawCall::Pool drawCallPool;
 	DrawCall::BatchData::Pool batchDataPool;
 
-	std::atomic<int> nextDrawID = {0};
+	std::atomic<int> nextDrawID = { 0 };
 
 	vk::Query *occlusionQuery = nullptr;
 	marl::Ticket::Queue drawTickets;
@@ -238,9 +238,9 @@
 	SetupProcessor::RoutineType setupRoutine;
 	PixelProcessor::RoutineType pixelRoutine;
 
-	vk::Device* device;
+	vk::Device *device;
 };
 
 }  // namespace sw
 
-#endif   // sw_Renderer_hpp
+#endif  // sw_Renderer_hpp
diff --git a/src/Device/RoutineCache.hpp b/src/Device/RoutineCache.hpp
index 9bde0d5..ce48e42 100644
--- a/src/Device/RoutineCache.hpp
+++ b/src/Device/RoutineCache.hpp
@@ -29,6 +29,6 @@
 template<class State, class FunctionType>
 using RoutineCacheT = LRUCache<State, RoutineT<FunctionType>>;
 
-}
+}  // namespace sw
 
-#endif   // sw_RoutineCache_hpp
+#endif  // sw_RoutineCache_hpp
diff --git a/src/Device/Sampler.hpp b/src/Device/Sampler.hpp
index a836ce2..a377ea0 100644
--- a/src/Device/Sampler.hpp
+++ b/src/Device/Sampler.hpp
@@ -20,7 +20,9 @@
 #include "System/Types.hpp"
 #include "Vulkan/VkFormat.h"
 
-namespace vk { class Image; }
+namespace vk {
+class Image;
+}
 
 namespace sw {
 
@@ -79,10 +81,10 @@
 	ADDRESSING_CLAMP,
 	ADDRESSING_MIRROR,
 	ADDRESSING_MIRRORONCE,
-	ADDRESSING_BORDER,     // Single color
-	ADDRESSING_SEAMLESS,   // Border of pixels
-	ADDRESSING_CUBEFACE,   // Cube face layer
-	ADDRESSING_LAYER,      // Array layer
+	ADDRESSING_BORDER,    // Single color
+	ADDRESSING_SEAMLESS,  // Border of pixels
+	ADDRESSING_CUBEFACE,  // Cube face layer
+	ADDRESSING_LAYER,     // Array layer
 	ADDRESSING_TEXELFETCH,
 
 	ADDRESSING_LAST = ADDRESSING_TEXELFETCH
@@ -114,4 +116,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Sampler_hpp
+#endif  // sw_Sampler_hpp
diff --git a/src/Device/SetupProcessor.cpp b/src/Device/SetupProcessor.cpp
index e5057b9..2271cb8 100644
--- a/src/Device/SetupProcessor.cpp
+++ b/src/Device/SetupProcessor.cpp
@@ -14,14 +14,14 @@
 
 #include "SetupProcessor.hpp"
 
-#include "Primitive.hpp"
-#include "Polygon.hpp"
 #include "Context.hpp"
+#include "Polygon.hpp"
+#include "Primitive.hpp"
 #include "Renderer.hpp"
-#include "Pipeline/SetupRoutine.hpp"
 #include "Pipeline/Constants.hpp"
-#include "Vulkan/VkDebug.hpp"
+#include "Pipeline/SetupRoutine.hpp"
 #include "Pipeline/SpirvShader.hpp"
+#include "Vulkan/VkDebug.hpp"
 
 #include <cstring>
 
@@ -29,7 +29,7 @@
 
 uint32_t SetupProcessor::States::computeHash()
 {
-	uint32_t *state = reinterpret_cast<uint32_t*>(this);
+	uint32_t *state = reinterpret_cast<uint32_t *>(this);
 	uint32_t hash = 0;
 
 	for(unsigned int i = 0; i < sizeof(States) / sizeof(uint32_t); i++)
@@ -48,7 +48,7 @@
 	}
 
 	static_assert(is_memcmparable<State>::value, "Cannot memcmp States");
-	return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	return memcmp(static_cast<const States *>(this), static_cast<const States *>(&state), sizeof(States)) == 0;
 }
 
 SetupProcessor::SetupProcessor()
@@ -63,7 +63,7 @@
 	routineCache = nullptr;
 }
 
-SetupProcessor::State SetupProcessor::update(const sw::Context* context) const
+SetupProcessor::State SetupProcessor::update(const sw::Context *context) const
 {
 	State state;
 
diff --git a/src/Device/SetupProcessor.hpp b/src/Device/SetupProcessor.hpp
index 4b6d5a8..e418bc9 100644
--- a/src/Device/SetupProcessor.hpp
+++ b/src/Device/SetupProcessor.hpp
@@ -15,11 +15,11 @@
 #ifndef sw_SetupProcessor_hpp
 #define sw_SetupProcessor_hpp
 
-#include <Pipeline/SpirvShader.hpp>
 #include "Context.hpp"
 #include "Memset.hpp"
 #include "RoutineCache.hpp"
 #include "System/Types.hpp"
+#include <Pipeline/SpirvShader.hpp>
 
 namespace sw {
 
@@ -30,29 +30,31 @@
 struct DrawCall;
 struct DrawData;
 
-using SetupFunction = FunctionT<int(Primitive* primitive, const Triangle* triangle, const Polygon* polygon, const DrawData* draw)>;
+using SetupFunction = FunctionT<int(Primitive *primitive, const Triangle *triangle, const Polygon *polygon, const DrawData *draw)>;
 
 class SetupProcessor
 {
 public:
 	struct States : Memset<States>
 	{
-		States() : Memset(this, 0) {}
+		States()
+		    : Memset(this, 0)
+		{}
 
 		uint32_t computeHash();
 
-		bool isDrawPoint               : 1;
-		bool isDrawLine                : 1;
-		bool isDrawTriangle            : 1;
-		bool applySlopeDepthBias       : 1;
-		bool interpolateZ              : 1;
-		bool interpolateW              : 1;
-		VkFrontFace frontFace          : BITS(VK_FRONT_FACE_MAX_ENUM);
-		VkCullModeFlags cullMode       : BITS(VK_CULL_MODE_FLAG_BITS_MAX_ENUM);
-		unsigned int multiSample       : 3;   // 1, 2 or 4
-		bool rasterizerDiscard         : 1;
-		unsigned int numClipDistances  : 4; // [0 - 8]
-		unsigned int numCullDistances  : 4; // [0 - 8]
+		bool isDrawPoint : 1;
+		bool isDrawLine : 1;
+		bool isDrawTriangle : 1;
+		bool applySlopeDepthBias : 1;
+		bool interpolateZ : 1;
+		bool interpolateW : 1;
+		VkFrontFace frontFace : BITS(VK_FRONT_FACE_MAX_ENUM);
+		VkCullModeFlags cullMode : BITS(VK_CULL_MODE_FLAG_BITS_MAX_ENUM);
+		unsigned int multiSample : 3;  // 1, 2 or 4
+		bool rasterizerDiscard : 1;
+		unsigned int numClipDistances : 4;  // [0 - 8]
+		unsigned int numCullDistances : 4;  // [0 - 8]
 
 		SpirvShader::InterfaceComponent gradient[MAX_INTERFACE_COMPONENTS];
 	};
@@ -71,7 +73,7 @@
 	~SetupProcessor();
 
 protected:
-	State update(const sw::Context* context) const;
+	State update(const sw::Context *context) const;
 	RoutineType routine(const State &state);
 
 	void setRoutineCacheSize(int cacheSize);
@@ -83,4 +85,4 @@
 
 }  // namespace sw
 
-#endif   // sw_SetupProcessor_hpp
+#endif  // sw_SetupProcessor_hpp
diff --git a/src/Device/Stream.hpp b/src/Device/Stream.hpp
index f83d97a..8e2fd98 100644
--- a/src/Device/Stream.hpp
+++ b/src/Device/Stream.hpp
@@ -21,15 +21,15 @@
 
 enum StreamType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
 {
-	STREAMTYPE_COLOR,     // 4 normalized unsigned bytes, ZYXW order
-	STREAMTYPE_FLOAT,     // Normalization ignored
+	STREAMTYPE_COLOR,  // 4 normalized unsigned bytes, ZYXW order
+	STREAMTYPE_FLOAT,  // Normalization ignored
 	STREAMTYPE_BYTE,
 	STREAMTYPE_SBYTE,
 	STREAMTYPE_SHORT,
 	STREAMTYPE_USHORT,
 	STREAMTYPE_INT,
 	STREAMTYPE_UINT,
-	STREAMTYPE_HALF,      // Normalization ignored
+	STREAMTYPE_HALF,  // Normalization ignored
 	STREAMTYPE_2_10_10_10_INT,
 	STREAMTYPE_2_10_10_10_UINT,
 
@@ -51,4 +51,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Stream_hpp
+#endif  // sw_Stream_hpp
diff --git a/src/Device/Triangle.hpp b/src/Device/Triangle.hpp
index 7cb4055..d99fe84 100644
--- a/src/Device/Triangle.hpp
+++ b/src/Device/Triangle.hpp
@@ -28,4 +28,4 @@
 
 }  // namespace sw
 
-#endif   // sw_Triangle_hpp
+#endif  // sw_Triangle_hpp
diff --git a/src/Device/Vector.cpp b/src/Device/Vector.cpp
index 511b51f..681efc3 100644
--- a/src/Device/Vector.cpp
+++ b/src/Device/Vector.cpp
@@ -81,7 +81,7 @@
 
 bool operator>(const Vector &u, const Vector &v)
 {
-	if((u^2) > (v^2))
+	if((u ^ 2) > (v ^ 2))
 		return true;
 	else
 		return false;
@@ -89,7 +89,7 @@
 
 bool operator<(const Vector &u, const Vector &v)
 {
-	if((u^2) < (v^2))
+	if((u ^ 2) < (v ^ 2))
 		return true;
 	else
 		return false;
@@ -158,12 +158,12 @@
 
 float Vector::N(const Vector &v)
 {
-	return sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
+	return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
 }
 
 float Vector::N2(const Vector &v)
 {
-	return v.x*v.x + v.y*v.y + v.z*v.z;
+	return v.x * v.x + v.y * v.y + v.z * v.z;
 }
 
 Vector lerp(const Vector &u, const Vector &v, float t)
diff --git a/src/Device/Vector.hpp b/src/Device/Vector.hpp
index 0df6f5a..a398943 100644
--- a/src/Device/Vector.hpp
+++ b/src/Device/Vector.hpp
@@ -62,19 +62,19 @@
 
 	friend Vector operator+(const Vector &u, const Vector &v);
 	friend Vector operator-(const Vector &u, const Vector &v);
-	friend float operator*(const Vector &u, const Vector &v);   // Dot product
+	friend float operator*(const Vector &u, const Vector &v);  // Dot product
 	friend Vector operator*(float s, const Vector &v);
 	friend Vector operator*(const Vector &v, float s);
 	friend Vector operator/(const Vector &v, float s);
 	friend float operator^(const Vector &u, const Vector &v);   // Angle between vectors
-	friend Vector operator%(const Vector &u, const Vector &v);   // Cross product
+	friend Vector operator%(const Vector &u, const Vector &v);  // Cross product
 
-	friend Vector operator*(const Matrix &M, const Vector& v);
+	friend Vector operator*(const Matrix &M, const Vector &v);
 	friend Vector operator*(const Vector &v, const Matrix &M);
 	friend Vector &operator*=(Vector &v, const Matrix &M);
 
 	static float N(const Vector &v);   // Norm
-	static float N2(const Vector &v);   // Squared norm
+	static float N2(const Vector &v);  // Squared norm
 
 	static Vector mirror(const Vector &v, const Plane &p);
 	static Vector reflect(const Vector &v, const Plane &p);
@@ -154,4 +154,4 @@
 
 }  // namespace sw
 
-#endif   // Vector_hpp
+#endif  // Vector_hpp
diff --git a/src/Device/Vertex.hpp b/src/Device/Vertex.hpp
index f6436e9..b328c44 100644
--- a/src/Device/Vertex.hpp
+++ b/src/Device/Vertex.hpp
@@ -16,8 +16,8 @@
 #define Vertex_hpp
 
 #include "Color.hpp"
-#include "System/Types.hpp"
 #include "Device/Config.hpp"
+#include "System/Types.hpp"
 
 namespace sw {
 
@@ -58,4 +58,4 @@
 
 }  // namespace sw
 
-#endif   // Vertex_hpp
+#endif  // Vertex_hpp
diff --git a/src/Device/VertexProcessor.cpp b/src/Device/VertexProcessor.cpp
index e77b2f7..3f72121 100644
--- a/src/Device/VertexProcessor.cpp
+++ b/src/Device/VertexProcessor.cpp
@@ -14,8 +14,8 @@
 
 #include "VertexProcessor.hpp"
 
-#include "Pipeline/VertexProgram.hpp"
 #include "Pipeline/Constants.hpp"
+#include "Pipeline/VertexProgram.hpp"
 #include "System/Math.hpp"
 #include "Vulkan/VkDebug.hpp"
 
@@ -33,7 +33,7 @@
 
 uint32_t VertexProcessor::States::computeHash()
 {
-	uint32_t *state = reinterpret_cast<uint32_t*>(this);
+	uint32_t *state = reinterpret_cast<uint32_t *>(this);
 	uint32_t hash = 0;
 
 	for(unsigned int i = 0; i < sizeof(States) / sizeof(uint32_t); i++)
@@ -48,23 +48,23 @@
 {
 	switch(type)
 	{
-	case STREAMTYPE_FLOAT:
-	case STREAMTYPE_INT:
-	case STREAMTYPE_UINT:
-		return count * sizeof(uint32_t);
-	case STREAMTYPE_HALF:
-	case STREAMTYPE_SHORT:
-	case STREAMTYPE_USHORT:
-		return count * sizeof(uint16_t);
-	case STREAMTYPE_BYTE:
-	case STREAMTYPE_SBYTE:
-		return count * sizeof(uint8_t);
-	case STREAMTYPE_COLOR:
-	case STREAMTYPE_2_10_10_10_INT:
-	case STREAMTYPE_2_10_10_10_UINT:
-		return sizeof(int);
-	default:
-		UNSUPPORTED("stream.type %d", int(type));
+		case STREAMTYPE_FLOAT:
+		case STREAMTYPE_INT:
+		case STREAMTYPE_UINT:
+			return count * sizeof(uint32_t);
+		case STREAMTYPE_HALF:
+		case STREAMTYPE_SHORT:
+		case STREAMTYPE_USHORT:
+			return count * sizeof(uint16_t);
+		case STREAMTYPE_BYTE:
+		case STREAMTYPE_SBYTE:
+			return count * sizeof(uint8_t);
+		case STREAMTYPE_COLOR:
+		case STREAMTYPE_2_10_10_10_INT:
+		case STREAMTYPE_2_10_10_10_UINT:
+			return sizeof(int);
+		default:
+			UNSUPPORTED("stream.type %d", int(type));
 	}
 
 	return 0;
@@ -78,7 +78,7 @@
 	}
 
 	static_assert(is_memcmparable<State>::value, "Cannot memcmp States");
-	return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	return memcmp(static_cast<const States *>(this), static_cast<const States *>(&state), sizeof(States)) == 0;
 }
 
 VertexProcessor::VertexProcessor()
@@ -99,7 +99,7 @@
 	routineCache = new RoutineCacheType(clamp(cacheSize, 1, 65536));
 }
 
-const VertexProcessor::State VertexProcessor::update(const sw::Context* context)
+const VertexProcessor::State VertexProcessor::update(const sw::Context *context)
 {
 	State state;
 
@@ -114,7 +114,7 @@
 		state.input[i].normalized = context->input[i].normalized;
 		// 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 = context->vertexShader->inputs[i * 4].Type;
 	}
 
 	state.hash = state.computeHash();
@@ -129,7 +129,7 @@
 {
 	auto routine = routineCache->query(state);
 
-	if(!routine)   // Create one
+	if(!routine)  // Create one
 	{
 		VertexRoutine *generator = new VertexProgram(state, pipelineLayout, vertexShader, descriptorSets);
 		generator->generate();
diff --git a/src/Device/VertexProcessor.hpp b/src/Device/VertexProcessor.hpp
index c94e82e..d72fd10 100644
--- a/src/Device/VertexProcessor.hpp
+++ b/src/Device/VertexProcessor.hpp
@@ -29,7 +29,7 @@
 // Basic direct mapped vertex cache.
 struct VertexCache
 {
-	static constexpr uint32_t SIZE = 64;  // TODO: Variable size?
+	static constexpr uint32_t SIZE = 64;            // TODO: Variable size?
 	static constexpr uint32_t TAG_MASK = SIZE - 1;  // Size must be power of 2.
 
 	void clear();
@@ -50,14 +50,16 @@
 	VertexCache vertexCache;
 };
 
-using VertexRoutineFunction = FunctionT<void(Vertex* output, unsigned int* batch, VertexTask* vertextask, DrawData* draw)>;
+using VertexRoutineFunction = FunctionT<void(Vertex *output, unsigned int *batch, VertexTask *vertextask, DrawData *draw)>;
 
 class VertexProcessor
 {
 public:
 	struct States : Memset<States>
 	{
-		States() : Memset(this, 0) {}
+		States()
+		    : Memset(this, 0)
+		{}
 
 		uint32_t computeHash();
 
@@ -65,16 +67,16 @@
 
 		struct Input
 		{
-			operator bool() const   // Returns true if stream contains data
+			operator bool() const  // Returns true if stream contains data
 			{
 				return count != 0;
 			}
 
 			unsigned int bytesPerAttrib() const;
 
-			StreamType type    : BITS(STREAMTYPE_LAST);
+			StreamType type : BITS(STREAMTYPE_LAST);
 			unsigned int count : 3;
-			bool normalized    : 1;
+			bool normalized : 1;
 			unsigned int attribType : BITS(SpirvShader::ATTRIBTYPE_LAST);
 		};
 
@@ -97,7 +99,7 @@
 	virtual ~VertexProcessor();
 
 protected:
-	const State update(const sw::Context* context);
+	const State update(const sw::Context *context);
 	RoutineType routine(const State &state, vk::PipelineLayout const *pipelineLayout,
 	                    SpirvShader const *vertexShader, const vk::DescriptorSet::Bindings &descriptorSets);
 
@@ -110,4 +112,4 @@
 
 }  // namespace sw
 
-#endif   // sw_VertexProcessor_hpp
+#endif  // sw_VertexProcessor_hpp