diff --git a/src/Device/Blitter.cpp b/src/Device/Blitter.cpp
new file mode 100644
index 0000000..6522a13
--- /dev/null
+++ b/src/Device/Blitter.cpp
@@ -0,0 +1,1481 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Blitter.hpp"
+
+#include "Shader/ShaderCore.hpp"
+#include "Reactor/Reactor.hpp"
+#include "Common/Memory.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	Blitter::Blitter()
+	{
+		blitCache = new RoutineCache<State>(1024);
+	}
+
+	Blitter::~Blitter()
+	{
+		delete blitCache;
+	}
+
+	void Blitter::clear(void *pixel, sw::Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask)
+	{
+		if(fastClear(pixel, format, dest, dRect, rgbaMask))
+		{
+			return;
+		}
+
+		sw::Surface *color = sw::Surface::create(1, 1, 1, format, pixel, sw::Surface::bytes(format), sw::Surface::bytes(format));
+		SliceRectF sRect(0.5f, 0.5f, 0.5f, 0.5f, 0);   // Sample from the middle.
+		blit(color, sRect, dest, dRect, {rgbaMask});
+		delete color;
+	}
+
+	bool Blitter::fastClear(void *pixel, sw::Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask)
+	{
+		if(format != FORMAT_A32B32G32R32F)
+		{
+			return false;
+		}
+
+		float *color = (float*)pixel;
+		float r = color[0];
+		float g = color[1];
+		float b = color[2];
+		float a = color[3];
+
+		uint32_t packed;
+
+		switch(dest->getFormat())
+		{
+		case FORMAT_R5G6B5:
+			if((rgbaMask & 0x7) != 0x7) return false;
+			packed = ((uint16_t)(31 * b + 0.5f) << 0) |
+			         ((uint16_t)(63 * g + 0.5f) << 5) |
+			         ((uint16_t)(31 * r + 0.5f) << 11);
+			break;
+		case FORMAT_X8B8G8R8:
+			if((rgbaMask & 0x7) != 0x7) return false;
+			packed = ((uint32_t)(255) << 24) |
+			         ((uint32_t)(255 * b + 0.5f) << 16) |
+			         ((uint32_t)(255 * g + 0.5f) << 8) |
+			         ((uint32_t)(255 * r + 0.5f) << 0);
+			break;
+		case FORMAT_A8B8G8R8:
+			if((rgbaMask & 0xF) != 0xF) return false;
+			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 FORMAT_X8R8G8B8:
+			if((rgbaMask & 0x7) != 0x7) return false;
+			packed = ((uint32_t)(255) << 24) |
+			         ((uint32_t)(255 * r + 0.5f) << 16) |
+			         ((uint32_t)(255 * g + 0.5f) << 8) |
+			         ((uint32_t)(255 * b + 0.5f) << 0);
+			break;
+		case FORMAT_A8R8G8B8:
+			if((rgbaMask & 0xF) != 0xF) return false;
+			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;
+		default:
+			return false;
+		}
+
+		bool useDestInternal = !dest->isExternalDirty();
+		uint8_t *slice = (uint8_t*)dest->lock(dRect.x0, dRect.y0, dRect.slice, sw::LOCK_WRITEONLY, sw::PUBLIC, useDestInternal);
+
+		for(int j = 0; j < dest->getSamples(); j++)
+		{
+			uint8_t *d = slice;
+
+			switch(Surface::bytes(dest->getFormat()))
+			{
+			case 2:
+				for(int i = dRect.y0; i < dRect.y1; i++)
+				{
+					sw::clear((uint16_t*)d, packed, dRect.x1 - dRect.x0);
+					d += dest->getPitchB(useDestInternal);
+				}
+				break;
+			case 4:
+				for(int i = dRect.y0; i < dRect.y1; i++)
+				{
+					sw::clear((uint32_t*)d, packed, dRect.x1 - dRect.x0);
+					d += dest->getPitchB(useDestInternal);
+				}
+				break;
+			default:
+				assert(false);
+			}
+
+			slice += dest->getSliceB(useDestInternal);
+		}
+
+		dest->unlock(useDestInternal);
+
+		return true;
+	}
+
+	void Blitter::blit(Surface *source, const SliceRectF &sourceRect, Surface *dest, const SliceRect &destRect, const Blitter::Options& options)
+	{
+		if(dest->getInternalFormat() == FORMAT_NULL)
+		{
+			return;
+		}
+
+		if(blitReactor(source, sourceRect, dest, destRect, options))
+		{
+			return;
+		}
+
+		SliceRectF sRect = sourceRect;
+		SliceRect dRect = destRect;
+
+		bool flipX = destRect.x0 > destRect.x1;
+		bool flipY = destRect.y0 > destRect.y1;
+
+		if(flipX)
+		{
+			swap(dRect.x0, dRect.x1);
+			swap(sRect.x0, sRect.x1);
+		}
+		if(flipY)
+		{
+			swap(dRect.y0, dRect.y1);
+			swap(sRect.y0, sRect.y1);
+		}
+
+		source->lockInternal(0, 0, sRect.slice, sw::LOCK_READONLY, sw::PUBLIC);
+		dest->lockInternal(0, 0, dRect.slice, sw::LOCK_WRITEONLY, sw::PUBLIC);
+
+		float w = sRect.width() / dRect.width();
+		float h = sRect.height() / dRect.height();
+
+		float xStart = sRect.x0 + (0.5f - dRect.x0) * w;
+		float yStart = sRect.y0 + (0.5f - dRect.y0) * h;
+
+		for(int j = dRect.y0; j < dRect.y1; j++)
+		{
+			float y = yStart + j * h;
+
+			for(int i = dRect.x0; i < dRect.x1; i++)
+			{
+				float x = xStart + i * w;
+
+				// FIXME: Support RGBA mask
+				dest->copyInternal(source, i, j, x, y, options.filter);
+			}
+		}
+
+		source->unlockInternal();
+		dest->unlockInternal();
+	}
+
+	void Blitter::blit3D(Surface *source, Surface *dest)
+	{
+		source->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
+		dest->lockInternal(0, 0, 0, sw::LOCK_WRITEONLY, sw::PUBLIC);
+
+		float w = static_cast<float>(source->getWidth())  / static_cast<float>(dest->getWidth());
+		float h = static_cast<float>(source->getHeight()) / static_cast<float>(dest->getHeight());
+		float d = static_cast<float>(source->getDepth())  / static_cast<float>(dest->getDepth());
+
+		for(int k = 0; k < dest->getDepth(); k++)
+		{
+			float z = (k + 0.5f) * d;
+
+			for(int j = 0; j < dest->getHeight(); j++)
+			{
+				float y = (j + 0.5f) * h;
+
+				for(int i = 0; i < dest->getWidth(); i++)
+				{
+					float x = (i + 0.5f) * w;
+
+					dest->copyInternal(source, i, j, k, x, y, z, true);
+				}
+			}
+		}
+
+		source->unlockInternal();
+		dest->unlockInternal();
+	}
+
+	bool Blitter::read(Float4 &c, Pointer<Byte> element, const State &state)
+	{
+		c = Float4(0.0f, 0.0f, 0.0f, 1.0f);
+
+		switch(state.sourceFormat)
+		{
+		case FORMAT_L8:
+			c.xyz = Float(Int(*Pointer<Byte>(element)));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_A8:
+			c.w = Float(Int(*Pointer<Byte>(element)));
+			break;
+		case FORMAT_R8I:
+		case FORMAT_R8_SNORM:
+			c.x = Float(Int(*Pointer<SByte>(element)));
+			c.w = float(0x7F);
+			break;
+		case FORMAT_R8:
+		case FORMAT_R8UI:
+			c.x = Float(Int(*Pointer<Byte>(element)));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_R16I:
+			c.x = Float(Int(*Pointer<Short>(element)));
+			c.w = float(0x7FFF);
+			break;
+		case FORMAT_R16UI:
+			c.x = Float(Int(*Pointer<UShort>(element)));
+			c.w = float(0xFFFF);
+			break;
+		case FORMAT_R32I:
+			c.x = Float(*Pointer<Int>(element));
+			c.w = float(0x7FFFFFFF);
+			break;
+		case FORMAT_R32UI:
+			c.x = Float(*Pointer<UInt>(element));
+			c.w = float(0xFFFFFFFF);
+			break;
+		case FORMAT_A8R8G8B8:
+			c = Float4(*Pointer<Byte4>(element)).zyxw;
+			break;
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8_SNORM:
+			c = Float4(*Pointer<SByte4>(element));
+			break;
+		case FORMAT_A8B8G8R8:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_SRGB8_A8:
+			c = Float4(*Pointer<Byte4>(element));
+			break;
+		case FORMAT_X8R8G8B8:
+			c = Float4(*Pointer<Byte4>(element)).zyxw;
+			c.w = float(0xFF);
+			break;
+		case FORMAT_R8G8B8:
+			c.z = Float(Int(*Pointer<Byte>(element + 0)));
+			c.y = Float(Int(*Pointer<Byte>(element + 1)));
+			c.x = Float(Int(*Pointer<Byte>(element + 2)));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_B8G8R8:
+			c.x = Float(Int(*Pointer<Byte>(element + 0)));
+			c.y = Float(Int(*Pointer<Byte>(element + 1)));
+			c.z = Float(Int(*Pointer<Byte>(element + 2)));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8_SNORM:
+			c = Float4(*Pointer<SByte4>(element));
+			c.w = float(0x7F);
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_SRGB8_X8:
+			c = Float4(*Pointer<Byte4>(element));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_A16B16G16R16I:
+			c = Float4(*Pointer<Short4>(element));
+			break;
+		case FORMAT_A16B16G16R16:
+		case FORMAT_A16B16G16R16UI:
+			c = Float4(*Pointer<UShort4>(element));
+			break;
+		case FORMAT_X16B16G16R16I:
+			c = Float4(*Pointer<Short4>(element));
+			c.w = float(0x7FFF);
+			break;
+		case FORMAT_X16B16G16R16UI:
+			c = Float4(*Pointer<UShort4>(element));
+			c.w = float(0xFFFF);
+			break;
+		case FORMAT_A32B32G32R32I:
+			c = Float4(*Pointer<Int4>(element));
+			break;
+		case FORMAT_A32B32G32R32UI:
+			c = Float4(*Pointer<UInt4>(element));
+			break;
+		case FORMAT_X32B32G32R32I:
+			c = Float4(*Pointer<Int4>(element));
+			c.w = float(0x7FFFFFFF);
+			break;
+		case FORMAT_X32B32G32R32UI:
+			c = Float4(*Pointer<UInt4>(element));
+			c.w = float(0xFFFFFFFF);
+			break;
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8_SNORM:
+			c.x = Float(Int(*Pointer<SByte>(element + 0)));
+			c.y = Float(Int(*Pointer<SByte>(element + 1)));
+			c.w = float(0x7F);
+			break;
+		case FORMAT_G8R8:
+		case FORMAT_G8R8UI:
+			c.x = Float(Int(*Pointer<Byte>(element + 0)));
+			c.y = Float(Int(*Pointer<Byte>(element + 1)));
+			c.w = float(0xFF);
+			break;
+		case FORMAT_G16R16I:
+			c.x = Float(Int(*Pointer<Short>(element + 0)));
+			c.y = Float(Int(*Pointer<Short>(element + 2)));
+			c.w = float(0x7FFF);
+			break;
+		case FORMAT_G16R16:
+		case FORMAT_G16R16UI:
+			c.x = Float(Int(*Pointer<UShort>(element + 0)));
+			c.y = Float(Int(*Pointer<UShort>(element + 2)));
+			c.w = float(0xFFFF);
+			break;
+		case FORMAT_G32R32I:
+			c.x = Float(*Pointer<Int>(element + 0));
+			c.y = Float(*Pointer<Int>(element + 4));
+			c.w = float(0x7FFFFFFF);
+			break;
+		case FORMAT_G32R32UI:
+			c.x = Float(*Pointer<UInt>(element + 0));
+			c.y = Float(*Pointer<UInt>(element + 4));
+			c.w = float(0xFFFFFFFF);
+			break;
+		case FORMAT_A32B32G32R32F:
+			c = *Pointer<Float4>(element);
+			break;
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_B32G32R32F:
+			c.z = *Pointer<Float>(element + 8);
+		case FORMAT_G32R32F:
+			c.x = *Pointer<Float>(element + 0);
+			c.y = *Pointer<Float>(element + 4);
+			break;
+		case FORMAT_R32F:
+			c.x = *Pointer<Float>(element);
+			break;
+		case FORMAT_R5G6B5:
+			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 FORMAT_A2B10G10R10:
+		case FORMAT_A2B10G10R10UI:
+			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 FORMAT_D16:
+			c.x = Float(Int((*Pointer<UShort>(element))));
+			break;
+		case FORMAT_D24S8:
+		case FORMAT_D24X8:
+			c.x = Float(Int((*Pointer<UInt>(element) & UInt(0xFFFFFF00)) >> 8));
+			break;
+		case FORMAT_D32:
+			c.x = Float(Int((*Pointer<UInt>(element))));
+			break;
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+			c.x = 1.0f - *Pointer<Float>(element);
+			break;
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+			c.x = *Pointer<Float>(element);
+			break;
+		case FORMAT_S8:
+			c.x = Float(Int(*Pointer<Byte>(element)));
+			break;
+		default:
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Blitter::write(Float4 &c, Pointer<Byte> element, const State &state)
+	{
+		bool writeR = state.writeRed;
+		bool writeG = state.writeGreen;
+		bool writeB = state.writeBlue;
+		bool writeA = state.writeAlpha;
+		bool writeRGBA = writeR && writeG && writeB && writeA;
+
+		switch(state.destFormat)
+		{
+		case FORMAT_L8:
+			*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
+			break;
+		case FORMAT_A8:
+			if(writeA) { *Pointer<Byte>(element) = Byte(RoundInt(Float(c.w))); }
+			break;
+		case FORMAT_A8R8G8B8:
+			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 FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_A8:
+			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 FORMAT_X8R8G8B8:
+			if(writeRGBA)
+			{
+				Short4 c0 = RoundShort4(c.zyxw) | Short4(0x0000, 0x0000, 0x0000, 0x00FF);
+				*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(0xFF); }
+			}
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+			if(writeRGBA)
+			{
+				Short4 c0 = RoundShort4(c) | Short4(0x0000, 0x0000, 0x0000, 0x00FF);
+				*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(0xFF); }
+			}
+			break;
+		case FORMAT_R8G8B8:
+			if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); }
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
+			if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); }
+			break;
+		case FORMAT_B8G8R8:
+			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))); }
+			break;
+		case FORMAT_A32B32G32R32F:
+			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 FORMAT_X32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+			if(writeA) { *Pointer<Float>(element + 12) = 1.0f; }
+		case FORMAT_B32G32R32F:
+			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 FORMAT_G32R32F:
+			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 FORMAT_R32F:
+			if(writeR) { *Pointer<Float>(element) = c.x; }
+			break;
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8_SNORM:
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); }
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8_SNORM:
+			if(writeA && (state.destFormat == FORMAT_X8B8G8R8I || state.destFormat == FORMAT_X8B8G8R8_SNORM))
+			{
+				*Pointer<SByte>(element + 3) = SByte(0x7F);
+			}
+			if(writeB) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.z))); }
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8_SNORM:
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); }
+		case FORMAT_R8I:
+		case FORMAT_R8_SNORM:
+			if(writeR) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.x))); }
+			break;
+		case FORMAT_A8B8G8R8UI:
+			if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); }
+		case FORMAT_X8B8G8R8UI:
+			if(writeA && (state.destFormat == FORMAT_X8B8G8R8UI))
+			{
+				*Pointer<Byte>(element + 3) = Byte(0xFF);
+			}
+			if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); }
+		case FORMAT_G8R8UI:
+		case FORMAT_G8R8:
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); }
+		case FORMAT_R8UI:
+		case FORMAT_R8:
+			if(writeR) { *Pointer<Byte>(element) = Byte(RoundInt(Float(c.x))); }
+			break;
+		case FORMAT_A16B16G16R16I:
+			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 FORMAT_X16B16G16R16I:
+			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(0x7F); }
+			break;
+		case FORMAT_G16R16I:
+			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 FORMAT_R16I:
+			if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); }
+			break;
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_A16B16G16R16:
+			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 FORMAT_X16B16G16R16UI:
+			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(0xFF); }
+			break;
+		case FORMAT_G16R16UI:
+		case FORMAT_G16R16:
+			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 FORMAT_R16UI:
+			if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); }
+			break;
+		case FORMAT_A32B32G32R32I:
+			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 FORMAT_X32B32G32R32I:
+			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) = Int(0x7FFFFFFF); }
+			break;
+		case FORMAT_G32R32I:
+			if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); }
+		case FORMAT_R32I:
+			if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); }
+			break;
+		case FORMAT_A32B32G32R32UI:
+			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 FORMAT_X32B32G32R32UI:
+			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<UInt4>(element + 12) = UInt4(0xFFFFFFFF); }
+			break;
+		case FORMAT_G32R32UI:
+			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); }
+		case FORMAT_R32UI:
+			if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); }
+			break;
+		case FORMAT_R5G6B5:
+			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 FORMAT_A2B10G10R10:
+		case FORMAT_A2B10G10R10UI:
+			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 FORMAT_D16:
+			*Pointer<UShort>(element) = UShort(RoundInt(Float(c.x)));
+			break;
+		case FORMAT_D24S8:
+		case FORMAT_D24X8:
+			*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) << 8);
+			break;
+		case FORMAT_D32:
+			*Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)));
+			break;
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+			*Pointer<Float>(element) = 1.0f - c.x;
+			break;
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+			*Pointer<Float>(element) = c.x;
+			break;
+		case FORMAT_S8:
+			*Pointer<Byte>(element) = Byte(RoundInt(Float(c.x)));
+			break;
+		default:
+			return false;
+		}
+		return true;
+	}
+
+	bool Blitter::read(Int4 &c, Pointer<Byte> element, const State &state)
+	{
+		c = Int4(0, 0, 0, 1);
+
+		switch(state.sourceFormat)
+		{
+		case FORMAT_A8B8G8R8I:
+			c = Insert(c, Int(*Pointer<SByte>(element + 3)), 3);
+		case FORMAT_X8B8G8R8I:
+			c = Insert(c, Int(*Pointer<SByte>(element + 2)), 2);
+		case FORMAT_G8R8I:
+			c = Insert(c, Int(*Pointer<SByte>(element + 1)), 1);
+		case FORMAT_R8I:
+			c = Insert(c, Int(*Pointer<SByte>(element)), 0);
+			break;
+		case FORMAT_A8B8G8R8UI:
+			c = Insert(c, Int(*Pointer<Byte>(element + 3)), 3);
+		case FORMAT_X8B8G8R8UI:
+			c = Insert(c, Int(*Pointer<Byte>(element + 2)), 2);
+		case FORMAT_G8R8UI:
+			c = Insert(c, Int(*Pointer<Byte>(element + 1)), 1);
+		case FORMAT_R8UI:
+			c = Insert(c, Int(*Pointer<Byte>(element)), 0);
+			break;
+		case FORMAT_A16B16G16R16I:
+			c = Insert(c, Int(*Pointer<Short>(element + 6)), 3);
+		case FORMAT_X16B16G16R16I:
+			c = Insert(c, Int(*Pointer<Short>(element + 4)), 2);
+		case FORMAT_G16R16I:
+			c = Insert(c, Int(*Pointer<Short>(element + 2)), 1);
+		case FORMAT_R16I:
+			c = Insert(c, Int(*Pointer<Short>(element)), 0);
+			break;
+		case FORMAT_A16B16G16R16UI:
+			c = Insert(c, Int(*Pointer<UShort>(element + 6)), 3);
+		case FORMAT_X16B16G16R16UI:
+			c = Insert(c, Int(*Pointer<UShort>(element + 4)), 2);
+		case FORMAT_G16R16UI:
+			c = Insert(c, Int(*Pointer<UShort>(element + 2)), 1);
+		case FORMAT_R16UI:
+			c = Insert(c, Int(*Pointer<UShort>(element)), 0);
+			break;
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			c = *Pointer<Int4>(element);
+			break;
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+			c = Insert(c, *Pointer<Int>(element + 8), 2);
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+			c = Insert(c, *Pointer<Int>(element + 4), 1);
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+			c = Insert(c, *Pointer<Int>(element), 0);
+			break;
+		default:
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Blitter::write(Int4 &c, Pointer<Byte> element, const State &state)
+	{
+		bool writeR = state.writeRed;
+		bool writeG = state.writeGreen;
+		bool writeB = state.writeBlue;
+		bool writeA = state.writeAlpha;
+		bool writeRGBA = writeR && writeG && writeB && writeA;
+
+		switch(state.destFormat)
+		{
+		case FORMAT_A8B8G8R8I:
+			if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); }
+		case FORMAT_X8B8G8R8I:
+			if(writeA && (state.destFormat != FORMAT_A8B8G8R8I))
+			{
+				*Pointer<SByte>(element + 3) = SByte(0x7F);
+			}
+			if(writeB) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 2)); }
+		case FORMAT_G8R8I:
+			if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); }
+		case FORMAT_R8I:
+			if(writeR) { *Pointer<SByte>(element) = SByte(Extract(c, 0)); }
+			break;
+		case FORMAT_A8B8G8R8UI:
+			if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); }
+		case FORMAT_X8B8G8R8UI:
+			if(writeA && (state.destFormat != FORMAT_A8B8G8R8UI))
+			{
+				*Pointer<Byte>(element + 3) = Byte(0xFF);
+			}
+			if(writeB) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 2)); }
+		case FORMAT_G8R8UI:
+			if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); }
+		case FORMAT_R8UI:
+			if(writeR) { *Pointer<Byte>(element) = Byte(Extract(c, 0)); }
+			break;
+		case FORMAT_A16B16G16R16I:
+			if(writeA) { *Pointer<Short>(element + 6) = Short(Extract(c, 3)); }
+		case FORMAT_X16B16G16R16I:
+			if(writeA && (state.destFormat != FORMAT_A16B16G16R16I))
+			{
+				*Pointer<Short>(element + 6) = Short(0x7FFF);
+			}
+			if(writeB) { *Pointer<Short>(element + 4) = Short(Extract(c, 2)); }
+		case FORMAT_G16R16I:
+			if(writeG) { *Pointer<Short>(element + 2) = Short(Extract(c, 1)); }
+		case FORMAT_R16I:
+			if(writeR) { *Pointer<Short>(element) = Short(Extract(c, 0)); }
+			break;
+		case FORMAT_A16B16G16R16UI:
+			if(writeA) { *Pointer<UShort>(element + 6) = UShort(Extract(c, 3)); }
+		case FORMAT_X16B16G16R16UI:
+			if(writeA && (state.destFormat != FORMAT_A16B16G16R16UI))
+			{
+				*Pointer<UShort>(element + 6) = UShort(0xFFFF);
+			}
+			if(writeB) { *Pointer<UShort>(element + 4) = UShort(Extract(c, 2)); }
+		case FORMAT_G16R16UI:
+			if(writeG) { *Pointer<UShort>(element + 2) = UShort(Extract(c, 1)); }
+		case FORMAT_R16UI:
+			if(writeR) { *Pointer<UShort>(element) = UShort(Extract(c, 0)); }
+			break;
+		case FORMAT_A32B32G32R32I:
+			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 FORMAT_X32B32G32R32I:
+			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) = Int(0x7FFFFFFF); }
+			break;
+		case FORMAT_G32R32I:
+			if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
+			if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); }
+			break;
+		case FORMAT_R32I:
+			if(writeR) { *Pointer<Int>(element) = Extract(c, 0); }
+			break;
+		case FORMAT_A32B32G32R32UI:
+			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 FORMAT_X32B32G32R32UI:
+			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 + 3) = UInt(0xFFFFFFFF); }
+			break;
+		case FORMAT_G32R32UI:
+			if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
+			if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); }
+			break;
+		case FORMAT_R32UI:
+			if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); }
+			break;
+		default:
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Blitter::GetScale(float4 &scale, Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_L8:
+		case FORMAT_A8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_R8:
+		case FORMAT_G8R8:
+		case FORMAT_R8G8B8:
+		case FORMAT_B8G8R8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+			scale = vector(0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+			scale = vector(0x7F, 0x7F, 0x7F, 0x7F);
+			break;
+		case FORMAT_A16B16G16R16:
+			scale = vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
+			break;
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_B32G32R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_R32F:
+		case FORMAT_A2B10G10R10UI:
+			scale = vector(1.0f, 1.0f, 1.0f, 1.0f);
+			break;
+		case FORMAT_R5G6B5:
+			scale = vector(0x1F, 0x3F, 0x1F, 1.0f);
+			break;
+		case FORMAT_A2B10G10R10:
+			scale = vector(0x3FF, 0x3FF, 0x3FF, 0x03);
+			break;
+		case FORMAT_D16:
+			scale = vector(0xFFFF, 0.0f, 0.0f, 0.0f);
+			break;
+		case FORMAT_D24S8:
+		case FORMAT_D24X8:
+			scale = vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
+			break;
+		case FORMAT_D32:
+			scale = vector(static_cast<float>(0xFFFFFFFF), 0.0f, 0.0f, 0.0f);
+			break;
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_S8:
+			scale = vector(1.0f, 1.0f, 1.0f, 1.0f);
+			break;
+		default:
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
+	{
+		float4 scale, unscale;
+		if(state.clearOperation &&
+		   Surface::isNonNormalizedInteger(state.sourceFormat) &&
+		   !Surface::isNonNormalizedInteger(state.destFormat))
+		{
+			// If we're clearing a buffer from an int or uint color into a normalized color,
+			// then the whole range of the int or uint color must be scaled between 0 and 1.
+			switch(state.sourceFormat)
+			{
+			case FORMAT_A32B32G32R32I:
+				unscale = replicate(static_cast<float>(0x7FFFFFFF));
+				break;
+			case FORMAT_A32B32G32R32UI:
+				unscale = replicate(static_cast<float>(0xFFFFFFFF));
+				break;
+			default:
+				return false;
+			}
+		}
+		else if(!GetScale(unscale, state.sourceFormat))
+		{
+			return false;
+		}
+
+		if(!GetScale(scale, state.destFormat))
+		{
+			return false;
+		}
+
+		bool srcSRGB = Surface::isSRGBformat(state.sourceFormat);
+		bool dstSRGB = Surface::isSRGBformat(state.destFormat);
+
+		if(state.convertSRGB && ((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 = (srcSRGB && !preScaled) ? sRGBtoLinear(value) : LinearToSRGB(value);
+			value *= Float4(scale.x, scale.y, scale.z, scale.w); // Apply scale
+		}
+		else if(unscale != scale)
+		{
+			value *= Float4(scale.x / unscale.x, scale.y / unscale.y, scale.z / unscale.z, scale.w / unscale.w);
+		}
+
+		if(state.destFormat == FORMAT_X32B32G32R32F_UNSIGNED)
+		{
+			value = Max(value, Float4(0.0f));  // TODO: Only necessary if source is signed.
+		}
+		else if(Surface::isFloatFormat(state.sourceFormat) && !Surface::isFloatFormat(state.destFormat))
+		{
+			value = Min(value, Float4(scale.x, scale.y, scale.z, scale.w));
+
+			value = Max(value, Float4(Surface::isUnsignedComponent(state.destFormat, 0) ? 0.0f : -scale.x,
+			                          Surface::isUnsignedComponent(state.destFormat, 1) ? 0.0f : -scale.y,
+			                          Surface::isUnsignedComponent(state.destFormat, 2) ? 0.0f : -scale.z,
+			                          Surface::isUnsignedComponent(state.destFormat, 3) ? 0.0f : -scale.w));
+		}
+
+		return true;
+	}
+
+	Int Blitter::ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout)
+	{
+		if(!quadLayout)
+		{
+			return y * pitchB + x * bytes;
+		}
+		else
+		{
+			// (x & ~1) * 2 + (x & 1) == (x - (x & 1)) * 2 + (x & 1) == x * 2 - (x & 1) * 2 + (x & 1) == x * 2 - (x & 1)
+			return (y & Int(~1)) * pitchB +
+			       ((y & Int(1)) * 2 + x * 2 - (x & Int(1))) * bytes;
+		}
+	}
+
+	Float4 Blitter::LinearToSRGB(Float4 &c)
+	{
+		Float4 lc = Min(c, Float4(0.0031308f)) * Float4(12.92f);
+		Float4 ec = Float4(1.055f) * power(c, Float4(1.0f / 2.4f)) - Float4(0.055f);
+
+		Float4 s = c;
+		s.xyz = Max(lc, ec);
+
+		return s;
+	}
+
+	Float4 Blitter::sRGBtoLinear(Float4 &c)
+	{
+		Float4 lc = c * Float4(1.0f / 12.92f);
+		Float4 ec = power((c + Float4(0.055f)) * Float4(1.0f / 1.055f), Float4(2.4f));
+
+		Int4 linear = CmpLT(c, Float4(0.04045f));
+
+		Float4 s = c;
+		s.xyz = As<Float4>((linear & As<Int4>(lc)) | (~linear & As<Int4>(ec)));   // FIXME: IfThenElse()
+
+		return s;
+	}
+
+	Routine *Blitter::generate(const State &state)
+	{
+		Function<Void(Pointer<Byte>)> function;
+		{
+			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));
+
+			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 sWidth = *Pointer<Int>(blit + OFFSET(BlitData,sWidth));
+			Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData,sHeight));
+
+			bool intSrc = Surface::isNonNormalizedInteger(state.sourceFormat);
+			bool intDst = Surface::isNonNormalizedInteger(state.destFormat);
+			bool intBoth = intSrc && intDst;
+			bool srcQuadLayout = Surface::hasQuadLayout(state.sourceFormat);
+			bool dstQuadLayout = Surface::hasQuadLayout(state.destFormat);
+			int srcBytes = Surface::bytes(state.sourceFormat);
+			int dstBytes = Surface::bytes(state.destFormat);
+
+			bool hasConstantColorI = false;
+			Int4 constantColorI;
+			bool hasConstantColorF = false;
+			Float4 constantColorF;
+			if(state.clearOperation)
+			{
+				if(intBoth) // Integer types
+				{
+					if(!read(constantColorI, source, state))
+					{
+						return nullptr;
+					}
+					hasConstantColorI = true;
+				}
+				else
+				{
+					if(!read(constantColorF, source, state))
+					{
+						return nullptr;
+					}
+					hasConstantColorF = true;
+
+					if(!ApplyScaleAndClamp(constantColorF, state))
+					{
+						return nullptr;
+					}
+				}
+			}
+
+			For(Int j = y0d, j < y1d, j++)
+			{
+				Float y = state.clearOperation ? RValue<Float>(y0) : y0 + Float(j) * h;
+				Pointer<Byte> destLine = dest + (dstQuadLayout ? j & Int(~1) : RValue<Int>(j)) * dPitchB;
+
+				For(Int i = x0d, i < x1d, i++)
+				{
+					Float x = state.clearOperation ? RValue<Float>(x0) : x0 + Float(i) * w;
+					Pointer<Byte> d = destLine + (dstQuadLayout ? (((j & Int(1)) << 1) + (i * 2) - (i & Int(1))) : RValue<Int>(i)) * dstBytes;
+
+					if(hasConstantColorI)
+					{
+						if(!write(constantColorI, d, state))
+						{
+							return nullptr;
+						}
+					}
+					else if(hasConstantColorF)
+					{
+						for(int s = 0; s < state.destSamples; s++)
+						{
+							if(!write(constantColorF, d, state))
+							{
+								return nullptr;
+							}
+
+							d += *Pointer<Int>(blit + OFFSET(BlitData, dSliceB));
+						}
+					}
+					else if(intBoth) // Integer types do not support filtering
+					{
+						Int4 color; // When both formats are true integer types, we don't go to float to avoid losing precision
+						Int X = Int(x);
+						Int Y = Int(y);
+
+						if(state.clampToEdge)
+						{
+							X = Clamp(X, 0, sWidth - 1);
+							Y = Clamp(Y, 0, sHeight - 1);
+						}
+
+						Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
+
+						if(!read(color, s, state))
+						{
+							return nullptr;
+						}
+
+						if(!write(color, d, state))
+						{
+							return nullptr;
+						}
+					}
+					else
+					{
+						Float4 color;
+
+						bool preScaled = false;
+						if(!state.filter || intSrc)
+						{
+							Int X = Int(x);
+							Int Y = Int(y);
+
+							if(state.clampToEdge)
+							{
+								X = Clamp(X, 0, sWidth - 1);
+								Y = Clamp(Y, 0, sHeight - 1);
+							}
+
+							Pointer<Byte> s = source + ComputeOffset(X, Y, sPitchB, srcBytes, srcQuadLayout);
+
+							if(!read(color, s, state))
+							{
+								return nullptr;
+							}
+						}
+						else   // Bilinear filtering
+						{
+							Float X = x;
+							Float Y = y;
+
+							if(state.clampToEdge)
+							{
+								X = Min(Max(x, 0.5f), Float(sWidth) - 0.5f);
+								Y = Min(Max(y, 0.5f), Float(sHeight) - 0.5f);
+							}
+
+							Float x0 = X - 0.5f;
+							Float y0 = Y - 0.5f;
+
+							Int X0 = Max(Int(x0), 0);
+							Int Y0 = Max(Int(y0), 0);
+
+							Int X1 = X0 + 1;
+							Int Y1 = Y0 + 1;
+							X1 = IfThenElse(X1 >= sWidth, X0, X1);
+							Y1 = IfThenElse(Y1 >= sHeight, Y0, Y1);
+
+							Pointer<Byte> s00 = source + ComputeOffset(X0, Y0, sPitchB, srcBytes, srcQuadLayout);
+							Pointer<Byte> s01 = source + ComputeOffset(X1, Y0, sPitchB, srcBytes, srcQuadLayout);
+							Pointer<Byte> s10 = source + ComputeOffset(X0, Y1, sPitchB, srcBytes, srcQuadLayout);
+							Pointer<Byte> s11 = source + ComputeOffset(X1, Y1, sPitchB, srcBytes, srcQuadLayout);
+
+							Float4 c00; if(!read(c00, s00, state)) return nullptr;
+							Float4 c01; if(!read(c01, s01, state)) return nullptr;
+							Float4 c10; if(!read(c10, s10, state)) return nullptr;
+							Float4 c11; if(!read(c11, s11, state)) return nullptr;
+
+							if(state.convertSRGB && Surface::isSRGBformat(state.sourceFormat)) // sRGB -> RGB
+							{
+								if(!ApplyScaleAndClamp(c00, state)) return nullptr;
+								if(!ApplyScaleAndClamp(c01, state)) return nullptr;
+								if(!ApplyScaleAndClamp(c10, state)) return nullptr;
+								if(!ApplyScaleAndClamp(c11, state)) return nullptr;
+								preScaled = true;
+							}
+
+							Float4 fx = Float4(x0 - Float(X0));
+							Float4 fy = Float4(y0 - Float(Y0));
+							Float4 ix = Float4(1.0f) - fx;
+							Float4 iy = Float4(1.0f) - fy;
+
+							color = (c00 * ix + c01 * fx) * iy +
+							        (c10 * ix + c11 * fx) * fy;
+						}
+
+						if(!ApplyScaleAndClamp(color, state, preScaled))
+						{
+							return nullptr;
+						}
+
+						for(int s = 0; s < state.destSamples; s++)
+						{
+							if(!write(color, d, state))
+							{
+								return nullptr;
+							}
+
+							d += *Pointer<Int>(blit + OFFSET(BlitData,dSliceB));
+						}
+					}
+				}
+			}
+		}
+
+		return function(L"BlitRoutine");
+	}
+
+	bool Blitter::blitReactor(Surface *source, const SliceRectF &sourceRect, Surface *dest, const SliceRect &destRect, const Blitter::Options &options)
+	{
+		ASSERT(!options.clearOperation || ((source->getWidth() == 1) && (source->getHeight() == 1) && (source->getDepth() == 1)));
+
+		Rect dRect = destRect;
+		RectF sRect = sourceRect;
+		if(destRect.x0 > destRect.x1)
+		{
+			swap(dRect.x0, dRect.x1);
+			swap(sRect.x0, sRect.x1);
+		}
+		if(destRect.y0 > destRect.y1)
+		{
+			swap(dRect.y0, dRect.y1);
+			swap(sRect.y0, sRect.y1);
+		}
+
+		State state(options);
+		state.clampToEdge = (sourceRect.x0 < 0.0f) ||
+		                    (sourceRect.y0 < 0.0f) ||
+		                    (sourceRect.x1 > (float)source->getWidth()) ||
+		                    (sourceRect.y1 > (float)source->getHeight());
+
+		bool useSourceInternal = !source->isExternalDirty();
+		bool useDestInternal = !dest->isExternalDirty();
+		bool isStencil = options.useStencil;
+
+		state.sourceFormat = isStencil ? source->getStencilFormat() : source->getFormat(useSourceInternal);
+		state.destFormat = isStencil ? dest->getStencilFormat() : dest->getFormat(useDestInternal);
+		state.destSamples = dest->getSamples();
+
+		criticalSection.lock();
+		Routine *blitRoutine = blitCache->query(state);
+
+		if(!blitRoutine)
+		{
+			blitRoutine = generate(state);
+
+			if(!blitRoutine)
+			{
+				criticalSection.unlock();
+				return false;
+			}
+
+			blitCache->add(state, blitRoutine);
+		}
+
+		criticalSection.unlock();
+
+		void (*blitFunction)(const BlitData *data) = (void(*)(const BlitData*))blitRoutine->getEntry();
+
+		BlitData data;
+
+		bool isRGBA = options.writeMask == 0xF;
+		bool isEntireDest = dest->isEntire(destRect);
+
+		data.source = isStencil ? source->lockStencil(0, 0, 0, sw::PUBLIC) :
+		                          source->lock(0, 0, sourceRect.slice, sw::LOCK_READONLY, sw::PUBLIC, useSourceInternal);
+		data.dest = isStencil ? dest->lockStencil(0, 0, 0, sw::PUBLIC) :
+		                        dest->lock(0, 0, destRect.slice, isRGBA ? (isEntireDest ? sw::LOCK_DISCARD : sw::LOCK_WRITEONLY) : sw::LOCK_READWRITE, sw::PUBLIC, useDestInternal);
+		data.sPitchB = isStencil ? source->getStencilPitchB() : source->getPitchB(useSourceInternal);
+		data.dPitchB = isStencil ? dest->getStencilPitchB() : dest->getPitchB(useDestInternal);
+		data.dSliceB = isStencil ? dest->getStencilSliceB() : dest->getSliceB(useDestInternal);
+
+		data.w = sRect.width() / dRect.width();
+		data.h = sRect.height() / dRect.height();
+		data.x0 = sRect.x0 + (0.5f - dRect.x0) * data.w;
+		data.y0 = sRect.y0 + (0.5f - dRect.y0) * data.h;
+
+		data.x0d = dRect.x0;
+		data.x1d = dRect.x1;
+		data.y0d = dRect.y0;
+		data.y1d = dRect.y1;
+
+		data.sWidth = source->getWidth();
+		data.sHeight = source->getHeight();
+
+		blitFunction(&data);
+
+		if(isStencil)
+		{
+			source->unlockStencil();
+			dest->unlockStencil();
+		}
+		else
+		{
+			source->unlock(useSourceInternal);
+			dest->unlock(useDestInternal);
+		}
+
+		return true;
+	}
+}
diff --git a/src/Device/Blitter.hpp b/src/Device/Blitter.hpp
new file mode 100644
index 0000000..e3db745
--- /dev/null
+++ b/src/Device/Blitter.hpp
@@ -0,0 +1,121 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Blitter_hpp
+#define sw_Blitter_hpp
+
+#include "Surface.hpp"
+#include "RoutineCache.hpp"
+#include "Reactor/Reactor.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	class Blitter
+	{
+		struct Options
+		{
+			Options() = default;
+			Options(bool filter, bool useStencil, bool convertSRGB)
+				: writeMask(0xF), clearOperation(false), filter(filter), useStencil(useStencil), convertSRGB(convertSRGB), clampToEdge(false) {}
+			Options(unsigned int writeMask)
+				: writeMask(writeMask), clearOperation(true), filter(false), useStencil(false), convertSRGB(true), clampToEdge(false) {}
+
+			union
+			{
+				struct
+				{
+					bool writeRed : 1;
+					bool writeGreen : 1;
+					bool writeBlue : 1;
+					bool writeAlpha : 1;
+				};
+
+				unsigned char writeMask;
+			};
+
+			bool clearOperation : 1;
+			bool filter : 1;
+			bool useStencil : 1;
+			bool convertSRGB : 1;
+			bool clampToEdge : 1;
+		};
+
+		struct State : Options
+		{
+			State() = default;
+			State(const Options &options) : Options(options) {}
+
+			bool operator==(const State &state) const
+			{
+				return memcmp(this, &state, sizeof(State)) == 0;
+			}
+
+			Format sourceFormat;
+			Format destFormat;
+			int destSamples;
+		};
+
+		struct BlitData
+		{
+			void *source;
+			void *dest;
+			int sPitchB;
+			int dPitchB;
+			int dSliceB;
+
+			float x0;
+			float y0;
+			float w;
+			float h;
+
+			int y0d;
+			int y1d;
+			int x0d;
+			int x1d;
+
+			int sWidth;
+			int sHeight;
+		};
+
+	public:
+		Blitter();
+		virtual ~Blitter();
+
+		void clear(void *pixel, sw::Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask);
+		void blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, const Options &options);
+		void blit3D(Surface *source, Surface *dest);
+
+	private:
+		bool fastClear(void *pixel, sw::Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask);
+
+		bool read(Float4 &color, Pointer<Byte> element, const State &state);
+		bool write(Float4 &color, Pointer<Byte> element, const State &state);
+		bool read(Int4 &color, Pointer<Byte> element, const State &state);
+		bool write(Int4 &color, Pointer<Byte> element, const State &state);
+		static bool GetScale(float4& scale, Format format);
+		static bool ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
+		static Int ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout);
+		static Float4 LinearToSRGB(Float4 &color);
+		static Float4 sRGBtoLinear(Float4 &color);
+		bool blitReactor(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, const Options &options);
+		Routine *generate(const State &state);
+
+		RoutineCache<State> *blitCache;
+		MutexLock criticalSection;
+	};
+}
+
+#endif   // sw_Blitter_hpp
diff --git a/src/Device/Clipper.cpp b/src/Device/Clipper.cpp
new file mode 100644
index 0000000..a100f05
--- /dev/null
+++ b/src/Device/Clipper.cpp
@@ -0,0 +1,359 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Clipper.hpp"
+
+#include "Polygon.hpp"
+#include "Renderer.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	Clipper::Clipper(bool symmetricNormalizedDepth)
+	{
+		n = symmetricNormalizedDepth ? -1.0f : 0.0f;
+	}
+
+	Clipper::~Clipper()
+	{
+	}
+
+	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 < n * v.w) ? 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_USER)
+		{
+			int clipFlags = draw.clipFlags;
+			DrawData &data = *draw.data;
+
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE0) clipPlane(polygon, data.clipPlane[0]);
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE1) clipPlane(polygon, data.clipPlane[1]);
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE2) clipPlane(polygon, data.clipPlane[2]);
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE3) clipPlane(polygon, data.clipPlane[3]);
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE4) clipPlane(polygon, data.clipPlane[4]);
+			if(polygon.n >= 3) {
+			if(clipFlags & CLIP_PLANE5) clipPlane(polygon, data.clipPlane[5]);
+			}}}}}}
+		}
+
+		return polygon.n >= 3;
+	}
+
+	void Clipper::clipNear(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->z - n * V[i]->w;
+			float dj = V[j]->z - n * V[j]->w;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipFar(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->w - V[i]->z;
+			float dj = V[j]->w - V[j]->z;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipLeft(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->w + V[i]->x;
+			float dj = V[j]->w + V[j]->x;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipRight(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->w - V[i]->x;
+			float dj = V[j]->w - V[j]->x;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipTop(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->w - V[i]->y;
+			float dj = V[j]->w - V[j]->y;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipBottom(Polygon &polygon)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = V[i]->w + V[i]->y;
+			float dj = V[j]->w + V[j]->y;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	void Clipper::clipPlane(Polygon &polygon, const Plane &p)
+	{
+		const float4 **V = polygon.P[polygon.i];
+		const float4 **T = polygon.P[polygon.i + 1];
+
+		int t = 0;
+
+		for(int i = 0; i < polygon.n; i++)
+		{
+			int j = i == polygon.n - 1 ? 0 : i + 1;
+
+			float di = p.A * V[i]->x + p.B * V[i]->y + p.C * V[i]->z + p.D * V[i]->w;
+			float dj = p.A * V[j]->x + p.B * V[j]->y + p.C * V[j]->z + p.D * V[j]->w;
+
+			if(di >= 0)
+			{
+				T[t++] = V[i];
+
+				if(dj < 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[i], *V[j], di, dj);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+			else
+			{
+				if(dj > 0)
+				{
+					clipEdge(polygon.B[polygon.b], *V[j], *V[i], dj, di);
+					T[t++] = &polygon.B[polygon.b++];
+				}
+			}
+		}
+
+		polygon.n = t;
+		polygon.i += 1;
+	}
+
+	inline void Clipper::clipEdge(float4 &Vo, const float4 &Vi, const float4 &Vj, float di, float dj) const
+	{
+		float D = 1.0f / (dj - di);
+
+		Vo.x = (dj * Vi.x - di * Vj.x) * D;
+		Vo.y = (dj * Vi.y - di * Vj.y) * D;
+		Vo.z = (dj * Vi.z - di * Vj.z) * D;
+		Vo.w = (dj * Vi.w - di * Vj.w) * D;
+	}
+}
diff --git a/src/Device/Clipper.hpp b/src/Device/Clipper.hpp
new file mode 100644
index 0000000..057153a
--- /dev/null
+++ b/src/Device/Clipper.hpp
@@ -0,0 +1,77 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Clipper_hpp
+#define sw_Clipper_hpp
+
+#include "Plane.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	struct Polygon;
+	struct DrawCall;
+	struct DrawData;
+
+	class Clipper
+	{
+	public:
+		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_BOTTOM = 1 << 4,
+			CLIP_NEAR   = 1 << 5,
+
+			CLIP_FRUSTUM = 0x003F,
+
+			CLIP_FINITE = 1 << 7,   // All position coordinates are finite
+
+			// User-defined clipping planes
+			CLIP_PLANE0 = 1 << 8,
+			CLIP_PLANE1 = 1 << 9,
+			CLIP_PLANE2 = 1 << 10,
+			CLIP_PLANE3 = 1 << 11,
+			CLIP_PLANE4 = 1 << 12,
+			CLIP_PLANE5 = 1 << 13,
+
+			CLIP_USER = 0x3F00
+		};
+
+		Clipper(bool symmetricNormalizedDepth);
+
+		~Clipper();
+
+		unsigned int computeClipFlags(const float4 &v);
+		bool clip(Polygon &polygon, int clipFlagsOr, const DrawCall &draw);
+
+	private:
+		void clipNear(Polygon &polygon);
+		void clipFar(Polygon &polygon);
+		void clipLeft(Polygon &polygon);
+		void clipRight(Polygon &polygon);
+		void clipTop(Polygon &polygon);
+		void clipBottom(Polygon &polygon);
+		void clipPlane(Polygon &polygon, const Plane &plane);
+
+		void clipEdge(float4 &Vo, const float4 &Vi, const float4 &Vj, float di, float dj) const;
+
+		float n;   // Near clip plane distance
+	};
+}
+
+#endif   // sw_Clipper_hpp
diff --git a/src/Device/Color.cpp b/src/Device/Color.cpp
new file mode 100644
index 0000000..9ad6767
--- /dev/null
+++ b/src/Device/Color.cpp
@@ -0,0 +1,19 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Color.hpp"
+
+namespace sw
+{
+}
diff --git a/src/Device/Color.hpp b/src/Device/Color.hpp
new file mode 100644
index 0000000..7afe61f
--- /dev/null
+++ b/src/Device/Color.hpp
@@ -0,0 +1,472 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Color_hpp
+#define sw_Color_hpp
+
+#include "Common/Types.hpp"
+#include "Common/Math.hpp"
+
+namespace sw
+{
+	template<class T>
+	struct Color
+	{
+		Color();
+	
+		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;
+
+		T &operator[](int i);
+		const T &operator[](int i) const;
+
+		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*=(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);
+
+		template<class S>
+		friend Color<S> operator+(const Color<S> &c1, const Color<S> &c2);
+		template<class S>
+		friend Color<S> operator-(const Color<S> &c1, const Color<S> &c2);
+
+		template<class S>
+		friend Color<S> operator*(float l, const Color<S> &c);
+		template<class S>
+		friend Color<S> operator*(const Color<S> &c1, const Color<S> &c2);
+		template<class S>
+		friend Color<S> operator/(const Color<S> &c, float l);
+
+		T r;
+		T g;
+		T b;
+		T a;
+	};
+}
+
+#include "Common/Math.hpp"
+
+namespace sw
+{
+	template<class T>
+	inline Color<T>::Color()
+	{
+	}
+
+	template<>
+	inline Color<byte>::Color(const Color<byte> &c)
+	{
+		r = c.r;
+		g = c.g;
+		b = c.b;
+		a = c.a;
+	}
+
+	template<>
+	inline Color<byte>::Color(const Color<short> &c)
+	{
+		r = clamp(c.r >> 4, 0, 255);
+		g = clamp(c.g >> 4, 0, 255);
+		b = clamp(c.b >> 4, 0, 255);
+		a = clamp(c.a >> 4, 0, 255);
+	}
+
+	template<>
+	inline Color<byte>::Color(const Color<float> &c)
+	{
+		r = ifloor(clamp(c.r * 256.0f, 0.0f, 255.0f));
+		g = ifloor(clamp(c.g * 256.0f, 0.0f, 255.0f));
+		b = ifloor(clamp(c.b * 256.0f, 0.0f, 255.0f));
+		a = ifloor(clamp(c.a * 256.0f, 0.0f, 255.0f));
+	}
+
+	template<>
+	inline Color<short>::Color(const Color<short> &c)
+	{
+		r = c.r;
+		g = c.g;
+		b = c.b;
+		a = c.a;
+	}
+
+	template<>
+	inline Color<short>::Color(const Color<byte> &c)
+	{
+		r = c.r << 4;
+		g = c.g << 4;
+		b = c.b << 4;
+		a = c.a << 4;
+	}
+
+	template<>
+	inline Color<float>::Color(const Color<float> &c)
+	{
+		r = c.r;
+		g = c.g;
+		b = c.b;
+		a = c.a;
+	}
+
+	template<>
+	inline Color<short>::Color(const Color<float> &c)
+	{
+		r = iround(clamp(c.r * 4095.0f, -4096.0f, 4095.0f));
+		g = iround(clamp(c.g * 4095.0f, -4096.0f, 4095.0f));
+		b = iround(clamp(c.b * 4095.0f, -4096.0f, 4095.0f));
+		a = iround(clamp(c.a * 4095.0f, -4096.0f, 4095.0f));
+	}
+
+	template<>
+	inline Color<float>::Color(const Color<byte> &c)
+	{
+		r = c.r / 255.0f;
+		g = c.g / 255.0f;
+		b = c.b / 255.0f;
+		a = c.a / 255.0f;
+	}
+
+	template<>
+	inline Color<float>::Color(const Color<short> &c)
+	{
+		r = c.r / 4095.0f;
+		g = c.g / 4095.0f;
+		b = c.b / 4095.0f;
+		a = c.a / 4095.0f;
+	}
+
+	template<>
+	inline Color<float>::Color(unsigned short c)
+	{
+		r = (float)(c & 0xF800) / (float)0xF800;
+		g = (float)(c & 0x07E0) / (float)0x07E0;
+		b = (float)(c & 0x001F) / (float)0x001F;
+		a = 1;
+	}
+
+	template<>
+	inline Color<short>::Color(unsigned short c)
+	{
+		// 4.12 fixed-point format
+		r = ((c & 0xF800) >> 4) + ((c & 0xF800) >> 9) + ((c & 0xF800) >> 14);
+		g = ((c & 0x07E0) << 1) + ((c & 0x07E0) >> 5);
+		b = ((c & 0x001F) << 7) + ((c & 0x001F) << 2) + ((c & 0x001F) >> 3);
+		a = 0x1000;
+	}
+
+	template<>
+	inline Color<byte>::Color(unsigned short c)
+	{
+		r = (byte)(((c & 0xF800) >> 8) + ((c & 0xE000) >> 13));
+		g = (byte)(((c & 0x07E0) >> 3) + ((c & 0x0600) >> 9));
+		b = (byte)(((c & 0x001F) << 3) + ((c & 0x001C) >> 2));
+		a = 0xFF;
+	}
+
+	template<>
+	inline Color<float>::Color(int c)
+	{
+		const float d = 1.0f / 255.0f;
+
+		r = (float)((c & 0x00FF0000) >> 16) * d;
+		g = (float)((c & 0x0000FF00) >> 8) * d;
+		b = (float)((c & 0x000000FF) >> 0) * d;
+		a = (float)((c & 0xFF000000) >> 24) * d;
+	}
+
+	template<>
+	inline Color<short>::Color(int c)
+	{
+		// 4.12 fixed-point format
+		r = (short)((c & 0x00FF0000) >> 12);
+		g = (short)((c & 0x0000FF00) >> 4);
+		b = (short)((c & 0x000000FF) << 4);
+		a = (short)((c & 0xFF000000) >> 20);
+	}
+
+	template<>
+	inline Color<byte>::Color(int c)
+	{
+		r = (byte)((c & 0x00FF0000) >> 16);
+		g = (byte)((c & 0x0000FF00) >> 8);
+		b = (byte)((c & 0x000000FF) >> 0);
+		a = (byte)((c & 0xFF000000) >> 24);
+	}
+
+	template<>
+	inline Color<float>::Color(unsigned int c)
+	{
+		const float d = 1.0f / 255.0f;
+
+		r = (float)((c & 0x00FF0000) >> 16) * d;
+		g = (float)((c & 0x0000FF00) >> 8) * d;
+		b = (float)((c & 0x000000FF) >> 0) * d;
+		a = (float)((c & 0xFF000000) >> 24) * d;
+	}
+
+	template<>
+	inline Color<short>::Color(unsigned int c)
+	{
+		// 4.12 fixed-point format
+		r = (short)((c & 0x00FF0000) >> 12);
+		g = (short)((c & 0x0000FF00) >> 4);
+		b = (short)((c & 0x000000FF) << 4);
+		a = (short)((c & 0xFF000000) >> 20);
+	}
+
+	template<>
+	inline Color<byte>::Color(unsigned int c)
+	{
+		r = (byte)((c & 0x00FF0000) >> 16);
+		g = (byte)((c & 0x0000FF00) >> 8);
+		b = (byte)((c & 0x000000FF) >> 0);
+		a = (byte)((c & 0xFF000000) >> 24);
+	}
+
+	template<>
+	inline Color<float>::Color(unsigned long c)
+	{
+		const float d = 1.0f / 255.0f;
+
+		r = (float)((c & 0x00FF0000) >> 16) * d;
+		g = (float)((c & 0x0000FF00) >> 8) * d;
+		b = (float)((c & 0x000000FF) >> 0) * d;
+		a = (float)((c & 0xFF000000) >> 24) * d;
+	}
+
+	template<>
+	inline Color<short>::Color(unsigned long c)
+	{
+		// 4.12 fixed-point format
+		r = (short)((c & 0x00FF0000) >> 12);
+		g = (short)((c & 0x0000FF00) >> 4);
+		b = (short)((c & 0x000000FF) << 4);
+		a = (short)((c & 0xFF000000) >> 20);
+	}
+
+	template<>
+	inline Color<byte>::Color(unsigned long c)
+	{
+		r = (byte)((c & 0x00FF0000) >> 16);
+		g = (byte)((c & 0x0000FF00) >> 8);
+		b = (byte)((c & 0x000000FF) >> 0);
+		a = (byte)((c & 0xFF000000) >> 24);
+	}
+
+	template<class T>
+	inline Color<T>::Color(T r_, T g_, T b_, T a_)
+	{
+		r = r_;
+		g = g_;
+		b = b_;
+		a = a_;
+	}
+
+	template<>
+	inline Color<float>::operator unsigned int() const
+	{
+		return ((unsigned int)min(b * 255.0f, 255.0f) << 0) |
+		       ((unsigned int)min(g * 255.0f, 255.0f) << 8) |
+		       ((unsigned int)min(r * 255.0f, 255.0f) << 16) |
+		       ((unsigned int)min(a * 255.0f, 255.0f) << 24);
+	}
+
+	template<>
+	inline Color<short>::operator unsigned int() const
+	{
+		return ((unsigned int)min(b >> 4, 255) << 0) |
+		       ((unsigned int)min(g >> 4, 255) << 8) |
+		       ((unsigned int)min(r >> 4, 255) << 16) |
+		       ((unsigned int)min(a >> 4, 255) << 24);
+	}
+
+	template<>
+	inline Color<byte>::operator unsigned int() const
+	{
+		return (b << 0) +
+		       (g << 8) +
+		       (r << 16) +
+			   (a << 24);
+	}
+
+	template<class T>
+	inline T &Color<T>::operator[](int i)
+	{
+		return (&r)[i];
+	}
+
+	template<class T>
+	inline const T &Color<T>::operator[](int i) const
+	{
+		return (&r)[i];
+	}
+
+	template<class T>
+	inline Color<T> Color<T>::operator+() const
+	{
+		return *this;
+	}
+
+	template<class T>
+	inline Color<T> Color<T>::operator-() const
+	{
+		return Color(-r, -g, -b, -a);
+	}
+
+	template<class T>
+	inline Color<T> &Color<T>::operator=(const Color& c)
+	{
+		r = c.r;
+		g = c.g;
+		b = c.b;
+		a = c.a;
+
+		return *this;
+	}
+
+	template<class T>
+	inline Color<T> &Color<T>::operator+=(const Color &c)
+	{
+		r += c.r;
+		g += c.g;
+		b += c.b;
+		a += c.a;
+
+		return *this;
+	}
+
+	template<class T>
+	inline Color<T> &Color<T>::operator*=(float l)
+	{
+		*this = l * *this;
+
+		return *this;
+	}
+
+	template<class T>
+	inline Color<T> operator+(const Color<T> &c1, const Color<T> &c2)
+	{
+		return Color<T>(c1.r + c2.r,
+		                c1.g + c2.g,
+		                c1.b + c2.b,
+		                c1.a + c2.a);	
+	}
+
+	template<class T>
+	inline Color<T> operator-(const Color<T> &c1, const Color<T> &c2)
+	{
+		return Color<T>(c1.r - c2.r,
+		                c1.g - c2.g,
+		                c1.b - c2.b,
+		                c1.a - c2.a);	
+	}
+
+	template<class T>
+	inline Color<T> operator*(float l, const Color<T> &c)
+	{
+		T r = (T)(l * c.r);
+		T g = (T)(l * c.g);
+		T b = (T)(l * c.b);
+		T a = (T)(l * c.a);
+
+		return Color<T>(r, g, b, a);
+	}
+
+	template<class T>
+	inline Color<T> operator*(const Color<T> &c1, const Color<T> &c2)
+	{
+		T r = c1.r * c2.r;
+		T g = c1.g * c2.g;
+		T b = c1.b * c2.b;
+		T a = c1.a * c2.a;
+
+		return Color<T>(r, g, b, a);
+	}
+
+	template<>
+	inline Color<short> operator*(const Color<short> &c1, const Color<short> &c2)
+	{
+		short r = c1.r * c2.r >> 12;
+		short g = c1.g * c2.g >> 12;
+		short b = c1.b * c2.b >> 12;
+		short a = c1.a * c2.a >> 12;
+
+		return Color<short>(r, g, b, a);
+	}
+
+	template<>
+	inline Color<byte> operator*(const Color<byte> &c1, const Color<byte> &c2)
+	{
+		byte r = c1.r * c2.r >> 8;
+		byte g = c1.g * c2.g >> 8;
+		byte b = c1.b * c2.b >> 8;
+		byte a = c1.a * c2.a >> 8;
+
+		return Color<byte>(r, g, b, a);
+	}
+
+	template<class T>
+	inline Color<T> operator/(const Color<T> &c, float l)
+	{
+		l = 1.0f / l; 
+
+		T r = (T)(l * c.r);
+		T g = (T)(l * c.g);
+		T b = (T)(l * c.b);
+		T a = (T)(l * c.a);
+
+		return Color<T>(r, g, b, a);
+	}
+
+	template<class T>
+	inline Color<T> Color<T>::gradient(const Color<T> &c1, const Color<T> &c2, float d)
+	{
+		d = 1.0f / d; 
+
+		T r = (c2.r - c1.r) * d;
+		T g = (c2.g - c1.g) * d;
+		T b = (c2.b - c1.b) * d;
+		T a = (c2.a - c1.a) * d;
+
+		return Color<T>(r, g, b, a);
+	}
+
+	template<class T>
+	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));
+		T b = c1.b + (T)(d * (c2.b - c1.b));
+		T a = c1.a + (T)(d * (c2.a - c1.a));
+
+		return Color<T>(r, g, b, a);
+	}
+}
+
+#endif   // sw_Color_hpp
diff --git a/src/Device/Config.cpp b/src/Device/Config.cpp
new file mode 100644
index 0000000..7cb309a
--- /dev/null
+++ b/src/Device/Config.cpp
@@ -0,0 +1,82 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Config.hpp"
+
+#include "Common/Thread.hpp"
+#include "Common/Timer.hpp"
+
+namespace sw
+{
+	Profiler profiler;
+
+	Profiler::Profiler()
+	{
+		reset();
+	}
+
+	void Profiler::reset()
+	{
+		framesSec = 0;
+		framesTotal = 0;
+		FPS = 0;
+
+		#if PERF_PROFILE
+			for(int i = 0; i < PERF_TIMERS; i++)
+			{
+				cycles[i] = 0;
+			}
+
+			ropOperations = 0;
+			ropOperationsTotal = 0;
+			ropOperationsFrame = 0;
+
+			texOperations = 0;
+			texOperationsTotal = 0;
+			texOperationsFrame = 0;
+
+			compressedTex = 0;
+			compressedTexTotal = 0;
+			compressedTexFrame = 0;
+		#endif
+	};
+
+	void Profiler::nextFrame()
+	{
+		#if PERF_PROFILE
+			ropOperationsFrame = sw::atomicExchange(&ropOperations, 0);
+			texOperationsFrame = sw::atomicExchange(&texOperations, 0);
+			compressedTexFrame = sw::atomicExchange(&compressedTex, 0);
+
+			ropOperationsTotal += ropOperationsFrame;
+			texOperationsTotal += texOperationsFrame;
+			compressedTexTotal += compressedTexFrame;
+		#endif
+
+		static double fpsTime = sw::Timer::seconds();
+
+		double time = sw::Timer::seconds();
+		double delta = time - fpsTime;
+		framesSec++;
+
+		if(delta > 1.0)
+		{
+			FPS = framesSec / delta;
+
+			fpsTime = time;
+			framesTotal += framesSec;
+			framesSec = 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Device/Config.hpp b/src/Device/Config.hpp
new file mode 100644
index 0000000..017e38b
--- /dev/null
+++ b/src/Device/Config.hpp
@@ -0,0 +1,103 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Config_hpp
+#define sw_Config_hpp
+
+#include "Common/Types.hpp"
+
+#define PERF_HUD 0       // Display time spent on vertex, setup and pixel processing for each thread
+#define PERF_PROFILE 0   // Profile various pipeline stages and display the timing in SwiftConfig
+
+#define ASTC_SUPPORT 0
+
+// Worker thread count when not set by SwiftConfig
+// 0 = process affinity count (recommended)
+// 1 = rendering on main thread (no worker threads), useful for debugging
+#ifndef DEFAULT_THREAD_COUNT
+#define DEFAULT_THREAD_COUNT 0
+#endif
+
+namespace sw
+{
+	enum
+	{
+		PERF_PIXEL,
+		PERF_PIPE,
+		PERF_INTERP,
+		PERF_SHADER,
+		PERF_TEX,
+		PERF_ROP,
+
+		PERF_TIMERS
+	};
+
+	struct Profiler
+	{
+		Profiler();
+
+		void reset();
+		void nextFrame();
+
+		int framesSec;
+		int framesTotal;
+		double FPS;
+
+		#if PERF_PROFILE
+		double cycles[PERF_TIMERS];
+
+		int64_t ropOperations;
+		int64_t ropOperationsTotal;
+		int64_t ropOperationsFrame;
+
+		int64_t texOperations;
+		int64_t texOperationsTotal;
+		int64_t texOperationsFrame;
+
+		int64_t compressedTex;
+		int64_t compressedTexTotal;
+		int64_t compressedTexFrame;
+		#endif
+	};
+
+	extern Profiler profiler;
+
+	enum
+	{
+		OUTLINE_RESOLUTION = 8192,   // Maximum vertical resolution of the render target
+		MIPMAP_LEVELS = 14,
+		TEXTURE_IMAGE_UNITS = 16,
+		VERTEX_TEXTURE_IMAGE_UNITS = 16,
+		TOTAL_IMAGE_UNITS = TEXTURE_IMAGE_UNITS + VERTEX_TEXTURE_IMAGE_UNITS,
+		FRAGMENT_UNIFORM_VECTORS = 264,
+		VERTEX_UNIFORM_VECTORS = 259,
+		MAX_VERTEX_INPUTS = 32,
+		MAX_VERTEX_OUTPUTS = 34,
+		MAX_FRAGMENT_INPUTS = 32,
+		MAX_FRAGMENT_UNIFORM_BLOCKS = 12,
+		MAX_VERTEX_UNIFORM_BLOCKS = 12,
+		MAX_UNIFORM_BUFFER_BINDINGS = MAX_FRAGMENT_UNIFORM_BLOCKS + MAX_VERTEX_UNIFORM_BLOCKS,   // Limited to 127 by SourceParameter.bufferIndex in Shader.hpp
+		MAX_UNIFORM_BLOCK_SIZE = 16384,
+		MAX_CLIP_PLANES = 6,
+		MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 64,
+		MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 64,
+		MIN_PROGRAM_TEXEL_OFFSET = -8,
+		MAX_PROGRAM_TEXEL_OFFSET = 7,
+		MAX_TEXTURE_LOD = MIPMAP_LEVELS - 2,   // Trilinear accesses lod+1
+		RENDERTARGETS = 8,
+		NUM_TEMPORARY_REGISTERS = 4096,
+	};
+}
+
+#endif   // sw_Config_hpp
diff --git a/src/Device/Context.cpp b/src/Device/Context.cpp
new file mode 100644
index 0000000..25c5775
--- /dev/null
+++ b/src/Device/Context.cpp
@@ -0,0 +1,1496 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Context.hpp"
+
+#include "Primitive.hpp"
+#include "Surface.hpp"
+#include "Shader/PixelShader.hpp"
+#include "Shader/VertexShader.hpp"
+#include "Common/Memory.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	extern bool perspectiveCorrection;
+
+	bool halfIntegerCoordinates = false;     // Pixel centers are not at integer coordinates
+	bool symmetricNormalizedDepth = false;   // [-1, 1] instead of [0, 1]
+	bool booleanFaceRegister = false;
+	bool fullPixelPositionRegister = false;
+	bool leadingVertexFirst = false;         // Flat shading uses first vertex, else last
+	bool secondaryColor = false;             // Specular lighting is applied after texturing
+	bool colorsDefaultToZero = false;
+
+	bool forceWindowed = false;
+	bool quadLayoutEnabled = false;
+	bool veryEarlyDepthTest = true;
+	bool complementaryDepthBuffer = false;
+	bool postBlendSRGB = false;
+	bool exactColorRounding = false;
+	TransparencyAntialiasing transparencyAntialiasing = TRANSPARENCY_NONE;
+	bool forceClearRegisters = false;
+
+	Context::Context()
+	{
+		init();
+	}
+
+	Context::~Context()
+	{
+	}
+
+	void *Context::operator new(size_t bytes)
+	{
+		return allocate((unsigned int)bytes);
+	}
+
+	void Context::operator delete(void *pointer, size_t bytes)
+	{
+		deallocate(pointer);
+	}
+
+	bool Context::isDrawPoint(bool fillModeAware) const
+	{
+		switch(drawType)
+		{
+		case DRAW_POINTLIST:
+		case DRAW_INDEXEDPOINTLIST8:
+		case DRAW_INDEXEDPOINTLIST16:
+		case DRAW_INDEXEDPOINTLIST32:
+			return true;
+		case DRAW_LINELIST:
+		case DRAW_LINESTRIP:
+		case DRAW_LINELOOP:
+		case DRAW_INDEXEDLINELIST8:
+		case DRAW_INDEXEDLINESTRIP8:
+		case DRAW_INDEXEDLINELOOP8:
+		case DRAW_INDEXEDLINELIST16:
+		case DRAW_INDEXEDLINESTRIP16:
+		case DRAW_INDEXEDLINELOOP16:
+		case DRAW_INDEXEDLINELIST32:
+		case DRAW_INDEXEDLINESTRIP32:
+		case DRAW_INDEXEDLINELOOP32:
+			return false;
+		case DRAW_TRIANGLELIST:
+		case DRAW_TRIANGLESTRIP:
+		case DRAW_TRIANGLEFAN:
+		case DRAW_INDEXEDTRIANGLELIST8:
+		case DRAW_INDEXEDTRIANGLESTRIP8:
+		case DRAW_INDEXEDTRIANGLEFAN8:
+		case DRAW_INDEXEDTRIANGLELIST16:
+		case DRAW_INDEXEDTRIANGLESTRIP16:
+		case DRAW_INDEXEDTRIANGLEFAN16:
+		case DRAW_INDEXEDTRIANGLELIST32:
+		case DRAW_INDEXEDTRIANGLESTRIP32:
+		case DRAW_INDEXEDTRIANGLEFAN32:
+			return fillModeAware ? fillMode == FILL_VERTEX : false;
+		case DRAW_QUADLIST:
+			return false;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool Context::isDrawLine(bool fillModeAware) const
+	{
+		switch(drawType)
+		{
+		case DRAW_POINTLIST:
+		case DRAW_INDEXEDPOINTLIST8:
+		case DRAW_INDEXEDPOINTLIST16:
+		case DRAW_INDEXEDPOINTLIST32:
+			return false;
+		case DRAW_LINELIST:
+		case DRAW_LINESTRIP:
+		case DRAW_LINELOOP:
+		case DRAW_INDEXEDLINELIST8:
+		case DRAW_INDEXEDLINESTRIP8:
+		case DRAW_INDEXEDLINELOOP8:
+		case DRAW_INDEXEDLINELIST16:
+		case DRAW_INDEXEDLINESTRIP16:
+		case DRAW_INDEXEDLINELOOP16:
+		case DRAW_INDEXEDLINELIST32:
+		case DRAW_INDEXEDLINESTRIP32:
+		case DRAW_INDEXEDLINELOOP32:
+			return true;
+		case DRAW_TRIANGLELIST:
+		case DRAW_TRIANGLESTRIP:
+		case DRAW_TRIANGLEFAN:
+		case DRAW_INDEXEDTRIANGLELIST8:
+		case DRAW_INDEXEDTRIANGLESTRIP8:
+		case DRAW_INDEXEDTRIANGLEFAN8:
+		case DRAW_INDEXEDTRIANGLELIST16:
+		case DRAW_INDEXEDTRIANGLESTRIP16:
+		case DRAW_INDEXEDTRIANGLEFAN16:
+		case DRAW_INDEXEDTRIANGLELIST32:
+		case DRAW_INDEXEDTRIANGLESTRIP32:
+		case DRAW_INDEXEDTRIANGLEFAN32:
+			return fillModeAware ? fillMode == FILL_WIREFRAME : false;
+		case DRAW_QUADLIST:
+			return false;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool Context::isDrawTriangle(bool fillModeAware) const
+	{
+		switch(drawType)
+		{
+		case DRAW_POINTLIST:
+		case DRAW_INDEXEDPOINTLIST8:
+		case DRAW_INDEXEDPOINTLIST16:
+		case DRAW_INDEXEDPOINTLIST32:
+			return false;
+		case DRAW_LINELIST:
+		case DRAW_LINESTRIP:
+		case DRAW_LINELOOP:
+		case DRAW_INDEXEDLINELIST8:
+		case DRAW_INDEXEDLINESTRIP8:
+		case DRAW_INDEXEDLINELOOP8:
+		case DRAW_INDEXEDLINELIST16:
+		case DRAW_INDEXEDLINESTRIP16:
+		case DRAW_INDEXEDLINELOOP16:
+		case DRAW_INDEXEDLINELIST32:
+		case DRAW_INDEXEDLINESTRIP32:
+		case DRAW_INDEXEDLINELOOP32:
+			return false;
+		case DRAW_TRIANGLELIST:
+		case DRAW_TRIANGLESTRIP:
+		case DRAW_TRIANGLEFAN:
+		case DRAW_INDEXEDTRIANGLELIST8:
+		case DRAW_INDEXEDTRIANGLESTRIP8:
+		case DRAW_INDEXEDTRIANGLEFAN8:
+		case DRAW_INDEXEDTRIANGLELIST16:
+		case DRAW_INDEXEDTRIANGLESTRIP16:
+		case DRAW_INDEXEDTRIANGLEFAN16:
+		case DRAW_INDEXEDTRIANGLELIST32:
+		case DRAW_INDEXEDTRIANGLESTRIP32:
+		case DRAW_INDEXEDTRIANGLEFAN32:
+			return fillModeAware ? fillMode == FILL_SOLID : true;
+		case DRAW_QUADLIST:
+			// Quads are broken up into triangles
+			return fillModeAware ? fillMode == FILL_SOLID : true;
+		default:
+			ASSERT(false);
+		}
+
+		return true;
+	}
+
+	void Context::init()
+	{
+		for(int i = 0; i < 8; i++)
+		{
+			textureStage[i].init(i, &sampler[i], (i >= 1) ? &textureStage[i - 1] : 0);
+		}
+
+		// Set vertex streams to null stream
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			input[i].defaults();
+		}
+
+		fogStart = 0.0f;
+		fogEnd = 1.0f;
+
+		for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++) textureWrap[i] = 0;
+		for(int i = 0; i < 8; i++) texGen[i] = TEXGEN_PASSTHRU;
+		for(int i = 0; i < 8; i++) textureTransformCount[i] = 0;
+		for(int i = 0; i < 8; i++) textureTransformProject[i] = false;
+		textureWrapActive = false;
+		localViewer = true;
+		normalizeNormals = false;
+
+		for(int i = 0; i < RENDERTARGETS; ++i)
+		{
+			renderTarget[i] = nullptr;
+		}
+		depthBuffer = nullptr;
+		stencilBuffer = nullptr;
+
+		stencilEnable = false;
+		stencilCompareMode = STENCIL_ALWAYS;
+		stencilReference = 0;
+		stencilMask = 0xFFFFFFFF;
+		stencilFailOperation = OPERATION_KEEP;
+		stencilPassOperation = OPERATION_KEEP;
+		stencilZFailOperation = OPERATION_KEEP;
+		stencilWriteMask = 0xFFFFFFFF;
+
+		twoSidedStencil = false;
+		stencilCompareModeCCW = STENCIL_ALWAYS;
+		stencilReferenceCCW = 0;
+		stencilMaskCCW = 0xFFFFFFFF;
+		stencilFailOperationCCW = OPERATION_KEEP;
+		stencilPassOperationCCW = OPERATION_KEEP;
+		stencilZFailOperationCCW = OPERATION_KEEP;
+		stencilWriteMaskCCW = 0xFFFFFFFF;
+
+		setGlobalMipmapBias(0);
+
+		lightingEnable = true;
+		specularEnable = false;
+		for(int i = 0; i < 8; i++) lightEnable[i] = false;
+		for(int i = 0; i < 8; i++) worldLightPosition[i] = 0;
+
+		alphaCompareMode = ALPHA_ALWAYS;
+		alphaTestEnable = false;
+		fillMode = FILL_SOLID;
+		shadingMode = SHADING_GOURAUD;
+
+		rasterizerDiscard = false;
+
+		depthCompareMode = DEPTH_LESS;
+		depthBufferEnable = true;
+		depthWriteEnable = true;
+
+		alphaBlendEnable = false;
+		sourceBlendFactorState = BLEND_ONE;
+		destBlendFactorState = BLEND_ZERO;
+		blendOperationState = BLENDOP_ADD;
+
+		separateAlphaBlendEnable = false;
+		sourceBlendFactorStateAlpha = BLEND_ONE;
+		destBlendFactorStateAlpha = BLEND_ZERO;
+		blendOperationStateAlpha = BLENDOP_ADD;
+
+		cullMode = CULL_CLOCKWISE;
+		frontFacingCCW = true;
+		alphaReference = 0.0f;
+
+		depthBias = 0.0f;
+		slopeDepthBias = 0.0f;
+
+		for(int i = 0; i < RENDERTARGETS; i++)
+		{
+			colorWriteMask[i] = 0x0000000F;
+		}
+
+		ambientMaterialSource = MATERIAL_MATERIAL;
+		diffuseMaterialSource = MATERIAL_COLOR1;
+		specularMaterialSource = MATERIAL_COLOR2;
+		emissiveMaterialSource = MATERIAL_MATERIAL;
+		colorVertexEnable = true;
+
+		fogEnable = false;
+		pixelFogMode = FOG_NONE;
+		vertexFogMode = FOG_NONE;
+		wBasedFog = false;
+		rangeFogEnable = false;
+
+		indexedVertexBlendEnable = false;
+		vertexBlendMatrixCount = 0;
+
+		pixelShader = 0;
+		vertexShader = 0;
+
+		instanceID = 0;
+
+		occlusionEnabled = false;
+		transformFeedbackQueryEnabled = false;
+		transformFeedbackEnabled = 0;
+
+		pointSpriteEnable = false;
+		pointScaleEnable = false;
+		lineWidth = 1.0f;
+
+		writeSRGB = false;
+		sampleMask = 0xFFFFFFFF;
+
+		colorLogicOpEnabled = false;
+		logicalOperation = LOGICALOP_COPY;
+	}
+
+	const float &Context::exp2Bias()
+	{
+		return bias;
+	}
+
+	const Point &Context::getLightPosition(int light)
+	{
+		return worldLightPosition[light];
+	}
+
+	void Context::setGlobalMipmapBias(float bias)
+	{
+		this->bias = exp2(bias + 0.5f);
+	}
+
+	void Context::setLightingEnable(bool lightingEnable)
+	{
+		this->lightingEnable = lightingEnable;
+	}
+
+	void Context::setSpecularEnable(bool specularEnable)
+	{
+		Context::specularEnable = specularEnable;
+	}
+
+	void Context::setLightEnable(int light, bool lightEnable)
+	{
+		Context::lightEnable[light] = lightEnable;
+	}
+
+	void Context::setLightPosition(int light, Point worldLightPosition)
+	{
+		Context::worldLightPosition[light] = worldLightPosition;
+	}
+
+	void Context::setAmbientMaterialSource(MaterialSource ambientMaterialSource)
+	{
+		Context::ambientMaterialSource = ambientMaterialSource;
+	}
+
+	void Context::setDiffuseMaterialSource(MaterialSource diffuseMaterialSource)
+	{
+		Context::diffuseMaterialSource = diffuseMaterialSource;
+	}
+
+	void Context::setSpecularMaterialSource(MaterialSource specularMaterialSource)
+	{
+		Context::specularMaterialSource = specularMaterialSource;
+	}
+
+	void Context::setEmissiveMaterialSource(MaterialSource emissiveMaterialSource)
+	{
+		Context::emissiveMaterialSource = emissiveMaterialSource;
+	}
+
+	void Context::setPointSpriteEnable(bool pointSpriteEnable)
+	{
+		Context::pointSpriteEnable = pointSpriteEnable;
+	}
+
+	void Context::setPointScaleEnable(bool pointScaleEnable)
+	{
+		Context::pointScaleEnable = pointScaleEnable;
+	}
+
+	bool Context::setDepthBufferEnable(bool depthBufferEnable)
+	{
+		bool modified = (Context::depthBufferEnable != depthBufferEnable);
+		Context::depthBufferEnable = depthBufferEnable;
+		return modified;
+	}
+
+	bool Context::setAlphaBlendEnable(bool alphaBlendEnable)
+	{
+		bool modified = (Context::alphaBlendEnable != alphaBlendEnable);
+		Context::alphaBlendEnable = alphaBlendEnable;
+		return modified;
+	}
+
+	bool Context::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+	{
+		bool modified = (Context::sourceBlendFactorState != sourceBlendFactor);
+		Context::sourceBlendFactorState = sourceBlendFactor;
+		return modified;
+	}
+
+	bool Context::setDestBlendFactor(BlendFactor destBlendFactor)
+	{
+		bool modified = (Context::destBlendFactorState != destBlendFactor);
+		Context::destBlendFactorState = destBlendFactor;
+		return modified;
+	}
+
+	bool Context::setBlendOperation(BlendOperation blendOperation)
+	{
+		bool modified = (Context::blendOperationState != blendOperation);
+		Context::blendOperationState = blendOperation;
+		return modified;
+	}
+
+	bool Context::setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable)
+	{
+		bool modified = (Context::separateAlphaBlendEnable != separateAlphaBlendEnable);
+		Context::separateAlphaBlendEnable = separateAlphaBlendEnable;
+		return modified;
+	}
+
+	bool Context::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+	{
+		bool modified = (Context::sourceBlendFactorStateAlpha != sourceBlendFactorAlpha);
+		Context::sourceBlendFactorStateAlpha = sourceBlendFactorAlpha;
+		return modified;
+	}
+
+	bool Context::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+	{
+		bool modified = (Context::destBlendFactorStateAlpha != destBlendFactorAlpha);
+		Context::destBlendFactorStateAlpha = destBlendFactorAlpha;
+		return modified;
+	}
+
+	bool Context::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+	{
+		bool modified = (Context::blendOperationStateAlpha != blendOperationAlpha);
+		Context::blendOperationStateAlpha = blendOperationAlpha;
+		return modified;
+	}
+
+	bool Context::setColorWriteMask(int index, int colorWriteMask)
+	{
+		bool modified = (Context::colorWriteMask[index] != colorWriteMask);
+		Context::colorWriteMask[index] = colorWriteMask;
+		return modified;
+	}
+
+	bool Context::setWriteSRGB(bool sRGB)
+	{
+		bool modified = (Context::writeSRGB != sRGB);
+		Context::writeSRGB = sRGB;
+		return modified;
+	}
+
+	bool Context::setColorLogicOpEnabled(bool enabled)
+	{
+		bool modified = (Context::colorLogicOpEnabled != enabled);
+		Context::colorLogicOpEnabled = enabled;
+		return modified;
+	}
+
+	bool Context::setLogicalOperation(LogicalOperation logicalOperation)
+	{
+		bool modified = (Context::logicalOperation != logicalOperation);
+		Context::logicalOperation = logicalOperation;
+		return modified;
+	}
+
+	void Context::setColorVertexEnable(bool colorVertexEnable)
+	{
+		Context::colorVertexEnable = colorVertexEnable;
+	}
+
+	bool Context::fogActive()
+	{
+		if(!colorUsed()) return false;
+
+		if(pixelShaderModel() >= 0x0300) return false;
+
+		return fogEnable;
+	}
+
+	bool Context::pointSizeActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return isDrawPoint(true) && (input[PointSize] || (!preTransformed && pointScaleActive()));
+	}
+
+	FogMode Context::pixelFogActive()
+	{
+		if(fogActive())
+		{
+			return pixelFogMode;
+		}
+
+		return FOG_NONE;
+	}
+
+	bool Context::depthWriteActive()
+	{
+		if(!depthBufferActive()) return false;
+
+		return depthWriteEnable;
+	}
+
+	bool Context::alphaTestActive()
+	{
+		if(transparencyAntialiasing != TRANSPARENCY_NONE) return true;
+		if(!alphaTestEnable) return false;
+		if(alphaCompareMode == ALPHA_ALWAYS) return false;
+		if(alphaReference == 0.0f && alphaCompareMode == ALPHA_GREATEREQUAL) return false;
+
+		return true;
+	}
+
+	bool Context::depthBufferActive()
+	{
+		return depthBuffer && depthBufferEnable;
+	}
+
+	bool Context::stencilActive()
+	{
+		return stencilBuffer && stencilEnable;
+	}
+
+	bool Context::vertexLightingActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return lightingEnable && !preTransformed;
+	}
+
+	bool Context::texCoordActive(int coordinate, int component)
+	{
+		bool hasTexture = pointSpriteActive();
+
+		if(vertexShader)
+		{
+			if(!preTransformed)
+			{
+				if(vertexShader->getOutput(T0 + coordinate, component).usage == Shader::USAGE_TEXCOORD)
+				{
+					hasTexture = true;
+				}
+			}
+			else
+			{
+				hasTexture = true;   // FIXME: Check vertex buffer streams
+			}
+		}
+		else
+		{
+			switch(texGen[coordinate])
+			{
+			case TEXGEN_NONE:
+				hasTexture = true;
+				break;
+			case TEXGEN_PASSTHRU:
+				hasTexture = hasTexture || (component < input[TexCoord0 + textureStage[coordinate].texCoordIndex].count);
+				break;
+			case TEXGEN_NORMAL:
+				hasTexture = hasTexture || (component <= 2);
+				break;
+			case TEXGEN_POSITION:
+				hasTexture = hasTexture || (component <= 2);
+				break;
+			case TEXGEN_REFLECTION:
+				hasTexture = hasTexture || (component <= 2);
+				break;
+			case TEXGEN_SPHEREMAP:
+				hasTexture = hasTexture || (component <= 1);
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+
+		bool project = isProjectionComponent(coordinate, component);
+		bool usesTexture = false;
+
+		if(pixelShader)
+		{
+			usesTexture = pixelShader->usesTexture(coordinate, component) || project;
+		}
+		else
+		{
+			usesTexture = textureStage[coordinate].usesTexture() || project;
+		}
+
+		return hasTexture && usesTexture;
+	}
+
+	bool Context::texCoordActive(int coordinate)
+	{
+		return texCoordActive(coordinate, 0) ||
+		       texCoordActive(coordinate, 1) ||
+		       texCoordActive(coordinate, 2) ||
+		       texCoordActive(coordinate, 3);
+	}
+
+	bool Context::isProjectionComponent(unsigned int coordinate, int component)
+	{
+		if(pixelShaderModel() <= 0x0103 && coordinate < 8 && textureTransformProject[coordinate])
+		{
+			if(textureTransformCount[coordinate] == 2)
+			{
+				if(component == 1) return true;
+			}
+			else if(textureTransformCount[coordinate] == 3)
+			{
+				if(component == 2) return true;
+			}
+			else if(textureTransformCount[coordinate] == 4 || textureTransformCount[coordinate] == 0)
+			{
+				if(component == 3) return true;
+			}
+		}
+
+		return false;
+	}
+
+	bool Context::vertexSpecularActive()
+	{
+		return vertexLightingActive() && specularEnable && vertexNormalActive();
+	}
+
+	bool Context::vertexNormalActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return input[Normal];
+	}
+
+	bool Context::vertexLightActive(int i)
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return lightingEnable && lightEnable[i];
+	}
+
+	MaterialSource Context::vertexDiffuseMaterialSourceActive()
+	{
+		if(vertexShader)
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		if(diffuseMaterialSource == MATERIAL_MATERIAL || !colorVertexEnable ||
+		   (diffuseMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
+		   (diffuseMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		return diffuseMaterialSource;
+	}
+
+	MaterialSource Context::vertexSpecularMaterialSourceActive()
+	{
+		if(vertexShader)
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		if(!colorVertexEnable ||
+		   (specularMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
+		   (specularMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		return specularMaterialSource;
+	}
+
+	MaterialSource Context::vertexAmbientMaterialSourceActive()
+	{
+		if(vertexShader)
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		if(!colorVertexEnable ||
+		   (ambientMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
+		   (ambientMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		return ambientMaterialSource;
+	}
+
+	MaterialSource Context::vertexEmissiveMaterialSourceActive()
+	{
+		if(vertexShader)
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		if(!colorVertexEnable ||
+		   (emissiveMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
+		   (emissiveMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
+		{
+			return MATERIAL_MATERIAL;
+		}
+
+		return emissiveMaterialSource;
+	}
+
+	bool Context::pointSpriteActive()
+	{
+		return isDrawPoint(true) && pointSpriteEnable;
+	}
+
+	bool Context::pointScaleActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return isDrawPoint(true) && pointScaleEnable;
+	}
+
+	bool Context::alphaBlendActive()
+	{
+		if(!alphaBlendEnable)
+		{
+			return false;
+		}
+
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		bool colorBlend = !(blendOperation() == BLENDOP_SOURCE && sourceBlendFactor() == BLEND_ONE);
+		bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == BLENDOP_SOURCE && sourceBlendFactorAlpha() == BLEND_ONE) : colorBlend;
+
+		return colorBlend || alphaBlend;
+	}
+
+	LogicalOperation Context::colorLogicOp()
+	{
+		return colorLogicOpEnabled ? logicalOperation : LOGICALOP_COPY;
+	}
+
+	BlendFactor Context::sourceBlendFactor()
+	{
+		if(!alphaBlendEnable) return BLEND_ONE;
+
+		switch(blendOperationState)
+		{
+		case BLENDOP_ADD:
+		case BLENDOP_SUB:
+		case BLENDOP_INVSUB:
+			return sourceBlendFactorState;
+		case BLENDOP_MIN:
+			return BLEND_ONE;
+		case BLENDOP_MAX:
+			return BLEND_ONE;
+		default:
+			ASSERT(false);
+		}
+
+		return sourceBlendFactorState;
+	}
+
+	BlendFactor Context::destBlendFactor()
+	{
+		if(!alphaBlendEnable) return BLEND_ZERO;
+
+		switch(blendOperationState)
+		{
+		case BLENDOP_ADD:
+		case BLENDOP_SUB:
+		case BLENDOP_INVSUB:
+			return destBlendFactorState;
+		case BLENDOP_MIN:
+			return BLEND_ONE;
+		case BLENDOP_MAX:
+			return BLEND_ONE;
+		default:
+			ASSERT(false);
+		}
+
+		return destBlendFactorState;
+	}
+
+	BlendOperation Context::blendOperation()
+	{
+		if(!alphaBlendEnable) return BLENDOP_SOURCE;
+
+		switch(blendOperationState)
+		{
+		case BLENDOP_ADD:
+			if(sourceBlendFactor() == BLEND_ZERO)
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_NULL;
+				}
+				else
+				{
+					return BLENDOP_DEST;
+				}
+			}
+			else if(sourceBlendFactor() == BLEND_ONE)
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_SOURCE;
+				}
+				else
+				{
+					return BLENDOP_ADD;
+				}
+			}
+			else
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_SOURCE;
+				}
+				else
+				{
+					return BLENDOP_ADD;
+				}
+			}
+		case BLENDOP_SUB:
+			if(sourceBlendFactor() == BLEND_ZERO)
+			{
+				return BLENDOP_NULL;   // Negative, clamped to zero
+			}
+			else if(sourceBlendFactor() == BLEND_ONE)
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_SOURCE;
+				}
+				else
+				{
+					return BLENDOP_SUB;
+				}
+			}
+			else
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_SOURCE;
+				}
+				else
+				{
+					return BLENDOP_SUB;
+				}
+			}
+		case BLENDOP_INVSUB:
+			if(sourceBlendFactor() == BLEND_ZERO)
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_NULL;
+				}
+				else
+				{
+					return BLENDOP_DEST;
+				}
+			}
+			else if(sourceBlendFactor() == BLEND_ONE)
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_NULL;   // Negative, clamped to zero
+				}
+				else
+				{
+					return BLENDOP_INVSUB;
+				}
+			}
+			else
+			{
+				if(destBlendFactor() == BLEND_ZERO)
+				{
+					return BLENDOP_NULL;   // Negative, clamped to zero
+				}
+				else
+				{
+					return BLENDOP_INVSUB;
+				}
+			}
+		case BLENDOP_MIN:
+			return BLENDOP_MIN;
+		case BLENDOP_MAX:
+			return BLENDOP_MAX;
+		default:
+			ASSERT(false);
+		}
+
+		return blendOperationState;
+	}
+
+	BlendFactor Context::sourceBlendFactorAlpha()
+	{
+		if(!separateAlphaBlendEnable)
+		{
+			return sourceBlendFactor();
+		}
+		else
+		{
+			switch(blendOperationStateAlpha)
+			{
+			case BLENDOP_ADD:
+			case BLENDOP_SUB:
+			case BLENDOP_INVSUB:
+				return sourceBlendFactorStateAlpha;
+			case BLENDOP_MIN:
+				return BLEND_ONE;
+			case BLENDOP_MAX:
+				return BLEND_ONE;
+			default:
+				ASSERT(false);
+			}
+
+			return sourceBlendFactorStateAlpha;
+		}
+	}
+
+	BlendFactor Context::destBlendFactorAlpha()
+	{
+		if(!separateAlphaBlendEnable)
+		{
+			return destBlendFactor();
+		}
+		else
+		{
+			switch(blendOperationStateAlpha)
+			{
+			case BLENDOP_ADD:
+			case BLENDOP_SUB:
+			case BLENDOP_INVSUB:
+				return destBlendFactorStateAlpha;
+			case BLENDOP_MIN:
+				return BLEND_ONE;
+			case BLENDOP_MAX:
+				return BLEND_ONE;
+			default:
+				ASSERT(false);
+			}
+
+			return destBlendFactorStateAlpha;
+		}
+	}
+
+	BlendOperation Context::blendOperationAlpha()
+	{
+		if(!separateAlphaBlendEnable)
+		{
+			return blendOperation();
+		}
+		else
+		{
+			switch(blendOperationStateAlpha)
+			{
+			case BLENDOP_ADD:
+				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_NULL;
+					}
+					else
+					{
+						return BLENDOP_DEST;
+					}
+				}
+				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_SOURCE;
+					}
+					else
+					{
+						return BLENDOP_ADD;
+					}
+				}
+				else
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_SOURCE;
+					}
+					else
+					{
+						return BLENDOP_ADD;
+					}
+				}
+			case BLENDOP_SUB:
+				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+				{
+					return BLENDOP_NULL;   // Negative, clamped to zero
+				}
+				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_SOURCE;
+					}
+					else
+					{
+						return BLENDOP_SUB;
+					}
+				}
+				else
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_SOURCE;
+					}
+					else
+					{
+						return BLENDOP_SUB;
+					}
+				}
+			case BLENDOP_INVSUB:
+				if(sourceBlendFactorAlpha() == BLEND_ZERO)
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_NULL;
+					}
+					else
+					{
+						return BLENDOP_DEST;
+					}
+				}
+				else if(sourceBlendFactorAlpha() == BLEND_ONE)
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_NULL;   // Negative, clamped to zero
+					}
+					else
+					{
+						return BLENDOP_INVSUB;
+					}
+				}
+				else
+				{
+					if(destBlendFactorAlpha() == BLEND_ZERO)
+					{
+						return BLENDOP_NULL;   // Negative, clamped to zero
+					}
+					else
+					{
+						return BLENDOP_INVSUB;
+					}
+				}
+			case BLENDOP_MIN:
+				return BLENDOP_MIN;
+			case BLENDOP_MAX:
+				return BLENDOP_MAX;
+			default:
+				ASSERT(false);
+			}
+
+			return blendOperationStateAlpha;
+		}
+	}
+
+	bool Context::indexedVertexBlendActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return indexedVertexBlendEnable;
+	}
+
+	int Context::vertexBlendMatrixCountActive()
+	{
+		if(vertexShader)
+		{
+			return 0;
+		}
+
+		return vertexBlendMatrixCount;
+	}
+
+	bool Context::localViewerActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return localViewer;
+	}
+
+	bool Context::normalizeNormalsActive()
+	{
+		if(vertexShader)
+		{
+			return false;
+		}
+
+		return normalizeNormals;
+	}
+
+	FogMode Context::vertexFogModeActive()
+	{
+		if(vertexShader || !fogActive())
+		{
+			return FOG_NONE;
+		}
+
+		return vertexFogMode;
+	}
+
+	bool Context::rangeFogActive()
+	{
+		if(vertexShader || !fogActive())
+		{
+			return false;
+		}
+
+		return rangeFogEnable;
+	}
+
+	TexGen Context::texGenActive(int stage)
+	{
+		if(vertexShader || !texCoordActive(stage))
+		{
+			return TEXGEN_PASSTHRU;
+		}
+
+		return texGen[stage];
+	}
+
+	int Context::textureTransformCountActive(int stage)
+	{
+		if(vertexShader || !texCoordActive(stage))
+		{
+			return 0;
+		}
+
+		return textureTransformCount[stage];
+	}
+
+	int Context::texCoordIndexActive(int stage)
+	{
+		if(vertexShader || !texCoordActive(stage))
+		{
+			return stage;
+		}
+
+		return textureStage[stage].texCoordIndex;
+	}
+
+	bool Context::perspectiveActive()
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		if(!perspectiveCorrection)
+		{
+			return false;
+		}
+
+		if(isDrawPoint(true))
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool Context::diffuseUsed()
+	{
+		return diffuseUsed(0) || diffuseUsed(1) || diffuseUsed(2) || diffuseUsed(3);
+	}
+
+	bool Context::diffuseUsed(int component)
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		if(pixelShader)
+		{
+			return pixelShader->usesDiffuse(component);
+		}
+
+		// Directly using the diffuse input color
+		for(int i = 0; i < 8; i++)
+		{
+			if(textureStage[i].isStageDisabled())
+			{
+				break;
+			}
+
+			if(textureStage[i].usesDiffuse())
+			{
+				return true;
+			}
+		}
+
+		// Using the current color (initialized to diffuse) before it's overwritten
+		for(int i = 0; i < 8; i++)
+		{
+			if(textureStage[i].usesCurrent() || textureStage[i].isStageDisabled())   // Current color contains diffuse before being overwritten
+			{
+				return true;
+			}
+
+			if(textureStage[i].writesCurrent())
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	bool Context::diffuseActive()
+	{
+		return diffuseActive(0) || diffuseActive(1) || diffuseActive(2) || diffuseActive(3);
+	}
+
+	bool Context::diffuseActive(int component)
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		// Vertex processor provides diffuse component
+		bool vertexDiffuse;
+
+		if(vertexShader)
+		{
+			vertexDiffuse = vertexShader->getOutput(C0, component).active();
+		}
+		else if(!preTransformed)
+		{
+			vertexDiffuse = input[Color0] || lightingEnable;
+		}
+		else
+		{
+			vertexDiffuse = input[Color0];
+		}
+
+		// Pixel processor requires diffuse component
+		bool pixelDiffuse = diffuseUsed(component);
+
+		return vertexDiffuse && pixelDiffuse;
+	}
+
+	bool Context::specularUsed()
+	{
+		return Context::specularUsed(0) || Context::specularUsed(1) || Context::specularUsed(2) || Context::specularUsed(3);
+	}
+
+	bool Context::specularUsed(int component)
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		if(pixelShader)
+		{
+			return pixelShader->usesSpecular(component);
+		}
+
+		bool pixelSpecular = specularEnable;
+
+		for(int i = 0; i < 8; i++)
+		{
+			if(textureStage[i].isStageDisabled()) break;
+
+			pixelSpecular = pixelSpecular || textureStage[i].usesSpecular();
+		}
+
+		return pixelSpecular;
+	}
+
+	bool Context::specularActive()
+	{
+		return specularActive(0) || specularActive(1) || specularActive(2) || specularActive(3);
+	}
+
+	bool Context::specularActive(int component)
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		// Vertex processor provides specular component
+		bool vertexSpecular;
+
+		if(!vertexShader)
+		{
+			vertexSpecular = input[Color1] || (lightingEnable && specularEnable);
+		}
+		else
+		{
+			vertexSpecular = vertexShader->getOutput(C1, component).active();
+		}
+
+		// Pixel processor requires specular component
+		bool pixelSpecular = specularUsed(component);
+
+		return vertexSpecular && pixelSpecular;
+	}
+
+	bool Context::colorActive(int color, int component)
+	{
+		if(color == 0)
+		{
+			return diffuseActive(component);
+		}
+		else
+		{
+			return specularActive(component);
+		}
+	}
+
+	bool Context::textureActive()
+	{
+		for(int i = 0; i < 8; i++)
+		{
+			if(textureActive(i))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	bool Context::textureActive(int coordinate)
+	{
+		return textureActive(coordinate, 0) || textureActive(coordinate, 1) || textureActive(coordinate, 2) || textureActive(coordinate, 3);
+	}
+
+	bool Context::textureActive(int coordinate, int component)
+	{
+		if(!colorUsed())
+		{
+			return false;
+		}
+
+		if(!texCoordActive(coordinate, component))
+		{
+			return false;
+		}
+
+		if(textureTransformProject[coordinate] && pixelShaderModel() <= 0x0103)
+		{
+			if(textureTransformCount[coordinate] == 2)
+			{
+				if(component == 1) return true;
+			}
+			else if(textureTransformCount[coordinate] == 3)
+			{
+				if(component == 2) return true;
+			}
+			else if(textureTransformCount[coordinate] == 4 || textureTransformCount[coordinate] == 0)
+			{
+				if(component == 3) return true;
+			}
+		}
+
+		if(!pixelShader)
+		{
+			bool texture = textureStage[coordinate].usesTexture();
+			bool cube = sampler[coordinate].hasCubeTexture();
+			bool volume = sampler[coordinate].hasVolumeTexture();
+
+			if(texture)
+			{
+				for(int i = coordinate; i >= 0; i--)
+				{
+					if(textureStage[i].stageOperation == TextureStage::STAGE_DISABLE)
+					{
+						return false;
+					}
+				}
+			}
+
+			switch(component)
+			{
+			case 0:
+				return texture;
+			case 1:
+				return texture;
+			case 2:
+				return (texture && (cube || volume));
+			case 3:
+				return false;
+			}
+		}
+		else
+		{
+			return pixelShader->usesTexture(coordinate, component);
+		}
+
+		return false;
+	}
+
+	unsigned short Context::pixelShaderModel() const
+	{
+		return pixelShader ? pixelShader->getShaderModel() : 0x0000;
+	}
+
+	unsigned short Context::vertexShaderModel() const
+	{
+		return vertexShader ? vertexShader->getShaderModel() : 0x0000;
+	}
+
+	int Context::getMultiSampleCount() const
+	{
+		return renderTarget[0] ? renderTarget[0]->getMultiSampleCount() : 1;
+	}
+
+	int Context::getSuperSampleCount() const
+	{
+		return renderTarget[0] ? renderTarget[0]->getSuperSampleCount() : 1;
+	}
+
+	Format Context::renderTargetInternalFormat(int index)
+	{
+		if(renderTarget[index])
+		{
+			return renderTarget[index]->getInternalFormat();
+		}
+		else
+		{
+			return FORMAT_NULL;
+		}
+	}
+
+	int Context::colorWriteActive()
+	{
+		return colorWriteActive(0) | colorWriteActive(1) | colorWriteActive(2) | colorWriteActive(3);
+	}
+
+	int Context::colorWriteActive(int index)
+	{
+		if(!renderTarget[index] || renderTarget[index]->getInternalFormat() == FORMAT_NULL)
+		{
+			return 0;
+		}
+
+		if(blendOperation() == BLENDOP_DEST && destBlendFactor() == BLEND_ONE &&
+		   (!separateAlphaBlendEnable || (blendOperationAlpha() == BLENDOP_DEST && destBlendFactorAlpha() == BLEND_ONE)))
+		{
+			return 0;
+		}
+
+		return colorWriteMask[index];
+	}
+
+	bool Context::colorUsed()
+	{
+		return colorWriteActive() || alphaTestActive() || (pixelShader && pixelShader->containsKill());
+	}
+}
diff --git a/src/Device/Context.hpp b/src/Device/Context.hpp
new file mode 100644
index 0000000..d9110d8
--- /dev/null
+++ b/src/Device/Context.hpp
@@ -0,0 +1,542 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Context_hpp
+#define sw_Context_hpp
+
+#include "Sampler.hpp"
+#include "TextureStage.hpp"
+#include "Stream.hpp"
+#include "Point.hpp"
+#include "Vertex.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	class Sampler;
+	class Surface;
+	class PixelShader;
+	class VertexShader;
+	struct Triangle;
+	struct Primitive;
+	struct Vertex;
+	class Resource;
+
+	enum In   // Default input stream semantic
+	{
+		Position = 0,
+		BlendWeight = 1,
+		BlendIndices = 2,
+		Normal = 3,
+		PointSize = 4,
+		Color0 = 5,
+		Color1 = 6,
+		TexCoord0 = 7,
+		TexCoord1 = 8,
+		TexCoord2 = 9,
+		TexCoord3 = 10,
+		TexCoord4 = 11,
+		TexCoord5 = 12,
+		TexCoord6 = 13,
+		TexCoord7 = 14,
+		PositionT = 15
+	};
+
+	enum DrawType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		// These types must stay ordered by vertices per primitive. Also, if these basic types
+		// are modified, verify the value assigned to task->verticesPerPrimitive in Renderer.cpp
+		DRAW_POINTLIST     = 0x00,
+		DRAW_LINELIST      = 0x01,
+		DRAW_LINESTRIP     = 0x02,
+		DRAW_LINELOOP      = 0x03,
+		DRAW_TRIANGLELIST  = 0x04,
+		DRAW_TRIANGLESTRIP = 0x05,
+		DRAW_TRIANGLEFAN   = 0x06,
+		DRAW_QUADLIST      = 0x07,
+
+		DRAW_NONINDEXED = 0x00,
+		DRAW_INDEXED8   = 0x10,
+		DRAW_INDEXED16  = 0x20,
+		DRAW_INDEXED32  = 0x30,
+
+		DRAW_INDEXEDPOINTLIST8 = DRAW_POINTLIST | DRAW_INDEXED8,
+		DRAW_INDEXEDLINELIST8  = DRAW_LINELIST  | DRAW_INDEXED8,
+		DRAW_INDEXEDLINESTRIP8 = DRAW_LINESTRIP | DRAW_INDEXED8,
+		DRAW_INDEXEDLINELOOP8  = DRAW_LINELOOP  | DRAW_INDEXED8,
+		DRAW_INDEXEDTRIANGLELIST8  = DRAW_TRIANGLELIST  | DRAW_INDEXED8,
+		DRAW_INDEXEDTRIANGLESTRIP8 = DRAW_TRIANGLESTRIP | DRAW_INDEXED8,
+		DRAW_INDEXEDTRIANGLEFAN8   = DRAW_TRIANGLEFAN   | DRAW_INDEXED8,
+
+		DRAW_INDEXEDPOINTLIST16 = DRAW_POINTLIST | DRAW_INDEXED16,
+		DRAW_INDEXEDLINELIST16  = DRAW_LINELIST  | DRAW_INDEXED16,
+		DRAW_INDEXEDLINESTRIP16 = DRAW_LINESTRIP | DRAW_INDEXED16,
+		DRAW_INDEXEDLINELOOP16  = DRAW_LINELOOP  | DRAW_INDEXED16,
+		DRAW_INDEXEDTRIANGLELIST16  = DRAW_TRIANGLELIST  | DRAW_INDEXED16,
+		DRAW_INDEXEDTRIANGLESTRIP16 = DRAW_TRIANGLESTRIP | DRAW_INDEXED16,
+		DRAW_INDEXEDTRIANGLEFAN16   = DRAW_TRIANGLEFAN   | DRAW_INDEXED16,
+
+		DRAW_INDEXEDPOINTLIST32 = DRAW_POINTLIST | DRAW_INDEXED32,
+		DRAW_INDEXEDLINELIST32  = DRAW_LINELIST  | DRAW_INDEXED32,
+		DRAW_INDEXEDLINESTRIP32 = DRAW_LINESTRIP | DRAW_INDEXED32,
+		DRAW_INDEXEDLINELOOP32  = DRAW_LINELOOP  | DRAW_INDEXED32,
+		DRAW_INDEXEDTRIANGLELIST32  = DRAW_TRIANGLELIST  | DRAW_INDEXED32,
+		DRAW_INDEXEDTRIANGLESTRIP32 = DRAW_TRIANGLESTRIP | DRAW_INDEXED32,
+		DRAW_INDEXEDTRIANGLEFAN32   = DRAW_TRIANGLEFAN   | DRAW_INDEXED32,
+
+		DRAW_LAST = DRAW_INDEXEDTRIANGLEFAN32
+	};
+
+	enum FillMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		FILL_SOLID,
+		FILL_WIREFRAME,
+		FILL_VERTEX,
+
+		FILL_LAST = FILL_VERTEX
+	};
+
+	enum ShadingMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		SHADING_FLAT,
+		SHADING_GOURAUD,
+
+		SHADING_LAST = SHADING_GOURAUD
+	};
+
+	enum DepthCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		DEPTH_ALWAYS,
+		DEPTH_NEVER,
+		DEPTH_EQUAL,
+		DEPTH_NOTEQUAL,
+		DEPTH_LESS,
+		DEPTH_LESSEQUAL,
+		DEPTH_GREATER,
+		DEPTH_GREATEREQUAL,
+
+		DEPTH_LAST = DEPTH_GREATEREQUAL
+	};
+
+	enum StencilCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		STENCIL_ALWAYS,
+		STENCIL_NEVER,
+		STENCIL_EQUAL,
+		STENCIL_NOTEQUAL,
+		STENCIL_LESS,
+		STENCIL_LESSEQUAL,
+		STENCIL_GREATER,
+		STENCIL_GREATEREQUAL,
+
+		STENCIL_LAST = STENCIL_GREATEREQUAL
+	};
+
+	enum StencilOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		OPERATION_KEEP,
+		OPERATION_ZERO,
+		OPERATION_REPLACE,
+		OPERATION_INCRSAT,
+		OPERATION_DECRSAT,
+		OPERATION_INVERT,
+		OPERATION_INCR,
+		OPERATION_DECR,
+
+		OPERATION_LAST = OPERATION_DECR
+	};
+
+	enum AlphaCompareMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		ALPHA_ALWAYS,
+		ALPHA_NEVER,
+		ALPHA_EQUAL,
+		ALPHA_NOTEQUAL,
+		ALPHA_LESS,
+		ALPHA_LESSEQUAL,
+		ALPHA_GREATER,
+		ALPHA_GREATEREQUAL,
+
+		ALPHA_LAST = ALPHA_GREATEREQUAL
+	};
+
+	enum CullMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		CULL_NONE,
+		CULL_CLOCKWISE,
+		CULL_COUNTERCLOCKWISE,
+
+		CULL_LAST = CULL_COUNTERCLOCKWISE
+	};
+
+	enum BlendFactor ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		BLEND_ZERO,
+		BLEND_ONE,
+		BLEND_SOURCE,
+		BLEND_INVSOURCE,
+		BLEND_DEST,
+		BLEND_INVDEST,
+		BLEND_SOURCEALPHA,
+		BLEND_INVSOURCEALPHA,
+		BLEND_DESTALPHA,
+		BLEND_INVDESTALPHA,
+		BLEND_SRCALPHASAT,
+		BLEND_CONSTANT,
+		BLEND_INVCONSTANT,
+		BLEND_CONSTANTALPHA,
+		BLEND_INVCONSTANTALPHA,
+
+		BLEND_LAST = BLEND_INVCONSTANTALPHA
+	};
+
+	enum BlendOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		BLENDOP_ADD,
+		BLENDOP_SUB,
+		BLENDOP_INVSUB,
+		BLENDOP_MIN,
+		BLENDOP_MAX,
+
+		BLENDOP_SOURCE,   // Copy source
+		BLENDOP_DEST,     // Copy dest
+		BLENDOP_NULL,     // Nullify result
+
+		BLENDOP_LAST = BLENDOP_NULL
+	};
+
+	enum LogicalOperation ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		LOGICALOP_CLEAR,
+		LOGICALOP_SET,
+		LOGICALOP_COPY,
+		LOGICALOP_COPY_INVERTED,
+		LOGICALOP_NOOP,
+		LOGICALOP_INVERT,
+		LOGICALOP_AND,
+		LOGICALOP_NAND,
+		LOGICALOP_OR,
+		LOGICALOP_NOR,
+		LOGICALOP_XOR,
+		LOGICALOP_EQUIV,
+		LOGICALOP_AND_REVERSE,
+		LOGICALOP_AND_INVERTED,
+		LOGICALOP_OR_REVERSE,
+		LOGICALOP_OR_INVERTED,
+
+		LOGICALOP_LAST = LOGICALOP_OR_INVERTED
+	};
+
+	enum MaterialSource ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		MATERIAL_MATERIAL,
+		MATERIAL_COLOR1,
+		MATERIAL_COLOR2,
+
+		MATERIAL_LAST = MATERIAL_COLOR2
+	};
+
+	enum FogMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		FOG_NONE,
+		FOG_LINEAR,
+		FOG_EXP,
+		FOG_EXP2,
+
+		FOG_LAST = FOG_EXP2
+	};
+
+	enum TexGen ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		TEXGEN_PASSTHRU,
+		TEXGEN_NORMAL,
+		TEXGEN_POSITION,
+		TEXGEN_REFLECTION,
+		TEXGEN_SPHEREMAP,
+		TEXGEN_NONE,
+
+		TEXGEN_LAST = TEXGEN_NONE
+	};
+
+	enum TransparencyAntialiasing ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		TRANSPARENCY_NONE,
+		TRANSPARENCY_ALPHA_TO_COVERAGE,
+
+		TRANSPARENCY_LAST = TRANSPARENCY_ALPHA_TO_COVERAGE
+	};
+
+	class Context
+	{
+	public:
+		Context();
+
+		~Context();
+
+		void *operator new(size_t bytes);
+		void operator delete(void *pointer, size_t bytes);
+
+		bool isDrawPoint(bool fillModeAware = false) const;
+		bool isDrawLine(bool fillModeAware = false) const;
+		bool isDrawTriangle(bool fillModeAware = false) const;
+
+		void init();
+
+		const float &exp2Bias();   // NOTE: Needs address for JIT
+
+		const Point &getLightPosition(int light);
+
+		void setGlobalMipmapBias(float bias);
+
+		// Set fixed-function vertex pipeline states
+		void setLightingEnable(bool lightingEnable);
+		void setSpecularEnable(bool specularEnable);
+		void setLightEnable(int light, bool lightEnable);
+		void setLightPosition(int light, Point worldLightPosition);
+
+		void setColorVertexEnable(bool colorVertexEnable);
+		void setAmbientMaterialSource(MaterialSource ambientMaterialSource);
+		void setDiffuseMaterialSource(MaterialSource diffuseMaterialSource);
+		void setSpecularMaterialSource(MaterialSource specularMaterialSource);
+		void setEmissiveMaterialSource(MaterialSource emissiveMaterialSource);
+
+		void setPointSpriteEnable(bool pointSpriteEnable);
+		void setPointScaleEnable(bool pointScaleEnable);
+
+		// Set fixed-function pixel pipeline states, return true when modified
+		bool setDepthBufferEnable(bool depthBufferEnable);
+
+		bool setAlphaBlendEnable(bool alphaBlendEnable);
+		bool setSourceBlendFactor(BlendFactor sourceBlendFactor);
+		bool setDestBlendFactor(BlendFactor destBlendFactor);
+		bool setBlendOperation(BlendOperation blendOperation);
+
+		bool setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
+		bool setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
+		bool setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
+		bool setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+
+		bool setColorWriteMask(int index, int colorWriteMask);
+		bool setWriteSRGB(bool sRGB);
+
+		bool setColorLogicOpEnabled(bool colorLogicOpEnabled);
+		bool setLogicalOperation(LogicalOperation logicalOperation);
+
+		// Active fixed-function pixel pipeline states
+		bool fogActive();
+		bool pointSizeActive();
+		FogMode pixelFogActive();
+		bool depthWriteActive();
+		bool alphaTestActive();
+		bool depthBufferActive();
+		bool stencilActive();
+
+		bool perspectiveActive();
+
+		// Active fixed-function vertex pipeline states
+		bool vertexLightingActive();
+		bool texCoordActive(int coordinate, int component);
+		bool texCoordActive(int coordinate);
+		bool isProjectionComponent(unsigned int coordinate, int component);
+		bool vertexSpecularInputActive();
+		bool vertexSpecularActive();
+		bool vertexNormalActive();
+		bool vertexLightActive();
+		bool vertexLightActive(int i);
+		MaterialSource vertexDiffuseMaterialSourceActive();
+		MaterialSource vertexSpecularMaterialSourceActive();
+		MaterialSource vertexAmbientMaterialSourceActive();
+		MaterialSource vertexEmissiveMaterialSourceActive();
+
+		bool pointSpriteActive();
+		bool pointScaleActive();
+
+		bool alphaBlendActive();
+		BlendFactor sourceBlendFactor();
+		BlendFactor destBlendFactor();
+		BlendOperation blendOperation();
+
+		BlendFactor sourceBlendFactorAlpha();
+		BlendFactor destBlendFactorAlpha();
+		BlendOperation blendOperationAlpha();
+
+		LogicalOperation colorLogicOp();
+		LogicalOperation indexLogicOp();
+
+		bool indexedVertexBlendActive();
+		int vertexBlendMatrixCountActive();
+		bool localViewerActive();
+		bool normalizeNormalsActive();
+		FogMode vertexFogModeActive();
+		bool rangeFogActive();
+
+		TexGen texGenActive(int stage);
+		int textureTransformCountActive(int stage);
+		int texCoordIndexActive(int stage);
+
+		// Active context states
+		bool diffuseUsed();     // Used by pixel processor but not provided by vertex processor
+		bool diffuseUsed(int component);     // Used by pixel processor but not provided by vertex processor
+		bool diffuseActive();
+		bool diffuseActive(int component);
+		bool specularUsed();
+		bool specularUsed(int component);
+		bool specularActive();
+		bool specularActive(int component);
+		bool colorActive(int color, int component);
+		bool textureActive();
+		bool textureActive(int coordinate);
+		bool textureActive(int coordinate, int component);
+
+		unsigned short pixelShaderModel() const;
+		unsigned short vertexShaderModel() const;
+
+		int getMultiSampleCount() const;
+		int getSuperSampleCount() const;
+
+		DrawType drawType;
+
+		bool stencilEnable;
+		StencilCompareMode stencilCompareMode;
+		int stencilReference;
+		int stencilMask;
+		StencilOperation stencilFailOperation;
+		StencilOperation stencilPassOperation;
+		StencilOperation stencilZFailOperation;
+		int stencilWriteMask;
+
+		bool twoSidedStencil;
+		StencilCompareMode stencilCompareModeCCW;
+		int stencilReferenceCCW;
+		int stencilMaskCCW;
+		StencilOperation stencilFailOperationCCW;
+		StencilOperation stencilPassOperationCCW;
+		StencilOperation stencilZFailOperationCCW;
+		int stencilWriteMaskCCW;
+
+		// Pixel processor states
+		AlphaCompareMode alphaCompareMode;
+		bool alphaTestEnable;
+		FillMode fillMode;
+		ShadingMode shadingMode;
+
+		CullMode cullMode;
+		bool frontFacingCCW;
+		float alphaReference;
+
+		float depthBias;
+		float slopeDepthBias;
+
+		TextureStage textureStage[8];
+		Sampler sampler[TOTAL_IMAGE_UNITS];
+
+		Format renderTargetInternalFormat(int index);
+		int colorWriteActive();
+		int colorWriteActive(int index);
+		bool colorUsed();
+
+		Resource *texture[TOTAL_IMAGE_UNITS];
+		Stream input[MAX_VERTEX_INPUTS];
+		Resource *indexBuffer;
+
+		bool preTransformed;   // FIXME: Private
+
+		float fogStart;
+		float fogEnd;
+
+		void computeIllumination();
+
+		bool textureWrapActive;
+		unsigned char textureWrap[TEXTURE_IMAGE_UNITS];
+		TexGen texGen[8];
+		bool localViewer;
+		bool normalizeNormals;
+		int textureTransformCount[8];
+		bool textureTransformProject[8];
+
+		Surface *renderTarget[RENDERTARGETS];
+		unsigned int renderTargetLayer[RENDERTARGETS];
+		Surface *depthBuffer;
+		unsigned int depthBufferLayer;
+		Surface *stencilBuffer;
+		unsigned int stencilBufferLayer;
+
+		// Fog
+		bool fogEnable;
+		FogMode pixelFogMode;
+		FogMode vertexFogMode;
+		bool wBasedFog;
+		bool rangeFogEnable;
+
+		// Vertex blending
+		bool indexedVertexBlendEnable;
+		int vertexBlendMatrixCount;
+
+		// Shaders
+		const PixelShader *pixelShader;
+		const VertexShader *vertexShader;
+
+		// Global mipmap bias
+		float bias;
+
+		// Instancing
+		int instanceID;
+
+		// Fixed-function vertex pipeline state
+		bool lightingEnable;
+		bool specularEnable;
+		bool lightEnable[8];
+		Point worldLightPosition[8];
+
+		MaterialSource ambientMaterialSource;
+		MaterialSource diffuseMaterialSource;
+		MaterialSource specularMaterialSource;
+		MaterialSource emissiveMaterialSource;
+		bool colorVertexEnable;
+
+		bool occlusionEnabled;
+		bool transformFeedbackQueryEnabled;
+		uint64_t transformFeedbackEnabled;
+
+		// Pixel processor states
+		bool rasterizerDiscard;
+		bool depthBufferEnable;
+		DepthCompareMode depthCompareMode;
+		bool depthWriteEnable;
+
+		bool alphaBlendEnable;
+		BlendFactor sourceBlendFactorState;
+		BlendFactor destBlendFactorState;
+		BlendOperation blendOperationState;
+
+		bool separateAlphaBlendEnable;
+		BlendFactor sourceBlendFactorStateAlpha;
+		BlendFactor destBlendFactorStateAlpha;
+		BlendOperation blendOperationStateAlpha;
+
+		bool pointSpriteEnable;
+		bool pointScaleEnable;
+		float lineWidth;
+
+		int colorWriteMask[RENDERTARGETS];   // RGBA
+		bool writeSRGB;
+		unsigned int sampleMask;
+		unsigned int multiSampleMask;
+
+		bool colorLogicOpEnabled;
+		LogicalOperation logicalOperation;
+	};
+}
+
+#endif   // sw_Context_hpp
diff --git a/src/Device/ETC_Decoder.cpp b/src/Device/ETC_Decoder.cpp
new file mode 100644
index 0000000..dbc6276
--- /dev/null
+++ b/src/Device/ETC_Decoder.cpp
@@ -0,0 +1,741 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ETC_Decoder.hpp"
+
+namespace
+{
+	inline int clampByte(int value)
+	{
+		return (value < 0) ? 0 : ((value > 255) ? 255 : value);
+	}
+
+	inline int clampSByte(int value)
+	{
+		return (value < -128) ? -128 : ((value > 127) ? 127 : value);
+	}
+
+	inline int clampEAC(int value, bool isSigned)
+	{
+		int min = isSigned ? -1023 : 0;
+		int max = isSigned ? 1023 : 2047;
+		return (value < min) ? min : ((value > max) ? max : value);
+	}
+
+	struct bgra8
+	{
+		unsigned char b;
+		unsigned char g;
+		unsigned char r;
+		unsigned char a;
+
+		inline bgra8()
+		{
+		}
+
+		inline void set(int red, int green, int blue)
+		{
+			r = static_cast<unsigned char>(clampByte(red));
+			g = static_cast<unsigned char>(clampByte(green));
+			b = static_cast<unsigned char>(clampByte(blue));
+		}
+
+		inline void set(int red, int green, int blue, int alpha)
+		{
+			r = static_cast<unsigned char>(clampByte(red));
+			g = static_cast<unsigned char>(clampByte(green));
+			b = static_cast<unsigned char>(clampByte(blue));
+			a = static_cast<unsigned char>(clampByte(alpha));
+		}
+
+		const bgra8& addA(int 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++)
+				{
+					int* sDst = reinterpret_cast<int*>(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++)
+					{
+						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;
+				}
+			}
+			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;
+				}
+			}
+
+			if(nonOpaquePunchThroughAlpha)
+			{
+				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;
+			}
+
+			if(nonOpaquePunchThroughAlpha)
+			{
+				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;
+			case 3: return md;
+			case 4: return me;
+			case 5: return mf1 << 2 | mf2;
+			case 6: return mg;
+			case 7: return mh;
+			case 8: return mi;
+			case 9: return mj;
+			case 10: return mk1 << 1 | mk2;
+			case 11: return ml;
+			case 12: return mm;
+			case 13: return mn1 << 2 | mn2;
+			case 14: return mo;
+			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 } };
+
+			return modifierTable[table_index][getSingleChannelIndex(x, y)];
+		}
+	};
+}
+
+// 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)
+{
+	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]++)
+			{
+				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)
+			{
+				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]++)
+			{
+				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)
+			{
+				// 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]++;
+			}
+		}
+		break;
+	default:
+		return false;
+	}
+
+	return true;
+}
diff --git a/src/Device/ETC_Decoder.hpp b/src/Device/ETC_Decoder.hpp
new file mode 100644
index 0000000..1039b37
--- /dev/null
+++ b/src/Device/ETC_Decoder.hpp
@@ -0,0 +1,41 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+class ETC_Decoder
+{
+public:
+	enum InputType
+	{
+		ETC_R_SIGNED,
+		ETC_R_UNSIGNED,
+		ETC_RG_SIGNED,
+		ETC_RG_UNSIGNED,
+		ETC_RGB,
+		ETC_RGB_PUNCHTHROUGH_ALPHA,
+		ETC_RGBA
+	};
+
+	/// ETC_Decoder::Decode - Decodes 1 to 4 channel images to 8 bit output
+	/// @param src            Pointer to ETC2 encoded image
+	/// @param dst            Pointer to BGRA, 8 bit output
+	/// @param w              src image width
+	/// @param h              src image height
+	/// @param dstW           dst image width
+	/// @param dstH           dst image height
+	/// @param dstPitch       dst image pitch (bytes per row)
+	/// @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);
+};
diff --git a/src/Device/LRUCache.hpp b/src/Device/LRUCache.hpp
new file mode 100644
index 0000000..1a1a302
--- /dev/null
+++ b/src/Device/LRUCache.hpp
@@ -0,0 +1,145 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_LRUCache_hpp
+#define sw_LRUCache_hpp
+
+#include "Common/Math.hpp"
+
+namespace sw
+{
+	template<class Key, class Data>
+	class LRUCache
+	{
+	public:
+		LRUCache(int n);
+
+		~LRUCache();
+
+		Data *query(const Key &key) const;
+		Data *add(const Key &key, Data *data);
+	
+		int getSize() {return size;}
+		Key &getKey(int i) {return key[i];}
+
+	private:
+		int size;
+		int mask;
+		int top;
+		int fill;
+
+		Key *key;
+		Key **ref;
+		Data **data;
+	};
+}
+
+namespace sw
+{
+	template<class Key, class Data>
+	LRUCache<Key, Data>::LRUCache(int n)
+	{
+		size = ceilPow2(n);
+		mask = size - 1;
+		top = 0;
+		fill = 0;
+
+		key = new Key[size];
+		ref = new Key*[size];
+		data = new Data*[size];
+
+		for(int i = 0; i < size; i++)
+		{
+			data[i] = nullptr;
+
+			ref[i] = &key[i];
+		}
+	}
+
+	template<class Key, class Data>
+	LRUCache<Key, Data>::~LRUCache()
+	{
+		delete[] key;
+		key = nullptr;
+
+		delete[] ref;
+		ref = nullptr;
+
+		for(int i = 0; i < size; i++)
+		{
+			if(data[i])
+			{
+				data[i]->unbind();
+				data[i] = nullptr;
+			}
+		}
+
+		delete[] data;
+		data = nullptr;
+	}
+
+	template<class Key, class Data>
+	Data *LRUCache<Key, Data>::query(const Key &key) const
+	{
+		for(int i = top; i > top - fill; i--)
+		{
+			int j = i & mask;
+
+			if(key == *ref[j])
+			{
+				Data *hit = data[j];
+
+				if(i != top)
+				{
+					// Move one up
+					int k = (j + 1) & mask;
+
+					Data *swapD = data[k];
+					data[k] = data[j];
+					data[j] = swapD;
+
+					Key *swapK = ref[k];
+					ref[k] = ref[j];
+					ref[j] = swapK;
+				}
+
+				return hit;
+			}
+		}
+
+		return nullptr;   // Not found
+	}
+
+	template<class Key, class Data>
+	Data *LRUCache<Key, Data>::add(const Key &key, Data *data)
+	{
+		top = (top + 1) & mask;
+		fill = fill + 1 < size ? fill + 1 : size;
+
+		*ref[top] = key;
+
+		data->bind();
+
+		if(this->data[top])
+		{
+			this->data[top]->unbind();
+		}
+
+		this->data[top] = data;
+
+		return data;
+	}
+}
+
+#endif   // sw_LRUCache_hpp
diff --git a/src/Device/Matrix.cpp b/src/Device/Matrix.cpp
new file mode 100644
index 0000000..0da07e5
--- /dev/null
+++ b/src/Device/Matrix.cpp
@@ -0,0 +1,402 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Matrix.hpp"
+
+#include "Point.hpp"
+#include "Common/Math.hpp"
+
+namespace sw
+{
+	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);
+	}
+
+	Matrix::operator float*()
+	{
+		return &(*this)(1, 1);
+	}
+
+	Matrix Matrix::operator+() const
+	{
+		return *this;
+	}
+
+	Matrix Matrix::operator-() const
+	{
+		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), 
+		              -M(4, 1), -M(4, 2), -M(4, 3), -M(4, 4));
+	}
+
+	Matrix Matrix::operator!() const
+	{
+		const Matrix &M = *this;
+		Matrix I;
+
+		float M3344 = M(3, 3) * M(4, 4) - M(4, 3) * M(3, 4);
+		float M2344 = M(2, 3) * M(4, 4) - M(4, 3) * M(2, 4);
+		float M2334 = M(2, 3) * M(3, 4) - M(3, 3) * M(2, 4);
+		float M3244 = M(3, 2) * M(4, 4) - M(4, 2) * M(3, 4);
+		float M2244 = M(2, 2) * M(4, 4) - M(4, 2) * M(2, 4);
+		float M2234 = M(2, 2) * M(3, 4) - M(3, 2) * M(2, 4);
+		float M3243 = M(3, 2) * M(4, 3) - M(4, 2) * M(3, 3);
+		float M2243 = M(2, 2) * M(4, 3) - M(4, 2) * M(2, 3);
+		float M2233 = M(2, 2) * M(3, 3) - M(3, 2) * M(2, 3);
+		float M1344 = M(1, 3) * M(4, 4) - M(4, 3) * M(1, 4);
+		float M1334 = M(1, 3) * M(3, 4) - M(3, 3) * M(1, 4);
+		float M1244 = M(1, 2) * M(4, 4) - M(4, 2) * M(1, 4);
+		float M1234 = M(1, 2) * M(3, 4) - M(3, 2) * M(1, 4);
+		float M1243 = M(1, 2) * M(4, 3) - M(4, 2) * M(1, 3);
+		float M1233 = M(1, 2) * M(3, 3) - M(3, 2) * M(1, 3);
+		float M1324 = M(1, 3) * M(2, 4) - M(2, 3) * M(1, 4);
+		float M1224 = M(1, 2) * M(2, 4) - M(2, 2) * M(1, 4);
+		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(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(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(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(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(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(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;
+
+		// Division by determinant
+		I /= M(1, 1) * I(1, 1) +
+		     M(2, 1) * I(1, 2) +
+		     M(3, 1) * I(1, 3) +
+		     M(4, 1) * I(1, 4);
+
+		return I;
+	}
+
+	Matrix Matrix::operator~() const
+	{
+		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), 
+		              M(1, 4), M(2, 4), M(3, 4), M(4, 4));
+	}
+
+	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);
+
+		return M;
+	}
+
+	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);
+
+		return M;
+	}
+
+	Matrix &Matrix::operator*=(float s)
+	{
+		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;
+
+		return M;
+	}
+
+	Matrix &Matrix::operator*=(const Matrix &M)
+	{
+		return *this = *this * M;
+	}
+
+	Matrix &Matrix::operator/=(float s)
+	{
+		float r = 1.0f / s;
+
+		return *this *= r;
+	}
+
+	bool operator==(const Matrix &M, const Matrix &N)
+	{
+		if(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 true;
+		else
+			return false;
+	}
+
+	bool operator!=(const Matrix &M, const Matrix &N)
+	{
+		if(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 true;
+		else
+			return false;
+	}
+
+	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), 
+		              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), 
+		              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), 
+		              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, 
+		              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), 
+		              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));
+	}
+
+	Matrix operator/(const Matrix &M, float s)
+	{
+		float r = 1.0f / s;
+
+		return M * r;
+	}
+
+	float4 Matrix::operator*(const float4 &v) const
+	{
+		const Matrix &M = *this;
+		float Mx = M(1, 1) * v.x + M(1, 2) * v.y + M(1, 3) * v.z + M(1, 4) * v.w;
+		float My = M(2, 1) * v.x + M(2, 2) * v.y + M(2, 3) * v.z + M(2, 4) * v.w;
+		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};
+	}
+
+	float Matrix::det(const Matrix &M)
+	{
+		float M3344 = M(3, 3) * M(4, 4) - M(4, 3) * M(3, 4);
+		float M2344 = M(2, 3) * M(4, 4) - M(4, 3) * M(2, 4);
+		float M2334 = M(2, 3) * M(3, 4) - M(3, 3) * M(2, 4);
+		float M1344 = M(1, 3) * M(4, 4) - M(4, 3) * M(1, 4);
+		float M1334 = M(1, 3) * M(3, 4) - M(3, 3) * M(1, 4);
+		float M1324 = M(1, 3) * M(2, 4) - M(2, 3) * M(1, 4);
+
+		return M(1, 1) * (M(2, 2) * M3344 - M(3, 2) * M2344 + M(4, 2) * M2334) -
+		       M(2, 1) * (M(1, 2) * M3344 - M(3, 2) * M1344 + M(4, 2) * M1334) +
+		       M(3, 1) * (M(1, 2) * M2344 - M(2, 2) * M1344 + M(4, 2) * M1324) -
+		       M(4, 1) * (M(1, 2) * M2334 - M(2, 2) * M1334 + M(3, 2) * M1324);
+	}
+
+	float Matrix::det(float m11)
+	{
+		return m11;
+	}
+
+	float Matrix::det(float m11, float m12, 
+	                  float m21, float m22)
+	{
+		return m11 * m22 - m12 * m21; 
+	}
+
+	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) -
+		       m21 * (m12 * m33 - m32 * m13) +
+		       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 m41, float m42, float m43, float m44)
+	{
+		float M3344 = m33 * m44 - m43 * m34;
+		float M2344 = m23 * m44 - m43 * m24;
+		float M2334 = m23 * m34 - m33 * m24;
+		float M1344 = m13 * m44 - m43 * m14;
+		float M1334 = m13 * m34 - m33 * m14;
+		float M1324 = m13 * m24 - m23 * m14;
+
+		return m11 * (m22 * M3344 - m32 * M2344 + m42 * M2334) -
+		       m21 * (m12 * M3344 - m32 * M1344 + m42 * M1334) +
+		       m31 * (m12 * M2344 - m22 * M1344 + m42 * M1324) -
+		       m41 * (m12 * M2334 - m22 * M1334 + m32 * M1324);
+	}
+
+	float Matrix::det(const Vector &v1, const Vector &v2, const Vector &v3)
+	{
+		return v1 * (v2 % v3);
+	}
+
+	float Matrix::det3(const Matrix &M)
+	{
+		return M(1, 1) * (M(2, 2) * M(3, 3) - M(3, 2) * M(2, 3)) -
+		       M(2, 1) * (M(1, 2) * M(3, 3) - M(3, 2) * M(1, 3)) +
+		       M(3, 1) * (M(1, 2) * M(2, 3) - M(2, 2) * M(1, 3));
+	}
+
+	float Matrix::tr(const Matrix &M)
+	{
+		return M(1, 1) + M(2, 2) + M(3, 3) + M(4, 4);
+	}
+
+	Matrix &Matrix::orthogonalise()
+	{
+		// NOTE: Numnerically instable, won't return exact the same result when already orhtogonal
+
+		Matrix &M = *this;
+
+		Vector v1(M(1, 1), M(2, 1), M(3, 1));
+		Vector v2(M(1, 2), M(2, 2), M(3, 2));
+		Vector v3(M(1, 3), M(2, 3), M(3, 3));
+
+		v2 -= v1 * (v1 * v2) / (v1 * v1);
+		v3 -= v1 * (v1 * v3) / (v1 * v1);
+		v3 -= v2 * (v2 * v3) / (v2 * v2);
+
+		v1 /= Vector::N(v1);
+		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;
+
+		return *this;
+	}
+
+	Matrix Matrix::eulerRotate(const Vector &v)
+	{
+		float cz = cos(v.z);
+		float sz = sin(v.z);
+		float cx = cos(v.x);
+		float sx = sin(v.x);
+		float cy = cos(v.y);
+		float sy = sin(v.y);
+
+		float sxsy = sx * sy;
+		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);
+	}
+
+	Matrix Matrix::eulerRotate(float x, float y, float z)
+	{
+		return eulerRotate(Vector(x, y, z));
+	}
+
+	Matrix Matrix::translate(const Vector &v)
+	{
+		return Matrix(1, 0, 0, v.x,
+		              0, 1, 0, v.y,
+		              0, 0, 1, v.z,
+		              0, 0, 0, 1);
+	}
+
+	Matrix Matrix::translate(float x, float y, float z)
+	{
+		return translate(Vector(x, y, z));
+	}
+
+	Matrix Matrix::scale(const Vector &v)
+	{
+		return Matrix(v.x, 0,   0,
+		              0,   v.y, 0,
+		              0,   0,   v.z);
+	}
+
+	Matrix Matrix::scale(float x, float y, float z)
+	{
+		return scale(Vector(x, y, z));
+	}
+
+	Matrix Matrix::lookAt(const Vector &v)
+	{
+		Vector y = v;
+		y /= Vector::N(y);
+
+		Vector x = y % Vector(0, 0, 1);
+		x /= Vector::N(x);
+
+		Vector z = x % y;
+		z /= Vector::N(z);
+
+		return ~Matrix(x, y, z);
+	}
+
+	Matrix Matrix::lookAt(float x, float y, float z)
+	{
+		return translate(Vector(x, y, z));
+	}
+}
diff --git a/src/Device/Matrix.hpp b/src/Device/Matrix.hpp
new file mode 100644
index 0000000..41281a6
--- /dev/null
+++ b/src/Device/Matrix.hpp
@@ -0,0 +1,217 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Matrix_hpp
+#define Matrix_hpp
+
+namespace sw
+{
+	struct Vector;
+	struct Point;
+	struct float4;
+
+	struct Matrix
+	{
+		Matrix();
+		Matrix(const int i);
+		Matrix(const float m[16]);
+		Matrix(const float m[4][4]);
+		Matrix(float m11, float m12, float m13,
+		       float m21, float m22, float m23,
+		       float m31, float m32, float m33);
+		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(const Vector &v1, const Vector &v2, const Vector &v3);   // Column vectors
+
+		Matrix &operator=(const Matrix &N);
+
+		// Row major order
+		float m[4][4];
+
+		static Matrix diag(float m11, float m22, float m33, float m44);
+
+		operator float*();
+
+		Matrix operator+() const;
+		Matrix operator-() const;
+
+		Matrix operator!() const;   // Inverse
+		Matrix operator~() const;   // Transpose
+
+		Matrix &operator+=(const Matrix &N);
+		Matrix &operator-=(const Matrix &N);
+		Matrix &operator*=(float s);
+		Matrix &operator*=(const Matrix &N);
+		Matrix &operator/=(float s);
+
+		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)
+		const float &operator()(int i, int j) const;
+
+		friend bool operator==(const Matrix &M, const Matrix &N);
+		friend bool operator!=(const Matrix &M, const Matrix &N);
+
+		friend Matrix operator+(const Matrix &M, const Matrix &N);
+		friend Matrix operator-(const Matrix &M, const Matrix &N);
+		friend Matrix operator*(float s, const Matrix &M);
+		friend Matrix operator*(const Matrix &M, const Matrix &N);
+		friend Matrix operator/(const Matrix &M, float s);
+
+		float4 operator*(const float4 &v) const;
+
+		static float det(const Matrix &M);
+		static float det(float m11);
+		static float det(float m11, float m12,
+		                 float m21, float m22);
+		static float det(float m11, float m12, float m13,
+		                 float m21, float m22, float m23,
+		                 float m31, float m32, float m33);
+		static float 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);
+		static float det(const Vector &v1, const Vector &v2, const Vector &v3);
+		static float det3(const Matrix &M);
+
+		static float tr(const Matrix &M);
+
+		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);
+	};
+}
+
+#include "Vector.hpp"
+
+namespace sw
+{
+	inline Matrix::Matrix()
+	{
+	}
+
+	inline Matrix::Matrix(const int i)
+	{
+		const float s = (float)i;
+
+		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;
+	}
+
+	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];
+	}
+
+	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];
+	}
+
+	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;
+	}
+
+	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;
+	}
+
+	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;
+	}
+
+	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);
+
+		return M;
+	}
+
+	inline float *Matrix::operator[](int i)
+	{
+		return m[i];
+	}
+
+	inline const float *Matrix::operator[](int i) const
+	{
+		return m[i];
+	}
+
+	inline float &Matrix::operator()(int i, int j)
+	{
+		return m[i - 1][j - 1];
+	}
+
+	inline const float &Matrix::operator()(int i, int j) const
+	{
+		return m[i - 1][j - 1];
+	}
+}
+
+#endif   // Matrix_hpp
diff --git a/src/Device/PixelProcessor.cpp b/src/Device/PixelProcessor.cpp
new file mode 100644
index 0000000..8bc40c2
--- /dev/null
+++ b/src/Device/PixelProcessor.cpp
@@ -0,0 +1,1212 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelProcessor.hpp"
+
+#include "Surface.hpp"
+#include "Primitive.hpp"
+#include "Shader/PixelPipeline.hpp"
+#include "Shader/PixelProgram.hpp"
+#include "Shader/PixelShader.hpp"
+#include "Shader/Constants.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	extern bool complementaryDepthBuffer;
+	extern TransparencyAntialiasing transparencyAntialiasing;
+	extern bool perspectiveCorrection;
+
+	bool precachePixel = false;
+
+	unsigned int PixelProcessor::States::computeHash()
+	{
+		unsigned int *state = (unsigned int*)this;
+		unsigned int hash = 0;
+
+		for(unsigned int i = 0; i < sizeof(States) / 4; i++)
+		{
+			hash ^= state[i];
+		}
+
+		return hash;
+	}
+
+	PixelProcessor::State::State()
+	{
+		memset(this, 0, sizeof(State));
+	}
+
+	bool PixelProcessor::State::operator==(const State &state) const
+	{
+		if(hash != state.hash)
+		{
+			return false;
+		}
+
+		return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	}
+
+	PixelProcessor::UniformBufferInfo::UniformBufferInfo()
+	{
+		buffer = nullptr;
+		offset = 0;
+	}
+
+	PixelProcessor::PixelProcessor(Context *context) : context(context)
+	{
+		setGlobalMipmapBias(0.0f);   // Round to highest LOD [0.5, 1.0]: -0.5
+		                             // Round to nearest LOD [0.7, 1.4]:  0.0
+		                             // Round to lowest LOD  [1.0, 2.0]:  0.5
+
+		routineCache = 0;
+		setRoutineCacheSize(1024);
+	}
+
+	PixelProcessor::~PixelProcessor()
+	{
+		delete routineCache;
+		routineCache = 0;
+	}
+
+	void PixelProcessor::setFloatConstant(unsigned int index, const float value[4])
+	{
+		if(index < FRAGMENT_UNIFORM_VECTORS)
+		{
+			c[index][0] = value[0];
+			c[index][1] = value[1];
+			c[index][2] = value[2];
+			c[index][3] = value[3];
+		}
+		else ASSERT(false);
+
+		if(index < 8)   // ps_1_x constants
+		{
+			// FIXME: Compact into generic function
+			short x = iround(4095 * clamp(value[0], -1.0f, 1.0f));
+			short y = iround(4095 * clamp(value[1], -1.0f, 1.0f));
+			short z = iround(4095 * clamp(value[2], -1.0f, 1.0f));
+			short w = iround(4095 * clamp(value[3], -1.0f, 1.0f));
+
+			cW[index][0][0] = x;
+			cW[index][0][1] = x;
+			cW[index][0][2] = x;
+			cW[index][0][3] = x;
+
+			cW[index][1][0] = y;
+			cW[index][1][1] = y;
+			cW[index][1][2] = y;
+			cW[index][1][3] = y;
+
+			cW[index][2][0] = z;
+			cW[index][2][1] = z;
+			cW[index][2][2] = z;
+			cW[index][2][3] = z;
+
+			cW[index][3][0] = w;
+			cW[index][3][1] = w;
+			cW[index][3][2] = w;
+			cW[index][3][3] = w;
+		}
+	}
+
+	void PixelProcessor::setIntegerConstant(unsigned int index, const int value[4])
+	{
+		if(index < 16)
+		{
+			i[index][0] = value[0];
+			i[index][1] = value[1];
+			i[index][2] = value[2];
+			i[index][3] = value[3];
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setBooleanConstant(unsigned int index, int boolean)
+	{
+		if(index < 16)
+		{
+			b[index] = boolean != 0;
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setUniformBuffer(int index, sw::Resource* buffer, int offset)
+	{
+		uniformBufferInfo[index].buffer = buffer;
+		uniformBufferInfo[index].offset = offset;
+	}
+
+	void PixelProcessor::lockUniformBuffers(byte** u, sw::Resource* uniformBuffers[])
+	{
+		for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; ++i)
+		{
+			u[i] = uniformBufferInfo[i].buffer ? static_cast<byte*>(uniformBufferInfo[i].buffer->lock(PUBLIC, PRIVATE)) + uniformBufferInfo[i].offset : nullptr;
+			uniformBuffers[i] = uniformBufferInfo[i].buffer;
+		}
+	}
+
+	void PixelProcessor::setRenderTarget(int index, Surface *renderTarget, unsigned int layer)
+	{
+		context->renderTarget[index] = renderTarget;
+		context->renderTargetLayer[index] = layer;
+	}
+
+	void PixelProcessor::setDepthBuffer(Surface *depthBuffer, unsigned int layer)
+	{
+		context->depthBuffer = depthBuffer;
+		context->depthBufferLayer = layer;
+	}
+
+	void PixelProcessor::setStencilBuffer(Surface *stencilBuffer, unsigned int layer)
+	{
+		context->stencilBuffer = stencilBuffer;
+		context->stencilBufferLayer = layer;
+	}
+
+	void PixelProcessor::setTexCoordIndex(unsigned int stage, int texCoordIndex)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setTexCoordIndex(texCoordIndex);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setStageOperation(unsigned int stage, TextureStage::StageOperation stageOperation)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setStageOperation(stageOperation);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setFirstArgument(unsigned int stage, TextureStage::SourceArgument firstArgument)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setFirstArgument(firstArgument);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSecondArgument(unsigned int stage, TextureStage::SourceArgument secondArgument)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setSecondArgument(secondArgument);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setThirdArgument(unsigned int stage, TextureStage::SourceArgument thirdArgument)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setThirdArgument(thirdArgument);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setStageOperationAlpha(unsigned int stage, TextureStage::StageOperation stageOperationAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setStageOperationAlpha(stageOperationAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setFirstArgumentAlpha(unsigned int stage, TextureStage::SourceArgument firstArgumentAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setFirstArgumentAlpha(firstArgumentAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSecondArgumentAlpha(unsigned int stage, TextureStage::SourceArgument secondArgumentAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setSecondArgumentAlpha(secondArgumentAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setThirdArgumentAlpha(unsigned int stage, TextureStage::SourceArgument thirdArgumentAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setThirdArgumentAlpha(thirdArgumentAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setFirstModifier(unsigned int stage, TextureStage::ArgumentModifier firstModifier)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setFirstModifier(firstModifier);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSecondModifier(unsigned int stage, TextureStage::ArgumentModifier secondModifier)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setSecondModifier(secondModifier);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setThirdModifier(unsigned int stage, TextureStage::ArgumentModifier thirdModifier)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setThirdModifier(thirdModifier);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setFirstModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier firstModifierAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setFirstModifierAlpha(firstModifierAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSecondModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier secondModifierAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setSecondModifierAlpha(secondModifierAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setThirdModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier thirdModifierAlpha)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setThirdModifierAlpha(thirdModifierAlpha);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setDestinationArgument(unsigned int stage, TextureStage::DestinationArgument destinationArgument)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setDestinationArgument(destinationArgument);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setConstantColor(unsigned int stage, const Color<float> &constantColor)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setConstantColor(constantColor);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setBumpmapMatrix(unsigned int stage, int element, float value)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setBumpmapMatrix(element, value);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setLuminanceScale(unsigned int stage, float value)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setLuminanceScale(value);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setLuminanceOffset(unsigned int stage, float value)
+	{
+		if(stage < 8)
+		{
+			context->textureStage[stage].setLuminanceOffset(value);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setTextureFilter(unsigned int sampler, FilterType textureFilter)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setTextureFilter(textureFilter);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMipmapFilter(unsigned int sampler, MipmapType mipmapFilter)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMipmapFilter(mipmapFilter);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setGatherEnable(unsigned int sampler, bool enable)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setGatherEnable(enable);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setAddressingModeU(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setAddressingModeU(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setAddressingModeV(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setAddressingModeV(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setAddressingModeW(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setAddressingModeW(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setReadSRGB(unsigned int sampler, bool sRGB)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setReadSRGB(sRGB);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMipmapLOD(unsigned int sampler, float bias)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMipmapLOD(bias);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setBorderColor(unsigned int sampler, const Color<float> &borderColor)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setBorderColor(borderColor);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMaxAnisotropy(unsigned int sampler, float maxAnisotropy)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMaxAnisotropy(maxAnisotropy);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setHighPrecisionFiltering(highPrecisionFiltering);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSwizzleR(unsigned int sampler, SwizzleType swizzleR)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSwizzleR(swizzleR);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSwizzleG(unsigned int sampler, SwizzleType swizzleG)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSwizzleG(swizzleG);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSwizzleB(unsigned int sampler, SwizzleType swizzleB)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSwizzleB(swizzleB);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSwizzleA(unsigned int sampler, SwizzleType swizzleA)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSwizzleA(swizzleA);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setCompareFunc(unsigned int sampler, CompareFunc compFunc)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setCompareFunc(compFunc);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setBaseLevel(unsigned int sampler, int baseLevel)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setBaseLevel(baseLevel);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMaxLevel(unsigned int sampler, int maxLevel)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMaxLevel(maxLevel);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMinLod(unsigned int sampler, float minLod)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMinLod(minLod);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setMaxLod(unsigned int sampler, float maxLod)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setMaxLod(maxLod);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setSyncRequired(unsigned int sampler, bool isSincRequired)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSyncRequired(isSincRequired);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProcessor::setWriteSRGB(bool sRGB)
+	{
+		context->setWriteSRGB(sRGB);
+	}
+
+	void PixelProcessor::setColorLogicOpEnabled(bool colorLogicOpEnabled)
+	{
+		context->setColorLogicOpEnabled(colorLogicOpEnabled);
+	}
+
+	void PixelProcessor::setLogicalOperation(LogicalOperation logicalOperation)
+	{
+		context->setLogicalOperation(logicalOperation);
+	}
+
+	void PixelProcessor::setDepthBufferEnable(bool depthBufferEnable)
+	{
+		context->setDepthBufferEnable(depthBufferEnable);
+	}
+
+	void PixelProcessor::setDepthCompare(DepthCompareMode depthCompareMode)
+	{
+		context->depthCompareMode = depthCompareMode;
+	}
+
+	void PixelProcessor::setAlphaCompare(AlphaCompareMode alphaCompareMode)
+	{
+		context->alphaCompareMode = alphaCompareMode;
+	}
+
+	void PixelProcessor::setDepthWriteEnable(bool depthWriteEnable)
+	{
+		context->depthWriteEnable = depthWriteEnable;
+	}
+
+	void PixelProcessor::setAlphaTestEnable(bool alphaTestEnable)
+	{
+		context->alphaTestEnable = alphaTestEnable;
+	}
+
+	void PixelProcessor::setCullMode(CullMode cullMode, bool frontFacingCCW)
+	{
+		context->cullMode = cullMode;
+		context->frontFacingCCW = frontFacingCCW;
+	}
+
+	void PixelProcessor::setColorWriteMask(int index, int rgbaMask)
+	{
+		context->setColorWriteMask(index, rgbaMask);
+	}
+
+	void PixelProcessor::setStencilEnable(bool stencilEnable)
+	{
+		context->stencilEnable = stencilEnable;
+	}
+
+	void PixelProcessor::setStencilCompare(StencilCompareMode stencilCompareMode)
+	{
+		context->stencilCompareMode = stencilCompareMode;
+	}
+
+	void PixelProcessor::setStencilReference(int stencilReference)
+	{
+		context->stencilReference = stencilReference;
+		stencil.set(stencilReference, context->stencilMask, context->stencilWriteMask);
+	}
+
+	void PixelProcessor::setStencilReferenceCCW(int stencilReferenceCCW)
+	{
+		context->stencilReferenceCCW = stencilReferenceCCW;
+		stencilCCW.set(stencilReferenceCCW, context->stencilMaskCCW, context->stencilWriteMaskCCW);
+	}
+
+	void PixelProcessor::setStencilMask(int stencilMask)
+	{
+		context->stencilMask = stencilMask;
+		stencil.set(context->stencilReference, stencilMask, context->stencilWriteMask);
+	}
+
+	void PixelProcessor::setStencilMaskCCW(int stencilMaskCCW)
+	{
+		context->stencilMaskCCW = stencilMaskCCW;
+		stencilCCW.set(context->stencilReferenceCCW, stencilMaskCCW, context->stencilWriteMaskCCW);
+	}
+
+	void PixelProcessor::setStencilFailOperation(StencilOperation stencilFailOperation)
+	{
+		context->stencilFailOperation = stencilFailOperation;
+	}
+
+	void PixelProcessor::setStencilPassOperation(StencilOperation stencilPassOperation)
+	{
+		context->stencilPassOperation = stencilPassOperation;
+	}
+
+	void PixelProcessor::setStencilZFailOperation(StencilOperation stencilZFailOperation)
+	{
+		context->stencilZFailOperation = stencilZFailOperation;
+	}
+
+	void PixelProcessor::setStencilWriteMask(int stencilWriteMask)
+	{
+		context->stencilWriteMask = stencilWriteMask;
+		stencil.set(context->stencilReference, context->stencilMask, stencilWriteMask);
+	}
+
+	void PixelProcessor::setStencilWriteMaskCCW(int stencilWriteMaskCCW)
+	{
+		context->stencilWriteMaskCCW = stencilWriteMaskCCW;
+		stencilCCW.set(context->stencilReferenceCCW, context->stencilMaskCCW, stencilWriteMaskCCW);
+	}
+
+	void PixelProcessor::setTwoSidedStencil(bool enable)
+	{
+		context->twoSidedStencil = enable;
+	}
+
+	void PixelProcessor::setStencilCompareCCW(StencilCompareMode stencilCompareMode)
+	{
+		context->stencilCompareModeCCW = stencilCompareMode;
+	}
+
+	void PixelProcessor::setStencilFailOperationCCW(StencilOperation stencilFailOperation)
+	{
+		context->stencilFailOperationCCW = stencilFailOperation;
+	}
+
+	void PixelProcessor::setStencilPassOperationCCW(StencilOperation stencilPassOperation)
+	{
+		context->stencilPassOperationCCW = stencilPassOperation;
+	}
+
+	void PixelProcessor::setStencilZFailOperationCCW(StencilOperation stencilZFailOperation)
+	{
+		context->stencilZFailOperationCCW = stencilZFailOperation;
+	}
+
+	void PixelProcessor::setTextureFactor(const Color<float> &textureFactor)
+	{
+		// FIXME: Compact into generic function   // FIXME: Clamp
+		short textureFactorR = iround(4095 * textureFactor.r);
+		short textureFactorG = iround(4095 * textureFactor.g);
+		short textureFactorB = iround(4095 * textureFactor.b);
+		short textureFactorA = iround(4095 * textureFactor.a);
+
+		factor.textureFactor4[0][0] = textureFactorR;
+		factor.textureFactor4[0][1] = textureFactorR;
+		factor.textureFactor4[0][2] = textureFactorR;
+		factor.textureFactor4[0][3] = textureFactorR;
+
+		factor.textureFactor4[1][0] = textureFactorG;
+		factor.textureFactor4[1][1] = textureFactorG;
+		factor.textureFactor4[1][2] = textureFactorG;
+		factor.textureFactor4[1][3] = textureFactorG;
+
+		factor.textureFactor4[2][0] = textureFactorB;
+		factor.textureFactor4[2][1] = textureFactorB;
+		factor.textureFactor4[2][2] = textureFactorB;
+		factor.textureFactor4[2][3] = textureFactorB;
+
+		factor.textureFactor4[3][0] = textureFactorA;
+		factor.textureFactor4[3][1] = textureFactorA;
+		factor.textureFactor4[3][2] = textureFactorA;
+		factor.textureFactor4[3][3] = textureFactorA;
+	}
+
+	void PixelProcessor::setBlendConstant(const Color<float> &blendConstant)
+	{
+		// FIXME: Compact into generic function   // FIXME: Clamp
+		short blendConstantR = iround(65535 * blendConstant.r);
+		short blendConstantG = iround(65535 * blendConstant.g);
+		short blendConstantB = iround(65535 * blendConstant.b);
+		short blendConstantA = iround(65535 * blendConstant.a);
+
+		factor.blendConstant4W[0][0] = blendConstantR;
+		factor.blendConstant4W[0][1] = blendConstantR;
+		factor.blendConstant4W[0][2] = blendConstantR;
+		factor.blendConstant4W[0][3] = blendConstantR;
+
+		factor.blendConstant4W[1][0] = blendConstantG;
+		factor.blendConstant4W[1][1] = blendConstantG;
+		factor.blendConstant4W[1][2] = blendConstantG;
+		factor.blendConstant4W[1][3] = blendConstantG;
+
+		factor.blendConstant4W[2][0] = blendConstantB;
+		factor.blendConstant4W[2][1] = blendConstantB;
+		factor.blendConstant4W[2][2] = blendConstantB;
+		factor.blendConstant4W[2][3] = blendConstantB;
+
+		factor.blendConstant4W[3][0] = blendConstantA;
+		factor.blendConstant4W[3][1] = blendConstantA;
+		factor.blendConstant4W[3][2] = blendConstantA;
+		factor.blendConstant4W[3][3] = blendConstantA;
+
+		// FIXME: Compact into generic function   // FIXME: Clamp
+		short invBlendConstantR = iround(65535 * (1 - blendConstant.r));
+		short invBlendConstantG = iround(65535 * (1 - blendConstant.g));
+		short invBlendConstantB = iround(65535 * (1 - blendConstant.b));
+		short invBlendConstantA = iround(65535 * (1 - blendConstant.a));
+
+		factor.invBlendConstant4W[0][0] = invBlendConstantR;
+		factor.invBlendConstant4W[0][1] = invBlendConstantR;
+		factor.invBlendConstant4W[0][2] = invBlendConstantR;
+		factor.invBlendConstant4W[0][3] = invBlendConstantR;
+
+		factor.invBlendConstant4W[1][0] = invBlendConstantG;
+		factor.invBlendConstant4W[1][1] = invBlendConstantG;
+		factor.invBlendConstant4W[1][2] = invBlendConstantG;
+		factor.invBlendConstant4W[1][3] = invBlendConstantG;
+
+		factor.invBlendConstant4W[2][0] = invBlendConstantB;
+		factor.invBlendConstant4W[2][1] = invBlendConstantB;
+		factor.invBlendConstant4W[2][2] = invBlendConstantB;
+		factor.invBlendConstant4W[2][3] = invBlendConstantB;
+
+		factor.invBlendConstant4W[3][0] = invBlendConstantA;
+		factor.invBlendConstant4W[3][1] = invBlendConstantA;
+		factor.invBlendConstant4W[3][2] = invBlendConstantA;
+		factor.invBlendConstant4W[3][3] = invBlendConstantA;
+
+		factor.blendConstant4F[0][0] = blendConstant.r;
+		factor.blendConstant4F[0][1] = blendConstant.r;
+		factor.blendConstant4F[0][2] = blendConstant.r;
+		factor.blendConstant4F[0][3] = blendConstant.r;
+
+		factor.blendConstant4F[1][0] = blendConstant.g;
+		factor.blendConstant4F[1][1] = blendConstant.g;
+		factor.blendConstant4F[1][2] = blendConstant.g;
+		factor.blendConstant4F[1][3] = blendConstant.g;
+
+		factor.blendConstant4F[2][0] = blendConstant.b;
+		factor.blendConstant4F[2][1] = blendConstant.b;
+		factor.blendConstant4F[2][2] = blendConstant.b;
+		factor.blendConstant4F[2][3] = blendConstant.b;
+
+		factor.blendConstant4F[3][0] = blendConstant.a;
+		factor.blendConstant4F[3][1] = blendConstant.a;
+		factor.blendConstant4F[3][2] = blendConstant.a;
+		factor.blendConstant4F[3][3] = blendConstant.a;
+
+		factor.invBlendConstant4F[0][0] = 1 - blendConstant.r;
+		factor.invBlendConstant4F[0][1] = 1 - blendConstant.r;
+		factor.invBlendConstant4F[0][2] = 1 - blendConstant.r;
+		factor.invBlendConstant4F[0][3] = 1 - blendConstant.r;
+
+		factor.invBlendConstant4F[1][0] = 1 - blendConstant.g;
+		factor.invBlendConstant4F[1][1] = 1 - blendConstant.g;
+		factor.invBlendConstant4F[1][2] = 1 - blendConstant.g;
+		factor.invBlendConstant4F[1][3] = 1 - blendConstant.g;
+
+		factor.invBlendConstant4F[2][0] = 1 - blendConstant.b;
+		factor.invBlendConstant4F[2][1] = 1 - blendConstant.b;
+		factor.invBlendConstant4F[2][2] = 1 - blendConstant.b;
+		factor.invBlendConstant4F[2][3] = 1 - blendConstant.b;
+
+		factor.invBlendConstant4F[3][0] = 1 - blendConstant.a;
+		factor.invBlendConstant4F[3][1] = 1 - blendConstant.a;
+		factor.invBlendConstant4F[3][2] = 1 - blendConstant.a;
+		factor.invBlendConstant4F[3][3] = 1 - blendConstant.a;
+	}
+
+	void PixelProcessor::setFillMode(FillMode fillMode)
+	{
+		context->fillMode = fillMode;
+	}
+
+	void PixelProcessor::setShadingMode(ShadingMode shadingMode)
+	{
+		context->shadingMode = shadingMode;
+	}
+
+	void PixelProcessor::setAlphaBlendEnable(bool alphaBlendEnable)
+	{
+		context->setAlphaBlendEnable(alphaBlendEnable);
+	}
+
+	void PixelProcessor::setSourceBlendFactor(BlendFactor sourceBlendFactor)
+	{
+		context->setSourceBlendFactor(sourceBlendFactor);
+	}
+
+	void PixelProcessor::setDestBlendFactor(BlendFactor destBlendFactor)
+	{
+		context->setDestBlendFactor(destBlendFactor);
+	}
+
+	void PixelProcessor::setBlendOperation(BlendOperation blendOperation)
+	{
+		context->setBlendOperation(blendOperation);
+	}
+
+	void PixelProcessor::setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable)
+	{
+		context->setSeparateAlphaBlendEnable(separateAlphaBlendEnable);
+	}
+
+	void PixelProcessor::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
+	{
+		context->setSourceBlendFactorAlpha(sourceBlendFactorAlpha);
+	}
+
+	void PixelProcessor::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
+	{
+		context->setDestBlendFactorAlpha(destBlendFactorAlpha);
+	}
+
+	void PixelProcessor::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
+	{
+		context->setBlendOperationAlpha(blendOperationAlpha);
+	}
+
+	void PixelProcessor::setAlphaReference(float alphaReference)
+	{
+		context->alphaReference = alphaReference;
+
+		factor.alphaReference4[0] = (word)iround(alphaReference * 0x1000 / 0xFF);
+		factor.alphaReference4[1] = (word)iround(alphaReference * 0x1000 / 0xFF);
+		factor.alphaReference4[2] = (word)iround(alphaReference * 0x1000 / 0xFF);
+		factor.alphaReference4[3] = (word)iround(alphaReference * 0x1000 / 0xFF);
+	}
+
+	void PixelProcessor::setGlobalMipmapBias(float bias)
+	{
+		context->setGlobalMipmapBias(bias);
+	}
+
+	void PixelProcessor::setFogStart(float start)
+	{
+		setFogRanges(start, context->fogEnd);
+	}
+
+	void PixelProcessor::setFogEnd(float end)
+	{
+		setFogRanges(context->fogStart, end);
+	}
+
+	void PixelProcessor::setFogColor(Color<float> fogColor)
+	{
+		// TODO: Compact into generic function
+		word fogR = (unsigned short)(65535 * fogColor.r);
+		word fogG = (unsigned short)(65535 * fogColor.g);
+		word fogB = (unsigned short)(65535 * fogColor.b);
+
+		fog.color4[0][0] = fogR;
+		fog.color4[0][1] = fogR;
+		fog.color4[0][2] = fogR;
+		fog.color4[0][3] = fogR;
+
+		fog.color4[1][0] = fogG;
+		fog.color4[1][1] = fogG;
+		fog.color4[1][2] = fogG;
+		fog.color4[1][3] = fogG;
+
+		fog.color4[2][0] = fogB;
+		fog.color4[2][1] = fogB;
+		fog.color4[2][2] = fogB;
+		fog.color4[2][3] = fogB;
+
+		fog.colorF[0] = replicate(fogColor.r);
+		fog.colorF[1] = replicate(fogColor.g);
+		fog.colorF[2] = replicate(fogColor.b);
+	}
+
+	void PixelProcessor::setFogDensity(float fogDensity)
+	{
+		fog.densityE = replicate(-fogDensity * 1.442695f);   // 1/e^x = 2^(-x*1.44)
+		fog.density2E = replicate(-fogDensity * fogDensity * 1.442695f);
+	}
+
+	void PixelProcessor::setPixelFogMode(FogMode fogMode)
+	{
+		context->pixelFogMode = fogMode;
+	}
+
+	void PixelProcessor::setPerspectiveCorrection(bool perspectiveEnable)
+	{
+		perspectiveCorrection = perspectiveEnable;
+	}
+
+	void PixelProcessor::setOcclusionEnabled(bool enable)
+	{
+		context->occlusionEnabled = enable;
+	}
+
+	void PixelProcessor::setRoutineCacheSize(int cacheSize)
+	{
+		delete routineCache;
+		routineCache = new RoutineCache<State>(clamp(cacheSize, 1, 65536), precachePixel ? "sw-pixel" : 0);
+	}
+
+	void PixelProcessor::setFogRanges(float start, float end)
+	{
+		context->fogStart = start;
+		context->fogEnd = end;
+
+		if(start == end)
+		{
+			end += 0.001f;   // Hack: ensure there is a small range
+		}
+
+		float fogScale = -1.0f / (end - start);
+		float fogOffset = end * -fogScale;
+
+		fog.scale = replicate(fogScale);
+		fog.offset = replicate(fogOffset);
+	}
+
+	const PixelProcessor::State PixelProcessor::update() const
+	{
+		State state;
+
+		if(context->pixelShader)
+		{
+			state.shaderID = context->pixelShader->getSerialID();
+		}
+		else
+		{
+			state.shaderID = 0;
+		}
+
+		state.depthOverride = context->pixelShader && context->pixelShader->depthOverride();
+		state.shaderContainsKill = context->pixelShader ? context->pixelShader->containsKill() : false;
+
+		if(context->alphaTestActive())
+		{
+			state.alphaCompareMode = context->alphaCompareMode;
+
+			state.transparencyAntialiasing = context->getMultiSampleCount() > 1 ? transparencyAntialiasing : TRANSPARENCY_NONE;
+		}
+
+		state.depthWriteEnable = context->depthWriteActive();
+
+		if(context->stencilActive())
+		{
+			state.stencilActive = true;
+			state.stencilCompareMode = context->stencilCompareMode;
+			state.stencilFailOperation = context->stencilFailOperation;
+			state.stencilPassOperation = context->stencilPassOperation;
+			state.stencilZFailOperation = context->stencilZFailOperation;
+			state.noStencilMask = (context->stencilMask == 0xFF);
+			state.noStencilWriteMask = (context->stencilWriteMask == 0xFF);
+			state.stencilWriteMasked = (context->stencilWriteMask == 0x00);
+
+			state.twoSidedStencil = context->twoSidedStencil;
+			state.stencilCompareModeCCW = context->twoSidedStencil ? context->stencilCompareModeCCW : state.stencilCompareMode;
+			state.stencilFailOperationCCW = context->twoSidedStencil ? context->stencilFailOperationCCW : state.stencilFailOperation;
+			state.stencilPassOperationCCW = context->twoSidedStencil ? context->stencilPassOperationCCW : state.stencilPassOperation;
+			state.stencilZFailOperationCCW = context->twoSidedStencil ? context->stencilZFailOperationCCW : state.stencilZFailOperation;
+			state.noStencilMaskCCW = context->twoSidedStencil ? (context->stencilMaskCCW == 0xFF) : state.noStencilMask;
+			state.noStencilWriteMaskCCW = context->twoSidedStencil ? (context->stencilWriteMaskCCW == 0xFF) : state.noStencilWriteMask;
+			state.stencilWriteMaskedCCW = context->twoSidedStencil ? (context->stencilWriteMaskCCW == 0x00) : state.stencilWriteMasked;
+		}
+
+		if(context->depthBufferActive())
+		{
+			state.depthTestActive = true;
+			state.depthCompareMode = context->depthCompareMode;
+			state.quadLayoutDepthBuffer = Surface::hasQuadLayout(context->depthBuffer->getInternalFormat());
+		}
+
+		state.occlusionEnabled = context->occlusionEnabled;
+
+		state.fogActive = context->fogActive();
+		state.pixelFogMode = context->pixelFogActive();
+		state.wBasedFog = context->wBasedFog && context->pixelFogActive() != FOG_NONE;
+		state.perspective = context->perspectiveActive();
+		state.depthClamp = (context->depthBias != 0.0f) || (context->slopeDepthBias != 0.0f);
+
+		if(context->alphaBlendActive())
+		{
+			state.alphaBlendActive = true;
+			state.sourceBlendFactor = context->sourceBlendFactor();
+			state.destBlendFactor = context->destBlendFactor();
+			state.blendOperation = context->blendOperation();
+			state.sourceBlendFactorAlpha = context->sourceBlendFactorAlpha();
+			state.destBlendFactorAlpha = context->destBlendFactorAlpha();
+			state.blendOperationAlpha = context->blendOperationAlpha();
+		}
+
+		state.logicalOperation = context->colorLogicOp();
+
+		for(int i = 0; i < RENDERTARGETS; i++)
+		{
+			state.colorWriteMask |= context->colorWriteActive(i) << (4 * i);
+			state.targetFormat[i] = context->renderTargetInternalFormat(i);
+		}
+
+		state.writeSRGB	= context->writeSRGB && context->renderTarget[0] && Surface::isSRGBwritable(context->renderTarget[0]->getExternalFormat());
+		state.multiSample = context->getMultiSampleCount();
+		state.multiSampleMask = context->multiSampleMask;
+
+		if(state.multiSample > 1 && context->pixelShader)
+		{
+			state.centroid = context->pixelShader->containsCentroid();
+		}
+
+		state.frontFaceCCW = context->frontFacingCCW;
+
+		if(!context->pixelShader)
+		{
+			for(unsigned int i = 0; i < 8; i++)
+			{
+				state.textureStage[i] = context->textureStage[i].textureStageState();
+			}
+
+			state.specularAdd = context->specularActive() && context->specularEnable;
+		}
+
+		for(unsigned int i = 0; i < 16; i++)
+		{
+			if(context->pixelShader)
+			{
+				if(context->pixelShader->usesSampler(i))
+				{
+					state.sampler[i] = context->sampler[i].samplerState();
+				}
+			}
+			else
+			{
+				if(i < 8 && state.textureStage[i].stageOperation != TextureStage::STAGE_DISABLE)
+				{
+					state.sampler[i] = context->sampler[i].samplerState();
+				}
+				else break;
+			}
+		}
+
+		const bool point = context->isDrawPoint(true);
+		const bool sprite = context->pointSpriteActive();
+		const bool flatShading = (context->shadingMode == SHADING_FLAT) || point;
+
+		if(context->pixelShaderModel() < 0x0300)
+		{
+			for(int coordinate = 0; coordinate < 8; coordinate++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(context->textureActive(coordinate, component))
+					{
+						state.texture[coordinate].component |= 1 << component;
+
+						if(point && !sprite)
+						{
+							state.texture[coordinate].flat |= 1 << component;
+						}
+					}
+				}
+
+				if(context->textureTransformProject[coordinate] && context->pixelShaderModel() <= 0x0103)
+				{
+					if(context->textureTransformCount[coordinate] == 2)
+					{
+						state.texture[coordinate].project = 1;
+					}
+					else if(context->textureTransformCount[coordinate] == 3)
+					{
+						state.texture[coordinate].project = 2;
+					}
+					else if(context->textureTransformCount[coordinate] == 4 || context->textureTransformCount[coordinate] == 0)
+					{
+						state.texture[coordinate].project = 3;
+					}
+				}
+			}
+
+			for(int color = 0; color < 2; color++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(context->colorActive(color, component))
+					{
+						state.color[color].component |= 1 << component;
+
+						if(point || flatShading)
+						{
+							state.color[color].flat |= 1 << component;
+						}
+					}
+				}
+			}
+
+			if(context->fogActive())
+			{
+				state.fog.component = true;
+
+				if(point)
+				{
+					state.fog.flat = true;
+				}
+			}
+		}
+		else
+		{
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					const Shader::Semantic &semantic = context->pixelShader->getInput(interpolant, component);
+
+					if(semantic.active())
+					{
+						bool flat = point;
+
+						switch(semantic.usage)
+						{
+						case Shader::USAGE_TEXCOORD: flat = point && !sprite;             break;
+						case Shader::USAGE_COLOR:    flat = semantic.flat || flatShading; break;
+						}
+
+						state.interpolant[interpolant].component |= 1 << component;
+
+						if(flat)
+						{
+							state.interpolant[interpolant].flat |= 1 << component;
+						}
+					}
+				}
+			}
+		}
+
+		if(state.centroid)
+		{
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					state.interpolant[interpolant].centroid = context->pixelShader->getInput(interpolant, 0).centroid;
+				}
+			}
+		}
+
+		state.hash = state.computeHash();
+
+		return state;
+	}
+
+	Routine *PixelProcessor::routine(const State &state)
+	{
+		Routine *routine = routineCache->query(state);
+
+		if(!routine)
+		{
+			const bool integerPipeline = (context->pixelShaderModel() <= 0x0104);
+			QuadRasterizer *generator = nullptr;
+
+			if(integerPipeline)
+			{
+				generator = new PixelPipeline(state, context->pixelShader);
+			}
+			else
+			{
+				generator = new PixelProgram(state, context->pixelShader);
+			}
+
+			generator->generate();
+			routine = (*generator)(L"PixelRoutine_%0.8X", state.shaderID);
+			delete generator;
+
+			routineCache->add(state, routine);
+		}
+
+		return routine;
+	}
+}
diff --git a/src/Device/PixelProcessor.hpp b/src/Device/PixelProcessor.hpp
new file mode 100644
index 0000000..98300de
--- /dev/null
+++ b/src/Device/PixelProcessor.hpp
@@ -0,0 +1,342 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_PixelProcessor_hpp
+#define sw_PixelProcessor_hpp
+
+#include "Context.hpp"
+#include "RoutineCache.hpp"
+
+namespace sw
+{
+	class PixelShader;
+	class Rasterizer;
+	struct Texture;
+	struct DrawData;
+
+	class PixelProcessor
+	{
+	public:
+		struct States
+		{
+			unsigned int computeHash();
+
+			int shaderID;
+
+			bool depthOverride                        : 1;   // TODO: Eliminate by querying shader.
+			bool shaderContainsKill                   : 1;   // TODO: Eliminate by querying shader.
+
+			DepthCompareMode depthCompareMode         : BITS(DEPTH_LAST);
+			AlphaCompareMode alphaCompareMode         : BITS(ALPHA_LAST);
+			bool depthWriteEnable                     : 1;
+			bool quadLayoutDepthBuffer                : 1;
+
+			bool stencilActive                        : 1;
+			StencilCompareMode stencilCompareMode     : BITS(STENCIL_LAST);
+			StencilOperation stencilFailOperation     : BITS(OPERATION_LAST);
+			StencilOperation stencilPassOperation     : BITS(OPERATION_LAST);
+			StencilOperation stencilZFailOperation    : BITS(OPERATION_LAST);
+			bool noStencilMask                        : 1;
+			bool noStencilWriteMask                   : 1;
+			bool stencilWriteMasked                   : 1;
+			bool twoSidedStencil                      : 1;
+			StencilCompareMode stencilCompareModeCCW  : BITS(STENCIL_LAST);
+			StencilOperation stencilFailOperationCCW  : BITS(OPERATION_LAST);
+			StencilOperation stencilPassOperationCCW  : BITS(OPERATION_LAST);
+			StencilOperation stencilZFailOperationCCW : BITS(OPERATION_LAST);
+			bool noStencilMaskCCW                     : 1;
+			bool noStencilWriteMaskCCW                : 1;
+			bool stencilWriteMaskedCCW                : 1;
+
+			bool depthTestActive                      : 1;
+			bool fogActive                            : 1;
+			FogMode pixelFogMode                      : BITS(FOG_LAST);
+			bool specularAdd                          : 1;
+			bool occlusionEnabled                     : 1;
+			bool wBasedFog                            : 1;
+			bool perspective                          : 1;
+			bool depthClamp                           : 1;
+
+			bool alphaBlendActive                     : 1;
+			BlendFactor sourceBlendFactor             : BITS(BLEND_LAST);
+			BlendFactor destBlendFactor               : BITS(BLEND_LAST);
+			BlendOperation blendOperation             : BITS(BLENDOP_LAST);
+			BlendFactor sourceBlendFactorAlpha        : BITS(BLEND_LAST);
+			BlendFactor destBlendFactorAlpha          : BITS(BLEND_LAST);
+			BlendOperation blendOperationAlpha        : BITS(BLENDOP_LAST);
+
+			unsigned int colorWriteMask                       : RENDERTARGETS * 4;   // Four component bit masks
+			Format targetFormat[RENDERTARGETS];
+			bool writeSRGB                                    : 1;
+			unsigned int multiSample                          : 3;
+			unsigned int multiSampleMask                      : 4;
+			TransparencyAntialiasing transparencyAntialiasing : BITS(TRANSPARENCY_LAST);
+			bool centroid                                     : 1;
+			bool frontFaceCCW                                 : 1;
+
+			LogicalOperation logicalOperation : BITS(LOGICALOP_LAST);
+
+			Sampler::State sampler[TEXTURE_IMAGE_UNITS];
+			TextureStage::State textureStage[8];
+
+			struct Interpolant
+			{
+				unsigned char component : 4;
+				unsigned char flat : 4;
+				unsigned char project : 2;
+				bool centroid : 1;
+			};
+
+			union
+			{
+				struct
+				{
+					Interpolant color[2];
+					Interpolant texture[8];
+					Interpolant fog;
+				};
+
+				Interpolant interpolant[MAX_FRAGMENT_INPUTS];
+			};
+		};
+
+		struct State : States
+		{
+			State();
+
+			bool operator==(const State &state) const;
+
+			int colorWriteActive(int index) const
+			{
+				return (colorWriteMask >> (index * 4)) & 0xF;
+			}
+
+			bool alphaTestActive() const
+			{
+				return (alphaCompareMode != ALPHA_ALWAYS) || (transparencyAntialiasing != TRANSPARENCY_NONE);
+			}
+
+			bool pixelFogActive() const
+			{
+				return pixelFogMode != FOG_NONE;
+			}
+
+			unsigned int hash;
+		};
+
+		struct Stencil
+		{
+			int64_t testMaskQ;
+			int64_t referenceMaskedQ;
+			int64_t referenceMaskedSignedQ;
+			int64_t writeMaskQ;
+			int64_t invWriteMaskQ;
+			int64_t referenceQ;
+
+			void set(int reference, int testMask, int writeMask)
+			{
+				referenceQ = replicate(reference);
+				testMaskQ = replicate(testMask);
+				writeMaskQ = replicate(writeMask);
+				invWriteMaskQ = ~writeMaskQ;
+				referenceMaskedQ = referenceQ & testMaskQ;
+				referenceMaskedSignedQ = replicate(((reference & testMask) + 0x80) & 0xFF);
+			}
+
+			static int64_t replicate(int b)
+			{
+				int64_t w = b & 0xFF;
+
+				return (w << 0) | (w << 8) | (w << 16) | (w << 24) | (w << 32) | (w << 40) | (w << 48) | (w << 56);
+			}
+		};
+
+		struct Fog
+		{
+			float4 scale;
+			float4 offset;
+			word4 color4[3];
+			float4 colorF[3];
+			float4 densityE;
+			float4 density2E;
+		};
+
+		struct Factor
+		{
+			word4 textureFactor4[4];
+
+			word4 alphaReference4;
+
+			word4 blendConstant4W[4];
+			float4 blendConstant4F[4];
+			word4 invBlendConstant4W[4];
+			float4 invBlendConstant4F[4];
+		};
+
+	public:
+		typedef void (*RoutinePointer)(const Primitive *primitive, int count, int thread, DrawData *draw);
+
+		PixelProcessor(Context *context);
+
+		virtual ~PixelProcessor();
+
+		void setFloatConstant(unsigned int index, const float value[4]);
+		void setIntegerConstant(unsigned int index, const int value[4]);
+		void setBooleanConstant(unsigned int index, int boolean);
+
+		void setUniformBuffer(int index, sw::Resource* buffer, int offset);
+		void lockUniformBuffers(byte** u, sw::Resource* uniformBuffers[]);
+
+		void setRenderTarget(int index, Surface *renderTarget, unsigned int layer = 0);
+		void setDepthBuffer(Surface *depthBuffer, unsigned int layer = 0);
+		void setStencilBuffer(Surface *stencilBuffer, unsigned int layer = 0);
+
+		void setTexCoordIndex(unsigned int stage, int texCoordIndex);
+		void setStageOperation(unsigned int stage, TextureStage::StageOperation stageOperation);
+		void setFirstArgument(unsigned int stage, TextureStage::SourceArgument firstArgument);
+		void setSecondArgument(unsigned int stage, TextureStage::SourceArgument secondArgument);
+		void setThirdArgument(unsigned int stage, TextureStage::SourceArgument thirdArgument);
+		void setStageOperationAlpha(unsigned int stage, TextureStage::StageOperation stageOperationAlpha);
+		void setFirstArgumentAlpha(unsigned int stage, TextureStage::SourceArgument firstArgumentAlpha);
+		void setSecondArgumentAlpha(unsigned int stage, TextureStage::SourceArgument secondArgumentAlpha);
+		void setThirdArgumentAlpha(unsigned int stage, TextureStage::SourceArgument thirdArgumentAlpha);
+		void setFirstModifier(unsigned int stage, TextureStage::ArgumentModifier firstModifier);
+		void setSecondModifier(unsigned int stage, TextureStage::ArgumentModifier secondModifier);
+		void setThirdModifier(unsigned int stage, TextureStage::ArgumentModifier thirdModifier);
+		void setFirstModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier firstModifierAlpha);
+		void setSecondModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier secondModifierAlpha);
+		void setThirdModifierAlpha(unsigned int stage, TextureStage::ArgumentModifier thirdModifierAlpha);
+		void setDestinationArgument(unsigned int stage, TextureStage::DestinationArgument destinationArgument);
+		void setConstantColor(unsigned int stage, const Color<float> &constantColor);
+		void setBumpmapMatrix(unsigned int stage, int element, float value);
+		void setLuminanceScale(unsigned int stage, float value);
+		void setLuminanceOffset(unsigned int stage, float value);
+
+		void setTextureFilter(unsigned int sampler, FilterType textureFilter);
+		void setMipmapFilter(unsigned int sampler, MipmapType mipmapFilter);
+		void setGatherEnable(unsigned int sampler, bool enable);
+		void setAddressingModeU(unsigned int sampler, AddressingMode addressingMode);
+		void setAddressingModeV(unsigned int sampler, AddressingMode addressingMode);
+		void setAddressingModeW(unsigned int sampler, AddressingMode addressingMode);
+		void setReadSRGB(unsigned int sampler, bool sRGB);
+		void setMipmapLOD(unsigned int sampler, float bias);
+		void setBorderColor(unsigned int sampler, const Color<float> &borderColor);
+		void setMaxAnisotropy(unsigned int sampler, float maxAnisotropy);
+		void setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering);
+		void setSwizzleR(unsigned int sampler, SwizzleType swizzleR);
+		void setSwizzleG(unsigned int sampler, SwizzleType swizzleG);
+		void setSwizzleB(unsigned int sampler, SwizzleType swizzleB);
+		void setSwizzleA(unsigned int sampler, SwizzleType swizzleA);
+		void setCompareFunc(unsigned int sampler, CompareFunc compare);
+		void setBaseLevel(unsigned int sampler, int baseLevel);
+		void setMaxLevel(unsigned int sampler, int maxLevel);
+		void setMinLod(unsigned int sampler, float minLod);
+		void setMaxLod(unsigned int sampler, float maxLod);
+		void setSyncRequired(unsigned int sampler, bool isSincRequired);
+
+		void setWriteSRGB(bool sRGB);
+		void setDepthBufferEnable(bool depthBufferEnable);
+		void setDepthCompare(DepthCompareMode depthCompareMode);
+		void setAlphaCompare(AlphaCompareMode alphaCompareMode);
+		void setDepthWriteEnable(bool depthWriteEnable);
+		void setAlphaTestEnable(bool alphaTestEnable);
+		void setCullMode(CullMode cullMode, bool frontFacingCCW);
+		void setColorWriteMask(int index, int rgbaMask);
+
+		void setColorLogicOpEnabled(bool colorLogicOpEnabled);
+		void setLogicalOperation(LogicalOperation logicalOperation);
+
+		void setStencilEnable(bool stencilEnable);
+		void setStencilCompare(StencilCompareMode stencilCompareMode);
+		void setStencilReference(int stencilReference);
+		void setStencilMask(int stencilMask);
+		void setStencilFailOperation(StencilOperation stencilFailOperation);
+		void setStencilPassOperation(StencilOperation stencilPassOperation);
+		void setStencilZFailOperation(StencilOperation stencilZFailOperation);
+		void setStencilWriteMask(int stencilWriteMask);
+		void setTwoSidedStencil(bool enable);
+		void setStencilCompareCCW(StencilCompareMode stencilCompareMode);
+		void setStencilReferenceCCW(int stencilReference);
+		void setStencilMaskCCW(int stencilMask);
+		void setStencilFailOperationCCW(StencilOperation stencilFailOperation);
+		void setStencilPassOperationCCW(StencilOperation stencilPassOperation);
+		void setStencilZFailOperationCCW(StencilOperation stencilZFailOperation);
+		void setStencilWriteMaskCCW(int stencilWriteMask);
+
+		void setTextureFactor(const Color<float> &textureFactor);
+		void setBlendConstant(const Color<float> &blendConstant);
+
+		void setFillMode(FillMode fillMode);
+		void setShadingMode(ShadingMode shadingMode);
+
+		void setAlphaBlendEnable(bool alphaBlendEnable);
+		void setSourceBlendFactor(BlendFactor sourceBlendFactor);
+		void setDestBlendFactor(BlendFactor destBlendFactor);
+		void setBlendOperation(BlendOperation blendOperation);
+
+		void setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable);
+		void setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha);
+		void setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha);
+		void setBlendOperationAlpha(BlendOperation blendOperationAlpha);
+
+		void setAlphaReference(float alphaReference);
+
+		void setGlobalMipmapBias(float bias);
+
+		void setFogStart(float start);
+		void setFogEnd(float end);
+		void setFogColor(Color<float> fogColor);
+		void setFogDensity(float fogDensity);
+		void setPixelFogMode(FogMode fogMode);
+
+		void setPerspectiveCorrection(bool perspectiveCorrection);
+
+		void setOcclusionEnabled(bool enable);
+
+	protected:
+		const State update() const;
+		Routine *routine(const State &state);
+		void setRoutineCacheSize(int routineCacheSize);
+
+		// Shader constants
+		word4 cW[8][4];
+		float4 c[FRAGMENT_UNIFORM_VECTORS];
+		int4 i[16];
+		bool b[16];
+
+		// Other semi-constants
+		Stencil stencil;
+		Stencil stencilCCW;
+		Fog fog;
+		Factor factor;
+
+	private:
+		struct UniformBufferInfo
+		{
+			UniformBufferInfo();
+
+			Resource* buffer;
+			int offset;
+		};
+		UniformBufferInfo uniformBufferInfo[MAX_UNIFORM_BUFFER_BINDINGS];
+
+		void setFogRanges(float start, float end);
+
+		Context *const context;
+
+		RoutineCache<State> *routineCache;
+	};
+}
+
+#endif   // sw_PixelProcessor_hpp
diff --git a/src/Device/Plane.cpp b/src/Device/Plane.cpp
new file mode 100644
index 0000000..095b7f2
--- /dev/null
+++ b/src/Device/Plane.cpp
@@ -0,0 +1,60 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Plane.hpp"
+
+#include "Matrix.hpp"
+
+namespace sw
+{
+	Plane::Plane()
+	{
+	}
+
+	Plane::Plane(float p_A, float p_B, float p_C, float p_D)
+	{
+		A = p_A;
+		B = p_B;
+		C = p_C;
+		D = p_D;
+	}
+
+	Plane::Plane(const float ABCD[4])
+	{
+		A = ABCD[0];
+		B = ABCD[1];
+		C = ABCD[2];
+		D = ABCD[3];
+	}
+
+	Plane operator*(const Plane &p, const Matrix &T)
+	{
+		Matrix M = !T;
+
+		return Plane(p.A * M(1, 1) + p.B * M(1, 2) + p.C * M(1, 3) + p.D * M(1, 4),
+		             p.A * M(2, 1) + p.B * M(2, 2) + p.C * M(2, 3) + p.D * M(2, 4),
+		             p.A * M(3, 1) + p.B * M(3, 2) + p.C * M(3, 3) + p.D * M(3, 4),
+		             p.A * M(4, 1) + p.B * M(4, 2) + p.C * M(4, 3) + p.D * M(4, 4));
+	}
+
+	Plane operator*(const Matrix &T, const Plane &p)
+	{
+		Matrix M = !T;
+
+		return Plane(M(1, 1) * p.A + M(2, 1) * p.B + M(3, 1) * p.C + M(4, 1) * p.D,
+		             M(1, 2) * p.A + M(2, 2) * p.B + M(3, 2) * p.C + M(4, 2) * p.D,
+		             M(1, 3) * p.A + M(2, 3) * p.B + M(3, 3) * p.C + M(4, 3) * p.D,
+		             M(1, 4) * p.A + M(2, 4) * p.B + M(3, 4) * p.C + M(4, 4) * p.D);
+	}
+}
diff --git a/src/Device/Plane.hpp b/src/Device/Plane.hpp
new file mode 100644
index 0000000..962b9ae
--- /dev/null
+++ b/src/Device/Plane.hpp
@@ -0,0 +1,40 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Plane_hpp
+#define Plane_hpp
+
+#include "Vector.hpp"
+
+namespace sw
+{
+	struct Matrix;
+
+	struct Plane
+	{
+		float A;
+		float B;
+		float C;
+		float D;
+
+		Plane();
+		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)
+	};
+}
+
+#endif   // Plane_hpp
diff --git a/src/Device/Point.cpp b/src/Device/Point.cpp
new file mode 100644
index 0000000..e7e33dd
--- /dev/null
+++ b/src/Device/Point.cpp
@@ -0,0 +1,92 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Point.hpp"
+
+#include "Matrix.hpp"
+
+namespace sw
+{
+	Point &Point::operator+=(const Vector &v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+
+		return *this;
+	}
+
+	Point &Point::operator-=(const Vector &v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+
+		return *this;
+	}
+
+	Point operator+(const Point &P, const Vector &v)
+	{
+		return Point(P.x + v.x, P.y + v.y, P.z + v.z);
+	}
+
+	Point operator-(const Point &P, const Vector &v)
+	{
+		return Point(P.x - v.x, P.y - v.y, P.z - v.z);
+	}
+
+	Vector operator-(const Point &P, const Point &Q)
+	{
+		return Vector(P.x - Q.x, P.y - Q.y, P.z - Q.z);
+	}
+
+	Point operator*(const Matrix &M, const Point &P)
+	{
+		return Point(M(1, 1) * P.x + M(1, 2) * P.y + M(1, 3) * P.z + M(1, 4),
+		             M(2, 1) * P.x + M(2, 2) * P.y + M(2, 3) * P.z + M(2, 4),
+		             M(3, 1) * P.x + M(3, 2) * P.y + M(3, 3) * P.z + M(3, 4));
+	}
+
+	Point operator*(const Point &P, const Matrix &M)
+	{
+		return Point(P.x * M(1, 1) + P.y * M(2, 1) + P.z * M(3, 1),
+		             P.x * M(1, 2) + P.y * M(2, 2) + P.z * M(3, 2),
+		             P.x * M(1, 3) + P.y * M(2, 3) + P.z * M(3, 3));
+	}
+
+	Point &operator*=(Point &P, const Matrix &M)
+	{
+		return P = P * M;
+	}
+
+	float Point::d(const Point &P) const
+	{
+		return Vector::N(*this - P);
+	}
+
+	float Point::d2(const Point &P) const
+	{
+		return Vector::N2(*this - P);
+	}
+
+	float Point::d(const Point &P, const Point &Q)
+	{
+		return Vector::N(P - Q);
+	}
+
+	float Point::d2(const Point &P, const Point &Q)
+	{
+		return Vector::N2(P - Q);
+	}
+}
diff --git a/src/Device/Point.hpp b/src/Device/Point.hpp
new file mode 100644
index 0000000..85198c5
--- /dev/null
+++ b/src/Device/Point.hpp
@@ -0,0 +1,139 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Point_hpp
+#define Point_hpp
+
+namespace sw
+{
+	struct Vector;
+	struct Matrix;
+
+	struct Point
+	{
+		Point();
+		Point(const int i);
+		Point(const Point &P);
+		Point(const Vector &v);
+		Point(float Px, float Py, float Pz);
+
+		Point &operator=(const Point &P);
+
+		union
+		{
+			float p[3];
+
+			struct
+			{	
+				float x;
+				float y;
+				float z;
+			};
+		};
+
+		float &operator[](int i);
+		float &operator()(int i);
+
+		const float &operator[](int i) const;
+		const float &operator()(int i) const;
+
+		Point &operator+=(const Vector &v);
+		Point &operator-=(const Vector &v);
+
+		friend Point operator+(const Point &P, const Vector &v);
+		friend Point operator-(const Point &P, const Vector &v);
+
+		friend Vector operator-(const Point &P, const Point &Q);
+
+		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
+
+		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
+	};
+}
+
+#include "Vector.hpp"
+
+namespace sw
+{
+	inline Point::Point()
+	{
+	}
+
+	inline Point::Point(const int i)
+	{
+		const float s = (float)i;
+
+		x = s;
+		y = s;
+		z = s;
+	}
+
+	inline Point::Point(const Point &P)
+	{
+		x = P.x;
+		y = P.y;
+		z = P.z;
+	}
+
+	inline Point::Point(const Vector &v)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+	}
+
+	inline Point::Point(float P_x, float P_y, float P_z)
+	{
+		x = P_x;
+		y = P_y;
+		z = P_z;
+	}
+
+	inline Point &Point::operator=(const Point &P)
+	{
+		x = P.x;
+		y = P.y;
+		z = P.z;
+
+		return *this;
+	}
+
+	inline float &Point::operator()(int i)
+	{
+		return p[i];
+	}
+
+	inline float &Point::operator[](int i)
+	{
+		return p[i];
+	}
+
+	inline const float &Point::operator()(int i) const
+	{
+		return p[i];
+	}
+
+	inline const float &Point::operator[](int i) const
+	{
+		return p[i];
+	}
+}
+
+#endif   // Point_hpp
diff --git a/src/Device/Polygon.hpp b/src/Device/Polygon.hpp
new file mode 100644
index 0000000..8ee8562
--- /dev/null
+++ b/src/Device/Polygon.hpp
@@ -0,0 +1,56 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Polygon_hpp
+#define sw_Polygon_hpp
+
+#include "Vertex.hpp"
+
+namespace sw
+{
+	struct Polygon
+	{
+		Polygon(const float4 *P0, const float4 *P1, const float4 *P2)
+		{
+			P[0][0] = P0;
+			P[0][1] = P1;
+			P[0][2] = P2;
+
+			n = 3;
+			i = 0;
+			b = 0;
+		}
+
+		Polygon(const float4 *P, int n)
+		{
+			for(int i = 0; i < n; i++)
+			{
+				this->P[0][i] = &P[i];
+			}
+
+			this->n = n;
+			this->i = 0;
+			this->b = 0;
+		}
+
+		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
+	};
+}
+
+#endif   // sw_Polygon_hpp
diff --git a/src/Device/Primitive.hpp b/src/Device/Primitive.hpp
new file mode 100644
index 0000000..52daa18
--- /dev/null
+++ b/src/Device/Primitive.hpp
@@ -0,0 +1,80 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Primitive_hpp
+#define sw_Primitive_hpp
+
+#include "Vertex.hpp"
+#include "Main/Config.hpp"
+
+namespace sw
+{
+	struct Triangle
+	{
+		Vertex v0;
+		Vertex v1;
+		Vertex v2;
+	};
+
+	struct PlaneEquation   // z = A * x + B * y + C
+	{
+		float4 A;
+		float4 B;
+		float4 C;
+	};
+
+	struct Primitive
+	{
+		int yMin;
+		int yMax;
+
+		float4 xQuad;
+		float4 yQuad;
+
+		PlaneEquation z;
+		PlaneEquation w;
+
+		union
+		{
+			struct
+			{
+				PlaneEquation C[2][4];
+				PlaneEquation T[8][4];
+				PlaneEquation f;
+			};
+
+			PlaneEquation V[MAX_FRAGMENT_INPUTS][4];
+		};
+
+		float area;
+
+		// Masks for two-sided stencil
+		int64_t clockwiseMask;
+		int64_t invClockwiseMask;
+
+		struct Span
+		{
+			unsigned short left;
+			unsigned short right;
+		};
+
+		// The rasterizer adds a zero length span to the top and bottom of the polygon to allow
+		// for 2x2 pixel processing. We need an even number of spans to keep accesses aligned.
+		Span outlineUnderflow[2];
+		Span outline[OUTLINE_RESOLUTION];
+		Span outlineOverflow[2];
+	};
+}
+
+#endif   // sw_Primitive_hpp
diff --git a/src/Device/QuadRasterizer.cpp b/src/Device/QuadRasterizer.cpp
new file mode 100644
index 0000000..6b319b4
--- /dev/null
+++ b/src/Device/QuadRasterizer.cpp
@@ -0,0 +1,350 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "QuadRasterizer.hpp"
+
+#include "Primitive.hpp"
+#include "Renderer.hpp"
+#include "Shader/Constants.hpp"
+#include "Common/Math.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool veryEarlyDepthTest;
+	extern bool complementaryDepthBuffer;
+	extern bool fullPixelPositionRegister;
+
+	extern int clusterCount;
+
+	QuadRasterizer::QuadRasterizer(const PixelProcessor::State &state, const PixelShader *pixelShader) : state(state), shader(pixelShader)
+	{
+	}
+
+	QuadRasterizer::~QuadRasterizer()
+	{
+	}
+
+	void QuadRasterizer::generate()
+	{
+		#if PERF_PROFILE
+			for(int i = 0; i < PERF_TIMERS; i++)
+			{
+				cycles[i] = 0;
+			}
+
+			Long pixelTime = Ticks();
+		#endif
+
+		constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
+		occlusion = 0;
+		int clusterCount = Renderer::getClusterCount();
+
+		Do
+		{
+			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;
+			yMin &= -clusterCount * 2;
+			yMin += cluster2;
+
+			If(yMin < yMax)
+			{
+				rasterize(yMin, yMax);
+			}
+
+			primitive += sizeof(Primitive) * state.multiSample;
+			count--;
+		}
+		Until(count == 0)
+
+		if(state.occlusionEnabled)
+		{
+			UInt clusterOcclusion = *Pointer<UInt>(data + OFFSET(DrawData,occlusion) + 4 * cluster);
+			clusterOcclusion += occlusion;
+			*Pointer<UInt>(data + OFFSET(DrawData,occlusion) + 4 * cluster) = clusterOcclusion;
+		}
+
+		#if PERF_PROFILE
+			cycles[PERF_PIXEL] = Ticks() - pixelTime;
+
+			for(int i = 0; i < PERF_TIMERS; i++)
+			{
+				*Pointer<Long>(data + OFFSET(DrawData,cycles[i]) + 8 * cluster) += cycles[i];
+			}
+		#endif
+
+		Return();
+	}
+
+	void QuadRasterizer::rasterize(Int &yMin, Int &yMax)
+	{
+		Pointer<Byte> cBuffer[RENDERTARGETS];
+		Pointer<Byte> zBuffer;
+		Pointer<Byte> sBuffer;
+
+		for(int index = 0; index < RENDERTARGETS; index++)
+		{
+			if(state.colorWriteActive(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));
+		}
+
+		if(state.stencilActive)
+		{
+			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 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)));
+				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 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)));
+				x1 = Max(x1, Max(x1a, x1b));
+			}
+
+			Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16);
+
+			if(interpolateZ())
+			{
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					Float4 y = yyyy;
+
+					if(state.multiSample > 1)
+					{
+						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);
+				}
+			}
+
+			if(veryEarlyDepthTest && state.multiSample == 1 && !state.depthOverride)
+			{
+				if(!state.stencilActive && state.depthTestActive && (state.depthCompareMode == DEPTH_LESSEQUAL || state.depthCompareMode == DEPTH_LESS))   // FIXME: Both modes ok?
+				{
+					Float4 xxxx = Float4(Float(x0)) + *Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16);
+
+					Pointer<Byte> buffer;
+					Int pitch;
+
+					if(!state.quadLayoutDepthBuffer)
+					{
+						buffer = zBuffer + 4 * x0;
+						pitch = *Pointer<Int>(data + OFFSET(DrawData,depthPitchB));
+					}
+					else
+					{
+						buffer = zBuffer + 8 * x0;
+					}
+
+					For(Int x = x0, x < x1, x += 2)
+					{
+						Float4 z = interpolate(xxxx, Dz[0], z, primitive + OFFSET(Primitive,z), false, false, state.depthClamp);
+
+						Float4 zValue;
+
+						if(!state.quadLayoutDepthBuffer)
+						{
+							// FIXME: Properly optimizes?
+							zValue.xy = *Pointer<Float4>(buffer);
+							zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
+						}
+						else
+						{
+							zValue = *Pointer<Float4>(buffer, 16);
+						}
+
+						Int4 zTest;
+
+						if(complementaryDepthBuffer)
+						{
+							zTest = CmpLE(zValue, z);
+						}
+						else
+						{
+							zTest = CmpNLT(zValue, z);
+						}
+
+						Int zMask = SignMask(zTest);
+
+						If(zMask == 0)
+						{
+							x0 += 2;
+						}
+						Else
+						{
+							x = x1;
+						}
+
+						xxxx += Float4(2);
+
+						if(!state.quadLayoutDepthBuffer)
+						{
+							buffer += 8;
+						}
+						else
+						{
+							buffer += 16;
+						}
+					}
+				}
+			}
+
+			If(x0 < x1)
+			{
+				if(interpolateW())
+				{
+					Dw = *Pointer<Float4>(primitive + OFFSET(Primitive,w.C), 16) + yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive,w.B), 16);
+				}
+
+				for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+				{
+					for(int component = 0; component < 4; component++)
+					{
+						if(state.interpolant[interpolant].component & (1 << component))
+						{
+							Dv[interpolant][component] = *Pointer<Float4>(primitive + OFFSET(Primitive,V[interpolant][component].C), 16);
+
+							if(!(state.interpolant[interpolant].flat & (1 << component)))
+							{
+								Dv[interpolant][component] += yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive,V[interpolant][component].B), 16);
+							}
+						}
+					}
+				}
+
+				if(state.fog.component)
+				{
+					Df = *Pointer<Float4>(primitive + OFFSET(Primitive,f.C), 16);
+
+					if(!state.fog.flat)
+					{
+						Df += yyyy * *Pointer<Float4>(primitive + OFFSET(Primitive,f.B), 16);
+					}
+				}
+
+				Short4 xLeft[4];
+				Short4 xRight[4];
+
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					xLeft[q] = *Pointer<Short4>(primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline) + y * sizeof(Primitive::Span));
+					xRight[q] = xLeft[q];
+
+					xLeft[q] = Swizzle(xLeft[q], 0xA0) - Short4(1, 2, 1, 2);
+					xRight[q] = Swizzle(xRight[q], 0xF5) - Short4(0, 1, 0, 1);
+				}
+
+				For(Int x = x0, x < x1, x += 2)
+				{
+					Short4 xxxx = Short4(x);
+					Int cMask[4];
+
+					for(unsigned int q = 0; q < state.multiSample; q++)
+					{
+						Short4 mask = CmpGT(xxxx, xLeft[q]) & CmpGT(xRight[q], xxxx);
+						cMask[q] = SignMask(PackSigned(mask, mask)) & 0x0000000F;
+					}
+
+					quad(cBuffer, zBuffer, sBuffer, cMask, x, y);
+				}
+			}
+
+			int clusterCount = Renderer::getClusterCount();
+
+			for(int index = 0; index < RENDERTARGETS; index++)
+			{
+				if(state.colorWriteActive(index))
+				{
+					cBuffer[index] += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index])) << (1 + sw::log2(clusterCount));   // FIXME: Precompute
+				}
+			}
+
+			if(state.depthTestActive)
+			{
+				zBuffer += *Pointer<Int>(data + OFFSET(DrawData,depthPitchB)) << (1 + sw::log2(clusterCount));   // FIXME: Precompute
+			}
+
+			if(state.stencilActive)
+			{
+				sBuffer += *Pointer<Int>(data + OFFSET(DrawData,stencilPitchB)) << (1 + sw::log2(clusterCount));   // FIXME: Precompute
+			}
+
+			y += 2 * clusterCount;
+		}
+		Until(y >= yMax)
+	}
+
+	Float4 QuadRasterizer::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective, bool clamp)
+	{
+		Float4 interpolant = D;
+
+		if(!flat)
+		{
+			interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation, A), 16);
+
+			if(perspective)
+			{
+				interpolant *= rhw;
+			}
+		}
+
+		if(clamp)
+		{
+			interpolant = Min(Max(interpolant, Float4(0.0f)), Float4(1.0f));
+		}
+
+		return interpolant;
+	}
+
+	bool QuadRasterizer::interpolateZ() const
+	{
+		return state.depthTestActive || state.pixelFogActive() || (shader && shader->isVPosDeclared() && fullPixelPositionRegister);
+	}
+
+	bool QuadRasterizer::interpolateW() const
+	{
+		return state.perspective || (shader && shader->isVPosDeclared() && fullPixelPositionRegister);
+	}
+}
diff --git a/src/Device/QuadRasterizer.hpp b/src/Device/QuadRasterizer.hpp
new file mode 100644
index 0000000..1d7681d
--- /dev/null
+++ b/src/Device/QuadRasterizer.hpp
@@ -0,0 +1,61 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_QuadRasterizer_hpp
+#define sw_QuadRasterizer_hpp
+
+#include "Rasterizer.hpp"
+#include "Shader/ShaderCore.hpp"
+#include "Shader/PixelShader.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	class QuadRasterizer : public Rasterizer
+	{
+	public:
+		QuadRasterizer(const PixelProcessor::State &state, const PixelShader *shader);
+		virtual ~QuadRasterizer();
+
+		void generate();
+
+	protected:
+		Pointer<Byte> constants;
+
+		Float4 Dz[4];
+		Float4 Dw;
+		Float4 Dv[MAX_FRAGMENT_INPUTS][4];
+		Float4 Df;
+
+		UInt occlusion;
+
+#if PERF_PROFILE
+		Long cycles[PERF_TIMERS];
+#endif
+
+		virtual void quad(Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y) = 0;
+
+		bool interpolateZ() const;
+		bool interpolateW() const;
+		Float4 interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective, bool clamp);
+
+		const PixelProcessor::State &state;
+		const PixelShader *const shader;
+
+	private:
+		void rasterize(Int &yMin, Int &yMax);
+	};
+}
+
+#endif   // sw_QuadRasterizer_hpp
diff --git a/src/Device/Rasterizer.hpp b/src/Device/Rasterizer.hpp
new file mode 100644
index 0000000..3811a25
--- /dev/null
+++ b/src/Device/Rasterizer.hpp
@@ -0,0 +1,38 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Rasterizer_hpp
+#define sw_Rasterizer_hpp
+
+#include "Context.hpp"
+#include "PixelProcessor.hpp"
+#include "Main/Config.hpp"
+
+namespace sw
+{
+	class Rasterizer : public Function<Void(Pointer<Byte>, Int, Int, Pointer<Byte>)>
+	{
+	public:
+		Rasterizer() : primitive(Arg<0>()), count(Arg<1>()), cluster(Arg<2>()), data(Arg<3>()) {}
+		virtual ~Rasterizer() {};
+
+	protected:
+		Pointer<Byte> primitive;
+		Int count;
+		Int cluster;
+		Pointer<Byte> data;
+	};
+}
+
+#endif   // sw_Rasterizer_hpp
diff --git a/src/Device/Renderer.cpp b/src/Device/Renderer.cpp
new file mode 100644
index 0000000..e7ec20a
--- /dev/null
+++ b/src/Device/Renderer.cpp
@@ -0,0 +1,2854 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Renderer.hpp"
+
+#include "Clipper.hpp"
+#include "Surface.hpp"
+#include "Primitive.hpp"
+#include "Polygon.hpp"
+#include "Main/FrameBuffer.hpp"
+#include "Main/SwiftConfig.hpp"
+#include "Reactor/Reactor.hpp"
+#include "Shader/Constants.hpp"
+#include "Common/MutexLock.hpp"
+#include "Common/CPUID.hpp"
+#include "Common/Memory.hpp"
+#include "Common/Resource.hpp"
+#include "Common/Half.hpp"
+#include "Common/Math.hpp"
+#include "Common/Timer.hpp"
+#include "Common/Debug.hpp"
+
+#undef max
+
+bool disableServer = true;
+
+#ifndef NDEBUG
+unsigned int minPrimitives = 1;
+unsigned int maxPrimitives = 1 << 21;
+#endif
+
+namespace sw
+{
+	extern bool halfIntegerCoordinates;     // Pixel centers are not at integer coordinates
+	extern bool symmetricNormalizedDepth;   // [-1, 1] instead of [0, 1]
+	extern bool booleanFaceRegister;
+	extern bool fullPixelPositionRegister;
+	extern bool leadingVertexFirst;         // Flat shading uses first vertex, else last
+	extern bool secondaryColor;             // Specular lighting is applied after texturing
+	extern bool colorsDefaultToZero;
+
+	extern bool forceWindowed;
+	extern bool complementaryDepthBuffer;
+	extern bool postBlendSRGB;
+	extern bool exactColorRounding;
+	extern TransparencyAntialiasing transparencyAntialiasing;
+	extern bool forceClearRegisters;
+
+	extern bool precacheVertex;
+	extern bool precacheSetup;
+	extern bool precachePixel;
+
+	static const int batchSize = 128;
+	AtomicInt threadCount(1);
+	AtomicInt Renderer::unitCount(1);
+	AtomicInt Renderer::clusterCount(1);
+
+	TranscendentalPrecision logPrecision = ACCURATE;
+	TranscendentalPrecision expPrecision = ACCURATE;
+	TranscendentalPrecision rcpPrecision = ACCURATE;
+	TranscendentalPrecision rsqPrecision = ACCURATE;
+	bool perspectiveCorrection = true;
+
+	static void setGlobalRenderingSettings(Conventions conventions, bool exactColorRounding)
+	{
+		static bool initialized = false;
+
+		if(!initialized)
+		{
+			sw::halfIntegerCoordinates = conventions.halfIntegerCoordinates;
+			sw::symmetricNormalizedDepth = conventions.symmetricNormalizedDepth;
+			sw::booleanFaceRegister = conventions.booleanFaceRegister;
+			sw::fullPixelPositionRegister = conventions.fullPixelPositionRegister;
+			sw::leadingVertexFirst = conventions.leadingVertexFirst;
+			sw::secondaryColor = conventions.secondaryColor;
+			sw::colorsDefaultToZero = conventions.colorsDefaultToZero;
+			sw::exactColorRounding = exactColorRounding;
+			initialized = true;
+		}
+	}
+
+	struct Parameters
+	{
+		Renderer *renderer;
+		int threadIndex;
+	};
+
+	DrawCall::DrawCall()
+	{
+		queries = 0;
+
+		vsDirtyConstF = VERTEX_UNIFORM_VECTORS + 1;
+		vsDirtyConstI = 16;
+		vsDirtyConstB = 16;
+
+		psDirtyConstF = FRAGMENT_UNIFORM_VECTORS;
+		psDirtyConstI = 16;
+		psDirtyConstB = 16;
+
+		references = -1;
+
+		data = (DrawData*)allocate(sizeof(DrawData));
+		data->constants = &constants;
+	}
+
+	DrawCall::~DrawCall()
+	{
+		delete queries;
+
+		deallocate(data);
+	}
+
+	Renderer::Renderer(Context *context, Conventions conventions, bool exactColorRounding) : VertexProcessor(context), PixelProcessor(context), SetupProcessor(context), context(context), viewport()
+	{
+		setGlobalRenderingSettings(conventions, exactColorRounding);
+
+		setRenderTarget(0, 0);
+		clipper = new Clipper(symmetricNormalizedDepth);
+		blitter = new Blitter;
+
+		updateViewMatrix = true;
+		updateBaseMatrix = true;
+		updateProjectionMatrix = true;
+		updateClipPlanes = true;
+
+		#if PERF_HUD
+			resetTimers();
+		#endif
+
+		for(int i = 0; i < 16; i++)
+		{
+			vertexTask[i] = 0;
+
+			worker[i] = 0;
+			resume[i] = 0;
+			suspend[i] = 0;
+		}
+
+		threadsAwake = 0;
+		resumeApp = new Event();
+
+		currentDraw = 0;
+		nextDraw = 0;
+
+		qHead = 0;
+		qSize = 0;
+
+		for(int i = 0; i < 16; i++)
+		{
+			triangleBatch[i] = 0;
+			primitiveBatch[i] = 0;
+		}
+
+		for(int draw = 0; draw < DRAW_COUNT; draw++)
+		{
+			drawCall[draw] = new DrawCall();
+			drawList[draw] = drawCall[draw];
+		}
+
+		for(int unit = 0; unit < 16; unit++)
+		{
+			primitiveProgress[unit].init();
+		}
+
+		for(int cluster = 0; cluster < 16; cluster++)
+		{
+			pixelProgress[cluster].init();
+		}
+
+		clipFlags = 0;
+
+		swiftConfig = new SwiftConfig(disableServer);
+		updateConfiguration(true);
+
+		sync = new Resource(0);
+	}
+
+	Renderer::~Renderer()
+	{
+		sync->destruct();
+
+		delete clipper;
+		clipper = nullptr;
+
+		delete blitter;
+		blitter = nullptr;
+
+		terminateThreads();
+		delete resumeApp;
+
+		for(int draw = 0; draw < DRAW_COUNT; draw++)
+		{
+			delete drawCall[draw];
+		}
+
+		delete swiftConfig;
+	}
+
+	// This object has to be mem aligned
+	void* Renderer::operator new(size_t size)
+	{
+		ASSERT(size == sizeof(Renderer)); // This operator can't be called from a derived class
+		return sw::allocate(sizeof(Renderer), 16);
+	}
+
+	void Renderer::operator delete(void * mem)
+	{
+		sw::deallocate(mem);
+	}
+
+	void Renderer::draw(DrawType drawType, unsigned int indexOffset, unsigned int count, bool update)
+	{
+		#ifndef NDEBUG
+			if(count < minPrimitives || count > maxPrimitives)
+			{
+				return;
+			}
+		#endif
+
+		context->drawType = drawType;
+
+		updateConfiguration();
+		updateClipper();
+
+		int ss = context->getSuperSampleCount();
+		int ms = context->getMultiSampleCount();
+		bool requiresSync = false;
+
+		for(int q = 0; q < ss; q++)
+		{
+			unsigned int oldMultiSampleMask = context->multiSampleMask;
+			context->multiSampleMask = (context->sampleMask >> (ms * q)) & ((unsigned)0xFFFFFFFF >> (32 - ms));
+
+			if(!context->multiSampleMask)
+			{
+				continue;
+			}
+
+			sync->lock(sw::PRIVATE);
+
+			if(update || oldMultiSampleMask != context->multiSampleMask)
+			{
+				vertexState = VertexProcessor::update(drawType);
+				setupState = SetupProcessor::update();
+				pixelState = PixelProcessor::update();
+
+				vertexRoutine = VertexProcessor::routine(vertexState);
+				setupRoutine = SetupProcessor::routine(setupState);
+				pixelRoutine = PixelProcessor::routine(pixelState);
+			}
+
+			int batch = batchSize / ms;
+
+			int (Renderer::*setupPrimitives)(int batch, int count);
+
+			if(context->isDrawTriangle())
+			{
+				switch(context->fillMode)
+				{
+				case FILL_SOLID:
+					setupPrimitives = &Renderer::setupSolidTriangles;
+					break;
+				case FILL_WIREFRAME:
+					setupPrimitives = &Renderer::setupWireframeTriangle;
+					batch = 1;
+					break;
+				case FILL_VERTEX:
+					setupPrimitives = &Renderer::setupVertexTriangle;
+					batch = 1;
+					break;
+				default:
+					ASSERT(false);
+					return;
+				}
+			}
+			else if(context->isDrawLine())
+			{
+				setupPrimitives = &Renderer::setupLines;
+			}
+			else   // Point draw
+			{
+				setupPrimitives = &Renderer::setupPoints;
+			}
+
+			DrawCall *draw = nullptr;
+
+			do
+			{
+				for(int i = 0; i < DRAW_COUNT; i++)
+				{
+					if(drawCall[i]->references == -1)
+					{
+						draw = drawCall[i];
+						drawList[nextDraw & DRAW_COUNT_BITS] = draw;
+
+						break;
+					}
+				}
+
+				if(!draw)
+				{
+					resumeApp->wait();
+				}
+			}
+			while(!draw);
+
+			DrawData *data = draw->data;
+
+			if(queries.size() != 0)
+			{
+				draw->queries = new std::list<Query*>();
+				bool includePrimitivesWrittenQueries = vertexState.transformFeedbackQueryEnabled && vertexState.transformFeedbackEnabled;
+				for(auto &query : queries)
+				{
+					if(includePrimitivesWrittenQueries || (query->type != Query::TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN))
+					{
+						++query->reference; // Atomic
+						draw->queries->push_back(query);
+					}
+				}
+			}
+
+			draw->drawType = drawType;
+			draw->batchSize = batch;
+
+			vertexRoutine->bind();
+			setupRoutine->bind();
+			pixelRoutine->bind();
+
+			draw->vertexRoutine = vertexRoutine;
+			draw->setupRoutine = setupRoutine;
+			draw->pixelRoutine = pixelRoutine;
+			draw->vertexPointer = (VertexProcessor::RoutinePointer)vertexRoutine->getEntry();
+			draw->setupPointer = (SetupProcessor::RoutinePointer)setupRoutine->getEntry();
+			draw->pixelPointer = (PixelProcessor::RoutinePointer)pixelRoutine->getEntry();
+			draw->setupPrimitives = setupPrimitives;
+			draw->setupState = setupState;
+
+			for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+			{
+				draw->vertexStream[i] = context->input[i].resource;
+				data->input[i] = context->input[i].buffer;
+				data->stride[i] = context->input[i].stride;
+
+				if(draw->vertexStream[i])
+				{
+					draw->vertexStream[i]->lock(PUBLIC, PRIVATE);
+				}
+			}
+
+			if(context->indexBuffer)
+			{
+				data->indices = (unsigned char*)context->indexBuffer->lock(PUBLIC, PRIVATE) + indexOffset;
+			}
+
+			draw->indexBuffer = context->indexBuffer;
+
+			for(int sampler = 0; sampler < TOTAL_IMAGE_UNITS; sampler++)
+			{
+				draw->texture[sampler] = 0;
+			}
+
+			for(int sampler = 0; sampler < TEXTURE_IMAGE_UNITS; sampler++)
+			{
+				if(pixelState.sampler[sampler].textureType != TEXTURE_NULL)
+				{
+					draw->texture[sampler] = context->texture[sampler];
+					draw->texture[sampler]->lock(PUBLIC, isReadWriteTexture(sampler) ? MANAGED : PRIVATE);   // If the texure is both read and written, use the same read/write lock as render targets
+
+					data->mipmap[sampler] = context->sampler[sampler].getTextureData();
+
+					requiresSync |= context->sampler[sampler].requiresSync();
+				}
+			}
+
+			if(context->pixelShader)
+			{
+				if(draw->psDirtyConstF)
+				{
+					memcpy(&data->ps.cW, PixelProcessor::cW, sizeof(word4) * 4 * (draw->psDirtyConstF < 8 ? draw->psDirtyConstF : 8));
+					memcpy(&data->ps.c, PixelProcessor::c, sizeof(float4) * draw->psDirtyConstF);
+					draw->psDirtyConstF = 0;
+				}
+
+				if(draw->psDirtyConstI)
+				{
+					memcpy(&data->ps.i, PixelProcessor::i, sizeof(int4) * draw->psDirtyConstI);
+					draw->psDirtyConstI = 0;
+				}
+
+				if(draw->psDirtyConstB)
+				{
+					memcpy(&data->ps.b, PixelProcessor::b, sizeof(bool) * draw->psDirtyConstB);
+					draw->psDirtyConstB = 0;
+				}
+
+				PixelProcessor::lockUniformBuffers(data->ps.u, draw->pUniformBuffers);
+			}
+			else
+			{
+				for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; i++)
+				{
+					draw->pUniformBuffers[i] = nullptr;
+				}
+			}
+
+			if(context->pixelShaderModel() <= 0x0104)
+			{
+				for(int stage = 0; stage < 8; stage++)
+				{
+					if(pixelState.textureStage[stage].stageOperation != TextureStage::STAGE_DISABLE || context->pixelShader)
+					{
+						data->textureStage[stage] = context->textureStage[stage].uniforms;
+					}
+					else break;
+				}
+			}
+
+			if(context->vertexShader)
+			{
+				if(context->vertexShader->getShaderModel() >= 0x0300)
+				{
+					for(int sampler = 0; sampler < VERTEX_TEXTURE_IMAGE_UNITS; sampler++)
+					{
+						if(vertexState.sampler[sampler].textureType != TEXTURE_NULL)
+						{
+							draw->texture[TEXTURE_IMAGE_UNITS + sampler] = context->texture[TEXTURE_IMAGE_UNITS + sampler];
+							draw->texture[TEXTURE_IMAGE_UNITS + sampler]->lock(PUBLIC, PRIVATE);
+
+							data->mipmap[TEXTURE_IMAGE_UNITS + sampler] = context->sampler[TEXTURE_IMAGE_UNITS + sampler].getTextureData();
+
+							requiresSync |= context->sampler[TEXTURE_IMAGE_UNITS + sampler].requiresSync();
+						}
+					}
+				}
+
+				if(draw->vsDirtyConstF)
+				{
+					memcpy(&data->vs.c, VertexProcessor::c, sizeof(float4) * draw->vsDirtyConstF);
+					draw->vsDirtyConstF = 0;
+				}
+
+				if(draw->vsDirtyConstI)
+				{
+					memcpy(&data->vs.i, VertexProcessor::i, sizeof(int4) * draw->vsDirtyConstI);
+					draw->vsDirtyConstI = 0;
+				}
+
+				if(draw->vsDirtyConstB)
+				{
+					memcpy(&data->vs.b, VertexProcessor::b, sizeof(bool) * draw->vsDirtyConstB);
+					draw->vsDirtyConstB = 0;
+				}
+
+				if(context->vertexShader->isInstanceIdDeclared())
+				{
+					data->instanceID = context->instanceID;
+				}
+
+				VertexProcessor::lockUniformBuffers(data->vs.u, draw->vUniformBuffers);
+				VertexProcessor::lockTransformFeedbackBuffers(data->vs.t, data->vs.reg, data->vs.row, data->vs.col, data->vs.str, draw->transformFeedbackBuffers);
+			}
+			else
+			{
+				data->ff = ff;
+
+				draw->vsDirtyConstF = VERTEX_UNIFORM_VECTORS + 1;
+				draw->vsDirtyConstI = 16;
+				draw->vsDirtyConstB = 16;
+
+				for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; i++)
+				{
+					draw->vUniformBuffers[i] = nullptr;
+				}
+
+				for(int i = 0; i < MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; i++)
+				{
+					draw->transformFeedbackBuffers[i] = nullptr;
+				}
+			}
+
+			if(pixelState.stencilActive)
+			{
+				data->stencil[0] = stencil;
+				data->stencil[1] = stencilCCW;
+			}
+
+			if(pixelState.fogActive)
+			{
+				data->fog = fog;
+			}
+
+			if(setupState.isDrawPoint)
+			{
+				data->point = point;
+			}
+
+			data->lineWidth = context->lineWidth;
+
+			data->factor = factor;
+
+			if(pixelState.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
+			{
+				float ref = context->alphaReference * (1.0f / 255.0f);
+				float margin = sw::min(ref, 1.0f - ref);
+
+				if(ms == 4)
+				{
+					data->a2c0 = replicate(ref - margin * 0.6f);
+					data->a2c1 = replicate(ref - margin * 0.2f);
+					data->a2c2 = replicate(ref + margin * 0.2f);
+					data->a2c3 = replicate(ref + margin * 0.6f);
+				}
+				else if(ms == 2)
+				{
+					data->a2c0 = replicate(ref - margin * 0.3f);
+					data->a2c1 = replicate(ref + margin * 0.3f);
+				}
+				else ASSERT(false);
+			}
+
+			if(pixelState.occlusionEnabled)
+			{
+				for(int cluster = 0; cluster < clusterCount; cluster++)
+				{
+					data->occlusion[cluster] = 0;
+				}
+			}
+
+			#if PERF_PROFILE
+				for(int cluster = 0; cluster < clusterCount; cluster++)
+				{
+					for(int i = 0; i < PERF_TIMERS; i++)
+					{
+						data->cycles[i][cluster] = 0;
+					}
+				}
+			#endif
+
+			// Viewport
+			{
+				float W = 0.5f * viewport.width;
+				float H = 0.5f * viewport.height;
+				float X0 = viewport.x0 + W;
+				float Y0 = viewport.y0 + H;
+				float N = viewport.minZ;
+				float F = viewport.maxZ;
+				float Z = F - N;
+
+				if(context->isDrawTriangle(false))
+				{
+					N += context->depthBias;
+				}
+
+				if(complementaryDepthBuffer)
+				{
+					Z = -Z;
+					N = 1 - N;
+				}
+
+				static const float X[5][16] =   // Fragment offsets
+				{
+					{+0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 1 sample
+					{-0.2500f, +0.2500f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 2 samples
+					{-0.3000f, +0.1000f, +0.3000f, -0.1000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 4 samples
+					{+0.1875f, -0.3125f, +0.3125f, -0.4375f, -0.0625f, +0.4375f, +0.0625f, -0.1875f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 8 samples
+					{+0.2553f, -0.1155f, +0.1661f, -0.1828f, +0.2293f, -0.4132f, -0.1773f, -0.0577f, +0.3891f, -0.4656f, +0.4103f, +0.4248f, -0.2109f, +0.3966f, -0.2664f, -0.3872f}    // 16 samples
+				};
+
+				static const float Y[5][16] =   // Fragment offsets
+				{
+					{+0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 1 sample
+					{-0.2500f, +0.2500f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 2 samples
+					{-0.1000f, -0.3000f, +0.1000f, +0.3000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 4 samples
+					{-0.4375f, -0.3125f, -0.1875f, -0.0625f, +0.0625f, +0.1875f, +0.3125f, +0.4375f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f, +0.0000f},   // 8 samples
+					{-0.4503f, +0.1883f, +0.3684f, -0.4668f, -0.0690f, -0.1315f, +0.4999f, +0.0728f, +0.1070f, -0.3086f, +0.3725f, -0.1547f, -0.1102f, -0.3588f, +0.1789f, +0.0269f}    // 16 samples
+				};
+
+				int s = sw::log2(ss);
+
+				data->Wx16 = replicate(W * 16);
+				data->Hx16 = replicate(H * 16);
+				data->X0x16 = replicate(X0 * 16 - 8);
+				data->Y0x16 = replicate(Y0 * 16 - 8);
+				data->XXXX = replicate(X[s][q] / W);
+				data->YYYY = replicate(Y[s][q] / H);
+				data->halfPixelX = replicate(0.5f / W);
+				data->halfPixelY = replicate(0.5f / H);
+				data->viewportHeight = abs(viewport.height);
+				data->slopeDepthBias = context->slopeDepthBias;
+				data->depthRange = Z;
+				data->depthNear = N;
+				draw->clipFlags = clipFlags;
+
+				if(clipFlags)
+				{
+					if(clipFlags & Clipper::CLIP_PLANE0) data->clipPlane[0] = clipPlane[0];
+					if(clipFlags & Clipper::CLIP_PLANE1) data->clipPlane[1] = clipPlane[1];
+					if(clipFlags & Clipper::CLIP_PLANE2) data->clipPlane[2] = clipPlane[2];
+					if(clipFlags & Clipper::CLIP_PLANE3) data->clipPlane[3] = clipPlane[3];
+					if(clipFlags & Clipper::CLIP_PLANE4) data->clipPlane[4] = clipPlane[4];
+					if(clipFlags & Clipper::CLIP_PLANE5) data->clipPlane[5] = clipPlane[5];
+				}
+			}
+
+			// Target
+			{
+				for(int index = 0; index < RENDERTARGETS; index++)
+				{
+					draw->renderTarget[index] = context->renderTarget[index];
+
+					if(draw->renderTarget[index])
+					{
+						unsigned int layer = context->renderTargetLayer[index];
+						requiresSync |= context->renderTarget[index]->requiresSync();
+						data->colorBuffer[index] = (unsigned int*)context->renderTarget[index]->lockInternal(0, 0, layer, LOCK_READWRITE, MANAGED);
+						data->colorBuffer[index] += q * ms * context->renderTarget[index]->getSliceB(true);
+						data->colorPitchB[index] = context->renderTarget[index]->getInternalPitchB();
+						data->colorSliceB[index] = context->renderTarget[index]->getInternalSliceB();
+					}
+				}
+
+				draw->depthBuffer = context->depthBuffer;
+				draw->stencilBuffer = context->stencilBuffer;
+
+				if(draw->depthBuffer)
+				{
+					unsigned int layer = context->depthBufferLayer;
+					requiresSync |= context->depthBuffer->requiresSync();
+					data->depthBuffer = (float*)context->depthBuffer->lockInternal(0, 0, layer, LOCK_READWRITE, MANAGED);
+					data->depthBuffer += q * ms * context->depthBuffer->getSliceB(true);
+					data->depthPitchB = context->depthBuffer->getInternalPitchB();
+					data->depthSliceB = context->depthBuffer->getInternalSliceB();
+				}
+
+				if(draw->stencilBuffer)
+				{
+					unsigned int layer = context->stencilBufferLayer;
+					requiresSync |= context->stencilBuffer->requiresSync();
+					data->stencilBuffer = (unsigned char*)context->stencilBuffer->lockStencil(0, 0, layer, MANAGED);
+					data->stencilBuffer += q * ms * context->stencilBuffer->getSliceB(true);
+					data->stencilPitchB = context->stencilBuffer->getStencilPitchB();
+					data->stencilSliceB = context->stencilBuffer->getStencilSliceB();
+				}
+			}
+
+			// Scissor
+			{
+				data->scissorX0 = scissor.x0;
+				data->scissorX1 = scissor.x1;
+				data->scissorY0 = scissor.y0;
+				data->scissorY1 = scissor.y1;
+			}
+
+			draw->primitive = 0;
+			draw->count = count;
+
+			draw->references = (count + batch - 1) / batch;
+
+			schedulerMutex.lock();
+			++nextDraw; // Atomic
+			schedulerMutex.unlock();
+
+			#ifndef NDEBUG
+			if(threadCount == 1)   // Use main thread for draw execution
+			{
+				threadsAwake = 1;
+				task[0].type = Task::RESUME;
+
+				taskLoop(0);
+			}
+			else
+			#endif
+			{
+				if(!threadsAwake)
+				{
+					suspend[0]->wait();
+
+					threadsAwake = 1;
+					task[0].type = Task::RESUME;
+
+					resume[0]->signal();
+				}
+			}
+		}
+
+		// TODO(sugoi): This is a temporary brute-force workaround to ensure IOSurface synchronization.
+		if(requiresSync)
+		{
+			synchronize();
+		}
+	}
+
+	void Renderer::clear(void *value, Format format, Surface *dest, const Rect &clearRect, unsigned int rgbaMask)
+	{
+		blitter->clear(value, format, dest, clearRect, rgbaMask);
+	}
+
+	void Renderer::blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, bool filter, bool isStencil, bool sRGBconversion)
+	{
+		blitter->blit(source, sRect, dest, dRect, {filter, isStencil, sRGBconversion});
+	}
+
+	void Renderer::blit3D(Surface *source, Surface *dest)
+	{
+		blitter->blit3D(source, dest);
+	}
+
+	void Renderer::threadFunction(void *parameters)
+	{
+		Renderer *renderer = static_cast<Parameters*>(parameters)->renderer;
+		int threadIndex = static_cast<Parameters*>(parameters)->threadIndex;
+
+		if(logPrecision < IEEE)
+		{
+			CPUID::setFlushToZero(true);
+			CPUID::setDenormalsAreZero(true);
+		}
+
+		renderer->threadLoop(threadIndex);
+	}
+
+	void Renderer::threadLoop(int threadIndex)
+	{
+		while(!exitThreads)
+		{
+			taskLoop(threadIndex);
+
+			suspend[threadIndex]->signal();
+			resume[threadIndex]->wait();
+		}
+	}
+
+	void Renderer::taskLoop(int threadIndex)
+	{
+		while(task[threadIndex].type != Task::SUSPEND)
+		{
+			scheduleTask(threadIndex);
+			executeTask(threadIndex);
+		}
+	}
+
+	void Renderer::findAvailableTasks()
+	{
+		// Find pixel tasks
+		for(int cluster = 0; cluster < clusterCount; cluster++)
+		{
+			if(!pixelProgress[cluster].executing)
+			{
+				for(int unit = 0; unit < unitCount; unit++)
+				{
+					if(primitiveProgress[unit].references > 0)   // Contains processed primitives
+					{
+						if(pixelProgress[cluster].drawCall == primitiveProgress[unit].drawCall)
+						{
+							if(pixelProgress[cluster].processedPrimitives == primitiveProgress[unit].firstPrimitive)   // Previous primitives have been rendered
+							{
+								Task &task = taskQueue[qHead];
+								task.type = Task::PIXELS;
+								task.primitiveUnit = unit;
+								task.pixelCluster = cluster;
+
+								pixelProgress[cluster].executing = true;
+
+								// Commit to the task queue
+								qHead = (qHead + 1) & TASK_COUNT_BITS;
+								qSize++;
+
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Find primitive tasks
+		if(currentDraw == nextDraw)
+		{
+			return;   // No more primitives to process
+		}
+
+		for(int unit = 0; unit < unitCount; unit++)
+		{
+			DrawCall *draw = drawList[currentDraw & DRAW_COUNT_BITS];
+
+			int primitive = draw->primitive;
+			int count = draw->count;
+
+			if(primitive >= count)
+			{
+				++currentDraw; // Atomic
+
+				if(currentDraw == nextDraw)
+				{
+					return;   // No more primitives to process
+				}
+
+				draw = drawList[currentDraw & DRAW_COUNT_BITS];
+			}
+
+			if(!primitiveProgress[unit].references)   // Task not already being executed and not still in use by a pixel unit
+			{
+				primitive = draw->primitive;
+				count = draw->count;
+				int batch = draw->batchSize;
+
+				primitiveProgress[unit].drawCall = currentDraw;
+				primitiveProgress[unit].firstPrimitive = primitive;
+				primitiveProgress[unit].primitiveCount = count - primitive >= batch ? batch : count - primitive;
+
+				draw->primitive += batch;
+
+				Task &task = taskQueue[qHead];
+				task.type = Task::PRIMITIVES;
+				task.primitiveUnit = unit;
+
+				primitiveProgress[unit].references = -1;
+
+				// Commit to the task queue
+				qHead = (qHead + 1) & TASK_COUNT_BITS;
+				qSize++;
+			}
+		}
+	}
+
+	void Renderer::scheduleTask(int threadIndex)
+	{
+		schedulerMutex.lock();
+
+		int curThreadsAwake = threadsAwake;
+
+		if((int)qSize < threadCount - curThreadsAwake + 1)
+		{
+			findAvailableTasks();
+		}
+
+		if(qSize != 0)
+		{
+			task[threadIndex] = taskQueue[(qHead - qSize) & TASK_COUNT_BITS];
+			qSize--;
+
+			if(curThreadsAwake != threadCount)
+			{
+				int wakeup = qSize - curThreadsAwake + 1;
+
+				for(int i = 0; i < threadCount && wakeup > 0; i++)
+				{
+					if(task[i].type == Task::SUSPEND)
+					{
+						suspend[i]->wait();
+						task[i].type = Task::RESUME;
+						resume[i]->signal();
+
+						++threadsAwake; // Atomic
+						wakeup--;
+					}
+				}
+			}
+		}
+		else
+		{
+			task[threadIndex].type = Task::SUSPEND;
+
+			--threadsAwake; // Atomic
+		}
+
+		schedulerMutex.unlock();
+	}
+
+	void Renderer::executeTask(int threadIndex)
+	{
+		#if PERF_HUD
+			int64_t startTick = Timer::ticks();
+		#endif
+
+		switch(task[threadIndex].type)
+		{
+		case Task::PRIMITIVES:
+			{
+				int unit = task[threadIndex].primitiveUnit;
+
+				int input = primitiveProgress[unit].firstPrimitive;
+				int count = primitiveProgress[unit].primitiveCount;
+				DrawCall *draw = drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+				int (Renderer::*setupPrimitives)(int batch, int count) = draw->setupPrimitives;
+
+				processPrimitiveVertices(unit, input, count, draw->count, threadIndex);
+
+				#if PERF_HUD
+					int64_t time = Timer::ticks();
+					vertexTime[threadIndex] += time - startTick;
+					startTick = time;
+				#endif
+
+				int visible = 0;
+
+				if(!draw->setupState.rasterizerDiscard)
+				{
+					visible = (this->*setupPrimitives)(unit, count);
+				}
+
+				primitiveProgress[unit].visible = visible;
+				primitiveProgress[unit].references = clusterCount;
+
+				#if PERF_HUD
+					setupTime[threadIndex] += Timer::ticks() - startTick;
+				#endif
+			}
+			break;
+		case Task::PIXELS:
+			{
+				int unit = task[threadIndex].primitiveUnit;
+				int visible = primitiveProgress[unit].visible;
+
+				if(visible > 0)
+				{
+					int cluster = task[threadIndex].pixelCluster;
+					Primitive *primitive = primitiveBatch[unit];
+					DrawCall *draw = drawList[pixelProgress[cluster].drawCall & DRAW_COUNT_BITS];
+					DrawData *data = draw->data;
+					PixelProcessor::RoutinePointer pixelRoutine = draw->pixelPointer;
+
+					pixelRoutine(primitive, visible, cluster, data);
+				}
+
+				finishRendering(task[threadIndex]);
+
+				#if PERF_HUD
+					pixelTime[threadIndex] += Timer::ticks() - startTick;
+				#endif
+			}
+			break;
+		case Task::RESUME:
+			break;
+		case Task::SUSPEND:
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void Renderer::synchronize()
+	{
+		sync->lock(sw::PUBLIC);
+		sync->unlock();
+	}
+
+	void Renderer::finishRendering(Task &pixelTask)
+	{
+		int unit = pixelTask.primitiveUnit;
+		int cluster = pixelTask.pixelCluster;
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		DrawData &data = *draw.data;
+		int primitive = primitiveProgress[unit].firstPrimitive;
+		int count = primitiveProgress[unit].primitiveCount;
+		int processedPrimitives = primitive + count;
+
+		pixelProgress[cluster].processedPrimitives = processedPrimitives;
+
+		if(pixelProgress[cluster].processedPrimitives >= draw.count)
+		{
+			++pixelProgress[cluster].drawCall; // Atomic
+			pixelProgress[cluster].processedPrimitives = 0;
+		}
+
+		int ref = primitiveProgress[unit].references--; // Atomic
+
+		if(ref == 0)
+		{
+			ref = draw.references--; // Atomic
+
+			if(ref == 0)
+			{
+				#if PERF_PROFILE
+					for(int cluster = 0; cluster < clusterCount; cluster++)
+					{
+						for(int i = 0; i < PERF_TIMERS; i++)
+						{
+							profiler.cycles[i] += data.cycles[i][cluster];
+						}
+					}
+				#endif
+
+				if(draw.queries)
+				{
+					for(auto &query : *(draw.queries))
+					{
+						switch(query->type)
+						{
+						case Query::FRAGMENTS_PASSED:
+							for(int cluster = 0; cluster < clusterCount; cluster++)
+							{
+								query->data += data.occlusion[cluster];
+							}
+							break;
+						case Query::TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
+							query->data += processedPrimitives;
+							break;
+						default:
+							break;
+						}
+
+						--query->reference; // Atomic
+					}
+
+					delete draw.queries;
+					draw.queries = 0;
+				}
+
+				for(int i = 0; i < RENDERTARGETS; i++)
+				{
+					if(draw.renderTarget[i])
+					{
+						draw.renderTarget[i]->unlockInternal();
+					}
+				}
+
+				if(draw.depthBuffer)
+				{
+					draw.depthBuffer->unlockInternal();
+				}
+
+				if(draw.stencilBuffer)
+				{
+					draw.stencilBuffer->unlockStencil();
+				}
+
+				for(int i = 0; i < TOTAL_IMAGE_UNITS; i++)
+				{
+					if(draw.texture[i])
+					{
+						draw.texture[i]->unlock();
+					}
+				}
+
+				for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+				{
+					if(draw.vertexStream[i])
+					{
+						draw.vertexStream[i]->unlock();
+					}
+				}
+
+				if(draw.indexBuffer)
+				{
+					draw.indexBuffer->unlock();
+				}
+
+				for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; i++)
+				{
+					if(draw.pUniformBuffers[i])
+					{
+						draw.pUniformBuffers[i]->unlock();
+					}
+					if(draw.vUniformBuffers[i])
+					{
+						draw.vUniformBuffers[i]->unlock();
+					}
+				}
+
+				for(int i = 0; i < MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; i++)
+				{
+					if(draw.transformFeedbackBuffers[i])
+					{
+						draw.transformFeedbackBuffers[i]->unlock();
+					}
+				}
+
+				draw.vertexRoutine->unbind();
+				draw.setupRoutine->unbind();
+				draw.pixelRoutine->unbind();
+
+				sync->unlock();
+
+				draw.references = -1;
+				resumeApp->signal();
+			}
+		}
+
+		pixelProgress[cluster].executing = false;
+	}
+
+	void Renderer::processPrimitiveVertices(int unit, unsigned int start, unsigned int triangleCount, unsigned int loop, int thread)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		int primitiveDrawCall = primitiveProgress[unit].drawCall;
+		DrawCall *draw = drawList[primitiveDrawCall & DRAW_COUNT_BITS];
+		DrawData *data = draw->data;
+		VertexTask *task = vertexTask[thread];
+
+		const void *indices = data->indices;
+		VertexProcessor::RoutinePointer vertexRoutine = draw->vertexPointer;
+
+		if(task->vertexCache.drawCall != primitiveDrawCall)
+		{
+			task->vertexCache.clear();
+			task->vertexCache.drawCall = primitiveDrawCall;
+		}
+
+		unsigned int batch[128][3];   // FIXME: Adjust to dynamic batch size
+
+		switch(draw->drawType)
+		{
+		case DRAW_POINTLIST:
+			{
+				unsigned int index = start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index;
+					batch[i][1] = index;
+					batch[i][2] = index;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_LINELIST:
+			{
+				unsigned int index = 2 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index + 0;
+					batch[i][1] = index + 1;
+					batch[i][2] = index + 1;
+
+					index += 2;
+				}
+			}
+			break;
+		case DRAW_LINESTRIP:
+			{
+				unsigned int index = start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index + 0;
+					batch[i][1] = index + 1;
+					batch[i][2] = index + 1;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_LINELOOP:
+			{
+				unsigned int index = start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = (index + 0) % loop;
+					batch[i][1] = (index + 1) % loop;
+					batch[i][2] = (index + 1) % loop;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_TRIANGLELIST:
+			{
+				unsigned int index = 3 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index + 0;
+					batch[i][1] = index + 1;
+					batch[i][2] = index + 2;
+
+					index += 3;
+				}
+			}
+			break;
+		case DRAW_TRIANGLESTRIP:
+			{
+				unsigned int index = start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					if(leadingVertexFirst)
+					{
+						batch[i][0] = index + 0;
+						batch[i][1] = index + (index & 1) + 1;
+						batch[i][2] = index + (~index & 1) + 1;
+					}
+					else
+					{
+						batch[i][0] = index + (index & 1);
+						batch[i][1] = index + (~index & 1);
+						batch[i][2] = index + 2;
+					}
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_TRIANGLEFAN:
+			{
+				unsigned int index = start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					if(leadingVertexFirst)
+					{
+						batch[i][0] = index + 1;
+						batch[i][1] = index + 2;
+						batch[i][2] = 0;
+					}
+					else
+					{
+						batch[i][0] = 0;
+						batch[i][1] = index + 1;
+						batch[i][2] = index + 2;
+					}
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDPOINTLIST8:
+			{
+				const unsigned char *index = (const unsigned char*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = *index;
+					batch[i][1] = *index;
+					batch[i][2] = *index;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDPOINTLIST16:
+			{
+				const unsigned short *index = (const unsigned short*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = *index;
+					batch[i][1] = *index;
+					batch[i][2] = *index;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDPOINTLIST32:
+			{
+				const unsigned int *index = (const unsigned int*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = *index;
+					batch[i][1] = *index;
+					batch[i][2] = *index;
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELIST8:
+			{
+				const unsigned char *index = (const unsigned char*)indices + 2 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 2;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELIST16:
+			{
+				const unsigned short *index = (const unsigned short*)indices + 2 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 2;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELIST32:
+			{
+				const unsigned int *index = (const unsigned int*)indices + 2 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 2;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINESTRIP8:
+			{
+				const unsigned char *index = (const unsigned char*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINESTRIP16:
+			{
+				const unsigned short *index = (const unsigned short*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINESTRIP32:
+			{
+				const unsigned int *index = (const unsigned int*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELOOP8:
+			{
+				const unsigned char *index = (const unsigned char*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[(start + i + 0) % loop];
+					batch[i][1] = index[(start + i + 1) % loop];
+					batch[i][2] = index[(start + i + 1) % loop];
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELOOP16:
+			{
+				const unsigned short *index = (const unsigned short*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[(start + i + 0) % loop];
+					batch[i][1] = index[(start + i + 1) % loop];
+					batch[i][2] = index[(start + i + 1) % loop];
+				}
+			}
+			break;
+		case DRAW_INDEXEDLINELOOP32:
+			{
+				const unsigned int *index = (const unsigned int*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[(start + i + 0) % loop];
+					batch[i][1] = index[(start + i + 1) % loop];
+					batch[i][2] = index[(start + i + 1) % loop];
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLELIST8:
+			{
+				const unsigned char *index = (const unsigned char*)indices + 3 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[2];
+
+					index += 3;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLELIST16:
+			{
+				const unsigned short *index = (const unsigned short*)indices + 3 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[2];
+
+					index += 3;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLELIST32:
+			{
+				const unsigned int *index = (const unsigned int*)indices + 3 * start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[1];
+					batch[i][2] = index[2];
+
+					index += 3;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLESTRIP8:
+			{
+				const unsigned char *index = (const unsigned char*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[((start + i) & 1) + 1];
+					batch[i][2] = index[(~(start + i) & 1) + 1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLESTRIP16:
+			{
+				const unsigned short *index = (const unsigned short*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[((start + i) & 1) + 1];
+					batch[i][2] = index[(~(start + i) & 1) + 1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLESTRIP32:
+			{
+				const unsigned int *index = (const unsigned int*)indices + start;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[0];
+					batch[i][1] = index[((start + i) & 1) + 1];
+					batch[i][2] = index[(~(start + i) & 1) + 1];
+
+					index += 1;
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLEFAN8:
+			{
+				const unsigned char *index = (const unsigned char*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[start + i + 1];
+					batch[i][1] = index[start + i + 2];
+					batch[i][2] = index[0];
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLEFAN16:
+			{
+				const unsigned short *index = (const unsigned short*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[start + i + 1];
+					batch[i][1] = index[start + i + 2];
+					batch[i][2] = index[0];
+				}
+			}
+			break;
+		case DRAW_INDEXEDTRIANGLEFAN32:
+			{
+				const unsigned int *index = (const unsigned int*)indices;
+
+				for(unsigned int i = 0; i < triangleCount; i++)
+				{
+					batch[i][0] = index[start + i + 1];
+					batch[i][1] = index[start + i + 2];
+					batch[i][2] = index[0];
+				}
+			}
+			break;
+		case DRAW_QUADLIST:
+			{
+				unsigned int index = 4 * start / 2;
+
+				for(unsigned int i = 0; i < triangleCount; i += 2)
+				{
+					batch[i+0][0] = index + 0;
+					batch[i+0][1] = index + 1;
+					batch[i+0][2] = index + 2;
+
+					batch[i+1][0] = index + 0;
+					batch[i+1][1] = index + 2;
+					batch[i+1][2] = index + 3;
+
+					index += 4;
+				}
+			}
+			break;
+		default:
+			ASSERT(false);
+			return;
+		}
+
+		task->primitiveStart = start;
+		task->vertexCount = triangleCount * 3;
+		vertexRoutine(&triangle->v0, (unsigned int*)&batch, task, data);
+	}
+
+	int Renderer::setupSolidTriangles(int unit, int count)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		Primitive *primitive = primitiveBatch[unit];
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		SetupProcessor::State &state = draw.setupState;
+		const SetupProcessor::RoutinePointer &setupRoutine = draw.setupPointer;
+
+		int ms = state.multiSample;
+		int pos = state.positionRegister;
+		const DrawData *data = draw.data;
+		int visible = 0;
+
+		for(int i = 0; i < count; i++, triangle++)
+		{
+			Vertex &v0 = triangle->v0;
+			Vertex &v1 = triangle->v1;
+			Vertex &v2 = triangle->v2;
+
+			if((v0.clipFlags & v1.clipFlags & v2.clipFlags) == Clipper::CLIP_FINITE)
+			{
+				Polygon polygon(&v0.v[pos], &v1.v[pos], &v2.v[pos]);
+
+				int clipFlagsOr = v0.clipFlags | v1.clipFlags | v2.clipFlags | draw.clipFlags;
+
+				if(clipFlagsOr != Clipper::CLIP_FINITE)
+				{
+					if(!clipper->clip(polygon, clipFlagsOr, draw))
+					{
+						continue;
+					}
+				}
+
+				if(setupRoutine(primitive, triangle, &polygon, data))
+				{
+					primitive += ms;
+					visible++;
+				}
+			}
+		}
+
+		return visible;
+	}
+
+	int Renderer::setupWireframeTriangle(int unit, int count)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		Primitive *primitive = primitiveBatch[unit];
+		int visible = 0;
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		SetupProcessor::State &state = draw.setupState;
+
+		const Vertex &v0 = triangle[0].v0;
+		const Vertex &v1 = triangle[0].v1;
+		const Vertex &v2 = triangle[0].v2;
+
+		float d = (v0.y * v1.x - v0.x * v1.y) * v2.w + (v0.x * v2.y - v0.y * v2.x) * v1.w + (v2.x * v1.y - v1.x * v2.y) * v0.w;
+
+		if(state.cullMode == CULL_CLOCKWISE)
+		{
+			if(d >= 0) return 0;
+		}
+		else if(state.cullMode == CULL_COUNTERCLOCKWISE)
+		{
+			if(d <= 0) return 0;
+		}
+
+		// Copy attributes
+		triangle[1].v0 = v1;
+		triangle[1].v1 = v2;
+		triangle[2].v0 = v2;
+		triangle[2].v1 = v0;
+
+		if(state.color[0][0].flat)   // FIXME
+		{
+			for(int i = 0; i < 2; i++)
+			{
+				triangle[1].v0.C[i] = triangle[0].v0.C[i];
+				triangle[1].v1.C[i] = triangle[0].v0.C[i];
+				triangle[2].v0.C[i] = triangle[0].v0.C[i];
+				triangle[2].v1.C[i] = triangle[0].v0.C[i];
+			}
+		}
+
+		for(int i = 0; i < 3; i++)
+		{
+			if(setupLine(*primitive, *triangle, draw))
+			{
+				primitive->area = 0.5f * d;
+
+				primitive++;
+				visible++;
+			}
+
+			triangle++;
+		}
+
+		return visible;
+	}
+
+	int Renderer::setupVertexTriangle(int unit, int count)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		Primitive *primitive = primitiveBatch[unit];
+		int visible = 0;
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		SetupProcessor::State &state = draw.setupState;
+
+		const Vertex &v0 = triangle[0].v0;
+		const Vertex &v1 = triangle[0].v1;
+		const Vertex &v2 = triangle[0].v2;
+
+		float d = (v0.y * v1.x - v0.x * v1.y) * v2.w + (v0.x * v2.y - v0.y * v2.x) * v1.w + (v2.x * v1.y - v1.x * v2.y) * v0.w;
+
+		if(state.cullMode == CULL_CLOCKWISE)
+		{
+			if(d >= 0) return 0;
+		}
+		else if(state.cullMode == CULL_COUNTERCLOCKWISE)
+		{
+			if(d <= 0) return 0;
+		}
+
+		// Copy attributes
+		triangle[1].v0 = v1;
+		triangle[2].v0 = v2;
+
+		for(int i = 0; i < 3; i++)
+		{
+			if(setupPoint(*primitive, *triangle, draw))
+			{
+				primitive->area = 0.5f * d;
+
+				primitive++;
+				visible++;
+			}
+
+			triangle++;
+		}
+
+		return visible;
+	}
+
+	int Renderer::setupLines(int unit, int count)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		Primitive *primitive = primitiveBatch[unit];
+		int visible = 0;
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		SetupProcessor::State &state = draw.setupState;
+
+		int ms = state.multiSample;
+
+		for(int i = 0; i < count; i++)
+		{
+			if(setupLine(*primitive, *triangle, draw))
+			{
+				primitive += ms;
+				visible++;
+			}
+
+			triangle++;
+		}
+
+		return visible;
+	}
+
+	int Renderer::setupPoints(int unit, int count)
+	{
+		Triangle *triangle = triangleBatch[unit];
+		Primitive *primitive = primitiveBatch[unit];
+		int visible = 0;
+
+		DrawCall &draw = *drawList[primitiveProgress[unit].drawCall & DRAW_COUNT_BITS];
+		SetupProcessor::State &state = draw.setupState;
+
+		int ms = state.multiSample;
+
+		for(int i = 0; i < count; i++)
+		{
+			if(setupPoint(*primitive, *triangle, draw))
+			{
+				primitive += ms;
+				visible++;
+			}
+
+			triangle++;
+		}
+
+		return visible;
+	}
+
+	bool Renderer::setupLine(Primitive &primitive, Triangle &triangle, const DrawCall &draw)
+	{
+		const SetupProcessor::RoutinePointer &setupRoutine = draw.setupPointer;
+		const SetupProcessor::State &state = draw.setupState;
+		const DrawData &data = *draw.data;
+
+		float lineWidth = data.lineWidth;
+
+		Vertex &v0 = triangle.v0;
+		Vertex &v1 = triangle.v1;
+
+		int pos = state.positionRegister;
+
+		const float4 &P0 = v0.v[pos];
+		const float4 &P1 = v1.v[pos];
+
+		if(P0.w <= 0 && P1.w <= 0)
+		{
+			return false;
+		}
+
+		const float W = data.Wx16[0] * (1.0f / 16.0f);
+		const float H = data.Hx16[0] * (1.0f / 16.0f);
+
+		float dx = W * (P1.x / P1.w - P0.x / P0.w);
+		float dy = H * (P1.y / P1.w - P0.y / P0.w);
+
+		if(dx == 0 && dy == 0)
+		{
+			return false;
+		}
+
+		if(state.multiSample > 1)   // Rectangle
+		{
+			float4 P[4];
+			int C[4];
+
+			P[0] = P0;
+			P[1] = P1;
+			P[2] = P1;
+			P[3] = P0;
+
+			float scale = lineWidth * 0.5f / sqrt(dx*dx + dy*dy);
+
+			dx *= scale;
+			dy *= scale;
+
+			float dx0h = dx * P0.w / H;
+			float dy0w = dy * P0.w / W;
+
+			float dx1h = dx * P1.w / H;
+			float dy1w = dy * P1.w / W;
+
+			P[0].x += -dy0w;
+			P[0].y += +dx0h;
+			C[0] = clipper->computeClipFlags(P[0]);
+
+			P[1].x += -dy1w;
+			P[1].y += +dx1h;
+			C[1] = clipper->computeClipFlags(P[1]);
+
+			P[2].x += +dy1w;
+			P[2].y += -dx1h;
+			C[2] = clipper->computeClipFlags(P[2]);
+
+			P[3].x += +dy0w;
+			P[3].y += -dx0h;
+			C[3] = clipper->computeClipFlags(P[3]);
+
+			if((C[0] & C[1] & C[2] & C[3]) == Clipper::CLIP_FINITE)
+			{
+				Polygon polygon(P, 4);
+
+				int clipFlagsOr = C[0] | C[1] | C[2] | C[3] | draw.clipFlags;
+
+				if(clipFlagsOr != Clipper::CLIP_FINITE)
+				{
+					if(!clipper->clip(polygon, clipFlagsOr, draw))
+					{
+						return false;
+					}
+				}
+
+				return setupRoutine(&primitive, &triangle, &polygon, &data);
+			}
+		}
+		else   // Diamond test convention
+		{
+			float4 P[8];
+			int C[8];
+
+			P[0] = P0;
+			P[1] = P0;
+			P[2] = P0;
+			P[3] = P0;
+			P[4] = P1;
+			P[5] = P1;
+			P[6] = P1;
+			P[7] = P1;
+
+			float dx0 = lineWidth * 0.5f * P0.w / W;
+			float dy0 = lineWidth * 0.5f * P0.w / H;
+
+			float dx1 = lineWidth * 0.5f * P1.w / W;
+			float dy1 = lineWidth * 0.5f * P1.w / H;
+
+			P[0].x += -dx0;
+			C[0] = clipper->computeClipFlags(P[0]);
+
+			P[1].y += +dy0;
+			C[1] = clipper->computeClipFlags(P[1]);
+
+			P[2].x += +dx0;
+			C[2] = clipper->computeClipFlags(P[2]);
+
+			P[3].y += -dy0;
+			C[3] = clipper->computeClipFlags(P[3]);
+
+			P[4].x += -dx1;
+			C[4] = clipper->computeClipFlags(P[4]);
+
+			P[5].y += +dy1;
+			C[5] = clipper->computeClipFlags(P[5]);
+
+			P[6].x += +dx1;
+			C[6] = clipper->computeClipFlags(P[6]);
+
+			P[7].y += -dy1;
+			C[7] = clipper->computeClipFlags(P[7]);
+
+			if((C[0] & C[1] & C[2] & C[3] & C[4] & C[5] & C[6] & C[7]) == Clipper::CLIP_FINITE)
+			{
+				float4 L[6];
+
+				if(dx > -dy)
+				{
+					if(dx > dy)   // Right
+					{
+						L[0] = P[0];
+						L[1] = P[1];
+						L[2] = P[5];
+						L[3] = P[6];
+						L[4] = P[7];
+						L[5] = P[3];
+					}
+					else   // Down
+					{
+						L[0] = P[0];
+						L[1] = P[4];
+						L[2] = P[5];
+						L[3] = P[6];
+						L[4] = P[2];
+						L[5] = P[3];
+					}
+				}
+				else
+				{
+					if(dx > dy)   // Up
+					{
+						L[0] = P[0];
+						L[1] = P[1];
+						L[2] = P[2];
+						L[3] = P[6];
+						L[4] = P[7];
+						L[5] = P[4];
+					}
+					else   // Left
+					{
+						L[0] = P[1];
+						L[1] = P[2];
+						L[2] = P[3];
+						L[3] = P[7];
+						L[4] = P[4];
+						L[5] = P[5];
+					}
+				}
+
+				Polygon polygon(L, 6);
+
+				int clipFlagsOr = C[0] | C[1] | C[2] | C[3] | C[4] | C[5] | C[6] | C[7] | draw.clipFlags;
+
+				if(clipFlagsOr != Clipper::CLIP_FINITE)
+				{
+					if(!clipper->clip(polygon, clipFlagsOr, draw))
+					{
+						return false;
+					}
+				}
+
+				return setupRoutine(&primitive, &triangle, &polygon, &data);
+			}
+		}
+
+		return false;
+	}
+
+	bool Renderer::setupPoint(Primitive &primitive, Triangle &triangle, const DrawCall &draw)
+	{
+		const SetupProcessor::RoutinePointer &setupRoutine = draw.setupPointer;
+		const SetupProcessor::State &state = draw.setupState;
+		const DrawData &data = *draw.data;
+
+		Vertex &v = triangle.v0;
+
+		float pSize;
+
+		int pts = state.pointSizeRegister;
+
+		if(state.pointSizeRegister != Unused)
+		{
+			pSize = v.v[pts].y;
+		}
+		else
+		{
+			pSize = data.point.pointSize[0];
+		}
+
+		pSize = clamp(pSize, data.point.pointSizeMin, data.point.pointSizeMax);
+
+		float4 P[4];
+		int C[4];
+
+		int pos = state.positionRegister;
+
+		P[0] = v.v[pos];
+		P[1] = v.v[pos];
+		P[2] = v.v[pos];
+		P[3] = v.v[pos];
+
+		const float X = pSize * P[0].w * data.halfPixelX[0];
+		const float Y = pSize * P[0].w * data.halfPixelY[0];
+
+		P[0].x -= X;
+		P[0].y += Y;
+		C[0] = clipper->computeClipFlags(P[0]);
+
+		P[1].x += X;
+		P[1].y += Y;
+		C[1] = clipper->computeClipFlags(P[1]);
+
+		P[2].x += X;
+		P[2].y -= Y;
+		C[2] = clipper->computeClipFlags(P[2]);
+
+		P[3].x -= X;
+		P[3].y -= Y;
+		C[3] = clipper->computeClipFlags(P[3]);
+
+		triangle.v1 = triangle.v0;
+		triangle.v2 = triangle.v0;
+
+		triangle.v1.X += iround(16 * 0.5f * pSize);
+		triangle.v2.Y -= iround(16 * 0.5f * pSize) * (data.Hx16[0] > 0.0f ? 1 : -1);   // Both Direct3D and OpenGL expect (0, 0) in the top-left corner
+
+		Polygon polygon(P, 4);
+
+		if((C[0] & C[1] & C[2] & C[3]) == Clipper::CLIP_FINITE)
+		{
+			int clipFlagsOr = C[0] | C[1] | C[2] | C[3] | draw.clipFlags;
+
+			if(clipFlagsOr != Clipper::CLIP_FINITE)
+			{
+				if(!clipper->clip(polygon, clipFlagsOr, draw))
+				{
+					return false;
+				}
+			}
+
+			return setupRoutine(&primitive, &triangle, &polygon, &data);
+		}
+
+		return false;
+	}
+
+	void Renderer::initializeThreads()
+	{
+		unitCount = ceilPow2(threadCount);
+		clusterCount = ceilPow2(threadCount);
+
+		for(int i = 0; i < unitCount; i++)
+		{
+			triangleBatch[i] = (Triangle*)allocate(batchSize * sizeof(Triangle));
+			primitiveBatch[i] = (Primitive*)allocate(batchSize * sizeof(Primitive));
+		}
+
+		for(int i = 0; i < threadCount; i++)
+		{
+			vertexTask[i] = (VertexTask*)allocate(sizeof(VertexTask));
+			vertexTask[i]->vertexCache.drawCall = -1;
+
+			task[i].type = Task::SUSPEND;
+
+			resume[i] = new Event();
+			suspend[i] = new Event();
+
+			Parameters parameters;
+			parameters.threadIndex = i;
+			parameters.renderer = this;
+
+			exitThreads = false;
+			worker[i] = new Thread(threadFunction, &parameters);
+
+			suspend[i]->wait();
+			suspend[i]->signal();
+		}
+	}
+
+	void Renderer::terminateThreads()
+	{
+		while(threadsAwake != 0)
+		{
+			Thread::sleep(1);
+		}
+
+		for(int thread = 0; thread < threadCount; thread++)
+		{
+			if(worker[thread])
+			{
+				exitThreads = true;
+				resume[thread]->signal();
+				worker[thread]->join();
+
+				delete worker[thread];
+				worker[thread] = 0;
+				delete resume[thread];
+				resume[thread] = 0;
+				delete suspend[thread];
+				suspend[thread] = 0;
+			}
+
+			deallocate(vertexTask[thread]);
+			vertexTask[thread] = 0;
+		}
+
+		for(int i = 0; i < 16; i++)
+		{
+			deallocate(triangleBatch[i]);
+			triangleBatch[i] = 0;
+
+			deallocate(primitiveBatch[i]);
+			primitiveBatch[i] = 0;
+		}
+	}
+
+	void Renderer::loadConstants(const VertexShader *vertexShader)
+	{
+		if(!vertexShader) return;
+
+		size_t count = vertexShader->getLength();
+
+		for(size_t i = 0; i < count; i++)
+		{
+			const Shader::Instruction *instruction = vertexShader->getInstruction(i);
+
+			if(instruction->opcode == Shader::OPCODE_DEF)
+			{
+				int index = instruction->dst.index;
+				float value[4];
+
+				value[0] = instruction->src[0].value[0];
+				value[1] = instruction->src[0].value[1];
+				value[2] = instruction->src[0].value[2];
+				value[3] = instruction->src[0].value[3];
+
+				setVertexShaderConstantF(index, value);
+			}
+			else if(instruction->opcode == Shader::OPCODE_DEFI)
+			{
+				int index = instruction->dst.index;
+				int integer[4];
+
+				integer[0] = instruction->src[0].integer[0];
+				integer[1] = instruction->src[0].integer[1];
+				integer[2] = instruction->src[0].integer[2];
+				integer[3] = instruction->src[0].integer[3];
+
+				setVertexShaderConstantI(index, integer);
+			}
+			else if(instruction->opcode == Shader::OPCODE_DEFB)
+			{
+				int index = instruction->dst.index;
+				int boolean = instruction->src[0].boolean[0];
+
+				setVertexShaderConstantB(index, &boolean);
+			}
+		}
+	}
+
+	void Renderer::loadConstants(const PixelShader *pixelShader)
+	{
+		if(!pixelShader) return;
+
+		size_t count = pixelShader->getLength();
+
+		for(size_t i = 0; i < count; i++)
+		{
+			const Shader::Instruction *instruction = pixelShader->getInstruction(i);
+
+			if(instruction->opcode == Shader::OPCODE_DEF)
+			{
+				int index = instruction->dst.index;
+				float value[4];
+
+				value[0] = instruction->src[0].value[0];
+				value[1] = instruction->src[0].value[1];
+				value[2] = instruction->src[0].value[2];
+				value[3] = instruction->src[0].value[3];
+
+				setPixelShaderConstantF(index, value);
+			}
+			else if(instruction->opcode == Shader::OPCODE_DEFI)
+			{
+				int index = instruction->dst.index;
+				int integer[4];
+
+				integer[0] = instruction->src[0].integer[0];
+				integer[1] = instruction->src[0].integer[1];
+				integer[2] = instruction->src[0].integer[2];
+				integer[3] = instruction->src[0].integer[3];
+
+				setPixelShaderConstantI(index, integer);
+			}
+			else if(instruction->opcode == Shader::OPCODE_DEFB)
+			{
+				int index = instruction->dst.index;
+				int boolean = instruction->src[0].boolean[0];
+
+				setPixelShaderConstantB(index, &boolean);
+			}
+		}
+	}
+
+	void Renderer::setIndexBuffer(Resource *indexBuffer)
+	{
+		context->indexBuffer = indexBuffer;
+	}
+
+	void Renderer::setMultiSampleMask(unsigned int mask)
+	{
+		context->sampleMask = mask;
+	}
+
+	void Renderer::setTransparencyAntialiasing(TransparencyAntialiasing transparencyAntialiasing)
+	{
+		sw::transparencyAntialiasing = transparencyAntialiasing;
+	}
+
+	bool Renderer::isReadWriteTexture(int sampler)
+	{
+		for(int index = 0; index < RENDERTARGETS; index++)
+		{
+			if(context->renderTarget[index] && context->texture[sampler] == context->renderTarget[index]->getResource())
+			{
+				return true;
+			}
+		}
+
+		if(context->depthBuffer && context->texture[sampler] == context->depthBuffer->getResource())
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	void Renderer::updateClipper()
+	{
+		if(updateClipPlanes)
+		{
+			if(VertexProcessor::isFixedFunction())   // User plane in world space
+			{
+				const Matrix &scissorWorld = getViewTransform();
+
+				if(clipFlags & Clipper::CLIP_PLANE0) clipPlane[0] = scissorWorld * userPlane[0];
+				if(clipFlags & Clipper::CLIP_PLANE1) clipPlane[1] = scissorWorld * userPlane[1];
+				if(clipFlags & Clipper::CLIP_PLANE2) clipPlane[2] = scissorWorld * userPlane[2];
+				if(clipFlags & Clipper::CLIP_PLANE3) clipPlane[3] = scissorWorld * userPlane[3];
+				if(clipFlags & Clipper::CLIP_PLANE4) clipPlane[4] = scissorWorld * userPlane[4];
+				if(clipFlags & Clipper::CLIP_PLANE5) clipPlane[5] = scissorWorld * userPlane[5];
+			}
+			else   // User plane in clip space
+			{
+				if(clipFlags & Clipper::CLIP_PLANE0) clipPlane[0] = userPlane[0];
+				if(clipFlags & Clipper::CLIP_PLANE1) clipPlane[1] = userPlane[1];
+				if(clipFlags & Clipper::CLIP_PLANE2) clipPlane[2] = userPlane[2];
+				if(clipFlags & Clipper::CLIP_PLANE3) clipPlane[3] = userPlane[3];
+				if(clipFlags & Clipper::CLIP_PLANE4) clipPlane[4] = userPlane[4];
+				if(clipFlags & Clipper::CLIP_PLANE5) clipPlane[5] = userPlane[5];
+			}
+
+			updateClipPlanes = false;
+		}
+	}
+
+	void Renderer::setTextureResource(unsigned int sampler, Resource *resource)
+	{
+		ASSERT(sampler < TOTAL_IMAGE_UNITS);
+
+		context->texture[sampler] = resource;
+	}
+
+	void Renderer::setTextureLevel(unsigned int sampler, unsigned int face, unsigned int level, Surface *surface, TextureType type)
+	{
+		ASSERT(sampler < TOTAL_IMAGE_UNITS && face < 6 && level < MIPMAP_LEVELS);
+
+		context->sampler[sampler].setTextureLevel(face, level, surface, type);
+	}
+
+	void Renderer::setTextureFilter(SamplerType type, int sampler, FilterType textureFilter)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setTextureFilter(sampler, textureFilter);
+		}
+		else
+		{
+			VertexProcessor::setTextureFilter(sampler, textureFilter);
+		}
+	}
+
+	void Renderer::setMipmapFilter(SamplerType type, int sampler, MipmapType mipmapFilter)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMipmapFilter(sampler, mipmapFilter);
+		}
+		else
+		{
+			VertexProcessor::setMipmapFilter(sampler, mipmapFilter);
+		}
+	}
+
+	void Renderer::setGatherEnable(SamplerType type, int sampler, bool enable)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setGatherEnable(sampler, enable);
+		}
+		else
+		{
+			VertexProcessor::setGatherEnable(sampler, enable);
+		}
+	}
+
+	void Renderer::setAddressingModeU(SamplerType type, int sampler, AddressingMode addressMode)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setAddressingModeU(sampler, addressMode);
+		}
+		else
+		{
+			VertexProcessor::setAddressingModeU(sampler, addressMode);
+		}
+	}
+
+	void Renderer::setAddressingModeV(SamplerType type, int sampler, AddressingMode addressMode)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setAddressingModeV(sampler, addressMode);
+		}
+		else
+		{
+			VertexProcessor::setAddressingModeV(sampler, addressMode);
+		}
+	}
+
+	void Renderer::setAddressingModeW(SamplerType type, int sampler, AddressingMode addressMode)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setAddressingModeW(sampler, addressMode);
+		}
+		else
+		{
+			VertexProcessor::setAddressingModeW(sampler, addressMode);
+		}
+	}
+
+	void Renderer::setReadSRGB(SamplerType type, int sampler, bool sRGB)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setReadSRGB(sampler, sRGB);
+		}
+		else
+		{
+			VertexProcessor::setReadSRGB(sampler, sRGB);
+		}
+	}
+
+	void Renderer::setMipmapLOD(SamplerType type, int sampler, float bias)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMipmapLOD(sampler, bias);
+		}
+		else
+		{
+			VertexProcessor::setMipmapLOD(sampler, bias);
+		}
+	}
+
+	void Renderer::setBorderColor(SamplerType type, int sampler, const Color<float> &borderColor)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setBorderColor(sampler, borderColor);
+		}
+		else
+		{
+			VertexProcessor::setBorderColor(sampler, borderColor);
+		}
+	}
+
+	void Renderer::setMaxAnisotropy(SamplerType type, int sampler, float maxAnisotropy)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMaxAnisotropy(sampler, maxAnisotropy);
+		}
+		else
+		{
+			VertexProcessor::setMaxAnisotropy(sampler, maxAnisotropy);
+		}
+	}
+
+	void Renderer::setHighPrecisionFiltering(SamplerType type, int sampler, bool highPrecisionFiltering)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setHighPrecisionFiltering(sampler, highPrecisionFiltering);
+		}
+		else
+		{
+			VertexProcessor::setHighPrecisionFiltering(sampler, highPrecisionFiltering);
+		}
+	}
+
+	void Renderer::setSwizzleR(SamplerType type, int sampler, SwizzleType swizzleR)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setSwizzleR(sampler, swizzleR);
+		}
+		else
+		{
+			VertexProcessor::setSwizzleR(sampler, swizzleR);
+		}
+	}
+
+	void Renderer::setSwizzleG(SamplerType type, int sampler, SwizzleType swizzleG)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setSwizzleG(sampler, swizzleG);
+		}
+		else
+		{
+			VertexProcessor::setSwizzleG(sampler, swizzleG);
+		}
+	}
+
+	void Renderer::setSwizzleB(SamplerType type, int sampler, SwizzleType swizzleB)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setSwizzleB(sampler, swizzleB);
+		}
+		else
+		{
+			VertexProcessor::setSwizzleB(sampler, swizzleB);
+		}
+	}
+
+	void Renderer::setSwizzleA(SamplerType type, int sampler, SwizzleType swizzleA)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setSwizzleA(sampler, swizzleA);
+		}
+		else
+		{
+			VertexProcessor::setSwizzleA(sampler, swizzleA);
+		}
+	}
+
+	void Renderer::setCompareFunc(SamplerType type, int sampler, CompareFunc compFunc)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setCompareFunc(sampler, compFunc);
+		}
+		else
+		{
+			VertexProcessor::setCompareFunc(sampler, compFunc);
+		}
+	}
+
+	void Renderer::setBaseLevel(SamplerType type, int sampler, int baseLevel)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setBaseLevel(sampler, baseLevel);
+		}
+		else
+		{
+			VertexProcessor::setBaseLevel(sampler, baseLevel);
+		}
+	}
+
+	void Renderer::setMaxLevel(SamplerType type, int sampler, int maxLevel)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMaxLevel(sampler, maxLevel);
+		}
+		else
+		{
+			VertexProcessor::setMaxLevel(sampler, maxLevel);
+		}
+	}
+
+	void Renderer::setMinLod(SamplerType type, int sampler, float minLod)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMinLod(sampler, minLod);
+		}
+		else
+		{
+			VertexProcessor::setMinLod(sampler, minLod);
+		}
+	}
+
+	void Renderer::setMaxLod(SamplerType type, int sampler, float maxLod)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setMaxLod(sampler, maxLod);
+		}
+		else
+		{
+			VertexProcessor::setMaxLod(sampler, maxLod);
+		}
+	}
+
+	void Renderer::setSyncRequired(SamplerType type, int sampler, bool syncRequired)
+	{
+		if(type == SAMPLER_PIXEL)
+		{
+			PixelProcessor::setSyncRequired(sampler, syncRequired);
+		}
+		else
+		{
+			VertexProcessor::setSyncRequired(sampler, syncRequired);
+		}
+	}
+
+	void Renderer::setPointSpriteEnable(bool pointSpriteEnable)
+	{
+		context->setPointSpriteEnable(pointSpriteEnable);
+	}
+
+	void Renderer::setPointScaleEnable(bool pointScaleEnable)
+	{
+		context->setPointScaleEnable(pointScaleEnable);
+	}
+
+	void Renderer::setLineWidth(float width)
+	{
+		context->lineWidth = width;
+	}
+
+	void Renderer::setDepthBias(float bias)
+	{
+		context->depthBias = bias;
+	}
+
+	void Renderer::setSlopeDepthBias(float slopeBias)
+	{
+		context->slopeDepthBias = slopeBias;
+	}
+
+	void Renderer::setRasterizerDiscard(bool rasterizerDiscard)
+	{
+		context->rasterizerDiscard = rasterizerDiscard;
+	}
+
+	void Renderer::setPixelShader(const PixelShader *shader)
+	{
+		context->pixelShader = shader;
+
+		loadConstants(shader);
+	}
+
+	void Renderer::setVertexShader(const VertexShader *shader)
+	{
+		context->vertexShader = shader;
+
+		loadConstants(shader);
+	}
+
+	void Renderer::setPixelShaderConstantF(unsigned int index, const float value[4], unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->psDirtyConstF < index + count)
+			{
+				drawCall[i]->psDirtyConstF = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			PixelProcessor::setFloatConstant(index + i, value);
+			value += 4;
+		}
+	}
+
+	void Renderer::setPixelShaderConstantI(unsigned int index, const int value[4], unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->psDirtyConstI < index + count)
+			{
+				drawCall[i]->psDirtyConstI = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			PixelProcessor::setIntegerConstant(index + i, value);
+			value += 4;
+		}
+	}
+
+	void Renderer::setPixelShaderConstantB(unsigned int index, const int *boolean, unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->psDirtyConstB < index + count)
+			{
+				drawCall[i]->psDirtyConstB = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			PixelProcessor::setBooleanConstant(index + i, *boolean);
+			boolean++;
+		}
+	}
+
+	void Renderer::setVertexShaderConstantF(unsigned int index, const float value[4], unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->vsDirtyConstF < index + count)
+			{
+				drawCall[i]->vsDirtyConstF = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			VertexProcessor::setFloatConstant(index + i, value);
+			value += 4;
+		}
+	}
+
+	void Renderer::setVertexShaderConstantI(unsigned int index, const int value[4], unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->vsDirtyConstI < index + count)
+			{
+				drawCall[i]->vsDirtyConstI = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			VertexProcessor::setIntegerConstant(index + i, value);
+			value += 4;
+		}
+	}
+
+	void Renderer::setVertexShaderConstantB(unsigned int index, const int *boolean, unsigned int count)
+	{
+		for(unsigned int i = 0; i < DRAW_COUNT; i++)
+		{
+			if(drawCall[i]->vsDirtyConstB < index + count)
+			{
+				drawCall[i]->vsDirtyConstB = index + count;
+			}
+		}
+
+		for(unsigned int i = 0; i < count; i++)
+		{
+			VertexProcessor::setBooleanConstant(index + i, *boolean);
+			boolean++;
+		}
+	}
+
+	void Renderer::setModelMatrix(const Matrix &M, int i)
+	{
+		VertexProcessor::setModelMatrix(M, i);
+	}
+
+	void Renderer::setViewMatrix(const Matrix &V)
+	{
+		VertexProcessor::setViewMatrix(V);
+		updateClipPlanes = true;
+	}
+
+	void Renderer::setBaseMatrix(const Matrix &B)
+	{
+		VertexProcessor::setBaseMatrix(B);
+		updateClipPlanes = true;
+	}
+
+	void Renderer::setProjectionMatrix(const Matrix &P)
+	{
+		VertexProcessor::setProjectionMatrix(P);
+		updateClipPlanes = true;
+	}
+
+	void Renderer::addQuery(Query *query)
+	{
+		queries.push_back(query);
+	}
+
+	void Renderer::removeQuery(Query *query)
+	{
+		queries.remove(query);
+	}
+
+	#if PERF_HUD
+		int Renderer::getThreadCount()
+		{
+			return threadCount;
+		}
+
+		int64_t Renderer::getVertexTime(int thread)
+		{
+			return vertexTime[thread];
+		}
+
+		int64_t Renderer::getSetupTime(int thread)
+		{
+			return setupTime[thread];
+		}
+
+		int64_t Renderer::getPixelTime(int thread)
+		{
+			return pixelTime[thread];
+		}
+
+		void Renderer::resetTimers()
+		{
+			for(int thread = 0; thread < threadCount; thread++)
+			{
+				vertexTime[thread] = 0;
+				setupTime[thread] = 0;
+				pixelTime[thread] = 0;
+			}
+		}
+	#endif
+
+	void Renderer::setViewport(const Viewport &viewport)
+	{
+		this->viewport = viewport;
+	}
+
+	void Renderer::setScissor(const Rect &scissor)
+	{
+		this->scissor = scissor;
+	}
+
+	void Renderer::setClipFlags(int flags)
+	{
+		clipFlags = flags << 8;   // Bottom 8 bits used by legacy frustum
+	}
+
+	void Renderer::setClipPlane(unsigned int index, const float plane[4])
+	{
+		if(index < MAX_CLIP_PLANES)
+		{
+			userPlane[index] = plane;
+		}
+		else ASSERT(false);
+
+		updateClipPlanes = true;
+	}
+
+	void Renderer::updateConfiguration(bool initialUpdate)
+	{
+		bool newConfiguration = swiftConfig->hasNewConfiguration();
+
+		if(newConfiguration || initialUpdate)
+		{
+			terminateThreads();
+
+			SwiftConfig::Configuration configuration = {};
+			swiftConfig->getConfiguration(configuration);
+
+			precacheVertex = !newConfiguration && configuration.precache;
+			precacheSetup = !newConfiguration && configuration.precache;
+			precachePixel = !newConfiguration && configuration.precache;
+
+			VertexProcessor::setRoutineCacheSize(configuration.vertexRoutineCacheSize);
+			PixelProcessor::setRoutineCacheSize(configuration.pixelRoutineCacheSize);
+			SetupProcessor::setRoutineCacheSize(configuration.setupRoutineCacheSize);
+
+			switch(configuration.textureSampleQuality)
+			{
+			case 0:  Sampler::setFilterQuality(FILTER_POINT);       break;
+			case 1:  Sampler::setFilterQuality(FILTER_LINEAR);      break;
+			case 2:  Sampler::setFilterQuality(FILTER_ANISOTROPIC); break;
+			default: Sampler::setFilterQuality(FILTER_ANISOTROPIC); break;
+			}
+
+			switch(configuration.mipmapQuality)
+			{
+			case 0:  Sampler::setMipmapQuality(MIPMAP_POINT);  break;
+			case 1:  Sampler::setMipmapQuality(MIPMAP_LINEAR); break;
+			default: Sampler::setMipmapQuality(MIPMAP_LINEAR); break;
+			}
+
+			setPerspectiveCorrection(configuration.perspectiveCorrection);
+
+			switch(configuration.transcendentalPrecision)
+			{
+			case 0:
+				logPrecision = APPROXIMATE;
+				expPrecision = APPROXIMATE;
+				rcpPrecision = APPROXIMATE;
+				rsqPrecision = APPROXIMATE;
+				break;
+			case 1:
+				logPrecision = PARTIAL;
+				expPrecision = PARTIAL;
+				rcpPrecision = PARTIAL;
+				rsqPrecision = PARTIAL;
+				break;
+			case 2:
+				logPrecision = ACCURATE;
+				expPrecision = ACCURATE;
+				rcpPrecision = ACCURATE;
+				rsqPrecision = ACCURATE;
+				break;
+			case 3:
+				logPrecision = WHQL;
+				expPrecision = WHQL;
+				rcpPrecision = WHQL;
+				rsqPrecision = WHQL;
+				break;
+			case 4:
+				logPrecision = IEEE;
+				expPrecision = IEEE;
+				rcpPrecision = IEEE;
+				rsqPrecision = IEEE;
+				break;
+			default:
+				logPrecision = ACCURATE;
+				expPrecision = ACCURATE;
+				rcpPrecision = ACCURATE;
+				rsqPrecision = ACCURATE;
+				break;
+			}
+
+			switch(configuration.transparencyAntialiasing)
+			{
+			case 0:  transparencyAntialiasing = TRANSPARENCY_NONE;              break;
+			case 1:  transparencyAntialiasing = TRANSPARENCY_ALPHA_TO_COVERAGE; break;
+			default: transparencyAntialiasing = TRANSPARENCY_NONE;              break;
+			}
+
+			switch(configuration.threadCount)
+			{
+			case -1: threadCount = CPUID::coreCount();        break;
+			case 0:  threadCount = CPUID::processAffinity();  break;
+			default: threadCount = configuration.threadCount; break;
+			}
+
+			CPUID::setEnableSSE4_1(configuration.enableSSE4_1);
+			CPUID::setEnableSSSE3(configuration.enableSSSE3);
+			CPUID::setEnableSSE3(configuration.enableSSE3);
+			CPUID::setEnableSSE2(configuration.enableSSE2);
+			CPUID::setEnableSSE(configuration.enableSSE);
+
+			for(int pass = 0; pass < 10; pass++)
+			{
+				optimization[pass] = configuration.optimization[pass];
+			}
+
+			forceWindowed = configuration.forceWindowed;
+			complementaryDepthBuffer = configuration.complementaryDepthBuffer;
+			postBlendSRGB = configuration.postBlendSRGB;
+			exactColorRounding = configuration.exactColorRounding;
+			forceClearRegisters = configuration.forceClearRegisters;
+
+		#ifndef NDEBUG
+			minPrimitives = configuration.minPrimitives;
+			maxPrimitives = configuration.maxPrimitives;
+		#endif
+		}
+
+		if(!initialUpdate && !worker[0])
+		{
+			initializeThreads();
+		}
+	}
+}
diff --git a/src/Device/Renderer.hpp b/src/Device/Renderer.hpp
new file mode 100644
index 0000000..ce22866
--- /dev/null
+++ b/src/Device/Renderer.hpp
@@ -0,0 +1,508 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Renderer_hpp
+#define sw_Renderer_hpp
+
+#include "VertexProcessor.hpp"
+#include "PixelProcessor.hpp"
+#include "SetupProcessor.hpp"
+#include "Plane.hpp"
+#include "Blitter.hpp"
+#include "Common/MutexLock.hpp"
+#include "Common/Thread.hpp"
+#include "Main/Config.hpp"
+
+#include <list>
+
+namespace sw
+{
+	class Clipper;
+	struct DrawCall;
+	class PixelShader;
+	class VertexShader;
+	class SwiftConfig;
+	struct Task;
+	class Resource;
+	struct Constants;
+
+	enum TranscendentalPrecision
+	{
+		APPROXIMATE,
+		PARTIAL,	// 2^-10
+		ACCURATE,
+		WHQL,		// 2^-21
+		IEEE		// 2^-23
+	};
+
+	extern TranscendentalPrecision logPrecision;
+	extern TranscendentalPrecision expPrecision;
+	extern TranscendentalPrecision rcpPrecision;
+	extern TranscendentalPrecision rsqPrecision;
+	extern bool perspectiveCorrection;
+
+	struct Conventions
+	{
+		bool halfIntegerCoordinates;
+		bool symmetricNormalizedDepth;
+		bool booleanFaceRegister;
+		bool fullPixelPositionRegister;
+		bool leadingVertexFirst;
+		bool secondaryColor;
+		bool colorsDefaultToZero;
+	};
+
+	static const Conventions OpenGL =
+	{
+		true,    // halfIntegerCoordinates
+		true,    // symmetricNormalizedDepth
+		true,    // booleanFaceRegister
+		true,    // fullPixelPositionRegister
+		false,   // leadingVertexFirst
+		false,   // secondaryColor
+		true,    // colorsDefaultToZero
+	};
+
+	static const Conventions Direct3D =
+	{
+		false,   // halfIntegerCoordinates
+		false,   // symmetricNormalizedDepth
+		false,   // booleanFaceRegister
+		false,   // fullPixelPositionRegister
+		true,    // leadingVertexFirst
+		true,    // secondardyColor
+		false,   // colorsDefaultToZero
+	};
+
+	struct Query
+	{
+		enum Type { FRAGMENTS_PASSED, TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN };
+
+		Query(Type type) : building(false), reference(0), data(0), type(type)
+		{
+		}
+
+		void begin()
+		{
+			building = true;
+			data = 0;
+		}
+
+		void end()
+		{
+			building = false;
+		}
+
+		bool building;
+		AtomicInt reference;
+		AtomicInt data;
+
+		const Type type;
+	};
+
+	struct DrawData
+	{
+		const Constants *constants;
+
+		const void *input[MAX_VERTEX_INPUTS];
+		unsigned int stride[MAX_VERTEX_INPUTS];
+		Texture mipmap[TOTAL_IMAGE_UNITS];
+		const void *indices;
+
+		struct VS
+		{
+			float4 c[VERTEX_UNIFORM_VECTORS + 1];   // One extra for indices out of range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0}
+			byte* u[MAX_UNIFORM_BUFFER_BINDINGS];
+			byte* t[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS];
+			unsigned int reg[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Offset used when reading from registers, in components
+			unsigned int row[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of rows to read
+			unsigned int col[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of columns to read
+			unsigned int str[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]; // Number of components between each varying in output buffer
+			int4 i[16];
+			bool b[16];
+		};
+
+		struct PS
+		{
+			word4 cW[8][4];
+			float4 c[FRAGMENT_UNIFORM_VECTORS];
+			byte* u[MAX_UNIFORM_BUFFER_BINDINGS];
+			int4 i[16];
+			bool b[16];
+		};
+
+		union
+		{
+			VS vs;
+			VertexProcessor::FixedFunction ff;
+		};
+
+		PS ps;
+
+		int instanceID;
+
+		VertexProcessor::PointSprite point;
+		float lineWidth;
+
+		PixelProcessor::Stencil stencil[2];   // clockwise, counterclockwise
+		PixelProcessor::Stencil stencilCCW;
+		PixelProcessor::Fog fog;
+		PixelProcessor::Factor factor;
+		unsigned int occlusion[16];   // Number of pixels passing depth test
+
+		#if PERF_PROFILE
+			int64_t cycles[PERF_TIMERS][16];
+		#endif
+
+		TextureStage::Uniforms textureStage[8];
+
+		float4 Wx16;
+		float4 Hx16;
+		float4 X0x16;
+		float4 Y0x16;
+		float4 XXXX;
+		float4 YYYY;
+		float4 halfPixelX;
+		float4 halfPixelY;
+		float viewportHeight;
+		float slopeDepthBias;
+		float depthRange;
+		float depthNear;
+		Plane clipPlane[6];
+
+		unsigned int *colorBuffer[RENDERTARGETS];
+		int colorPitchB[RENDERTARGETS];
+		int colorSliceB[RENDERTARGETS];
+		float *depthBuffer;
+		int depthPitchB;
+		int depthSliceB;
+		unsigned char *stencilBuffer;
+		int stencilPitchB;
+		int stencilSliceB;
+
+		int scissorX0;
+		int scissorX1;
+		int scissorY0;
+		int scissorY1;
+
+		float4 a2c0;
+		float4 a2c1;
+		float4 a2c2;
+		float4 a2c3;
+	};
+
+	struct Viewport
+	{
+		float x0;
+		float y0;
+		float width;
+		float height;
+		float minZ;
+		float maxZ;
+	};
+
+	class Renderer : public VertexProcessor, public PixelProcessor, public SetupProcessor
+	{
+		struct Task
+		{
+			enum Type
+			{
+				PRIMITIVES,
+				PIXELS,
+
+				RESUME,
+				SUSPEND
+			};
+
+			AtomicInt type;
+			AtomicInt primitiveUnit;
+			AtomicInt pixelCluster;
+		};
+
+		struct PrimitiveProgress
+		{
+			void init()
+			{
+				drawCall = 0;
+				firstPrimitive = 0;
+				primitiveCount = 0;
+				visible = 0;
+				references = 0;
+			}
+
+			AtomicInt drawCall;
+			AtomicInt firstPrimitive;
+			AtomicInt primitiveCount;
+			AtomicInt visible;
+			AtomicInt references;
+		};
+
+		struct PixelProgress
+		{
+			void init()
+			{
+				drawCall = 0;
+				processedPrimitives = 0;
+				executing = false;
+			}
+
+			AtomicInt drawCall;
+			AtomicInt processedPrimitives;
+			AtomicInt executing;
+		};
+
+	public:
+		Renderer(Context *context, Conventions conventions, bool exactColorRounding);
+
+		virtual ~Renderer();
+
+		void *operator new(size_t size);
+		void operator delete(void * mem);
+
+		void draw(DrawType drawType, unsigned int indexOffset, unsigned int count, bool update = true);
+
+		void clear(void *value, Format format, Surface *dest, const Rect &rect, unsigned int rgbaMask);
+		void blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, bool filter, bool isStencil = false, bool sRGBconversion = true);
+		void blit3D(Surface *source, Surface *dest);
+
+		void setIndexBuffer(Resource *indexBuffer);
+
+		void setMultiSampleMask(unsigned int mask);
+		void setTransparencyAntialiasing(TransparencyAntialiasing transparencyAntialiasing);
+
+		void setTextureResource(unsigned int sampler, Resource *resource);
+		void setTextureLevel(unsigned int sampler, unsigned int face, unsigned int level, Surface *surface, TextureType type);
+
+		void setTextureFilter(SamplerType type, int sampler, FilterType textureFilter);
+		void setMipmapFilter(SamplerType type, int sampler, MipmapType mipmapFilter);
+		void setGatherEnable(SamplerType type, int sampler, bool enable);
+		void setAddressingModeU(SamplerType type, int sampler, AddressingMode addressingMode);
+		void setAddressingModeV(SamplerType type, int sampler, AddressingMode addressingMode);
+		void setAddressingModeW(SamplerType type, int sampler, AddressingMode addressingMode);
+		void setReadSRGB(SamplerType type, int sampler, bool sRGB);
+		void setMipmapLOD(SamplerType type, int sampler, float bias);
+		void setBorderColor(SamplerType type, int sampler, const Color<float> &borderColor);
+		void setMaxAnisotropy(SamplerType type, int sampler, float maxAnisotropy);
+		void setHighPrecisionFiltering(SamplerType type, int sampler, bool highPrecisionFiltering);
+		void setSwizzleR(SamplerType type, int sampler, SwizzleType swizzleR);
+		void setSwizzleG(SamplerType type, int sampler, SwizzleType swizzleG);
+		void setSwizzleB(SamplerType type, int sampler, SwizzleType swizzleB);
+		void setSwizzleA(SamplerType type, int sampler, SwizzleType swizzleA);
+		void setCompareFunc(SamplerType type, int sampler, CompareFunc compare);
+		void setBaseLevel(SamplerType type, int sampler, int baseLevel);
+		void setMaxLevel(SamplerType type, int sampler, int maxLevel);
+		void setMinLod(SamplerType type, int sampler, float minLod);
+		void setMaxLod(SamplerType type, int sampler, float maxLod);
+		void setSyncRequired(SamplerType type, int sampler, bool syncRequired);
+
+		void setPointSpriteEnable(bool pointSpriteEnable);
+		void setPointScaleEnable(bool pointScaleEnable);
+		void setLineWidth(float width);
+
+		void setDepthBias(float bias);
+		void setSlopeDepthBias(float slopeBias);
+
+		void setRasterizerDiscard(bool rasterizerDiscard);
+
+		// Programmable pipelines
+		void setPixelShader(const PixelShader *shader);
+		void setVertexShader(const VertexShader *shader);
+
+		void setPixelShaderConstantF(unsigned int index, const float value[4], unsigned int count = 1);
+		void setPixelShaderConstantI(unsigned int index, const int value[4], unsigned int count = 1);
+		void setPixelShaderConstantB(unsigned int index, const int *boolean, unsigned int count = 1);
+
+		void setVertexShaderConstantF(unsigned int index, const float value[4], unsigned int count = 1);
+		void setVertexShaderConstantI(unsigned int index, const int value[4], unsigned int count = 1);
+		void setVertexShaderConstantB(unsigned int index, const int *boolean, unsigned int count = 1);
+
+		// Viewport & Clipper
+		void setViewport(const Viewport &viewport);
+		void setScissor(const Rect &scissor);
+		void setClipFlags(int flags);
+		void setClipPlane(unsigned int index, const float plane[4]);
+
+		// Partial transform
+		void setModelMatrix(const Matrix &M, int i = 0);
+		void setViewMatrix(const Matrix &V);
+		void setBaseMatrix(const Matrix &B);
+		void setProjectionMatrix(const Matrix &P);
+
+		void addQuery(Query *query);
+		void removeQuery(Query *query);
+
+		void synchronize();
+
+		#if PERF_HUD
+			// Performance timers
+			int getThreadCount();
+			int64_t getVertexTime(int thread);
+			int64_t getSetupTime(int thread);
+			int64_t getPixelTime(int thread);
+			void resetTimers();
+		#endif
+
+		static int getClusterCount() { return clusterCount; }
+
+	private:
+		static void threadFunction(void *parameters);
+		void threadLoop(int threadIndex);
+		void taskLoop(int threadIndex);
+		void findAvailableTasks();
+		void scheduleTask(int threadIndex);
+		void executeTask(int threadIndex);
+		void finishRendering(Task &pixelTask);
+
+		void processPrimitiveVertices(int unit, unsigned int start, unsigned int count, unsigned int loop, int thread);
+
+		int setupSolidTriangles(int batch, int count);
+		int setupWireframeTriangle(int batch, int count);
+		int setupVertexTriangle(int batch, int count);
+		int setupLines(int batch, int count);
+		int setupPoints(int batch, int count);
+
+		bool setupLine(Primitive &primitive, Triangle &triangle, const DrawCall &draw);
+		bool setupPoint(Primitive &primitive, Triangle &triangle, const DrawCall &draw);
+
+		bool isReadWriteTexture(int sampler);
+		void updateClipper();
+		void updateConfiguration(bool initialUpdate = false);
+		void initializeThreads();
+		void terminateThreads();
+
+		void loadConstants(const VertexShader *vertexShader);
+		void loadConstants(const PixelShader *pixelShader);
+
+		Context *context;
+		Clipper *clipper;
+		Blitter *blitter;
+		Viewport viewport;
+		Rect scissor;
+		int clipFlags;
+
+		Triangle *triangleBatch[16];
+		Primitive *primitiveBatch[16];
+
+		// User-defined clipping planes
+		Plane userPlane[MAX_CLIP_PLANES];
+		Plane clipPlane[MAX_CLIP_PLANES];   // Tranformed to clip space
+		bool updateClipPlanes;
+
+		AtomicInt exitThreads;
+		AtomicInt threadsAwake;
+		Thread *worker[16];
+		Event *resume[16];         // Events for resuming threads
+		Event *suspend[16];        // Events for suspending threads
+		Event *resumeApp;          // Event for resuming the application thread
+
+		PrimitiveProgress primitiveProgress[16];
+		PixelProgress pixelProgress[16];
+		Task task[16];   // Current tasks for threads
+
+		enum {
+			DRAW_COUNT = 16,   // Number of draw calls buffered (must be power of 2)
+			DRAW_COUNT_BITS = DRAW_COUNT - 1,
+		};
+		DrawCall *drawCall[DRAW_COUNT];
+		DrawCall *drawList[DRAW_COUNT];
+
+		AtomicInt currentDraw;
+		AtomicInt nextDraw;
+
+		enum {
+			TASK_COUNT = 32,   // Size of the task queue (must be power of 2)
+			TASK_COUNT_BITS = TASK_COUNT - 1,
+		};
+		Task taskQueue[TASK_COUNT];
+		AtomicInt qHead;
+		AtomicInt qSize;
+
+		static AtomicInt unitCount;
+		static AtomicInt clusterCount;
+
+		MutexLock schedulerMutex;
+
+		#if PERF_HUD
+			int64_t vertexTime[16];
+			int64_t setupTime[16];
+			int64_t pixelTime[16];
+		#endif
+
+		VertexTask *vertexTask[16];
+
+		SwiftConfig *swiftConfig;
+
+		std::list<Query*> queries;
+		Resource *sync;
+
+		VertexProcessor::State vertexState;
+		SetupProcessor::State setupState;
+		PixelProcessor::State pixelState;
+
+		Routine *vertexRoutine;
+		Routine *setupRoutine;
+		Routine *pixelRoutine;
+	};
+
+	struct DrawCall
+	{
+		DrawCall();
+
+		~DrawCall();
+
+		AtomicInt drawType;
+		AtomicInt batchSize;
+
+		Routine *vertexRoutine;
+		Routine *setupRoutine;
+		Routine *pixelRoutine;
+
+		VertexProcessor::RoutinePointer vertexPointer;
+		SetupProcessor::RoutinePointer setupPointer;
+		PixelProcessor::RoutinePointer pixelPointer;
+
+		int (Renderer::*setupPrimitives)(int batch, int count);
+		SetupProcessor::State setupState;
+
+		Resource *vertexStream[MAX_VERTEX_INPUTS];
+		Resource *indexBuffer;
+		Surface *renderTarget[RENDERTARGETS];
+		Surface *depthBuffer;
+		Surface *stencilBuffer;
+		Resource *texture[TOTAL_IMAGE_UNITS];
+		Resource* pUniformBuffers[MAX_UNIFORM_BUFFER_BINDINGS];
+		Resource* vUniformBuffers[MAX_UNIFORM_BUFFER_BINDINGS];
+		Resource* transformFeedbackBuffers[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS];
+
+		unsigned int vsDirtyConstF;
+		unsigned int vsDirtyConstI;
+		unsigned int vsDirtyConstB;
+
+		unsigned int psDirtyConstF;
+		unsigned int psDirtyConstI;
+		unsigned int psDirtyConstB;
+
+		std::list<Query*> *queries;
+
+		AtomicInt clipFlags;
+
+		AtomicInt primitive;    // Current primitive to enter pipeline
+		AtomicInt count;        // Number of primitives to render
+		AtomicInt references;   // Remaining references to this draw call, 0 when done drawing, -1 when resources unlocked and slot is free
+
+		DrawData *data;
+	};
+}
+
+#endif   // sw_Renderer_hpp
diff --git a/src/Device/RoutineCache.hpp b/src/Device/RoutineCache.hpp
new file mode 100644
index 0000000..74dd842
--- /dev/null
+++ b/src/Device/RoutineCache.hpp
@@ -0,0 +1,49 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_RoutineCache_hpp
+#define sw_RoutineCache_hpp
+
+#include "LRUCache.hpp"
+
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+	template<class State>
+	class RoutineCache : public LRUCache<State, Routine>
+	{
+	public:
+		RoutineCache(int n, const char *precache = 0);
+		~RoutineCache();
+
+	private:
+		const char *precache;
+		#if defined(_WIN32)
+		HMODULE precacheDLL;
+		#endif
+	};
+
+	template<class State>
+	RoutineCache<State>::RoutineCache(int n, const char *precache) : LRUCache<State, Routine>(n), precache(precache)
+	{
+	}
+
+	template<class State>
+	RoutineCache<State>::~RoutineCache()
+	{
+	}
+}
+
+#endif   // sw_RoutineCache_hpp
diff --git a/src/Device/Sampler.cpp b/src/Device/Sampler.cpp
new file mode 100644
index 0000000..efac4c6
--- /dev/null
+++ b/src/Device/Sampler.cpp
@@ -0,0 +1,514 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Sampler.hpp"
+
+#include "Context.hpp"
+#include "Surface.hpp"
+#include "Shader/PixelRoutine.hpp"
+#include "Common/Debug.hpp"
+
+#include <memory.h>
+#include <string.h>
+
+namespace sw
+{
+	FilterType Sampler::maximumTextureFilterQuality = FILTER_LINEAR;
+	MipmapType Sampler::maximumMipmapFilterQuality = MIPMAP_POINT;
+
+	Sampler::State::State()
+	{
+		memset(this, 0, sizeof(State));
+	}
+
+	Sampler::Sampler()
+	{
+		// FIXME: Mipmap::init
+		static const unsigned int zero = 0x00FF00FF;
+
+		for(int level = 0; level < MIPMAP_LEVELS; level++)
+		{
+			Mipmap &mipmap = texture.mipmap[level];
+
+			memset(&mipmap, 0, sizeof(Mipmap));
+
+			for(int face = 0; face < 6; face++)
+			{
+				mipmap.buffer[face] = &zero;
+			}
+		}
+
+		externalTextureFormat = FORMAT_NULL;
+		internalTextureFormat = FORMAT_NULL;
+		textureType = TEXTURE_NULL;
+
+		textureFilter = FILTER_LINEAR;
+		addressingModeU = ADDRESSING_WRAP;
+		addressingModeV = ADDRESSING_WRAP;
+		addressingModeW = ADDRESSING_WRAP;
+		mipmapFilterState = MIPMAP_NONE;
+		sRGB = false;
+		gather = false;
+		highPrecisionFiltering = false;
+		border = 0;
+
+		swizzleR = SWIZZLE_RED;
+		swizzleG = SWIZZLE_GREEN;
+		swizzleB = SWIZZLE_BLUE;
+		swizzleA = SWIZZLE_ALPHA;
+
+		compare = COMPARE_BYPASS;
+
+		texture.LOD = 0.0f;
+		exp2LOD = 1.0f;
+
+		texture.baseLevel = 0;
+		texture.maxLevel = 1000;
+		texture.maxLod = MAX_TEXTURE_LOD;
+		texture.minLod = 0;
+	}
+
+	Sampler::~Sampler()
+	{
+	}
+
+	Sampler::State Sampler::samplerState() const
+	{
+		State state;
+
+		if(textureType != TEXTURE_NULL)
+		{
+			state.textureType = textureType;
+			state.textureFormat = internalTextureFormat;
+			state.textureFilter = getTextureFilter();
+			state.addressingModeU = getAddressingModeU();
+			state.addressingModeV = getAddressingModeV();
+			state.addressingModeW = getAddressingModeW();
+			state.mipmapFilter = mipmapFilter();
+			state.sRGB = (sRGB && Surface::isSRGBreadable(externalTextureFormat)) || Surface::isSRGBformat(internalTextureFormat);
+			state.swizzleR = swizzleR;
+			state.swizzleG = swizzleG;
+			state.swizzleB = swizzleB;
+			state.swizzleA = swizzleA;
+			state.highPrecisionFiltering = highPrecisionFiltering;
+			state.compare = getCompareFunc();
+
+			#if PERF_PROFILE
+				state.compressedFormat = Surface::isCompressed(externalTextureFormat);
+			#endif
+		}
+
+		return state;
+	}
+
+	void Sampler::setTextureLevel(int face, int level, Surface *surface, TextureType type)
+	{
+		if(surface)
+		{
+			Mipmap &mipmap = texture.mipmap[level];
+
+			border = surface->getBorder();
+			mipmap.buffer[face] = surface->lockInternal(-border, -border, 0, LOCK_UNLOCKED, PRIVATE);
+
+			if(face == 0)
+			{
+				externalTextureFormat = surface->getExternalFormat();
+				internalTextureFormat = surface->getInternalFormat();
+
+				int width = surface->getWidth();
+				int height = surface->getHeight();
+				int depth = surface->getDepth();
+				int pitchP = surface->getInternalPitchP();
+				int sliceP = surface->getInternalSliceP();
+
+				if(level == 0)
+				{
+					texture.widthHeightLOD[0] = width * exp2LOD;
+					texture.widthHeightLOD[1] = width * exp2LOD;
+					texture.widthHeightLOD[2] = height * exp2LOD;
+					texture.widthHeightLOD[3] = height * exp2LOD;
+
+					texture.widthLOD[0] = width * exp2LOD;
+					texture.widthLOD[1] = width * exp2LOD;
+					texture.widthLOD[2] = width * exp2LOD;
+					texture.widthLOD[3] = width * exp2LOD;
+
+					texture.heightLOD[0] = height * exp2LOD;
+					texture.heightLOD[1] = height * exp2LOD;
+					texture.heightLOD[2] = height * exp2LOD;
+					texture.heightLOD[3] = height * exp2LOD;
+
+					texture.depthLOD[0] = depth * exp2LOD;
+					texture.depthLOD[1] = depth * exp2LOD;
+					texture.depthLOD[2] = depth * exp2LOD;
+					texture.depthLOD[3] = depth * exp2LOD;
+				}
+
+				if(Surface::isFloatFormat(internalTextureFormat))
+				{
+					mipmap.fWidth[0] = (float)width / 65536.0f;
+					mipmap.fWidth[1] = (float)width / 65536.0f;
+					mipmap.fWidth[2] = (float)width / 65536.0f;
+					mipmap.fWidth[3] = (float)width / 65536.0f;
+
+					mipmap.fHeight[0] = (float)height / 65536.0f;
+					mipmap.fHeight[1] = (float)height / 65536.0f;
+					mipmap.fHeight[2] = (float)height / 65536.0f;
+					mipmap.fHeight[3] = (float)height / 65536.0f;
+
+					mipmap.fDepth[0] = (float)depth / 65536.0f;
+					mipmap.fDepth[1] = (float)depth / 65536.0f;
+					mipmap.fDepth[2] = (float)depth / 65536.0f;
+					mipmap.fDepth[3] = (float)depth / 65536.0f;
+				}
+
+				short halfTexelU = 0x8000 / width;
+				short halfTexelV = 0x8000 / height;
+				short halfTexelW = 0x8000 / depth;
+
+				mipmap.uHalf[0] = halfTexelU;
+				mipmap.uHalf[1] = halfTexelU;
+				mipmap.uHalf[2] = halfTexelU;
+				mipmap.uHalf[3] = halfTexelU;
+
+				mipmap.vHalf[0] = halfTexelV;
+				mipmap.vHalf[1] = halfTexelV;
+				mipmap.vHalf[2] = halfTexelV;
+				mipmap.vHalf[3] = halfTexelV;
+
+				mipmap.wHalf[0] = halfTexelW;
+				mipmap.wHalf[1] = halfTexelW;
+				mipmap.wHalf[2] = halfTexelW;
+				mipmap.wHalf[3] = halfTexelW;
+
+				mipmap.width[0] = width;
+				mipmap.width[1] = width;
+				mipmap.width[2] = width;
+				mipmap.width[3] = width;
+
+				mipmap.height[0] = height;
+				mipmap.height[1] = height;
+				mipmap.height[2] = height;
+				mipmap.height[3] = height;
+
+				mipmap.depth[0] = depth;
+				mipmap.depth[1] = depth;
+				mipmap.depth[2] = depth;
+				mipmap.depth[3] = depth;
+
+				mipmap.onePitchP[0] = 1;
+				mipmap.onePitchP[1] = pitchP;
+				mipmap.onePitchP[2] = 1;
+				mipmap.onePitchP[3] = pitchP;
+
+				mipmap.pitchP[0] = pitchP;
+				mipmap.pitchP[1] = pitchP;
+				mipmap.pitchP[2] = pitchP;
+				mipmap.pitchP[3] = pitchP;
+
+				mipmap.sliceP[0] = sliceP;
+				mipmap.sliceP[1] = sliceP;
+				mipmap.sliceP[2] = sliceP;
+				mipmap.sliceP[3] = sliceP;
+
+				if(internalTextureFormat == FORMAT_YV12_BT601 ||
+				   internalTextureFormat == FORMAT_YV12_BT709 ||
+				   internalTextureFormat == FORMAT_YV12_JFIF)
+				{
+					unsigned int YStride = pitchP;
+					unsigned int YSize = YStride * height;
+					unsigned int CStride = align<16>(YStride / 2);
+					unsigned int CSize = CStride * height / 2;
+
+					mipmap.buffer[1] = (byte*)mipmap.buffer[0] + YSize;
+					mipmap.buffer[2] = (byte*)mipmap.buffer[1] + CSize;
+
+					texture.mipmap[1].width[0] = width / 2;
+					texture.mipmap[1].width[1] = width / 2;
+					texture.mipmap[1].width[2] = width / 2;
+					texture.mipmap[1].width[3] = width / 2;
+					texture.mipmap[1].height[0] = height / 2;
+					texture.mipmap[1].height[1] = height / 2;
+					texture.mipmap[1].height[2] = height / 2;
+					texture.mipmap[1].height[3] = height / 2;
+					texture.mipmap[1].onePitchP[0] = 1;
+					texture.mipmap[1].onePitchP[1] = CStride;
+					texture.mipmap[1].onePitchP[2] = 1;
+					texture.mipmap[1].onePitchP[3] = CStride;
+				}
+			}
+		}
+
+		textureType = type;
+	}
+
+	void Sampler::setTextureFilter(FilterType textureFilter)
+	{
+		this->textureFilter = (FilterType)min(textureFilter, maximumTextureFilterQuality);
+	}
+
+	void Sampler::setMipmapFilter(MipmapType mipmapFilter)
+	{
+		mipmapFilterState = (MipmapType)min(mipmapFilter, maximumMipmapFilterQuality);
+	}
+
+	void Sampler::setGatherEnable(bool enable)
+	{
+		gather = enable;
+	}
+
+	void Sampler::setAddressingModeU(AddressingMode addressingMode)
+	{
+		addressingModeU = addressingMode;
+	}
+
+	void Sampler::setAddressingModeV(AddressingMode addressingMode)
+	{
+		addressingModeV = addressingMode;
+	}
+
+	void Sampler::setAddressingModeW(AddressingMode addressingMode)
+	{
+		addressingModeW = addressingMode;
+	}
+
+	void Sampler::setReadSRGB(bool sRGB)
+	{
+		this->sRGB = sRGB;
+	}
+
+	void Sampler::setBorderColor(const Color<float> &borderColor)
+	{
+		// FIXME: Compact into generic function   // FIXME: Clamp
+		short r = iround(0xFFFF * borderColor.r);
+		short g = iround(0xFFFF * borderColor.g);
+		short b = iround(0xFFFF * borderColor.b);
+		short a = iround(0xFFFF * borderColor.a);
+
+		texture.borderColor4[0][0] = texture.borderColor4[0][1] = texture.borderColor4[0][2] = texture.borderColor4[0][3] = r;
+		texture.borderColor4[1][0] = texture.borderColor4[1][1] = texture.borderColor4[1][2] = texture.borderColor4[1][3] = g;
+		texture.borderColor4[2][0] = texture.borderColor4[2][1] = texture.borderColor4[2][2] = texture.borderColor4[2][3] = b;
+		texture.borderColor4[3][0] = texture.borderColor4[3][1] = texture.borderColor4[3][2] = texture.borderColor4[3][3] = a;
+
+		texture.borderColorF[0][0] = texture.borderColorF[0][1] = texture.borderColorF[0][2] = texture.borderColorF[0][3] = borderColor.r;
+		texture.borderColorF[1][0] = texture.borderColorF[1][1] = texture.borderColorF[1][2] = texture.borderColorF[1][3] = borderColor.g;
+		texture.borderColorF[2][0] = texture.borderColorF[2][1] = texture.borderColorF[2][2] = texture.borderColorF[2][3] = borderColor.b;
+		texture.borderColorF[3][0] = texture.borderColorF[3][1] = texture.borderColorF[3][2] = texture.borderColorF[3][3] = borderColor.a;
+	}
+
+	void Sampler::setMaxAnisotropy(float maxAnisotropy)
+	{
+		texture.maxAnisotropy = maxAnisotropy;
+	}
+
+	void Sampler::setHighPrecisionFiltering(bool highPrecisionFiltering)
+	{
+		this->highPrecisionFiltering = highPrecisionFiltering;
+	}
+
+	void Sampler::setSwizzleR(SwizzleType swizzleR)
+	{
+		this->swizzleR = swizzleR;
+	}
+
+	void Sampler::setSwizzleG(SwizzleType swizzleG)
+	{
+		this->swizzleG = swizzleG;
+	}
+
+	void Sampler::setSwizzleB(SwizzleType swizzleB)
+	{
+		this->swizzleB = swizzleB;
+	}
+
+	void Sampler::setSwizzleA(SwizzleType swizzleA)
+	{
+		this->swizzleA = swizzleA;
+	}
+
+	void Sampler::setCompareFunc(CompareFunc compare)
+	{
+		this->compare = compare;
+	}
+
+	void Sampler::setBaseLevel(int baseLevel)
+	{
+		texture.baseLevel = baseLevel;
+	}
+
+	void Sampler::setMaxLevel(int maxLevel)
+	{
+		texture.maxLevel = maxLevel;
+	}
+
+	void Sampler::setMinLod(float minLod)
+	{
+		texture.minLod = clamp(minLod, 0.0f, (float)(MAX_TEXTURE_LOD));
+	}
+
+	void Sampler::setMaxLod(float maxLod)
+	{
+		texture.maxLod = clamp(maxLod, 0.0f, (float)(MAX_TEXTURE_LOD));
+	}
+
+	void Sampler::setFilterQuality(FilterType maximumFilterQuality)
+	{
+		Sampler::maximumTextureFilterQuality = maximumFilterQuality;
+	}
+
+	void Sampler::setMipmapQuality(MipmapType maximumFilterQuality)
+	{
+		Sampler::maximumMipmapFilterQuality = maximumFilterQuality;
+	}
+
+	void Sampler::setMipmapLOD(float LOD)
+	{
+		texture.LOD = LOD;
+		exp2LOD = exp2(LOD);
+	}
+
+	bool Sampler::hasTexture() const
+	{
+		return textureType != TEXTURE_NULL;
+	}
+
+	bool Sampler::hasUnsignedTexture() const
+	{
+		return Surface::isUnsignedComponent(internalTextureFormat, 0) &&
+		       Surface::isUnsignedComponent(internalTextureFormat, 1) &&
+		       Surface::isUnsignedComponent(internalTextureFormat, 2) &&
+		       Surface::isUnsignedComponent(internalTextureFormat, 3);
+	}
+
+	bool Sampler::hasCubeTexture() const
+	{
+		return textureType == TEXTURE_CUBE;
+	}
+
+	bool Sampler::hasVolumeTexture() const
+	{
+		return textureType == TEXTURE_3D || textureType == TEXTURE_2D_ARRAY;
+	}
+
+	void Sampler::setSyncRequired(bool isSyncRequired)
+	{
+		syncRequired = isSyncRequired;
+	}
+
+	bool Sampler::requiresSync() const
+	{
+		return syncRequired;
+	}
+
+	const Texture &Sampler::getTextureData()
+	{
+		return texture;
+	}
+
+	MipmapType Sampler::mipmapFilter() const
+	{
+		if(mipmapFilterState != MIPMAP_NONE)
+		{
+			for(int i = 1; i < MIPMAP_LEVELS; i++)
+			{
+				if(texture.mipmap[0].buffer[0] != texture.mipmap[i].buffer[0])
+				{
+					return mipmapFilterState;
+				}
+			}
+		}
+
+		// Only one mipmap level
+		return MIPMAP_NONE;
+	}
+
+	TextureType Sampler::getTextureType() const
+	{
+		return textureType;
+	}
+
+	FilterType Sampler::getTextureFilter() const
+	{
+		// Don't filter 1x1 textures.
+		if(texture.mipmap[0].width[0] == 1 && texture.mipmap[0].height[0] == 1 && texture.mipmap[0].depth[0] == 1)
+		{
+			if(mipmapFilter() == MIPMAP_NONE)
+			{
+				return FILTER_POINT;
+			}
+		}
+
+		FilterType filter = textureFilter;
+
+		if(gather && Surface::componentCount(internalTextureFormat) == 1)
+		{
+			filter = FILTER_GATHER;
+		}
+
+		if(textureType != TEXTURE_2D || texture.maxAnisotropy == 1.0f)
+		{
+			return (FilterType)min(filter, FILTER_LINEAR);
+		}
+
+		return filter;
+	}
+
+	AddressingMode Sampler::getAddressingModeU() const
+	{
+		if(textureType == TEXTURE_CUBE)
+		{
+			return border ? ADDRESSING_SEAMLESS : ADDRESSING_CLAMP;
+		}
+
+		return addressingModeU;
+	}
+
+	AddressingMode Sampler::getAddressingModeV() const
+	{
+		if(textureType == TEXTURE_CUBE)
+		{
+			return border ? ADDRESSING_SEAMLESS : ADDRESSING_CLAMP;
+		}
+
+		return addressingModeV;
+	}
+
+	AddressingMode Sampler::getAddressingModeW() const
+	{
+		if(textureType == TEXTURE_2D_ARRAY ||
+		   textureType == TEXTURE_2D ||
+		   textureType == TEXTURE_CUBE ||
+		   textureType == TEXTURE_RECTANGLE)
+		{
+			return ADDRESSING_LAYER;
+		}
+
+		return addressingModeW;
+	}
+
+	CompareFunc Sampler::getCompareFunc() const
+	{
+		if(getTextureFilter() == FILTER_GATHER)
+		{
+			return COMPARE_BYPASS;
+		}
+
+		if(internalTextureFormat == FORMAT_D32FS8_SHADOW)
+		{
+			return COMPARE_LESSEQUAL;
+		}
+
+		return compare;
+	}
+}
diff --git a/src/Device/Sampler.hpp b/src/Device/Sampler.hpp
new file mode 100644
index 0000000..af225c5
--- /dev/null
+++ b/src/Device/Sampler.hpp
@@ -0,0 +1,248 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Sampler_hpp
+#define sw_Sampler_hpp
+
+#include "Main/Config.hpp"
+#include "Renderer/Surface.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	struct Mipmap
+	{
+		const void *buffer[6];
+
+		float4 fWidth;
+		float4 fHeight;
+		float4 fDepth;
+
+		short uHalf[4];
+		short vHalf[4];
+		short wHalf[4];
+		short width[4];
+		short height[4];
+		short depth[4];
+		short onePitchP[4];
+		int4 pitchP;
+		int4 sliceP;
+	};
+
+	struct Texture
+	{
+		Mipmap mipmap[MIPMAP_LEVELS];
+
+		float LOD;
+		float4 widthHeightLOD;
+		float4 widthLOD;
+		float4 heightLOD;
+		float4 depthLOD;
+
+		word4 borderColor4[4];
+		float4 borderColorF[4];
+		float maxAnisotropy;
+		int baseLevel;
+		int maxLevel;
+		float minLod;
+		float maxLod;
+	};
+
+	enum SamplerType
+	{
+		SAMPLER_PIXEL,
+		SAMPLER_VERTEX
+	};
+
+	enum TextureType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		TEXTURE_NULL,
+		TEXTURE_2D,
+		TEXTURE_RECTANGLE,
+		TEXTURE_CUBE,
+		TEXTURE_3D,
+		TEXTURE_2D_ARRAY,
+
+		TEXTURE_LAST = TEXTURE_2D_ARRAY
+	};
+
+	enum FilterType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		FILTER_POINT,
+		FILTER_GATHER,
+		FILTER_MIN_POINT_MAG_LINEAR,
+		FILTER_MIN_LINEAR_MAG_POINT,
+		FILTER_LINEAR,
+		FILTER_ANISOTROPIC,
+
+		FILTER_LAST = FILTER_ANISOTROPIC
+	};
+
+	enum MipmapType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		MIPMAP_NONE,
+		MIPMAP_POINT,
+		MIPMAP_LINEAR,
+
+		MIPMAP_LAST = MIPMAP_LINEAR
+	};
+
+	enum AddressingMode ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		ADDRESSING_WRAP,
+		ADDRESSING_CLAMP,
+		ADDRESSING_MIRROR,
+		ADDRESSING_MIRRORONCE,
+		ADDRESSING_BORDER,     // Single color
+		ADDRESSING_SEAMLESS,   // Border of pixels
+		ADDRESSING_LAYER,
+		ADDRESSING_TEXELFETCH,
+
+		ADDRESSING_LAST = ADDRESSING_TEXELFETCH
+	};
+
+	enum CompareFunc ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		COMPARE_BYPASS,
+		COMPARE_LESSEQUAL,
+		COMPARE_GREATEREQUAL,
+		COMPARE_LESS,
+		COMPARE_GREATER,
+		COMPARE_EQUAL,
+		COMPARE_NOTEQUAL,
+		COMPARE_ALWAYS,
+		COMPARE_NEVER,
+
+		COMPARE_LAST = COMPARE_NEVER
+	};
+
+	enum SwizzleType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		SWIZZLE_RED,
+		SWIZZLE_GREEN,
+		SWIZZLE_BLUE,
+		SWIZZLE_ALPHA,
+		SWIZZLE_ZERO,
+		SWIZZLE_ONE,
+
+		SWIZZLE_LAST = SWIZZLE_ONE
+	};
+
+	class Sampler
+	{
+	public:
+		struct State
+		{
+			State();
+
+			TextureType textureType        : BITS(TEXTURE_LAST);
+			Format textureFormat           : BITS(FORMAT_LAST);
+			FilterType textureFilter       : BITS(FILTER_LAST);
+			AddressingMode addressingModeU : BITS(ADDRESSING_LAST);
+			AddressingMode addressingModeV : BITS(ADDRESSING_LAST);
+			AddressingMode addressingModeW : BITS(ADDRESSING_LAST);
+			MipmapType mipmapFilter        : BITS(FILTER_LAST);
+			bool sRGB                      : 1;
+			SwizzleType swizzleR           : BITS(SWIZZLE_LAST);
+			SwizzleType swizzleG           : BITS(SWIZZLE_LAST);
+			SwizzleType swizzleB           : BITS(SWIZZLE_LAST);
+			SwizzleType swizzleA           : BITS(SWIZZLE_LAST);
+			bool highPrecisionFiltering    : 1;
+			CompareFunc compare            : BITS(COMPARE_LAST);
+
+			#if PERF_PROFILE
+			bool compressedFormat          : 1;
+			#endif
+		};
+
+		Sampler();
+
+		~Sampler();
+
+		State samplerState() const;
+
+		void setTextureLevel(int face, int level, Surface *surface, TextureType type);
+
+		void setTextureFilter(FilterType textureFilter);
+		void setMipmapFilter(MipmapType mipmapFilter);
+		void setGatherEnable(bool enable);
+		void setAddressingModeU(AddressingMode addressingMode);
+		void setAddressingModeV(AddressingMode addressingMode);
+		void setAddressingModeW(AddressingMode addressingMode);
+		void setReadSRGB(bool sRGB);
+		void setBorderColor(const Color<float> &borderColor);
+		void setMaxAnisotropy(float maxAnisotropy);
+		void setHighPrecisionFiltering(bool highPrecisionFiltering);
+		void setSwizzleR(SwizzleType swizzleR);
+		void setSwizzleG(SwizzleType swizzleG);
+		void setSwizzleB(SwizzleType swizzleB);
+		void setSwizzleA(SwizzleType swizzleA);
+		void setCompareFunc(CompareFunc compare);
+		void setBaseLevel(int baseLevel);
+		void setMaxLevel(int maxLevel);
+		void setMinLod(float minLod);
+		void setMaxLod(float maxLod);
+		void setSyncRequired(bool isSincRequired);
+
+		static void setFilterQuality(FilterType maximumFilterQuality);
+		static void setMipmapQuality(MipmapType maximumFilterQuality);
+		void setMipmapLOD(float lod);
+
+		bool hasTexture() const;
+		bool hasUnsignedTexture() const;
+		bool hasCubeTexture() const;
+		bool hasVolumeTexture() const;
+		bool requiresSync() const;
+
+		const Texture &getTextureData();
+
+	private:
+		MipmapType mipmapFilter() const;
+		TextureType getTextureType() const;
+		FilterType getTextureFilter() const;
+		AddressingMode getAddressingModeU() const;
+		AddressingMode getAddressingModeV() const;
+		AddressingMode getAddressingModeW() const;
+		CompareFunc getCompareFunc() const;
+
+		Format externalTextureFormat;
+		Format internalTextureFormat;
+		TextureType textureType;
+
+		FilterType textureFilter;
+		AddressingMode addressingModeU;
+		AddressingMode addressingModeV;
+		AddressingMode addressingModeW;
+		MipmapType mipmapFilterState;
+		bool sRGB;
+		bool gather;
+		bool highPrecisionFiltering;
+		bool syncRequired;
+		int border;
+
+		SwizzleType swizzleR;
+		SwizzleType swizzleG;
+		SwizzleType swizzleB;
+		SwizzleType swizzleA;
+		CompareFunc compare;
+
+		Texture texture;
+		float exp2LOD;
+
+		static FilterType maximumTextureFilterQuality;
+		static MipmapType maximumMipmapFilterQuality;
+	};
+}
+
+#endif   // sw_Sampler_hpp
diff --git a/src/Device/SetupProcessor.cpp b/src/Device/SetupProcessor.cpp
new file mode 100644
index 0000000..c5c2a16
--- /dev/null
+++ b/src/Device/SetupProcessor.cpp
@@ -0,0 +1,248 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "SetupProcessor.hpp"
+
+#include "Primitive.hpp"
+#include "Polygon.hpp"
+#include "Context.hpp"
+#include "Renderer.hpp"
+#include "Shader/SetupRoutine.hpp"
+#include "Shader/Constants.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool complementaryDepthBuffer;
+	extern bool fullPixelPositionRegister;
+
+	bool precacheSetup = false;
+
+	unsigned int SetupProcessor::States::computeHash()
+	{
+		unsigned int *state = (unsigned int*)this;
+		unsigned int hash = 0;
+
+		for(unsigned int i = 0; i < sizeof(States) / 4; i++)
+		{
+			hash ^= state[i];
+		}
+
+		return hash;
+	}
+
+	SetupProcessor::State::State(int i)
+	{
+		memset(this, 0, sizeof(State));
+	}
+
+	bool SetupProcessor::State::operator==(const State &state) const
+	{
+		if(hash != state.hash)
+		{
+			return false;
+		}
+
+		return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	}
+
+	SetupProcessor::SetupProcessor(Context *context) : context(context)
+	{
+		routineCache = 0;
+		setRoutineCacheSize(1024);
+	}
+
+	SetupProcessor::~SetupProcessor()
+	{
+		delete routineCache;
+		routineCache = 0;
+	}
+
+	SetupProcessor::State SetupProcessor::update() const
+	{
+		State state;
+
+		bool vPosZW = (context->pixelShader && context->pixelShader->isVPosDeclared() && fullPixelPositionRegister);
+
+		state.isDrawPoint = context->isDrawPoint(true);
+		state.isDrawLine = context->isDrawLine(true);
+		state.isDrawTriangle = context->isDrawTriangle(false);
+		state.isDrawSolidTriangle = context->isDrawTriangle(true);
+		state.interpolateZ = context->depthBufferActive() || context->pixelFogActive() != FOG_NONE || vPosZW;
+		state.interpolateW = context->perspectiveActive() || vPosZW;
+		state.perspective = context->perspectiveActive();
+		state.pointSprite = context->pointSpriteActive();
+		state.cullMode = context->cullMode;
+		state.twoSidedStencil = context->stencilActive() && context->twoSidedStencil;
+		state.slopeDepthBias = context->slopeDepthBias != 0.0f;
+		state.vFace = context->pixelShader && context->pixelShader->isVFaceDeclared();
+
+		state.positionRegister = Pos;
+		state.pointSizeRegister = Unused;
+
+		state.multiSample = context->getMultiSampleCount();
+		state.rasterizerDiscard = context->rasterizerDiscard;
+
+		if(context->vertexShader)
+		{
+			state.positionRegister = context->vertexShader->getPositionRegister();
+			state.pointSizeRegister = context->vertexShader->getPointSizeRegister();
+		}
+		else if(context->pointSizeActive())
+		{
+			state.pointSizeRegister = Pts;
+		}
+
+		for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+		{
+			for(int component = 0; component < 4; component++)
+			{
+				state.gradient[interpolant][component].attribute = Unused;
+				state.gradient[interpolant][component].flat = false;
+				state.gradient[interpolant][component].wrap = false;
+			}
+		}
+
+		state.fog.attribute = Unused;
+		state.fog.flat = false;
+		state.fog.wrap = false;
+
+		const bool point = context->isDrawPoint(true);
+		const bool sprite = context->pointSpriteActive();
+		const bool flatShading = (context->shadingMode == SHADING_FLAT) || point;
+
+		if(context->vertexShader && context->pixelShader)
+		{
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					int project = context->isProjectionComponent(interpolant - 2, component) ? 1 : 0;
+					const Shader::Semantic& semantic = context->pixelShader->getInput(interpolant, component - project);
+
+					if(semantic.active())
+					{
+						int input = interpolant;
+						for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
+						{
+							if(semantic == context->vertexShader->getOutput(i, component - project))
+							{
+								input = i;
+								break;
+							}
+						}
+
+						bool flat = point;
+
+						switch(semantic.usage)
+						{
+						case Shader::USAGE_TEXCOORD: flat = point && !sprite;             break;
+						case Shader::USAGE_COLOR:    flat = semantic.flat || flatShading; break;
+						}
+
+						state.gradient[interpolant][component].attribute = input;
+						state.gradient[interpolant][component].flat = flat;
+					}
+				}
+			}
+		}
+		else if(context->preTransformed && context->pixelShader)
+		{
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					const Shader::Semantic& semantic = context->pixelShader->getInput(interpolant, component);
+
+					switch(semantic.usage)
+					{
+					case 0xFF:
+						break;
+					case Shader::USAGE_TEXCOORD:
+						state.gradient[interpolant][component].attribute = T0 + semantic.index;
+						state.gradient[interpolant][component].flat = semantic.flat || (point && !sprite);
+						break;
+					case Shader::USAGE_COLOR:
+						state.gradient[interpolant][component].attribute = C0 + semantic.index;
+						state.gradient[interpolant][component].flat = semantic.flat || flatShading;
+						break;
+					default:
+						ASSERT(false);
+					}
+				}
+			}
+		}
+		else if(context->pixelShaderModel() < 0x0300)
+		{
+			for(int coordinate = 0; coordinate < 8; coordinate++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(context->textureActive(coordinate, component))
+					{
+						state.texture[coordinate][component].attribute = T0 + coordinate;
+						state.texture[coordinate][component].flat = point && !sprite;
+						state.texture[coordinate][component].wrap = (context->textureWrap[coordinate] & (1 << component)) != 0;
+					}
+				}
+			}
+
+			for(int color = 0; color < 2; color++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(context->colorActive(color, component))
+					{
+						state.color[color][component].attribute = C0 + color;
+						state.color[color][component].flat = flatShading;
+					}
+				}
+			}
+		}
+		else ASSERT(false);
+
+		if(context->fogActive())
+		{
+			state.fog.attribute = Fog;
+			state.fog.flat = point;
+		}
+
+		state.hash = state.computeHash();
+
+		return state;
+	}
+
+	Routine *SetupProcessor::routine(const State &state)
+	{
+		Routine *routine = routineCache->query(state);
+
+		if(!routine)
+		{
+			SetupRoutine *generator = new SetupRoutine(state);
+			generator->generate();
+			routine = generator->getRoutine();
+			delete generator;
+
+			routineCache->add(state, routine);
+		}
+
+		return routine;
+	}
+
+	void SetupProcessor::setRoutineCacheSize(int cacheSize)
+	{
+		delete routineCache;
+		routineCache = new RoutineCache<State>(clamp(cacheSize, 1, 65536), precacheSetup ? "sw-setup" : 0);
+	}
+}
diff --git a/src/Device/SetupProcessor.hpp b/src/Device/SetupProcessor.hpp
new file mode 100644
index 0000000..be0adc7
--- /dev/null
+++ b/src/Device/SetupProcessor.hpp
@@ -0,0 +1,105 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_SetupProcessor_hpp
+#define sw_SetupProcessor_hpp
+
+#include "Context.hpp"
+#include "RoutineCache.hpp"
+#include "Shader/VertexShader.hpp"
+#include "Shader/PixelShader.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	struct Primitive;
+	struct Triangle;
+	struct Polygon;
+	struct Vertex;
+	struct DrawCall;
+	struct DrawData;
+
+	class SetupProcessor
+	{
+	public:
+		struct States
+		{
+			unsigned int computeHash();
+
+			bool isDrawPoint               : 1;
+			bool isDrawLine                : 1;
+			bool isDrawTriangle            : 1;
+			bool isDrawSolidTriangle       : 1;
+			bool interpolateZ              : 1;
+			bool interpolateW              : 1;
+			bool perspective               : 1;
+			bool pointSprite               : 1;
+			unsigned int positionRegister  : BITS(VERTEX_OUTPUT_LAST);
+			unsigned int pointSizeRegister : BITS(VERTEX_OUTPUT_LAST);
+			CullMode cullMode              : BITS(CULL_LAST);
+			bool twoSidedStencil           : 1;
+			bool slopeDepthBias            : 1;
+			bool vFace                     : 1;
+			unsigned int multiSample       : 3;   // 1, 2 or 4
+			bool rasterizerDiscard         : 1;
+
+			struct Gradient
+			{
+				unsigned char attribute : BITS(VERTEX_OUTPUT_LAST);
+				bool flat               : 1;
+				bool wrap               : 1;
+			};
+
+			union
+			{
+				struct
+				{
+					Gradient color[2][4];
+					Gradient texture[8][4];
+					Gradient fog;
+				};
+
+				Gradient gradient[MAX_FRAGMENT_INPUTS][4];
+			};
+		};
+
+		struct State : States
+		{
+			State(int i = 0);
+
+			bool operator==(const State &states) const;
+
+			unsigned int hash;
+		};
+
+		typedef bool (*RoutinePointer)(Primitive *primitive, const Triangle *triangle, const Polygon *polygon, const DrawData *draw);
+
+		SetupProcessor(Context *context);
+
+		~SetupProcessor();
+
+	protected:
+		State update() const;
+		Routine *routine(const State &state);
+
+		void setRoutineCacheSize(int cacheSize);
+
+	private:
+		Context *const context;
+
+		RoutineCache<State> *routineCache;
+	};
+}
+
+#endif   // sw_SetupProcessor_hpp
diff --git a/src/Device/Stream.hpp b/src/Device/Stream.hpp
new file mode 100644
index 0000000..969d8b2
--- /dev/null
+++ b/src/Device/Stream.hpp
@@ -0,0 +1,105 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Stream_hpp
+#define sw_Stream_hpp
+
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	class Resource;
+
+	enum StreamType ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+	{
+		STREAMTYPE_COLOR,     // 4 normalized unsigned bytes, ZYXW order
+		STREAMTYPE_UDEC3,     // 3 unsigned 10-bit fields
+		STREAMTYPE_DEC3N,     // 3 normalized signed 10-bit fields
+		STREAMTYPE_INDICES,   // 4 unsigned bytes, stored unconverted into X component
+		STREAMTYPE_FLOAT,     // Normalization ignored
+		STREAMTYPE_BYTE,
+		STREAMTYPE_SBYTE,
+		STREAMTYPE_SHORT,
+		STREAMTYPE_USHORT,
+		STREAMTYPE_INT,
+		STREAMTYPE_UINT,
+		STREAMTYPE_FIXED,     // Normalization ignored (16.16 format)
+		STREAMTYPE_HALF,      // Normalization ignored
+		STREAMTYPE_2_10_10_10_INT,
+		STREAMTYPE_2_10_10_10_UINT,
+
+		STREAMTYPE_LAST = STREAMTYPE_2_10_10_10_UINT
+	};
+
+	struct StreamResource
+	{
+		Resource *resource;
+		const void *buffer;
+		unsigned int stride;
+	};
+
+	struct Stream : public StreamResource
+	{
+		Stream(Resource *resource = 0, const void *buffer = 0, unsigned int stride = 0)
+		{
+			this->resource = resource;
+			this->buffer = buffer;
+			this->stride = stride;
+		}
+
+		Stream &define(StreamType type, unsigned int count, bool normalized = false)
+		{
+			this->type = type;
+			this->count = count;
+			this->normalized = normalized;
+
+			return *this;
+		}
+
+		Stream &define(const void *buffer, StreamType type, unsigned int count, bool normalized = false)
+		{
+			this->buffer = buffer;
+			this->type = type;
+			this->count = count;
+			this->normalized = normalized;
+
+			return *this;
+		}
+
+		Stream &defaults()
+		{
+			static const float4 null = {0, 0, 0, 1};
+
+			resource = 0;
+			buffer = &null;
+			stride = 0;
+			type = STREAMTYPE_FLOAT;
+			count = 0;
+			normalized = false;
+
+			return *this;
+		}
+
+		operator bool() const   // Returns true if stream contains data
+		{
+			return count != 0;
+		}
+
+		StreamType type;
+		unsigned char count;
+		bool normalized;
+	};
+}
+
+#endif   // sw_Stream_hpp
diff --git a/src/Device/Surface.cpp b/src/Device/Surface.cpp
new file mode 100644
index 0000000..e06f2bd
--- /dev/null
+++ b/src/Device/Surface.cpp
@@ -0,0 +1,6217 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Surface.hpp"
+
+#include "Color.hpp"
+#include "Context.hpp"
+#include "ETC_Decoder.hpp"
+#include "Renderer.hpp"
+#include "Common/Half.hpp"
+#include "Common/Memory.hpp"
+#include "Common/CPUID.hpp"
+#include "Common/Resource.hpp"
+#include "Common/Debug.hpp"
+#include "Reactor/Reactor.hpp"
+
+#if defined(__i386__) || defined(__x86_64__)
+	#include <xmmintrin.h>
+	#include <emmintrin.h>
+#endif
+
+#undef min
+#undef max
+
+namespace sw
+{
+	extern bool quadLayoutEnabled;
+	extern bool complementaryDepthBuffer;
+	extern TranscendentalPrecision logPrecision;
+
+	unsigned int *Surface::palette = 0;
+	unsigned int Surface::paletteID = 0;
+
+	void Surface::Buffer::write(int x, int y, int z, const Color<float> &color)
+	{
+		ASSERT((x >= -border) && (x < (width + border)));
+		ASSERT((y >= -border) && (y < (height + border)));
+		ASSERT((z >= 0) && (z < depth));
+
+		byte *element = (byte*)buffer + (x + border) * bytes + (y + border) * pitchB + z * samples * sliceB;
+
+		for(int i = 0; i < samples; i++)
+		{
+			write(element, color);
+			element += sliceB;
+		}
+	}
+
+	void Surface::Buffer::write(int x, int y, const Color<float> &color)
+	{
+		ASSERT((x >= -border) && (x < (width + border)));
+		ASSERT((y >= -border) && (y < (height + border)));
+
+		byte *element = (byte*)buffer + (x + border) * bytes + (y + border) * pitchB;
+
+		for(int i = 0; i < samples; i++)
+		{
+			write(element, color);
+			element += sliceB;
+		}
+	}
+
+	inline void Surface::Buffer::write(void *element, const Color<float> &color)
+	{
+		float r = color.r;
+		float g = color.g;
+		float b = color.b;
+		float a = color.a;
+
+		if(isSRGBformat(format))
+		{
+			r = linearToSRGB(r);
+			g = linearToSRGB(g);
+			b = linearToSRGB(b);
+		}
+
+		switch(format)
+		{
+		case FORMAT_A8:
+			*(unsigned char*)element = unorm<8>(a);
+			break;
+		case FORMAT_R8_SNORM:
+			*(char*)element = snorm<8>(r);
+			break;
+		case FORMAT_R8:
+			*(unsigned char*)element = unorm<8>(r);
+			break;
+		case FORMAT_R8I:
+			*(char*)element = scast<8>(r);
+			break;
+		case FORMAT_R8UI:
+			*(unsigned char*)element = ucast<8>(r);
+			break;
+		case FORMAT_R16I:
+			*(short*)element = scast<16>(r);
+			break;
+		case FORMAT_R16UI:
+			*(unsigned short*)element = ucast<16>(r);
+			break;
+		case FORMAT_R32I:
+			*(int*)element = static_cast<int>(r);
+			break;
+		case FORMAT_R32UI:
+			*(unsigned int*)element = static_cast<unsigned int>(r);
+			break;
+		case FORMAT_R3G3B2:
+			*(unsigned char*)element = (unorm<3>(r) << 5) | (unorm<3>(g) << 2) | (unorm<2>(b) << 0);
+			break;
+		case FORMAT_A8R3G3B2:
+			*(unsigned short*)element = (unorm<8>(a) << 8) | (unorm<3>(r) << 5) | (unorm<3>(g) << 2) | (unorm<2>(b) << 0);
+			break;
+		case FORMAT_X4R4G4B4:
+			*(unsigned short*)element = 0xF000 | (unorm<4>(r) << 8) | (unorm<4>(g) << 4) | (unorm<4>(b) << 0);
+			break;
+		case FORMAT_A4R4G4B4:
+			*(unsigned short*)element = (unorm<4>(a) << 12) | (unorm<4>(r) << 8) | (unorm<4>(g) << 4) | (unorm<4>(b) << 0);
+			break;
+		case FORMAT_R4G4B4A4:
+			*(unsigned short*)element = (unorm<4>(r) << 12) | (unorm<4>(g) << 8) | (unorm<4>(b) << 4) | (unorm<4>(a) << 0);
+			break;
+		case FORMAT_R5G6B5:
+			*(unsigned short*)element = (unorm<5>(r) << 11) | (unorm<6>(g) << 5) | (unorm<5>(b) << 0);
+			break;
+		case FORMAT_A1R5G5B5:
+			*(unsigned short*)element = (unorm<1>(a) << 15) | (unorm<5>(r) << 10) | (unorm<5>(g) << 5) | (unorm<5>(b) << 0);
+			break;
+		case FORMAT_R5G5B5A1:
+			*(unsigned short*)element = (unorm<5>(r) << 11) | (unorm<5>(g) << 6) | (unorm<5>(b) << 1) | (unorm<5>(a) << 0);
+			break;
+		case FORMAT_X1R5G5B5:
+			*(unsigned short*)element = 0x8000 | (unorm<5>(r) << 10) | (unorm<5>(g) << 5) | (unorm<5>(b) << 0);
+			break;
+		case FORMAT_A8R8G8B8:
+			*(unsigned int*)element = (unorm<8>(a) << 24) | (unorm<8>(r) << 16) | (unorm<8>(g) << 8) | (unorm<8>(b) << 0);
+			break;
+		case FORMAT_X8R8G8B8:
+			*(unsigned int*)element = 0xFF000000 | (unorm<8>(r) << 16) | (unorm<8>(g) << 8) | (unorm<8>(b) << 0);
+			break;
+		case FORMAT_A8B8G8R8_SNORM:
+			*(unsigned int*)element = (static_cast<unsigned int>(snorm<8>(a)) << 24) |
+			                          (static_cast<unsigned int>(snorm<8>(b)) << 16) |
+			                          (static_cast<unsigned int>(snorm<8>(g)) << 8) |
+			                          (static_cast<unsigned int>(snorm<8>(r)) << 0);
+			break;
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_A8:
+			*(unsigned int*)element = (unorm<8>(a) << 24) | (unorm<8>(b) << 16) | (unorm<8>(g) << 8) | (unorm<8>(r) << 0);
+			break;
+		case FORMAT_A8B8G8R8I:
+			*(unsigned int*)element = (static_cast<unsigned int>(scast<8>(a)) << 24) |
+			                          (static_cast<unsigned int>(scast<8>(b)) << 16) |
+			                          (static_cast<unsigned int>(scast<8>(g)) << 8) |
+			                          (static_cast<unsigned int>(scast<8>(r)) << 0);
+			break;
+		case FORMAT_A8B8G8R8UI:
+			*(unsigned int*)element = (ucast<8>(a) << 24) | (ucast<8>(b) << 16) | (ucast<8>(g) << 8) | (ucast<8>(r) << 0);
+			break;
+		case FORMAT_X8B8G8R8_SNORM:
+			*(unsigned int*)element = 0x7F000000 |
+			                          (static_cast<unsigned int>(snorm<8>(b)) << 16) |
+			                          (static_cast<unsigned int>(snorm<8>(g)) << 8) |
+			                          (static_cast<unsigned int>(snorm<8>(r)) << 0);
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+			*(unsigned int*)element = 0xFF000000 | (unorm<8>(b) << 16) | (unorm<8>(g) << 8) | (unorm<8>(r) << 0);
+			break;
+		case FORMAT_X8B8G8R8I:
+			*(unsigned int*)element = 0x7F000000 |
+			                          (static_cast<unsigned int>(scast<8>(b)) << 16) |
+			                          (static_cast<unsigned int>(scast<8>(g)) << 8) |
+			                          (static_cast<unsigned int>(scast<8>(r)) << 0);
+		case FORMAT_X8B8G8R8UI:
+			*(unsigned int*)element = 0xFF000000 | (ucast<8>(b) << 16) | (ucast<8>(g) << 8) | (ucast<8>(r) << 0);
+			break;
+		case FORMAT_A2R10G10B10:
+			*(unsigned int*)element = (unorm<2>(a) << 30) | (unorm<10>(r) << 20) | (unorm<10>(g) << 10) | (unorm<10>(b) << 0);
+			break;
+		case FORMAT_A2B10G10R10:
+		case FORMAT_A2B10G10R10UI:
+			*(unsigned int*)element = (unorm<2>(a) << 30) | (unorm<10>(b) << 20) | (unorm<10>(g) << 10) | (unorm<10>(r) << 0);
+			break;
+		case FORMAT_G8R8_SNORM:
+			*(unsigned short*)element = (static_cast<unsigned short>(snorm<8>(g)) << 8) |
+			                            (static_cast<unsigned short>(snorm<8>(r)) << 0);
+			break;
+		case FORMAT_G8R8:
+			*(unsigned short*)element = (unorm<8>(g) << 8) | (unorm<8>(r) << 0);
+			break;
+		case FORMAT_G8R8I:
+			*(unsigned short*)element = (static_cast<unsigned short>(scast<8>(g)) << 8) |
+			                            (static_cast<unsigned short>(scast<8>(r)) << 0);
+			break;
+		case FORMAT_G8R8UI:
+			*(unsigned short*)element = (ucast<8>(g) << 8) | (ucast<8>(r) << 0);
+			break;
+		case FORMAT_G16R16:
+			*(unsigned int*)element = (unorm<16>(g) << 16) | (unorm<16>(r) << 0);
+			break;
+		case FORMAT_G16R16I:
+			*(unsigned int*)element = (static_cast<unsigned int>(scast<16>(g)) << 16) |
+			                          (static_cast<unsigned int>(scast<16>(r)) << 0);
+			break;
+		case FORMAT_G16R16UI:
+			*(unsigned int*)element = (ucast<16>(g) << 16) | (ucast<16>(r) << 0);
+			break;
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+			((unsigned int*)element)[0] = static_cast<unsigned int>(r);
+			((unsigned int*)element)[1] = static_cast<unsigned int>(g);
+			break;
+		case FORMAT_A16B16G16R16:
+			((unsigned short*)element)[0] = unorm<16>(r);
+			((unsigned short*)element)[1] = unorm<16>(g);
+			((unsigned short*)element)[2] = unorm<16>(b);
+			((unsigned short*)element)[3] = unorm<16>(a);
+			break;
+		case FORMAT_A16B16G16R16I:
+			((unsigned short*)element)[0] = static_cast<unsigned short>(scast<16>(r));
+			((unsigned short*)element)[1] = static_cast<unsigned short>(scast<16>(g));
+			((unsigned short*)element)[2] = static_cast<unsigned short>(scast<16>(b));
+			((unsigned short*)element)[3] = static_cast<unsigned short>(scast<16>(a));
+			break;
+		case FORMAT_A16B16G16R16UI:
+			((unsigned short*)element)[0] = static_cast<unsigned short>(ucast<16>(r));
+			((unsigned short*)element)[1] = static_cast<unsigned short>(ucast<16>(g));
+			((unsigned short*)element)[2] = static_cast<unsigned short>(ucast<16>(b));
+			((unsigned short*)element)[3] = static_cast<unsigned short>(ucast<16>(a));
+			break;
+		case FORMAT_X16B16G16R16I:
+			((unsigned short*)element)[0] = static_cast<unsigned short>(scast<16>(r));
+			((unsigned short*)element)[1] = static_cast<unsigned short>(scast<16>(g));
+			((unsigned short*)element)[2] = static_cast<unsigned short>(scast<16>(b));
+			break;
+		case FORMAT_X16B16G16R16UI:
+			((unsigned short*)element)[0] = static_cast<unsigned short>(ucast<16>(r));
+			((unsigned short*)element)[1] = static_cast<unsigned short>(ucast<16>(g));
+			((unsigned short*)element)[2] = static_cast<unsigned short>(ucast<16>(b));
+			break;
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			((unsigned int*)element)[0] = static_cast<unsigned int>(r);
+			((unsigned int*)element)[1] = static_cast<unsigned int>(g);
+			((unsigned int*)element)[2] = static_cast<unsigned int>(b);
+			((unsigned int*)element)[3] = static_cast<unsigned int>(a);
+			break;
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+			((unsigned int*)element)[0] = static_cast<unsigned int>(r);
+			((unsigned int*)element)[1] = static_cast<unsigned int>(g);
+			((unsigned int*)element)[2] = static_cast<unsigned int>(b);
+			break;
+		case FORMAT_V8U8:
+			*(unsigned short*)element = (snorm<8>(g) << 8) | (snorm<8>(r) << 0);
+			break;
+		case FORMAT_L6V5U5:
+			*(unsigned short*)element = (unorm<6>(b) << 10) | (snorm<5>(g) << 5) | (snorm<5>(r) << 0);
+			break;
+		case FORMAT_Q8W8V8U8:
+			*(unsigned int*)element = (snorm<8>(a) << 24) | (snorm<8>(b) << 16) | (snorm<8>(g) << 8) | (snorm<8>(r) << 0);
+			break;
+		case FORMAT_X8L8V8U8:
+			*(unsigned int*)element = 0xFF000000 | (unorm<8>(b) << 16) | (snorm<8>(g) << 8) | (snorm<8>(r) << 0);
+			break;
+		case FORMAT_V16U16:
+			*(unsigned int*)element = (snorm<16>(g) << 16) | (snorm<16>(r) << 0);
+			break;
+		case FORMAT_A2W10V10U10:
+			*(unsigned int*)element = (unorm<2>(a) << 30) | (snorm<10>(b) << 20) | (snorm<10>(g) << 10) | (snorm<10>(r) << 0);
+			break;
+		case FORMAT_A16W16V16U16:
+			((unsigned short*)element)[0] = snorm<16>(r);
+			((unsigned short*)element)[1] = snorm<16>(g);
+			((unsigned short*)element)[2] = snorm<16>(b);
+			((unsigned short*)element)[3] = unorm<16>(a);
+			break;
+		case FORMAT_Q16W16V16U16:
+			((unsigned short*)element)[0] = snorm<16>(r);
+			((unsigned short*)element)[1] = snorm<16>(g);
+			((unsigned short*)element)[2] = snorm<16>(b);
+			((unsigned short*)element)[3] = snorm<16>(a);
+			break;
+		case FORMAT_R8G8B8:
+			((unsigned char*)element)[0] = unorm<8>(b);
+			((unsigned char*)element)[1] = unorm<8>(g);
+			((unsigned char*)element)[2] = unorm<8>(r);
+			break;
+		case FORMAT_B8G8R8:
+			((unsigned char*)element)[0] = unorm<8>(r);
+			((unsigned char*)element)[1] = unorm<8>(g);
+			((unsigned char*)element)[2] = unorm<8>(b);
+			break;
+		case FORMAT_R16F:
+			*(half*)element = (half)r;
+			break;
+		case FORMAT_A16F:
+			*(half*)element = (half)a;
+			break;
+		case FORMAT_G16R16F:
+			((half*)element)[0] = (half)r;
+			((half*)element)[1] = (half)g;
+			break;
+		case FORMAT_X16B16G16R16F_UNSIGNED:
+			r = max(r, 0.0f); g = max(g, 0.0f); b = max(b, 0.0f);
+			// Fall through to FORMAT_X16B16G16R16F.
+		case FORMAT_X16B16G16R16F:
+			((half*)element)[3] = 1.0f;
+			// Fall through to FORMAT_B16G16R16F.
+		case FORMAT_B16G16R16F:
+			((half*)element)[0] = (half)r;
+			((half*)element)[1] = (half)g;
+			((half*)element)[2] = (half)b;
+			break;
+		case FORMAT_A16B16G16R16F:
+			((half*)element)[0] = (half)r;
+			((half*)element)[1] = (half)g;
+			((half*)element)[2] = (half)b;
+			((half*)element)[3] = (half)a;
+			break;
+		case FORMAT_A32F:
+			*(float*)element = a;
+			break;
+		case FORMAT_R32F:
+			*(float*)element = r;
+			break;
+		case FORMAT_G32R32F:
+			((float*)element)[0] = r;
+			((float*)element)[1] = g;
+			break;
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+			r = max(r, 0.0f); g = max(g, 0.0f); b = max(b, 0.0f);
+			// Fall through to FORMAT_X32B32G32R32F.
+		case FORMAT_X32B32G32R32F:
+			((float*)element)[3] = 1.0f;
+			// Fall through to FORMAT_B32G32R32F.
+		case FORMAT_B32G32R32F:
+			((float*)element)[0] = r;
+			((float*)element)[1] = g;
+			((float*)element)[2] = b;
+			break;
+		case FORMAT_A32B32G32R32F:
+			((float*)element)[0] = r;
+			((float*)element)[1] = g;
+			((float*)element)[2] = b;
+			((float*)element)[3] = a;
+			break;
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+			*((float*)element) = r;
+			break;
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+			*((float*)element) = 1 - r;
+			break;
+		case FORMAT_S8:
+			*((unsigned char*)element) = unorm<8>(r);
+			break;
+		case FORMAT_L8:
+			*(unsigned char*)element = unorm<8>(r);
+			break;
+		case FORMAT_A4L4:
+			*(unsigned char*)element = (unorm<4>(a) << 4) | (unorm<4>(r) << 0);
+			break;
+		case FORMAT_L16:
+			*(unsigned short*)element = unorm<16>(r);
+			break;
+		case FORMAT_A8L8:
+			*(unsigned short*)element = (unorm<8>(a) << 8) | (unorm<8>(r) << 0);
+			break;
+		case FORMAT_L16F:
+			*(half*)element = (half)r;
+			break;
+		case FORMAT_A16L16F:
+			((half*)element)[0] = (half)r;
+			((half*)element)[1] = (half)a;
+			break;
+		case FORMAT_L32F:
+			*(float*)element = r;
+			break;
+		case FORMAT_A32L32F:
+			((float*)element)[0] = r;
+			((float*)element)[1] = a;
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	Color<float> Surface::Buffer::read(int x, int y, int z) const
+	{
+		ASSERT((x >= -border) && (x < (width + border)));
+		ASSERT((y >= -border) && (y < (height + border)));
+		ASSERT((z >= 0) && (z < depth));
+
+		void *element = (unsigned char*)buffer + (x + border) * bytes + (y + border) * pitchB + z * samples * sliceB;
+
+		return read(element);
+	}
+
+	Color<float> Surface::Buffer::read(int x, int y) const
+	{
+		ASSERT((x >= -border) && (x < (width + border)));
+		ASSERT((y >= -border) && (y < (height + border)));
+
+		void *element = (unsigned char*)buffer + (x + border) * bytes + (y + border) * pitchB;
+
+		return read(element);
+	}
+
+	inline Color<float> Surface::Buffer::read(void *element) const
+	{
+		float r = 0.0f;
+		float g = 0.0f;
+		float b = 0.0f;
+		float a = 1.0f;
+
+		switch(format)
+		{
+		case FORMAT_P8:
+			{
+				ASSERT(palette);
+
+				unsigned int abgr = palette[*(unsigned char*)element];
+
+				r = (abgr & 0x000000FF) * (1.0f / 0x000000FF);
+				g = (abgr & 0x0000FF00) * (1.0f / 0x0000FF00);
+				b = (abgr & 0x00FF0000) * (1.0f / 0x00FF0000);
+				a = (abgr & 0xFF000000) * (1.0f / 0xFF000000);
+			}
+			break;
+		case FORMAT_A8P8:
+			{
+				ASSERT(palette);
+
+				unsigned int bgr = palette[((unsigned char*)element)[0]];
+
+				r = (bgr & 0x000000FF) * (1.0f / 0x000000FF);
+				g = (bgr & 0x0000FF00) * (1.0f / 0x0000FF00);
+				b = (bgr & 0x00FF0000) * (1.0f / 0x00FF0000);
+				a = ((unsigned char*)element)[1] * (1.0f / 0xFF);
+			}
+			break;
+		case FORMAT_A8:
+			r = 0;
+			g = 0;
+			b = 0;
+			a = *(unsigned char*)element * (1.0f / 0xFF);
+			break;
+		case FORMAT_R8_SNORM:
+			r = max((*(signed char*)element) * (1.0f / 0x7F), -1.0f);
+			break;
+		case FORMAT_R8:
+			r = *(unsigned char*)element * (1.0f / 0xFF);
+			break;
+		case FORMAT_R8I:
+			r = *(signed char*)element;
+			break;
+		case FORMAT_R8UI:
+			r = *(unsigned char*)element;
+			break;
+		case FORMAT_R3G3B2:
+			{
+				unsigned char rgb = *(unsigned char*)element;
+
+				r = (rgb & 0xE0) * (1.0f / 0xE0);
+				g = (rgb & 0x1C) * (1.0f / 0x1C);
+				b = (rgb & 0x03) * (1.0f / 0x03);
+			}
+			break;
+		case FORMAT_A8R3G3B2:
+			{
+				unsigned short argb = *(unsigned short*)element;
+
+				a = (argb & 0xFF00) * (1.0f / 0xFF00);
+				r = (argb & 0x00E0) * (1.0f / 0x00E0);
+				g = (argb & 0x001C) * (1.0f / 0x001C);
+				b = (argb & 0x0003) * (1.0f / 0x0003);
+			}
+			break;
+		case FORMAT_X4R4G4B4:
+			{
+				unsigned short rgb = *(unsigned short*)element;
+
+				r = (rgb & 0x0F00) * (1.0f / 0x0F00);
+				g = (rgb & 0x00F0) * (1.0f / 0x00F0);
+				b = (rgb & 0x000F) * (1.0f / 0x000F);
+			}
+			break;
+		case FORMAT_A4R4G4B4:
+			{
+				unsigned short argb = *(unsigned short*)element;
+
+				a = (argb & 0xF000) * (1.0f / 0xF000);
+				r = (argb & 0x0F00) * (1.0f / 0x0F00);
+				g = (argb & 0x00F0) * (1.0f / 0x00F0);
+				b = (argb & 0x000F) * (1.0f / 0x000F);
+			}
+			break;
+		case FORMAT_R4G4B4A4:
+			{
+				unsigned short rgba = *(unsigned short*)element;
+
+				r = (rgba & 0xF000) * (1.0f / 0xF000);
+				g = (rgba & 0x0F00) * (1.0f / 0x0F00);
+				b = (rgba & 0x00F0) * (1.0f / 0x00F0);
+				a = (rgba & 0x000F) * (1.0f / 0x000F);
+			}
+			break;
+		case FORMAT_R5G6B5:
+			{
+				unsigned short rgb = *(unsigned short*)element;
+
+				r = (rgb & 0xF800) * (1.0f / 0xF800);
+				g = (rgb & 0x07E0) * (1.0f / 0x07E0);
+				b = (rgb & 0x001F) * (1.0f / 0x001F);
+			}
+			break;
+		case FORMAT_A1R5G5B5:
+			{
+				unsigned short argb = *(unsigned short*)element;
+
+				a = (argb & 0x8000) * (1.0f / 0x8000);
+				r = (argb & 0x7C00) * (1.0f / 0x7C00);
+				g = (argb & 0x03E0) * (1.0f / 0x03E0);
+				b = (argb & 0x001F) * (1.0f / 0x001F);
+			}
+			break;
+		case FORMAT_R5G5B5A1:
+			{
+				unsigned short rgba = *(unsigned short*)element;
+
+				r = (rgba & 0xF800) * (1.0f / 0xF800);
+				g = (rgba & 0x07C0) * (1.0f / 0x07C0);
+				b = (rgba & 0x003E) * (1.0f / 0x003E);
+				a = (rgba & 0x0001) * (1.0f / 0x0001);
+			}
+			break;
+		case FORMAT_X1R5G5B5:
+			{
+				unsigned short xrgb = *(unsigned short*)element;
+
+				r = (xrgb & 0x7C00) * (1.0f / 0x7C00);
+				g = (xrgb & 0x03E0) * (1.0f / 0x03E0);
+				b = (xrgb & 0x001F) * (1.0f / 0x001F);
+			}
+			break;
+		case FORMAT_A8R8G8B8:
+			{
+				unsigned int argb = *(unsigned int*)element;
+
+				a = (argb & 0xFF000000) * (1.0f / 0xFF000000);
+				r = (argb & 0x00FF0000) * (1.0f / 0x00FF0000);
+				g = (argb & 0x0000FF00) * (1.0f / 0x0000FF00);
+				b = (argb & 0x000000FF) * (1.0f / 0x000000FF);
+			}
+			break;
+		case FORMAT_X8R8G8B8:
+			{
+				unsigned int xrgb = *(unsigned int*)element;
+
+				r = (xrgb & 0x00FF0000) * (1.0f / 0x00FF0000);
+				g = (xrgb & 0x0000FF00) * (1.0f / 0x0000FF00);
+				b = (xrgb & 0x000000FF) * (1.0f / 0x000000FF);
+			}
+			break;
+		case FORMAT_A8B8G8R8_SNORM:
+			{
+				signed char* abgr = (signed char*)element;
+
+				r = max(abgr[0] * (1.0f / 0x7F), -1.0f);
+				g = max(abgr[1] * (1.0f / 0x7F), -1.0f);
+				b = max(abgr[2] * (1.0f / 0x7F), -1.0f);
+				a = max(abgr[3] * (1.0f / 0x7F), -1.0f);
+			}
+			break;
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_A8:
+			{
+				unsigned int abgr = *(unsigned int*)element;
+
+				a = (abgr & 0xFF000000) * (1.0f / 0xFF000000);
+				b = (abgr & 0x00FF0000) * (1.0f / 0x00FF0000);
+				g = (abgr & 0x0000FF00) * (1.0f / 0x0000FF00);
+				r = (abgr & 0x000000FF) * (1.0f / 0x000000FF);
+			}
+			break;
+		case FORMAT_A8B8G8R8I:
+			{
+				signed char* abgr = (signed char*)element;
+
+				r = abgr[0];
+				g = abgr[1];
+				b = abgr[2];
+				a = abgr[3];
+			}
+			break;
+		case FORMAT_A8B8G8R8UI:
+			{
+				unsigned char* abgr = (unsigned char*)element;
+
+				r = abgr[0];
+				g = abgr[1];
+				b = abgr[2];
+				a = abgr[3];
+			}
+			break;
+		case FORMAT_X8B8G8R8_SNORM:
+			{
+				signed char* bgr = (signed char*)element;
+
+				r = max(bgr[0] * (1.0f / 0x7F), -1.0f);
+				g = max(bgr[1] * (1.0f / 0x7F), -1.0f);
+				b = max(bgr[2] * (1.0f / 0x7F), -1.0f);
+			}
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+			{
+				unsigned int xbgr = *(unsigned int*)element;
+
+				b = (xbgr & 0x00FF0000) * (1.0f / 0x00FF0000);
+				g = (xbgr & 0x0000FF00) * (1.0f / 0x0000FF00);
+				r = (xbgr & 0x000000FF) * (1.0f / 0x000000FF);
+			}
+			break;
+		case FORMAT_X8B8G8R8I:
+			{
+				signed char* bgr = (signed char*)element;
+
+				r = bgr[0];
+				g = bgr[1];
+				b = bgr[2];
+			}
+			break;
+		case FORMAT_X8B8G8R8UI:
+			{
+				unsigned char* bgr = (unsigned char*)element;
+
+				r = bgr[0];
+				g = bgr[1];
+				b = bgr[2];
+			}
+			break;
+		case FORMAT_G8R8_SNORM:
+			{
+				signed char* gr = (signed char*)element;
+
+				r = (gr[0] & 0xFF00) * (1.0f / 0xFF00);
+				g = (gr[1] & 0x00FF) * (1.0f / 0x00FF);
+			}
+			break;
+		case FORMAT_G8R8:
+			{
+				unsigned short gr = *(unsigned short*)element;
+
+				g = (gr & 0xFF00) * (1.0f / 0xFF00);
+				r = (gr & 0x00FF) * (1.0f / 0x00FF);
+			}
+			break;
+		case FORMAT_G8R8I:
+			{
+				signed char* gr = (signed char*)element;
+
+				r = gr[0];
+				g = gr[1];
+			}
+			break;
+		case FORMAT_G8R8UI:
+			{
+				unsigned char* gr = (unsigned char*)element;
+
+				r = gr[0];
+				g = gr[1];
+			}
+			break;
+		case FORMAT_R16I:
+			r = *((short*)element);
+			break;
+		case FORMAT_R16UI:
+			r = *((unsigned short*)element);
+			break;
+		case FORMAT_G16R16I:
+			{
+				short* gr = (short*)element;
+
+				r = gr[0];
+				g = gr[1];
+			}
+			break;
+		case FORMAT_G16R16:
+			{
+				unsigned int gr = *(unsigned int*)element;
+
+				g = (gr & 0xFFFF0000) * (1.0f / 0xFFFF0000);
+				r = (gr & 0x0000FFFF) * (1.0f / 0x0000FFFF);
+			}
+			break;
+		case FORMAT_G16R16UI:
+			{
+				unsigned short* gr = (unsigned short*)element;
+
+				r = gr[0];
+				g = gr[1];
+			}
+			break;
+		case FORMAT_A2R10G10B10:
+			{
+				unsigned int argb = *(unsigned int*)element;
+
+				a = (argb & 0xC0000000) * (1.0f / 0xC0000000);
+				r = (argb & 0x3FF00000) * (1.0f / 0x3FF00000);
+				g = (argb & 0x000FFC00) * (1.0f / 0x000FFC00);
+				b = (argb & 0x000003FF) * (1.0f / 0x000003FF);
+			}
+			break;
+		case FORMAT_A2B10G10R10:
+			{
+				unsigned int abgr = *(unsigned int*)element;
+
+				a = (abgr & 0xC0000000) * (1.0f / 0xC0000000);
+				b = (abgr & 0x3FF00000) * (1.0f / 0x3FF00000);
+				g = (abgr & 0x000FFC00) * (1.0f / 0x000FFC00);
+				r = (abgr & 0x000003FF) * (1.0f / 0x000003FF);
+			}
+			break;
+		case FORMAT_A2B10G10R10UI:
+			{
+				unsigned int abgr = *(unsigned int*)element;
+
+				a = static_cast<float>((abgr & 0xC0000000) >> 30);
+				b = static_cast<float>((abgr & 0x3FF00000) >> 20);
+				g = static_cast<float>((abgr & 0x000FFC00) >> 10);
+				r = static_cast<float>(abgr & 0x000003FF);
+			}
+			break;
+		case FORMAT_A16B16G16R16I:
+			{
+				short* abgr = (short*)element;
+
+				r = abgr[0];
+				g = abgr[1];
+				b = abgr[2];
+				a = abgr[3];
+			}
+			break;
+		case FORMAT_A16B16G16R16:
+			r = ((unsigned short*)element)[0] * (1.0f / 0xFFFF);
+			g = ((unsigned short*)element)[1] * (1.0f / 0xFFFF);
+			b = ((unsigned short*)element)[2] * (1.0f / 0xFFFF);
+			a = ((unsigned short*)element)[3] * (1.0f / 0xFFFF);
+			break;
+		case FORMAT_A16B16G16R16UI:
+			{
+				unsigned short* abgr = (unsigned short*)element;
+
+				r = abgr[0];
+				g = abgr[1];
+				b = abgr[2];
+				a = abgr[3];
+			}
+			break;
+		case FORMAT_X16B16G16R16I:
+			{
+				short* bgr = (short*)element;
+
+				r = bgr[0];
+				g = bgr[1];
+				b = bgr[2];
+			}
+			break;
+		case FORMAT_X16B16G16R16UI:
+			{
+				unsigned short* bgr = (unsigned short*)element;
+
+				r = bgr[0];
+				g = bgr[1];
+				b = bgr[2];
+			}
+			break;
+		case FORMAT_A32B32G32R32I:
+			{
+				int* abgr = (int*)element;
+
+				r = static_cast<float>(abgr[0]);
+				g = static_cast<float>(abgr[1]);
+				b = static_cast<float>(abgr[2]);
+				a = static_cast<float>(abgr[3]);
+			}
+			break;
+		case FORMAT_A32B32G32R32UI:
+			{
+				unsigned int* abgr = (unsigned int*)element;
+
+				r = static_cast<float>(abgr[0]);
+				g = static_cast<float>(abgr[1]);
+				b = static_cast<float>(abgr[2]);
+				a = static_cast<float>(abgr[3]);
+			}
+			break;
+		case FORMAT_X32B32G32R32I:
+			{
+				int* bgr = (int*)element;
+
+				r = static_cast<float>(bgr[0]);
+				g = static_cast<float>(bgr[1]);
+				b = static_cast<float>(bgr[2]);
+			}
+			break;
+		case FORMAT_X32B32G32R32UI:
+			{
+				unsigned int* bgr = (unsigned int*)element;
+
+				r = static_cast<float>(bgr[0]);
+				g = static_cast<float>(bgr[1]);
+				b = static_cast<float>(bgr[2]);
+			}
+			break;
+		case FORMAT_G32R32I:
+			{
+				int* gr = (int*)element;
+
+				r = static_cast<float>(gr[0]);
+				g = static_cast<float>(gr[1]);
+			}
+			break;
+		case FORMAT_G32R32UI:
+			{
+				unsigned int* gr = (unsigned int*)element;
+
+				r = static_cast<float>(gr[0]);
+				g = static_cast<float>(gr[1]);
+			}
+			break;
+		case FORMAT_R32I:
+			r = static_cast<float>(*((int*)element));
+			break;
+		case FORMAT_R32UI:
+			r = static_cast<float>(*((unsigned int*)element));
+			break;
+		case FORMAT_V8U8:
+			{
+				unsigned short vu = *(unsigned short*)element;
+
+				r = ((int)(vu & 0x00FF) << 24) * (1.0f / 0x7F000000);
+				g = ((int)(vu & 0xFF00) << 16) * (1.0f / 0x7F000000);
+			}
+			break;
+		case FORMAT_L6V5U5:
+			{
+				unsigned short lvu = *(unsigned short*)element;
+
+				r = ((int)(lvu & 0x001F) << 27) * (1.0f / 0x78000000);
+				g = ((int)(lvu & 0x03E0) << 22) * (1.0f / 0x78000000);
+				b = (lvu & 0xFC00) * (1.0f / 0xFC00);
+			}
+			break;
+		case FORMAT_Q8W8V8U8:
+			{
+				unsigned int qwvu = *(unsigned int*)element;
+
+				r = ((int)(qwvu & 0x000000FF) << 24) * (1.0f / 0x7F000000);
+				g = ((int)(qwvu & 0x0000FF00) << 16) * (1.0f / 0x7F000000);
+				b = ((int)(qwvu & 0x00FF0000) << 8)  * (1.0f / 0x7F000000);
+				a = ((int)(qwvu & 0xFF000000) << 0)  * (1.0f / 0x7F000000);
+			}
+			break;
+		case FORMAT_X8L8V8U8:
+			{
+				unsigned int xlvu = *(unsigned int*)element;
+
+				r = ((int)(xlvu & 0x000000FF) << 24) * (1.0f / 0x7F000000);
+				g = ((int)(xlvu & 0x0000FF00) << 16) * (1.0f / 0x7F000000);
+				b = (xlvu & 0x00FF0000) * (1.0f / 0x00FF0000);
+			}
+			break;
+		case FORMAT_R8G8B8:
+			r = ((unsigned char*)element)[2] * (1.0f / 0xFF);
+			g = ((unsigned char*)element)[1] * (1.0f / 0xFF);
+			b = ((unsigned char*)element)[0] * (1.0f / 0xFF);
+			break;
+		case FORMAT_B8G8R8:
+			r = ((unsigned char*)element)[0] * (1.0f / 0xFF);
+			g = ((unsigned char*)element)[1] * (1.0f / 0xFF);
+			b = ((unsigned char*)element)[2] * (1.0f / 0xFF);
+			break;
+		case FORMAT_V16U16:
+			{
+				unsigned int vu = *(unsigned int*)element;
+
+				r = ((int)(vu & 0x0000FFFF) << 16) * (1.0f / 0x7FFF0000);
+				g = ((int)(vu & 0xFFFF0000) << 0)  * (1.0f / 0x7FFF0000);
+			}
+			break;
+		case FORMAT_A2W10V10U10:
+			{
+				unsigned int awvu = *(unsigned int*)element;
+
+				r = ((int)(awvu & 0x000003FF) << 22) * (1.0f / 0x7FC00000);
+				g = ((int)(awvu & 0x000FFC00) << 12) * (1.0f / 0x7FC00000);
+				b = ((int)(awvu & 0x3FF00000) << 2)  * (1.0f / 0x7FC00000);
+				a = (awvu & 0xC0000000) * (1.0f / 0xC0000000);
+			}
+			break;
+		case FORMAT_A16W16V16U16:
+			r = ((signed short*)element)[0] * (1.0f / 0x7FFF);
+			g = ((signed short*)element)[1] * (1.0f / 0x7FFF);
+			b = ((signed short*)element)[2] * (1.0f / 0x7FFF);
+			a = ((unsigned short*)element)[3] * (1.0f / 0xFFFF);
+			break;
+		case FORMAT_Q16W16V16U16:
+			r = ((signed short*)element)[0] * (1.0f / 0x7FFF);
+			g = ((signed short*)element)[1] * (1.0f / 0x7FFF);
+			b = ((signed short*)element)[2] * (1.0f / 0x7FFF);
+			a = ((signed short*)element)[3] * (1.0f / 0x7FFF);
+			break;
+		case FORMAT_L8:
+			r =
+			g =
+			b = *(unsigned char*)element * (1.0f / 0xFF);
+			break;
+		case FORMAT_A4L4:
+			{
+				unsigned char al = *(unsigned char*)element;
+
+				r =
+				g =
+				b = (al & 0x0F) * (1.0f / 0x0F);
+				a = (al & 0xF0) * (1.0f / 0xF0);
+			}
+			break;
+		case FORMAT_L16:
+			r =
+			g =
+			b = *(unsigned short*)element * (1.0f / 0xFFFF);
+			break;
+		case FORMAT_A8L8:
+			r =
+			g =
+			b = ((unsigned char*)element)[0] * (1.0f / 0xFF);
+			a = ((unsigned char*)element)[1] * (1.0f / 0xFF);
+			break;
+		case FORMAT_L16F:
+			r =
+			g =
+			b = *(half*)element;
+			break;
+		case FORMAT_A16L16F:
+			r =
+			g =
+			b = ((half*)element)[0];
+			a = ((half*)element)[1];
+			break;
+		case FORMAT_L32F:
+			r =
+			g =
+			b = *(float*)element;
+			break;
+		case FORMAT_A32L32F:
+			r =
+			g =
+			b = ((float*)element)[0];
+			a = ((float*)element)[1];
+			break;
+		case FORMAT_A16F:
+			a = *(half*)element;
+			break;
+		case FORMAT_R16F:
+			r = *(half*)element;
+			break;
+		case FORMAT_G16R16F:
+			r = ((half*)element)[0];
+			g = ((half*)element)[1];
+			break;
+		case FORMAT_X16B16G16R16F:
+		case FORMAT_X16B16G16R16F_UNSIGNED:
+		case FORMAT_B16G16R16F:
+			r = ((half*)element)[0];
+			g = ((half*)element)[1];
+			b = ((half*)element)[2];
+			break;
+		case FORMAT_A16B16G16R16F:
+			r = ((half*)element)[0];
+			g = ((half*)element)[1];
+			b = ((half*)element)[2];
+			a = ((half*)element)[3];
+			break;
+		case FORMAT_A32F:
+			a = *(float*)element;
+			break;
+		case FORMAT_R32F:
+			r = *(float*)element;
+			break;
+		case FORMAT_G32R32F:
+			r = ((float*)element)[0];
+			g = ((float*)element)[1];
+			break;
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_B32G32R32F:
+			r = ((float*)element)[0];
+			g = ((float*)element)[1];
+			b = ((float*)element)[2];
+			break;
+		case FORMAT_A32B32G32R32F:
+			r = ((float*)element)[0];
+			g = ((float*)element)[1];
+			b = ((float*)element)[2];
+			a = ((float*)element)[3];
+			break;
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+			r = *(float*)element;
+			g = r;
+			b = r;
+			a = r;
+			break;
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+			r = 1.0f - *(float*)element;
+			g = r;
+			b = r;
+			a = r;
+			break;
+		case FORMAT_S8:
+			r = *(unsigned char*)element * (1.0f / 0xFF);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(isSRGBformat(format))
+		{
+			r = sRGBtoLinear(r);
+			g = sRGBtoLinear(g);
+			b = sRGBtoLinear(b);
+		}
+
+		return Color<float>(r, g, b, a);
+	}
+
+	Color<float> Surface::Buffer::sample(float x, float y, float z) const
+	{
+		x -= 0.5f;
+		y -= 0.5f;
+		z -= 0.5f;
+
+		int x0 = clamp((int)x, 0, width - 1);
+		int x1 = (x0 + 1 >= width) ? x0 : x0 + 1;
+
+		int y0 = clamp((int)y, 0, height - 1);
+		int y1 = (y0 + 1 >= height) ? y0 : y0 + 1;
+
+		int z0 = clamp((int)z, 0, depth - 1);
+		int z1 = (z0 + 1 >= depth) ? z0 : z0 + 1;
+
+		Color<float> c000 = read(x0, y0, z0);
+		Color<float> c100 = read(x1, y0, z0);
+		Color<float> c010 = read(x0, y1, z0);
+		Color<float> c110 = read(x1, y1, z0);
+		Color<float> c001 = read(x0, y0, z1);
+		Color<float> c101 = read(x1, y0, z1);
+		Color<float> c011 = read(x0, y1, z1);
+		Color<float> c111 = read(x1, y1, z1);
+
+		float fx = x - x0;
+		float fy = y - y0;
+		float fz = z - z0;
+
+		c000 *= (1 - fx) * (1 - fy) * (1 - fz);
+		c100 *= fx * (1 - fy) * (1 - fz);
+		c010 *= (1 - fx) * fy * (1 - fz);
+		c110 *= fx * fy * (1 - fz);
+		c001 *= (1 - fx) * (1 - fy) * fz;
+		c101 *= fx * (1 - fy) * fz;
+		c011 *= (1 - fx) * fy * fz;
+		c111 *= fx * fy * fz;
+
+		return c000 + c100 + c010 + c110 + c001 + c101 + c011 + c111;
+	}
+
+	Color<float> Surface::Buffer::sample(float x, float y, int layer) const
+	{
+		x -= 0.5f;
+		y -= 0.5f;
+
+		int x0 = clamp((int)x, 0, width - 1);
+		int x1 = (x0 + 1 >= width) ? x0 : x0 + 1;
+
+		int y0 = clamp((int)y, 0, height - 1);
+		int y1 = (y0 + 1 >= height) ? y0 : y0 + 1;
+
+		Color<float> c00 = read(x0, y0, layer);
+		Color<float> c10 = read(x1, y0, layer);
+		Color<float> c01 = read(x0, y1, layer);
+		Color<float> c11 = read(x1, y1, layer);
+
+		float fx = x - x0;
+		float fy = y - y0;
+
+		c00 *= (1 - fx) * (1 - fy);
+		c10 *= fx * (1 - fy);
+		c01 *= (1 - fx) * fy;
+		c11 *= fx * fy;
+
+		return c00 + c10 + c01 + c11;
+	}
+
+	void *Surface::Buffer::lockRect(int x, int y, int z, Lock lock)
+	{
+		this->lock = lock;
+
+		switch(lock)
+		{
+		case LOCK_UNLOCKED:
+		case LOCK_READONLY:
+		case LOCK_UPDATE:
+			break;
+		case LOCK_WRITEONLY:
+		case LOCK_READWRITE:
+		case LOCK_DISCARD:
+			dirty = true;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(buffer)
+		{
+			x += border;
+			y += border;
+
+			switch(format)
+			{
+			case FORMAT_DXT1:
+			case FORMAT_ATI1:
+			case FORMAT_ETC1:
+			case FORMAT_R11_EAC:
+			case FORMAT_SIGNED_R11_EAC:
+			case FORMAT_RGB8_ETC2:
+			case FORMAT_SRGB8_ETC2:
+			case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+			case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+				return (unsigned char*)buffer + 8 * (x / 4) + (y / 4) * pitchB + z * sliceB;
+			case FORMAT_RG11_EAC:
+			case FORMAT_SIGNED_RG11_EAC:
+			case FORMAT_RGBA8_ETC2_EAC:
+			case FORMAT_SRGB8_ALPHA8_ETC2_EAC:
+			case FORMAT_RGBA_ASTC_4x4_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+				return (unsigned char*)buffer + 16 * (x / 4) + (y / 4) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_5x4_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+				return (unsigned char*)buffer + 16 * (x / 5) + (y / 4) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_5x5_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+				return (unsigned char*)buffer + 16 * (x / 5) + (y / 5) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_6x5_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+				return (unsigned char*)buffer + 16 * (x / 6) + (y / 5) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_6x6_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+				return (unsigned char*)buffer + 16 * (x / 6) + (y / 6) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_8x5_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+				return (unsigned char*)buffer + 16 * (x / 8) + (y / 5) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_8x6_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+				return (unsigned char*)buffer + 16 * (x / 8) + (y / 6) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_8x8_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+				return (unsigned char*)buffer + 16 * (x / 8) + (y / 8) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_10x5_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+				return (unsigned char*)buffer + 16 * (x / 10) + (y / 5) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_10x6_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+				return (unsigned char*)buffer + 16 * (x / 10) + (y / 6) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_10x8_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+				return (unsigned char*)buffer + 16 * (x / 10) + (y / 8) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_10x10_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+				return (unsigned char*)buffer + 16 * (x / 10) + (y / 10) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_12x10_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+				return (unsigned char*)buffer + 16 * (x / 12) + (y / 10) * pitchB + z * sliceB;
+			case FORMAT_RGBA_ASTC_12x12_KHR:
+			case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR:
+				return (unsigned char*)buffer + 16 * (x / 12) + (y / 12) * pitchB + z * sliceB;
+			case FORMAT_DXT3:
+			case FORMAT_DXT5:
+			case FORMAT_ATI2:
+				return (unsigned char*)buffer + 16 * (x / 4) + (y / 4) * pitchB + z * sliceB;
+			default:
+				return (unsigned char*)buffer + x * bytes + y * pitchB + z * samples * sliceB;
+			}
+		}
+
+		return nullptr;
+	}
+
+	void Surface::Buffer::unlockRect()
+	{
+		lock = LOCK_UNLOCKED;
+	}
+
+	class SurfaceImplementation : public Surface
+	{
+	public:
+		SurfaceImplementation(int width, int height, int depth, Format format, void *pixels, int pitch, int slice)
+			: Surface(width, height, depth, format, pixels, pitch, slice) {}
+		SurfaceImplementation(Resource *texture, int width, int height, int depth, int border, int samples, Format format, bool lockable, bool renderTarget, int pitchP = 0)
+			: Surface(texture, width, height, depth, border, samples, format, lockable, renderTarget, pitchP) {}
+		~SurfaceImplementation() override {};
+
+		void *lockInternal(int x, int y, int z, Lock lock, Accessor client) override
+		{
+			return Surface::lockInternal(x, y, z, lock, client);
+		}
+
+		void unlockInternal() override
+		{
+			Surface::unlockInternal();
+		}
+	};
+
+	Surface *Surface::create(int width, int height, int depth, Format format, void *pixels, int pitch, int slice)
+	{
+		return new SurfaceImplementation(width, height, depth, format, pixels, pitch, slice);
+	}
+
+	Surface *Surface::create(Resource *texture, int width, int height, int depth, int border, int samples, Format format, bool lockable, bool renderTarget, int pitchPprovided)
+	{
+		return new SurfaceImplementation(texture, width, height, depth, border, samples, format, lockable, renderTarget, pitchPprovided);
+	}
+
+	Surface::Surface(int width, int height, int depth, Format format, void *pixels, int pitch, int slice) : lockable(true), renderTarget(false)
+	{
+		resource = new Resource(0);
+		hasParent = false;
+		ownExternal = false;
+		depth = max(1, depth);
+
+		external.buffer = pixels;
+		external.width = width;
+		external.height = height;
+		external.depth = depth;
+		external.samples = 1;
+		external.format = format;
+		external.bytes = bytes(external.format);
+		external.pitchB = pitch;
+		external.pitchP = external.bytes ? pitch / external.bytes : 0;
+		external.sliceB = slice;
+		external.sliceP = external.bytes ? slice / external.bytes : 0;
+		external.border = 0;
+		external.lock = LOCK_UNLOCKED;
+		external.dirty = true;
+
+		internal.buffer = nullptr;
+		internal.width = width;
+		internal.height = height;
+		internal.depth = depth;
+		internal.samples = 1;
+		internal.format = selectInternalFormat(format);
+		internal.bytes = bytes(internal.format);
+		internal.pitchB = pitchB(internal.width, 0, internal.format, false);
+		internal.pitchP = pitchP(internal.width, 0, internal.format, false);
+		internal.sliceB = sliceB(internal.width, internal.height, 0, internal.format, false);
+		internal.sliceP = sliceP(internal.width, internal.height, 0, internal.format, false);
+		internal.border = 0;
+		internal.lock = LOCK_UNLOCKED;
+		internal.dirty = false;
+
+		stencil.buffer = nullptr;
+		stencil.width = width;
+		stencil.height = height;
+		stencil.depth = depth;
+		stencil.samples = 1;
+		stencil.format = isStencil(format) ? FORMAT_S8 : FORMAT_NULL;
+		stencil.bytes = bytes(stencil.format);
+		stencil.pitchB = pitchB(stencil.width, 0, stencil.format, false);
+		stencil.pitchP = pitchP(stencil.width, 0, stencil.format, false);
+		stencil.sliceB = sliceB(stencil.width, stencil.height, 0, stencil.format, false);
+		stencil.sliceP = sliceP(stencil.width, stencil.height, 0, stencil.format, false);
+		stencil.border = 0;
+		stencil.lock = LOCK_UNLOCKED;
+		stencil.dirty = false;
+
+		dirtyContents = true;
+		paletteUsed = 0;
+	}
+
+	Surface::Surface(Resource *texture, int width, int height, int depth, int border, int samples, Format format, bool lockable, bool renderTarget, int pitchPprovided) : lockable(lockable), renderTarget(renderTarget)
+	{
+		resource = texture ? texture : new Resource(0);
+		hasParent = texture != nullptr;
+		ownExternal = true;
+		depth = max(1, depth);
+		samples = max(1, samples);
+
+		external.buffer = nullptr;
+		external.width = width;
+		external.height = height;
+		external.depth = depth;
+		external.samples = (short)samples;
+		external.format = format;
+		external.bytes = bytes(external.format);
+		external.pitchB = !pitchPprovided ? pitchB(external.width, 0, external.format, renderTarget && !texture) : pitchPprovided * external.bytes;
+		external.pitchP = !pitchPprovided ? pitchP(external.width, 0, external.format, renderTarget && !texture) : pitchPprovided;
+		external.sliceB = sliceB(external.width, external.height, 0, external.format, renderTarget && !texture);
+		external.sliceP = sliceP(external.width, external.height, 0, external.format, renderTarget && !texture);
+		external.border = 0;
+		external.lock = LOCK_UNLOCKED;
+		external.dirty = false;
+
+		internal.buffer = nullptr;
+		internal.width = width;
+		internal.height = height;
+		internal.depth = depth;
+		internal.samples = (short)samples;
+		internal.format = selectInternalFormat(format);
+		internal.bytes = bytes(internal.format);
+		internal.pitchB = !pitchPprovided ? pitchB(internal.width, border, internal.format, renderTarget) : pitchPprovided * internal.bytes;
+		internal.pitchP = !pitchPprovided ? pitchP(internal.width, border, internal.format, renderTarget) : pitchPprovided;
+		internal.sliceB = sliceB(internal.width, internal.height, border, internal.format, renderTarget);
+		internal.sliceP = sliceP(internal.width, internal.height, border, internal.format, renderTarget);
+		internal.border = (short)border;
+		internal.lock = LOCK_UNLOCKED;
+		internal.dirty = false;
+
+		stencil.buffer = nullptr;
+		stencil.width = width;
+		stencil.height = height;
+		stencil.depth = depth;
+		stencil.samples = (short)samples;
+		stencil.format = isStencil(format) ? FORMAT_S8 : FORMAT_NULL;
+		stencil.bytes = bytes(stencil.format);
+		stencil.pitchB = pitchB(stencil.width, 0, stencil.format, renderTarget);
+		stencil.pitchP = pitchP(stencil.width, 0, stencil.format, renderTarget);
+		stencil.sliceB = sliceB(stencil.width, stencil.height, 0, stencil.format, renderTarget);
+		stencil.sliceP = sliceP(stencil.width, stencil.height, 0, stencil.format, renderTarget);
+		stencil.border = 0;
+		stencil.lock = LOCK_UNLOCKED;
+		stencil.dirty = false;
+
+		dirtyContents = true;
+		paletteUsed = 0;
+	}
+
+	Surface::~Surface()
+	{
+		// sync() must be called before this destructor to ensure all locks have been released.
+		// We can't call it here because the parent resource may already have been destroyed.
+		ASSERT(isUnlocked());
+
+		if(!hasParent)
+		{
+			resource->destruct();
+		}
+
+		if(ownExternal)
+		{
+			deallocate(external.buffer);
+		}
+
+		if(internal.buffer != external.buffer)
+		{
+			deallocate(internal.buffer);
+		}
+
+		deallocate(stencil.buffer);
+
+		external.buffer = nullptr;
+		internal.buffer = nullptr;
+		stencil.buffer = nullptr;
+	}
+
+	void *Surface::lockExternal(int x, int y, int z, Lock lock, Accessor client)
+	{
+		resource->lock(client);
+
+		if(!external.buffer)
+		{
+			if(internal.buffer && identicalBuffers())
+			{
+				external.buffer = internal.buffer;
+			}
+			else
+			{
+				external.buffer = allocateBuffer(external.width, external.height, external.depth, external.border, external.samples, external.format);
+			}
+		}
+
+		if(internal.dirty)
+		{
+			if(lock != LOCK_DISCARD)
+			{
+				update(external, internal);
+			}
+
+			internal.dirty = false;
+		}
+
+		switch(lock)
+		{
+		case LOCK_READONLY:
+			break;
+		case LOCK_WRITEONLY:
+		case LOCK_READWRITE:
+		case LOCK_DISCARD:
+			dirtyContents = true;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		return external.lockRect(x, y, z, lock);
+	}
+
+	void Surface::unlockExternal()
+	{
+		external.unlockRect();
+
+		resource->unlock();
+	}
+
+	void *Surface::lockInternal(int x, int y, int z, Lock lock, Accessor client)
+	{
+		if(lock != LOCK_UNLOCKED)
+		{
+			resource->lock(client);
+		}
+
+		if(!internal.buffer)
+		{
+			if(external.buffer && identicalBuffers())
+			{
+				internal.buffer = external.buffer;
+			}
+			else
+			{
+				internal.buffer = allocateBuffer(internal.width, internal.height, internal.depth, internal.border, internal.samples, internal.format);
+			}
+		}
+
+		// FIXME: WHQL requires conversion to lower external precision and back
+		if(logPrecision >= WHQL)
+		{
+			if(internal.dirty && renderTarget && internal.format != external.format)
+			{
+				if(lock != LOCK_DISCARD)
+				{
+					switch(external.format)
+					{
+					case FORMAT_R3G3B2:
+					case FORMAT_A8R3G3B2:
+					case FORMAT_A1R5G5B5:
+					case FORMAT_A2R10G10B10:
+					case FORMAT_A2B10G10R10:
+						lockExternal(0, 0, 0, LOCK_READWRITE, client);
+						unlockExternal();
+						break;
+					default:
+						// Difference passes WHQL
+						break;
+					}
+				}
+			}
+		}
+
+		if(external.dirty || (isPalette(external.format) && paletteUsed != Surface::paletteID))
+		{
+			if(lock != LOCK_DISCARD)
+			{
+				update(internal, external);
+			}
+
+			external.dirty = false;
+			paletteUsed = Surface::paletteID;
+		}
+
+		switch(lock)
+		{
+		case LOCK_UNLOCKED:
+		case LOCK_READONLY:
+			break;
+		case LOCK_WRITEONLY:
+		case LOCK_READWRITE:
+		case LOCK_DISCARD:
+			dirtyContents = true;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(lock == LOCK_READONLY && client == PUBLIC)
+		{
+			resolve();
+		}
+
+		return internal.lockRect(x, y, z, lock);
+	}
+
+	void Surface::unlockInternal()
+	{
+		internal.unlockRect();
+
+		resource->unlock();
+	}
+
+	void *Surface::lockStencil(int x, int y, int front, Accessor client)
+	{
+		resource->lock(client);
+
+		if(stencil.format == FORMAT_NULL)
+		{
+			return nullptr;
+		}
+
+		if(!stencil.buffer)
+		{
+			stencil.buffer = allocateBuffer(stencil.width, stencil.height, stencil.depth, stencil.border, stencil.samples, stencil.format);
+		}
+
+		return stencil.lockRect(x, y, front, LOCK_READWRITE);   // FIXME
+	}
+
+	void Surface::unlockStencil()
+	{
+		stencil.unlockRect();
+
+		resource->unlock();
+	}
+
+	int Surface::bytes(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_NULL:				return 0;
+		case FORMAT_P8:					return 1;
+		case FORMAT_A8P8:				return 2;
+		case FORMAT_A8:					return 1;
+		case FORMAT_R8I:				return 1;
+		case FORMAT_R8:					return 1;
+		case FORMAT_R3G3B2:				return 1;
+		case FORMAT_R16I:				return 2;
+		case FORMAT_R16UI:				return 2;
+		case FORMAT_A8R3G3B2:			return 2;
+		case FORMAT_R5G6B5:				return 2;
+		case FORMAT_A1R5G5B5:			return 2;
+		case FORMAT_X1R5G5B5:			return 2;
+		case FORMAT_R5G5B5A1:           return 2;
+		case FORMAT_X4R4G4B4:			return 2;
+		case FORMAT_A4R4G4B4:			return 2;
+		case FORMAT_R4G4B4A4:           return 2;
+		case FORMAT_R8G8B8:				return 3;
+		case FORMAT_B8G8R8:             return 3;
+		case FORMAT_R32I:				return 4;
+		case FORMAT_R32UI:				return 4;
+		case FORMAT_X8R8G8B8:			return 4;
+	//	case FORMAT_X8G8R8B8Q:			return 4;
+		case FORMAT_A8R8G8B8:			return 4;
+	//	case FORMAT_A8G8R8B8Q:			return 4;
+		case FORMAT_X8B8G8R8I:			return 4;
+		case FORMAT_X8B8G8R8:			return 4;
+		case FORMAT_SRGB8_X8:			return 4;
+		case FORMAT_SRGB8_A8:			return 4;
+		case FORMAT_A8B8G8R8I:			return 4;
+		case FORMAT_R8UI:				return 1;
+		case FORMAT_G8R8UI:				return 2;
+		case FORMAT_X8B8G8R8UI:			return 4;
+		case FORMAT_A8B8G8R8UI:			return 4;
+		case FORMAT_A8B8G8R8:			return 4;
+		case FORMAT_R8_SNORM:			return 1;
+		case FORMAT_G8R8_SNORM:		return 2;
+		case FORMAT_X8B8G8R8_SNORM:	return 4;
+		case FORMAT_A8B8G8R8_SNORM:	return 4;
+		case FORMAT_A2R10G10B10:		return 4;
+		case FORMAT_A2B10G10R10:		return 4;
+		case FORMAT_A2B10G10R10UI:		return 4;
+		case FORMAT_G8R8I:				return 2;
+		case FORMAT_G8R8:				return 2;
+		case FORMAT_G16R16I:			return 4;
+		case FORMAT_G16R16UI:			return 4;
+		case FORMAT_G16R16:				return 4;
+		case FORMAT_G32R32I:			return 8;
+		case FORMAT_G32R32UI:			return 8;
+		case FORMAT_X16B16G16R16I:		return 8;
+		case FORMAT_X16B16G16R16UI:		return 8;
+		case FORMAT_A16B16G16R16I:		return 8;
+		case FORMAT_A16B16G16R16UI:		return 8;
+		case FORMAT_A16B16G16R16:		return 8;
+		case FORMAT_X32B32G32R32I:		return 16;
+		case FORMAT_X32B32G32R32UI:		return 16;
+		case FORMAT_A32B32G32R32I:		return 16;
+		case FORMAT_A32B32G32R32UI:		return 16;
+		// Compressed formats
+		case FORMAT_DXT1:				return 2;   // Column of four pixels
+		case FORMAT_DXT3:				return 4;   // Column of four pixels
+		case FORMAT_DXT5:				return 4;   // Column of four pixels
+		case FORMAT_ATI1:				return 2;   // Column of four pixels
+		case FORMAT_ATI2:				return 4;   // Column of four pixels
+		case FORMAT_ETC1:				return 2;   // Column of four pixels
+		case FORMAT_R11_EAC:			return 2;
+		case FORMAT_SIGNED_R11_EAC:		return 2;
+		case FORMAT_RG11_EAC:			return 4;
+		case FORMAT_SIGNED_RG11_EAC:	return 4;
+		case FORMAT_RGB8_ETC2:			return 2;
+		case FORMAT_SRGB8_ETC2:			return 2;
+		case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:	return 2;
+		case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:	return 2;
+		case FORMAT_RGBA8_ETC2_EAC:			return 4;
+		case FORMAT_SRGB8_ALPHA8_ETC2_EAC:	return 4;
+		case FORMAT_RGBA_ASTC_4x4_KHR:
+		case FORMAT_RGBA_ASTC_5x4_KHR:
+		case FORMAT_RGBA_ASTC_5x5_KHR:
+		case FORMAT_RGBA_ASTC_6x5_KHR:
+		case FORMAT_RGBA_ASTC_6x6_KHR:
+		case FORMAT_RGBA_ASTC_8x5_KHR:
+		case FORMAT_RGBA_ASTC_8x6_KHR:
+		case FORMAT_RGBA_ASTC_8x8_KHR:
+		case FORMAT_RGBA_ASTC_10x5_KHR:
+		case FORMAT_RGBA_ASTC_10x6_KHR:
+		case FORMAT_RGBA_ASTC_10x8_KHR:
+		case FORMAT_RGBA_ASTC_10x10_KHR:
+		case FORMAT_RGBA_ASTC_12x10_KHR:
+		case FORMAT_RGBA_ASTC_12x12_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR: return 0; // FIXME
+		// Bumpmap formats
+		case FORMAT_V8U8:				return 2;
+		case FORMAT_L6V5U5:				return 2;
+		case FORMAT_Q8W8V8U8:			return 4;
+		case FORMAT_X8L8V8U8:			return 4;
+		case FORMAT_A2W10V10U10:		return 4;
+		case FORMAT_V16U16:				return 4;
+		case FORMAT_A16W16V16U16:		return 8;
+		case FORMAT_Q16W16V16U16:		return 8;
+		// Luminance formats
+		case FORMAT_L8:					return 1;
+		case FORMAT_A4L4:				return 1;
+		case FORMAT_L16:				return 2;
+		case FORMAT_A8L8:				return 2;
+		case FORMAT_L16F:               return 2;
+		case FORMAT_A16L16F:            return 4;
+		case FORMAT_L32F:               return 4;
+		case FORMAT_A32L32F:            return 8;
+		// Floating-point formats
+		case FORMAT_A16F:				return 2;
+		case FORMAT_R16F:				return 2;
+		case FORMAT_G16R16F:			return 4;
+		case FORMAT_B16G16R16F:			return 6;
+		case FORMAT_X16B16G16R16F:		return 8;
+		case FORMAT_A16B16G16R16F:		return 8;
+		case FORMAT_X16B16G16R16F_UNSIGNED: return 8;
+		case FORMAT_A32F:				return 4;
+		case FORMAT_R32F:				return 4;
+		case FORMAT_G32R32F:			return 8;
+		case FORMAT_B32G32R32F:			return 12;
+		case FORMAT_X32B32G32R32F:		return 16;
+		case FORMAT_A32B32G32R32F:		return 16;
+		case FORMAT_X32B32G32R32F_UNSIGNED: return 16;
+		// Depth/stencil formats
+		case FORMAT_D16:				return 2;
+		case FORMAT_D32:				return 4;
+		case FORMAT_D24X8:				return 4;
+		case FORMAT_D24S8:				return 4;
+		case FORMAT_D24FS8:				return 4;
+		case FORMAT_D32F:				return 4;
+		case FORMAT_D32FS8:				return 4;
+		case FORMAT_D32F_COMPLEMENTARY:	return 4;
+		case FORMAT_D32FS8_COMPLEMENTARY: return 4;
+		case FORMAT_D32F_LOCKABLE:		return 4;
+		case FORMAT_D32FS8_TEXTURE:		return 4;
+		case FORMAT_D32F_SHADOW:		return 4;
+		case FORMAT_D32FS8_SHADOW:		return 4;
+		case FORMAT_DF24S8:				return 4;
+		case FORMAT_DF16S8:				return 2;
+		case FORMAT_INTZ:				return 4;
+		case FORMAT_S8:					return 1;
+		case FORMAT_YV12_BT601:         return 1;   // Y plane only
+		case FORMAT_YV12_BT709:         return 1;   // Y plane only
+		case FORMAT_YV12_JFIF:          return 1;   // Y plane only
+		default:
+			ASSERT(false);
+		}
+
+		return 0;
+	}
+
+	int Surface::pitchB(int width, int border, Format format, bool target)
+	{
+		width += 2 * border;
+
+		// Render targets require 2x2 quads
+		if(target || isDepth(format) || isStencil(format))
+		{
+			width = align<2>(width);
+		}
+
+		switch(format)
+		{
+		case FORMAT_DXT1:
+		case FORMAT_ETC1:
+		case FORMAT_R11_EAC:
+		case FORMAT_SIGNED_R11_EAC:
+		case FORMAT_RGB8_ETC2:
+		case FORMAT_SRGB8_ETC2:
+		case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+			return 8 * ((width + 3) / 4);    // 64 bit per 4x4 block, computed per 4 rows
+		case FORMAT_RG11_EAC:
+		case FORMAT_SIGNED_RG11_EAC:
+		case FORMAT_RGBA8_ETC2_EAC:
+		case FORMAT_SRGB8_ALPHA8_ETC2_EAC:
+		case FORMAT_RGBA_ASTC_4x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+			return 16 * ((width + 3) / 4);    // 128 bit per 4x4 block, computed per 4 rows
+		case FORMAT_RGBA_ASTC_5x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+		case FORMAT_RGBA_ASTC_5x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+			return 16 * ((width + 4) / 5);
+		case FORMAT_RGBA_ASTC_6x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+		case FORMAT_RGBA_ASTC_6x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+			return 16 * ((width + 5) / 6);
+		case FORMAT_RGBA_ASTC_8x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+		case FORMAT_RGBA_ASTC_8x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+		case FORMAT_RGBA_ASTC_8x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+			return 16 * ((width + 7) / 8);
+		case FORMAT_RGBA_ASTC_10x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+		case FORMAT_RGBA_ASTC_10x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+		case FORMAT_RGBA_ASTC_10x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+		case FORMAT_RGBA_ASTC_10x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+			return 16 * ((width + 9) / 10);
+		case FORMAT_RGBA_ASTC_12x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+		case FORMAT_RGBA_ASTC_12x12_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR:
+			return 16 * ((width + 11) / 12);
+		case FORMAT_DXT3:
+		case FORMAT_DXT5:
+			return 16 * ((width + 3) / 4);   // 128 bit per 4x4 block, computed per 4 rows
+		case FORMAT_ATI1:
+			return 2 * ((width + 3) / 4);    // 64 bit per 4x4 block, computed per row
+		case FORMAT_ATI2:
+			return 4 * ((width + 3) / 4);    // 128 bit per 4x4 block, computed per row
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return align<16>(width);
+		default:
+			return bytes(format) * width;
+		}
+	}
+
+	int Surface::pitchP(int width, int border, Format format, bool target)
+	{
+		int B = bytes(format);
+
+		return B > 0 ? pitchB(width, border, format, target) / B : 0;
+	}
+
+	int Surface::sliceB(int width, int height, int border, Format format, bool target)
+	{
+		height += 2 * border;
+
+		// Render targets require 2x2 quads
+		if(target || isDepth(format) || isStencil(format))
+		{
+			height = align<2>(height);
+		}
+
+		switch(format)
+		{
+		case FORMAT_DXT1:
+		case FORMAT_DXT3:
+		case FORMAT_DXT5:
+		case FORMAT_ETC1:
+		case FORMAT_R11_EAC:
+		case FORMAT_SIGNED_R11_EAC:
+		case FORMAT_RG11_EAC:
+		case FORMAT_SIGNED_RG11_EAC:
+		case FORMAT_RGB8_ETC2:
+		case FORMAT_SRGB8_ETC2:
+		case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_RGBA8_ETC2_EAC:
+		case FORMAT_SRGB8_ALPHA8_ETC2_EAC:
+		case FORMAT_RGBA_ASTC_4x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+		case FORMAT_RGBA_ASTC_5x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+			return pitchB(width, border, format, target) * ((height + 3) / 4);   // Pitch computed per 4 rows
+		case FORMAT_RGBA_ASTC_5x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+		case FORMAT_RGBA_ASTC_6x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+		case FORMAT_RGBA_ASTC_8x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+		case FORMAT_RGBA_ASTC_10x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+			return pitchB(width, border, format, target) * ((height + 4) / 5);   // Pitch computed per 5 rows
+		case FORMAT_RGBA_ASTC_6x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+		case FORMAT_RGBA_ASTC_8x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+		case FORMAT_RGBA_ASTC_10x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+			return pitchB(width, border, format, target) * ((height + 5) / 6);   // Pitch computed per 6 rows
+		case FORMAT_RGBA_ASTC_8x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+		case FORMAT_RGBA_ASTC_10x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+			return pitchB(width, border, format, target) * ((height + 7) / 8);   // Pitch computed per 8 rows
+		case FORMAT_RGBA_ASTC_10x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+		case FORMAT_RGBA_ASTC_12x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+			return pitchB(width, border, format, target) * ((height + 9) / 10);   // Pitch computed per 10 rows
+		case FORMAT_RGBA_ASTC_12x12_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR:
+			return pitchB(width, border, format, target) * ((height + 11) / 12);   // Pitch computed per 12 rows
+		case FORMAT_ATI1:
+		case FORMAT_ATI2:
+			return pitchB(width, border, format, target) * align<4>(height);   // Pitch computed per row
+		default:
+			return pitchB(width, border, format, target) * height;   // Pitch computed per row
+		}
+	}
+
+	int Surface::sliceP(int width, int height, int border, Format format, bool target)
+	{
+		int B = bytes(format);
+
+		return B > 0 ? sliceB(width, height, border, format, target) / B : 0;
+	}
+
+	void Surface::update(Buffer &destination, Buffer &source)
+	{
+	//	ASSERT(source.lock != LOCK_UNLOCKED);
+	//	ASSERT(destination.lock != LOCK_UNLOCKED);
+
+		if(destination.buffer != source.buffer)
+		{
+			ASSERT(source.dirty && !destination.dirty);
+
+			switch(source.format)
+			{
+			case FORMAT_R8G8B8:		decodeR8G8B8(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_X1R5G5B5:	decodeX1R5G5B5(destination, source);	break;   // FIXME: Check destination format
+			case FORMAT_A1R5G5B5:	decodeA1R5G5B5(destination, source);	break;   // FIXME: Check destination format
+			case FORMAT_X4R4G4B4:	decodeX4R4G4B4(destination, source);	break;   // FIXME: Check destination format
+			case FORMAT_A4R4G4B4:	decodeA4R4G4B4(destination, source);	break;   // FIXME: Check destination format
+			case FORMAT_P8:			decodeP8(destination, source);			break;   // FIXME: Check destination format
+			case FORMAT_DXT1:		decodeDXT1(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_DXT3:		decodeDXT3(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_DXT5:		decodeDXT5(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_ATI1:		decodeATI1(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_ATI2:		decodeATI2(destination, source);		break;   // FIXME: Check destination format
+			case FORMAT_R11_EAC:         decodeEAC(destination, source, 1, false); break; // FIXME: Check destination format
+			case FORMAT_SIGNED_R11_EAC:  decodeEAC(destination, source, 1, true);  break; // FIXME: Check destination format
+			case FORMAT_RG11_EAC:        decodeEAC(destination, source, 2, false); break; // FIXME: Check destination format
+			case FORMAT_SIGNED_RG11_EAC: decodeEAC(destination, source, 2, true);  break; // FIXME: Check destination format
+			case FORMAT_ETC1:
+			case FORMAT_RGB8_ETC2:                      decodeETC2(destination, source, 0, false); break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ETC2:                     decodeETC2(destination, source, 0, true);  break; // FIXME: Check destination format
+			case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:  decodeETC2(destination, source, 1, false); break; // FIXME: Check destination format
+			case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: decodeETC2(destination, source, 1, true);  break; // FIXME: Check destination format
+			case FORMAT_RGBA8_ETC2_EAC:                 decodeETC2(destination, source, 8, false); break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ETC2_EAC:          decodeETC2(destination, source, 8, true);  break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_4x4_KHR:           decodeASTC(destination, source, 4,  4,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_5x4_KHR:           decodeASTC(destination, source, 5,  4,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_5x5_KHR:           decodeASTC(destination, source, 5,  5,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_6x5_KHR:           decodeASTC(destination, source, 6,  5,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_6x6_KHR:           decodeASTC(destination, source, 6,  6,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_8x5_KHR:           decodeASTC(destination, source, 8,  5,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_8x6_KHR:           decodeASTC(destination, source, 8,  6,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_8x8_KHR:           decodeASTC(destination, source, 8,  8,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_10x5_KHR:          decodeASTC(destination, source, 10, 5,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_10x6_KHR:          decodeASTC(destination, source, 10, 6,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_10x8_KHR:          decodeASTC(destination, source, 10, 8,  1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_10x10_KHR:         decodeASTC(destination, source, 10, 10, 1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_12x10_KHR:         decodeASTC(destination, source, 12, 10, 1, false); break; // FIXME: Check destination format
+			case FORMAT_RGBA_ASTC_12x12_KHR:         decodeASTC(destination, source, 12, 12, 1, false); break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:   decodeASTC(destination, source, 4,  4,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:   decodeASTC(destination, source, 5,  4,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:   decodeASTC(destination, source, 5,  5,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:   decodeASTC(destination, source, 6,  5,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:   decodeASTC(destination, source, 6,  6,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:   decodeASTC(destination, source, 8,  5,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:   decodeASTC(destination, source, 8,  6,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:   decodeASTC(destination, source, 8,  8,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:  decodeASTC(destination, source, 10, 5,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:  decodeASTC(destination, source, 10, 6,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:  decodeASTC(destination, source, 10, 8,  1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR: decodeASTC(destination, source, 10, 10, 1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR: decodeASTC(destination, source, 12, 10, 1, true);  break; // FIXME: Check destination format
+			case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR: decodeASTC(destination, source, 12, 12, 1, true);  break; // FIXME: Check destination format
+			default:				genericUpdate(destination, source);		break;
+			}
+		}
+	}
+
+	void Surface::genericUpdate(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+		int rowBytes = width * source.bytes;
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				if(source.format == destination.format)
+				{
+					memcpy(destinationRow, sourceRow, rowBytes);
+				}
+				else
+				{
+					unsigned char *sourceElement = sourceRow;
+					unsigned char *destinationElement = destinationRow;
+
+					for(int x = 0; x < width; x++)
+					{
+						Color<float> color = source.read(sourceElement);
+						destination.write(destinationElement, color);
+
+						sourceElement += source.bytes;
+						destinationElement += destination.bytes;
+					}
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeR8G8B8(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int b = sourceElement[0];
+					unsigned int g = sourceElement[1];
+					unsigned int r = sourceElement[2];
+
+					*(unsigned int*)destinationElement = 0xFF000000 | (r << 16) | (g << 8) | (b << 0);
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeX1R5G5B5(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int xrgb = *(unsigned short*)sourceElement;
+
+					unsigned int r = (((xrgb & 0x7C00) * 134771 + 0x800000) >> 8) & 0x00FF0000;
+					unsigned int g = (((xrgb & 0x03E0) * 16846 + 0x8000) >> 8) & 0x0000FF00;
+					unsigned int b = (((xrgb & 0x001F) * 2106  + 0x80) >> 8);
+
+					*(unsigned int*)destinationElement = 0xFF000000 | r | g | b;
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeA1R5G5B5(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int argb = *(unsigned short*)sourceElement;
+
+					unsigned int a =   (argb & 0x8000) * 130560;
+					unsigned int r = (((argb & 0x7C00) * 134771 + 0x800000) >> 8) & 0x00FF0000;
+					unsigned int g = (((argb & 0x03E0) * 16846  + 0x8000) >> 8) & 0x0000FF00;
+					unsigned int b = (((argb & 0x001F) * 2106   + 0x80) >> 8);
+
+					*(unsigned int*)destinationElement = a | r | g | b;
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeX4R4G4B4(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int xrgb = *(unsigned short*)sourceElement;
+
+					unsigned int r = ((xrgb & 0x0F00) * 0x00001100) & 0x00FF0000;
+					unsigned int g = ((xrgb & 0x00F0) * 0x00000110) & 0x0000FF00;
+					unsigned int b =  (xrgb & 0x000F) * 0x00000011;
+
+					*(unsigned int*)destinationElement = 0xFF000000 | r | g | b;
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeA4R4G4B4(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int argb = *(unsigned short*)sourceElement;
+
+					unsigned int a = ((argb & 0xF000) * 0x00011000) & 0xFF000000;
+					unsigned int r = ((argb & 0x0F00) * 0x00001100) & 0x00FF0000;
+					unsigned int g = ((argb & 0x00F0) * 0x00000110) & 0x0000FF00;
+					unsigned int b =  (argb & 0x000F) * 0x00000011;
+
+					*(unsigned int*)destinationElement = a | r | g | b;
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeP8(Buffer &destination, Buffer &source)
+	{
+		unsigned char *sourceSlice = (unsigned char*)source.lockRect(0, 0, 0, sw::LOCK_READONLY);
+		unsigned char *destinationSlice = (unsigned char*)destination.lockRect(0, 0, 0, sw::LOCK_UPDATE);
+
+		int depth = min(destination.depth, source.depth);
+		int height = min(destination.height, source.height);
+		int width = min(destination.width, source.width);
+
+		for(int z = 0; z < depth; z++)
+		{
+			unsigned char *sourceRow = sourceSlice;
+			unsigned char *destinationRow = destinationSlice;
+
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *sourceElement = sourceRow;
+				unsigned char *destinationElement = destinationRow;
+
+				for(int x = 0; x < width; x++)
+				{
+					unsigned int abgr = palette[*(unsigned char*)sourceElement];
+
+					unsigned int r = (abgr & 0x000000FF) << 16;
+					unsigned int g = (abgr & 0x0000FF00) << 0;
+					unsigned int b = (abgr & 0x00FF0000) >> 16;
+					unsigned int a = (abgr & 0xFF000000) >> 0;
+
+					*(unsigned int*)destinationElement = a | r | g | b;
+
+					sourceElement += source.bytes;
+					destinationElement += destination.bytes;
+				}
+
+				sourceRow += source.pitchB;
+				destinationRow += destination.pitchB;
+			}
+
+			sourceSlice += source.sliceB;
+			destinationSlice += destination.sliceB;
+		}
+
+		source.unlockRect();
+		destination.unlockRect();
+	}
+
+	void Surface::decodeDXT1(Buffer &internal, Buffer &external)
+	{
+		unsigned int *destSlice = (unsigned int*)internal.lockRect(0, 0, 0, LOCK_UPDATE);
+		const DXT1 *source = (const DXT1*)external.lockRect(0, 0, 0, LOCK_READONLY);
+
+		for(int z = 0; z < external.depth; z++)
+		{
+			unsigned int *dest = destSlice;
+
+			for(int y = 0; y < external.height; y += 4)
+			{
+				for(int x = 0; x < external.width; x += 4)
+				{
+					Color<byte> c[4];
+
+					c[0] = source->c0;
+					c[1] = source->c1;
+
+					if(source->c0 > source->c1)   // No transparency
+					{
+						// c2 = 2 / 3 * c0 + 1 / 3 * c1
+						c[2].r = (byte)((2 * (word)c[0].r + (word)c[1].r + 1) / 3);
+						c[2].g = (byte)((2 * (word)c[0].g + (word)c[1].g + 1) / 3);
+						c[2].b = (byte)((2 * (word)c[0].b + (word)c[1].b + 1) / 3);
+						c[2].a = 0xFF;
+
+						// c3 = 1 / 3 * c0 + 2 / 3 * c1
+						c[3].r = (byte)(((word)c[0].r + 2 * (word)c[1].r + 1) / 3);
+						c[3].g = (byte)(((word)c[0].g + 2 * (word)c[1].g + 1) / 3);
+						c[3].b = (byte)(((word)c[0].b + 2 * (word)c[1].b + 1) / 3);
+						c[3].a = 0xFF;
+					}
+					else   // c3 transparent
+					{
+						// c2 = 1 / 2 * c0 + 1 / 2 * c1
+						c[2].r = (byte)(((word)c[0].r + (word)c[1].r) / 2);
+						c[2].g = (byte)(((word)c[0].g + (word)c[1].g) / 2);
+						c[2].b = (byte)(((word)c[0].b + (word)c[1].b) / 2);
+						c[2].a = 0xFF;
+
+						c[3].r = 0;
+						c[3].g = 0;
+						c[3].b = 0;
+						c[3].a = 0;
+					}
+
+					for(int j = 0; j < 4 && (y + j) < internal.height; j++)
+					{
+						for(int i = 0; i < 4 && (x + i) < internal.width; i++)
+						{
+							dest[(x + i) + (y + j) * internal.pitchP] = c[(unsigned int)(source->lut >> 2 * (i + j * 4)) % 4];
+						}
+					}
+
+					source++;
+				}
+			}
+
+			(byte*&)destSlice += internal.sliceB;
+		}
+
+		external.unlockRect();
+		internal.unlockRect();
+	}
+
+	void Surface::decodeDXT3(Buffer &internal, Buffer &external)
+	{
+		unsigned int *destSlice = (unsigned int*)internal.lockRect(0, 0, 0, LOCK_UPDATE);
+		const DXT3 *source = (const DXT3*)external.lockRect(0, 0, 0, LOCK_READONLY);
+
+		for(int z = 0; z < external.depth; z++)
+		{
+			unsigned int *dest = destSlice;
+
+			for(int y = 0; y < external.height; y += 4)
+			{
+				for(int x = 0; x < external.width; x += 4)
+				{
+					Color<byte> c[4];
+
+					c[0] = source->c0;
+					c[1] = source->c1;
+
+					// c2 = 2 / 3 * c0 + 1 / 3 * c1
+					c[2].r = (byte)((2 * (word)c[0].r + (word)c[1].r + 1) / 3);
+					c[2].g = (byte)((2 * (word)c[0].g + (word)c[1].g + 1) / 3);
+					c[2].b = (byte)((2 * (word)c[0].b + (word)c[1].b + 1) / 3);
+
+					// c3 = 1 / 3 * c0 + 2 / 3 * c1
+					c[3].r = (byte)(((word)c[0].r + 2 * (word)c[1].r + 1) / 3);
+					c[3].g = (byte)(((word)c[0].g + 2 * (word)c[1].g + 1) / 3);
+					c[3].b = (byte)(((word)c[0].b + 2 * (word)c[1].b + 1) / 3);
+
+					for(int j = 0; j < 4 && (y + j) < internal.height; j++)
+					{
+						for(int i = 0; i < 4 && (x + i) < internal.width; i++)
+						{
+							unsigned int a = (unsigned int)(source->a >> 4 * (i + j * 4)) & 0x0F;
+							unsigned int color = (c[(unsigned int)(source->lut >> 2 * (i + j * 4)) % 4] & 0x00FFFFFF) | ((a << 28) + (a << 24));
+
+							dest[(x + i) + (y + j) * internal.pitchP] = color;
+						}
+					}
+
+					source++;
+				}
+			}
+
+			(byte*&)destSlice += internal.sliceB;
+		}
+
+		external.unlockRect();
+		internal.unlockRect();
+	}
+
+	void Surface::decodeDXT5(Buffer &internal, Buffer &external)
+	{
+		unsigned int *destSlice = (unsigned int*)internal.lockRect(0, 0, 0, LOCK_UPDATE);
+		const DXT5 *source = (const DXT5*)external.lockRect(0, 0, 0, LOCK_READONLY);
+
+		for(int z = 0; z < external.depth; z++)
+		{
+			unsigned int *dest = destSlice;
+
+			for(int y = 0; y < external.height; y += 4)
+			{
+				for(int x = 0; x < external.width; x += 4)
+				{
+					Color<byte> c[4];
+
+					c[0] = source->c0;
+					c[1] = source->c1;
+
+					// c2 = 2 / 3 * c0 + 1 / 3 * c1
+					c[2].r = (byte)((2 * (word)c[0].r + (word)c[1].r + 1) / 3);
+					c[2].g = (byte)((2 * (word)c[0].g + (word)c[1].g + 1) / 3);
+					c[2].b = (byte)((2 * (word)c[0].b + (word)c[1].b + 1) / 3);
+
+					// c3 = 1 / 3 * c0 + 2 / 3 * c1
+					c[3].r = (byte)(((word)c[0].r + 2 * (word)c[1].r + 1) / 3);
+					c[3].g = (byte)(((word)c[0].g + 2 * (word)c[1].g + 1) / 3);
+					c[3].b = (byte)(((word)c[0].b + 2 * (word)c[1].b + 1) / 3);
+
+					byte a[8];
+
+					a[0] = source->a0;
+					a[1] = source->a1;
+
+					if(a[0] > a[1])
+					{
+						a[2] = (byte)((6 * (word)a[0] + 1 * (word)a[1] + 3) / 7);
+						a[3] = (byte)((5 * (word)a[0] + 2 * (word)a[1] + 3) / 7);
+						a[4] = (byte)((4 * (word)a[0] + 3 * (word)a[1] + 3) / 7);
+						a[5] = (byte)((3 * (word)a[0] + 4 * (word)a[1] + 3) / 7);
+						a[6] = (byte)((2 * (word)a[0] + 5 * (word)a[1] + 3) / 7);
+						a[7] = (byte)((1 * (word)a[0] + 6 * (word)a[1] + 3) / 7);
+					}
+					else
+					{
+						a[2] = (byte)((4 * (word)a[0] + 1 * (word)a[1] + 2) / 5);
+						a[3] = (byte)((3 * (word)a[0] + 2 * (word)a[1] + 2) / 5);
+						a[4] = (byte)((2 * (word)a[0] + 3 * (word)a[1] + 2) / 5);
+						a[5] = (byte)((1 * (word)a[0] + 4 * (word)a[1] + 2) / 5);
+						a[6] = 0;
+						a[7] = 0xFF;
+					}
+
+					for(int j = 0; j < 4 && (y + j) < internal.height; j++)
+					{
+						for(int i = 0; i < 4 && (x + i) < internal.width; i++)
+						{
+							unsigned int alpha = (unsigned int)a[(unsigned int)(source->alut >> (16 + 3 * (i + j * 4))) % 8] << 24;
+							unsigned int color = (c[(source->clut >> 2 * (i + j * 4)) % 4] & 0x00FFFFFF) | alpha;
+
+							dest[(x + i) + (y + j) * internal.pitchP] = color;
+						}
+					}
+
+					source++;
+				}
+			}
+
+			(byte*&)destSlice += internal.sliceB;
+		}
+
+		external.unlockRect();
+		internal.unlockRect();
+	}
+
+	void Surface::decodeATI1(Buffer &internal, Buffer &external)
+	{
+		byte *destSlice = (byte*)internal.lockRect(0, 0, 0, LOCK_UPDATE);
+		const ATI1 *source = (const ATI1*)external.lockRect(0, 0, 0, LOCK_READONLY);
+
+		for(int z = 0; z < external.depth; z++)
+		{
+			byte *dest = destSlice;
+
+			for(int y = 0; y < external.height; y += 4)
+			{
+				for(int x = 0; x < external.width; x += 4)
+				{
+					byte r[8];
+
+					r[0] = source->r0;
+					r[1] = source->r1;
+
+					if(r[0] > r[1])
+					{
+						r[2] = (byte)((6 * (word)r[0] + 1 * (word)r[1] + 3) / 7);
+						r[3] = (byte)((5 * (word)r[0] + 2 * (word)r[1] + 3) / 7);
+						r[4] = (byte)((4 * (word)r[0] + 3 * (word)r[1] + 3) / 7);
+						r[5] = (byte)((3 * (word)r[0] + 4 * (word)r[1] + 3) / 7);
+						r[6] = (byte)((2 * (word)r[0] + 5 * (word)r[1] + 3) / 7);
+						r[7] = (byte)((1 * (word)r[0] + 6 * (word)r[1] + 3) / 7);
+					}
+					else
+					{
+						r[2] = (byte)((4 * (word)r[0] + 1 * (word)r[1] + 2) / 5);
+						r[3] = (byte)((3 * (word)r[0] + 2 * (word)r[1] + 2) / 5);
+						r[4] = (byte)((2 * (word)r[0] + 3 * (word)r[1] + 2) / 5);
+						r[5] = (byte)((1 * (word)r[0] + 4 * (word)r[1] + 2) / 5);
+						r[6] = 0;
+						r[7] = 0xFF;
+					}
+
+					for(int j = 0; j < 4 && (y + j) < internal.height; j++)
+					{
+						for(int i = 0; i < 4 && (x + i) < internal.width; i++)
+						{
+							dest[(x + i) + (y + j) * internal.pitchP] = r[(unsigned int)(source->rlut >> (16 + 3 * (i + j * 4))) % 8];
+						}
+					}
+
+					source++;
+				}
+			}
+
+			destSlice += internal.sliceB;
+		}
+
+		external.unlockRect();
+		internal.unlockRect();
+	}
+
+	void Surface::decodeATI2(Buffer &internal, Buffer &external)
+	{
+		word *destSlice = (word*)internal.lockRect(0, 0, 0, LOCK_UPDATE);
+		const ATI2 *source = (const ATI2*)external.lockRect(0, 0, 0, LOCK_READONLY);
+
+		for(int z = 0; z < external.depth; z++)
+		{
+			word *dest = destSlice;
+
+			for(int y = 0; y < external.height; y += 4)
+			{
+				for(int x = 0; x < external.width; x += 4)
+				{
+					byte X[8];
+
+					X[0] = source->x0;
+					X[1] = source->x1;
+
+					if(X[0] > X[1])
+					{
+						X[2] = (byte)((6 * (word)X[0] + 1 * (word)X[1] + 3) / 7);
+						X[3] = (byte)((5 * (word)X[0] + 2 * (word)X[1] + 3) / 7);
+						X[4] = (byte)((4 * (word)X[0] + 3 * (word)X[1] + 3) / 7);
+						X[5] = (byte)((3 * (word)X[0] + 4 * (word)X[1] + 3) / 7);
+						X[6] = (byte)((2 * (word)X[0] + 5 * (word)X[1] + 3) / 7);
+						X[7] = (byte)((1 * (word)X[0] + 6 * (word)X[1] + 3) / 7);
+					}
+					else
+					{
+						X[2] = (byte)((4 * (word)X[0] + 1 * (word)X[1] + 2) / 5);
+						X[3] = (byte)((3 * (word)X[0] + 2 * (word)X[1] + 2) / 5);
+						X[4] = (byte)((2 * (word)X[0] + 3 * (word)X[1] + 2) / 5);
+						X[5] = (byte)((1 * (word)X[0] + 4 * (word)X[1] + 2) / 5);
+						X[6] = 0;
+						X[7] = 0xFF;
+					}
+
+					byte Y[8];
+
+					Y[0] = source->y0;
+					Y[1] = source->y1;
+
+					if(Y[0] > Y[1])
+					{
+						Y[2] = (byte)((6 * (word)Y[0] + 1 * (word)Y[1] + 3) / 7);
+						Y[3] = (byte)((5 * (word)Y[0] + 2 * (word)Y[1] + 3) / 7);
+						Y[4] = (byte)((4 * (word)Y[0] + 3 * (word)Y[1] + 3) / 7);
+						Y[5] = (byte)((3 * (word)Y[0] + 4 * (word)Y[1] + 3) / 7);
+						Y[6] = (byte)((2 * (word)Y[0] + 5 * (word)Y[1] + 3) / 7);
+						Y[7] = (byte)((1 * (word)Y[0] + 6 * (word)Y[1] + 3) / 7);
+					}
+					else
+					{
+						Y[2] = (byte)((4 * (word)Y[0] + 1 * (word)Y[1] + 2) / 5);
+						Y[3] = (byte)((3 * (word)Y[0] + 2 * (word)Y[1] + 2) / 5);
+						Y[4] = (byte)((2 * (word)Y[0] + 3 * (word)Y[1] + 2) / 5);
+						Y[5] = (byte)((1 * (word)Y[0] + 4 * (word)Y[1] + 2) / 5);
+						Y[6] = 0;
+						Y[7] = 0xFF;
+					}
+
+					for(int j = 0; j < 4 && (y + j) < internal.height; j++)
+					{
+						for(int i = 0; i < 4 && (x + i) < internal.width; i++)
+						{
+							word r = X[(unsigned int)(source->xlut >> (16 + 3 * (i + j * 4))) % 8];
+							word g = Y[(unsigned int)(source->ylut >> (16 + 3 * (i + j * 4))) % 8];
+
+							dest[(x + i) + (y + j) * internal.pitchP] = (g << 8) + r;
+						}
+					}
+
+					source++;
+				}
+			}
+
+			(byte*&)destSlice += internal.sliceB;
+		}
+
+		external.unlockRect();
+		internal.unlockRect();
+	}
+
+	void Surface::decodeETC2(Buffer &internal, Buffer &external, int nbAlphaBits, bool isSRGB)
+	{
+		ETC_Decoder::Decode((const byte*)external.lockRect(0, 0, 0, LOCK_READONLY), (byte*)internal.lockRect(0, 0, 0, LOCK_UPDATE), external.width, external.height, internal.width, internal.height, internal.pitchB, internal.bytes,
+		                    (nbAlphaBits == 8) ? ETC_Decoder::ETC_RGBA : ((nbAlphaBits == 1) ? ETC_Decoder::ETC_RGB_PUNCHTHROUGH_ALPHA : ETC_Decoder::ETC_RGB));
+		external.unlockRect();
+		internal.unlockRect();
+
+		if(isSRGB)
+		{
+			static byte sRGBtoLinearTable[256];
+			static bool sRGBtoLinearTableDirty = true;
+			if(sRGBtoLinearTableDirty)
+			{
+				for(int i = 0; i < 256; i++)
+				{
+					sRGBtoLinearTable[i] = static_cast<byte>(sRGBtoLinear(static_cast<float>(i) / 255.0f) * 255.0f + 0.5f);
+				}
+				sRGBtoLinearTableDirty = false;
+			}
+
+			// Perform sRGB conversion in place after decoding
+			byte *src = (byte*)internal.lockRect(0, 0, 0, LOCK_READWRITE);
+			for(int y = 0; y < internal.height; y++)
+			{
+				byte *srcRow = src + y * internal.pitchB;
+				for(int x = 0; x <  internal.width; x++)
+				{
+					byte *srcPix = srcRow + x * internal.bytes;
+					for(int i = 0; i < 3; i++)
+					{
+						srcPix[i] = sRGBtoLinearTable[srcPix[i]];
+					}
+				}
+			}
+			internal.unlockRect();
+		}
+	}
+
+	void Surface::decodeEAC(Buffer &internal, Buffer &external, int nbChannels, bool isSigned)
+	{
+		ASSERT(nbChannels == 1 || nbChannels == 2);
+
+		byte *src = (byte*)internal.lockRect(0, 0, 0, LOCK_READWRITE);
+		ETC_Decoder::Decode((const byte*)external.lockRect(0, 0, 0, LOCK_READONLY), src, external.width, external.height, internal.width, internal.height, internal.pitchB, internal.bytes,
+		                    (nbChannels == 1) ? (isSigned ? ETC_Decoder::ETC_R_SIGNED : ETC_Decoder::ETC_R_UNSIGNED) : (isSigned ? ETC_Decoder::ETC_RG_SIGNED : ETC_Decoder::ETC_RG_UNSIGNED));
+		external.unlockRect();
+
+		// FIXME: We convert EAC data to float, until signed short internal formats are supported
+		//        This code can be removed if ETC2 images are decoded to internal 16 bit signed R/RG formats
+		const float normalization = isSigned ? (1.0f / (8.0f * 127.875f)) : (1.0f / (8.0f * 255.875f));
+		for(int y = 0; y < internal.height; y++)
+		{
+			byte* srcRow = src + y * internal.pitchB;
+			for(int x = internal.width - 1; x >= 0; x--)
+			{
+				int* srcPix = reinterpret_cast<int*>(srcRow + x * internal.bytes);
+				float* dstPix = reinterpret_cast<float*>(srcPix);
+				for(int c = nbChannels - 1; c >= 0; c--)
+				{
+					dstPix[c] = clamp(static_cast<float>(srcPix[c]) * normalization, -1.0f, 1.0f);
+				}
+			}
+		}
+
+		internal.unlockRect();
+	}
+
+	void Surface::decodeASTC(Buffer &internal, Buffer &external, int xBlockSize, int yBlockSize, int zBlockSize, bool isSRGB)
+	{
+	}
+
+	size_t Surface::size(int width, int height, int depth, int border, int samples, Format format)
+	{
+		samples = max(1, samples);
+
+		switch(format)
+		{
+		default:
+			{
+				uint64_t size = (uint64_t)sliceB(width, height, border, format, true) * depth * samples;
+
+				// FIXME: Unpacking byte4 to short4 in the sampler currently involves reading 8 bytes,
+				// and stencil operations also read 8 bytes per four 8-bit stencil values,
+				// so we have to allocate 4 extra bytes to avoid buffer overruns.
+				size += 4;
+
+				// We can only sample buffers smaller than 2 GiB.
+				// Force an out-of-memory if larger, or let the caller report an error.
+				return size < 0x80000000u ? (size_t)size : std::numeric_limits<size_t>::max();
+			}
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			{
+				width += 2 * border;
+				height += 2 * border;
+
+				size_t YStride = align<16>(width);
+				size_t YSize = YStride * height;
+				size_t CStride = align<16>(YStride / 2);
+				size_t CSize = CStride * height / 2;
+
+				return YSize + 2 * CSize;
+			}
+		}
+	}
+
+	bool Surface::isStencil(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_D32:
+		case FORMAT_D16:
+		case FORMAT_D24X8:
+		case FORMAT_D32F:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32F_SHADOW:
+			return false;
+		case FORMAT_D24S8:
+		case FORMAT_D24FS8:
+		case FORMAT_S8:
+		case FORMAT_DF24S8:
+		case FORMAT_DF16S8:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_D32FS8:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_INTZ:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isDepth(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_D32:
+		case FORMAT_D16:
+		case FORMAT_D24X8:
+		case FORMAT_D24S8:
+		case FORMAT_D24FS8:
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_DF24S8:
+		case FORMAT_DF16S8:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_INTZ:
+			return true;
+		case FORMAT_S8:
+			return false;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::hasQuadLayout(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_D32:
+		case FORMAT_D16:
+		case FORMAT_D24X8:
+		case FORMAT_D24S8:
+		case FORMAT_D24FS8:
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_DF24S8:
+		case FORMAT_DF16S8:
+		case FORMAT_INTZ:
+		case FORMAT_S8:
+		case FORMAT_A8G8R8B8Q:
+		case FORMAT_X8G8R8B8Q:
+			return true;
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		default:
+			break;
+		}
+
+		return false;
+	}
+
+	bool Surface::isPalette(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_P8:
+		case FORMAT_A8P8:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isFloatFormat(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_R5G6B5:
+		case FORMAT_R8G8B8:
+		case FORMAT_B8G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8:
+		case FORMAT_A2B10G10R10:
+		case FORMAT_A2B10G10R10UI:
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_G16R16:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+		case FORMAT_A8:
+		case FORMAT_R8I:
+		case FORMAT_R8:
+		case FORMAT_S8:
+		case FORMAT_L8:
+		case FORMAT_L16:
+		case FORMAT_A8L8:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			return false;
+		case FORMAT_R16F:
+		case FORMAT_G16R16F:
+		case FORMAT_B16G16R16F:
+		case FORMAT_X16B16G16R16F:
+		case FORMAT_A16B16G16R16F:
+		case FORMAT_X16B16G16R16F_UNSIGNED:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_B32G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_L16F:
+		case FORMAT_A16L16F:
+		case FORMAT_L32F:
+		case FORMAT_A32L32F:
+			return true;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool Surface::isUnsignedComponent(Format format, int component)
+	{
+		switch(format)
+		{
+		case FORMAT_NULL:
+		case FORMAT_R5G6B5:
+		case FORMAT_R8G8B8:
+		case FORMAT_B8G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_G8R8:
+		case FORMAT_A2B10G10R10:
+		case FORMAT_A2B10G10R10UI:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_D32F:
+		case FORMAT_D32FS8:
+		case FORMAT_D32F_COMPLEMENTARY:
+		case FORMAT_D32FS8_COMPLEMENTARY:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_L16:
+		case FORMAT_A8L8:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return true;
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_Q16W16V16U16:
+		case FORMAT_A32B32G32R32F:
+			return false;
+		case FORMAT_R32F:
+		case FORMAT_R8I:
+		case FORMAT_R16I:
+		case FORMAT_R32I:
+		case FORMAT_R8_SNORM:
+			return component >= 1;
+		case FORMAT_V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_V16U16:
+		case FORMAT_G32R32F:
+		case FORMAT_G8R8I:
+		case FORMAT_G16R16I:
+		case FORMAT_G32R32I:
+		case FORMAT_G8R8_SNORM:
+			return component >= 2;
+		case FORMAT_A16W16V16U16:
+		case FORMAT_B32G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X8B8G8R8_SNORM:
+			return component >= 3;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool Surface::isSRGBreadable(Format format)
+	{
+		// Keep in sync with Capabilities::isSRGBreadable
+		switch(format)
+		{
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_R8G8B8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_R5G6B5:
+		case FORMAT_X1R5G5B5:
+		case FORMAT_A1R5G5B5:
+		case FORMAT_A4R4G4B4:
+		case FORMAT_DXT1:
+		case FORMAT_DXT3:
+		case FORMAT_DXT5:
+		case FORMAT_ATI1:
+		case FORMAT_ATI2:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isSRGBwritable(Format format)
+	{
+		// Keep in sync with Capabilities::isSRGBwritable
+		switch(format)
+		{
+		case FORMAT_NULL:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_R5G6B5:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isSRGBformat(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isCompressed(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_DXT1:
+		case FORMAT_DXT3:
+		case FORMAT_DXT5:
+		case FORMAT_ATI1:
+		case FORMAT_ATI2:
+		case FORMAT_ETC1:
+		case FORMAT_R11_EAC:
+		case FORMAT_SIGNED_R11_EAC:
+		case FORMAT_RG11_EAC:
+		case FORMAT_SIGNED_RG11_EAC:
+		case FORMAT_RGB8_ETC2:
+		case FORMAT_SRGB8_ETC2:
+		case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_RGBA8_ETC2_EAC:
+		case FORMAT_SRGB8_ALPHA8_ETC2_EAC:
+		case FORMAT_RGBA_ASTC_4x4_KHR:
+		case FORMAT_RGBA_ASTC_5x4_KHR:
+		case FORMAT_RGBA_ASTC_5x5_KHR:
+		case FORMAT_RGBA_ASTC_6x5_KHR:
+		case FORMAT_RGBA_ASTC_6x6_KHR:
+		case FORMAT_RGBA_ASTC_8x5_KHR:
+		case FORMAT_RGBA_ASTC_8x6_KHR:
+		case FORMAT_RGBA_ASTC_8x8_KHR:
+		case FORMAT_RGBA_ASTC_10x5_KHR:
+		case FORMAT_RGBA_ASTC_10x6_KHR:
+		case FORMAT_RGBA_ASTC_10x8_KHR:
+		case FORMAT_RGBA_ASTC_10x10_KHR:
+		case FORMAT_RGBA_ASTC_12x10_KHR:
+		case FORMAT_RGBA_ASTC_12x12_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isSignedNonNormalizedInteger(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_G8R8I:
+		case FORMAT_R8I:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_G16R16I:
+		case FORMAT_R16I:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_G32R32I:
+		case FORMAT_R32I:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isUnsignedNonNormalizedInteger(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_G8R8UI:
+		case FORMAT_R8UI:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_G16R16UI:
+		case FORMAT_R16UI:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_G32R32UI:
+		case FORMAT_R32UI:
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	bool Surface::isNonNormalizedInteger(Format format)
+	{
+		return isSignedNonNormalizedInteger(format) ||
+		       isUnsignedNonNormalizedInteger(format);
+	}
+
+	bool Surface::isNormalizedInteger(Format format)
+	{
+		return !isFloatFormat(format) &&
+		       !isNonNormalizedInteger(format) &&
+		       !isCompressed(format) &&
+		       !isDepth(format) &&
+		       !isStencil(format);
+	}
+
+	int Surface::componentCount(Format format)
+	{
+		switch(format)
+		{
+		case FORMAT_R5G6B5:         return 3;
+		case FORMAT_X8R8G8B8:       return 3;
+		case FORMAT_X8B8G8R8I:      return 3;
+		case FORMAT_X8B8G8R8:       return 3;
+		case FORMAT_A8R8G8B8:       return 4;
+		case FORMAT_SRGB8_X8:       return 3;
+		case FORMAT_SRGB8_A8:       return 4;
+		case FORMAT_A8B8G8R8I:      return 4;
+		case FORMAT_A8B8G8R8:       return 4;
+		case FORMAT_G8R8I:          return 2;
+		case FORMAT_G8R8:           return 2;
+		case FORMAT_R8_SNORM:      return 1;
+		case FORMAT_G8R8_SNORM:    return 2;
+		case FORMAT_X8B8G8R8_SNORM:return 3;
+		case FORMAT_A8B8G8R8_SNORM:return 4;
+		case FORMAT_R8UI:           return 1;
+		case FORMAT_G8R8UI:         return 2;
+		case FORMAT_X8B8G8R8UI:     return 3;
+		case FORMAT_A8B8G8R8UI:     return 4;
+		case FORMAT_A2B10G10R10:    return 4;
+		case FORMAT_A2B10G10R10UI:  return 4;
+		case FORMAT_G16R16I:        return 2;
+		case FORMAT_G16R16UI:       return 2;
+		case FORMAT_G16R16:         return 2;
+		case FORMAT_G32R32I:        return 2;
+		case FORMAT_G32R32UI:       return 2;
+		case FORMAT_X16B16G16R16I:  return 3;
+		case FORMAT_X16B16G16R16UI: return 3;
+		case FORMAT_A16B16G16R16I:  return 4;
+		case FORMAT_A16B16G16R16UI: return 4;
+		case FORMAT_A16B16G16R16:   return 4;
+		case FORMAT_X32B32G32R32I:  return 3;
+		case FORMAT_X32B32G32R32UI: return 3;
+		case FORMAT_A32B32G32R32I:  return 4;
+		case FORMAT_A32B32G32R32UI: return 4;
+		case FORMAT_V8U8:           return 2;
+		case FORMAT_Q8W8V8U8:       return 4;
+		case FORMAT_X8L8V8U8:       return 3;
+		case FORMAT_V16U16:         return 2;
+		case FORMAT_A16W16V16U16:   return 4;
+		case FORMAT_Q16W16V16U16:   return 4;
+		case FORMAT_R32F:           return 1;
+		case FORMAT_G32R32F:        return 2;
+		case FORMAT_X32B32G32R32F:  return 3;
+		case FORMAT_A32B32G32R32F:  return 4;
+		case FORMAT_X32B32G32R32F_UNSIGNED: return 3;
+		case FORMAT_D32F:           return 1;
+		case FORMAT_D32FS8:         return 1;
+		case FORMAT_D32F_LOCKABLE:  return 1;
+		case FORMAT_D32FS8_TEXTURE: return 1;
+		case FORMAT_D32F_SHADOW:    return 1;
+		case FORMAT_D32FS8_SHADOW:  return 1;
+		case FORMAT_A8:             return 1;
+		case FORMAT_R8I:            return 1;
+		case FORMAT_R8:             return 1;
+		case FORMAT_R16I:           return 1;
+		case FORMAT_R16UI:          return 1;
+		case FORMAT_R32I:           return 1;
+		case FORMAT_R32UI:          return 1;
+		case FORMAT_L8:             return 1;
+		case FORMAT_L16:            return 1;
+		case FORMAT_A8L8:           return 2;
+		case FORMAT_YV12_BT601:     return 3;
+		case FORMAT_YV12_BT709:     return 3;
+		case FORMAT_YV12_JFIF:      return 3;
+		default:
+			ASSERT(false);
+		}
+
+		return 1;
+	}
+
+	void *Surface::allocateBuffer(int width, int height, int depth, int border, int samples, Format format)
+	{
+		return allocate(size(width, height, depth, border, samples, format));
+	}
+
+	void Surface::memfill4(void *buffer, int pattern, int bytes)
+	{
+		while((size_t)buffer & 0x1 && bytes >= 1)
+		{
+			*(char*)buffer = (char)pattern;
+			(char*&)buffer += 1;
+			bytes -= 1;
+		}
+
+		while((size_t)buffer & 0x3 && bytes >= 2)
+		{
+			*(short*)buffer = (short)pattern;
+			(short*&)buffer += 1;
+			bytes -= 2;
+		}
+
+		#if defined(__i386__) || defined(__x86_64__)
+			if(CPUID::supportsSSE())
+			{
+				while((size_t)buffer & 0xF && bytes >= 4)
+				{
+					*(int*)buffer = pattern;
+					(int*&)buffer += 1;
+					bytes -= 4;
+				}
+
+				__m128 quad = _mm_set_ps1((float&)pattern);
+
+				float *pointer = (float*)buffer;
+				int qxwords = bytes / 64;
+				bytes -= qxwords * 64;
+
+				while(qxwords--)
+				{
+					_mm_stream_ps(pointer + 0, quad);
+					_mm_stream_ps(pointer + 4, quad);
+					_mm_stream_ps(pointer + 8, quad);
+					_mm_stream_ps(pointer + 12, quad);
+
+					pointer += 16;
+				}
+
+				buffer = pointer;
+			}
+		#endif
+
+		while(bytes >= 4)
+		{
+			*(int*)buffer = (int)pattern;
+			(int*&)buffer += 1;
+			bytes -= 4;
+		}
+
+		while(bytes >= 2)
+		{
+			*(short*)buffer = (short)pattern;
+			(short*&)buffer += 1;
+			bytes -= 2;
+		}
+
+		while(bytes >= 1)
+		{
+			*(char*)buffer = (char)pattern;
+			(char*&)buffer += 1;
+			bytes -= 1;
+		}
+	}
+
+	void Surface::sync()
+	{
+		resource->lock(EXCLUSIVE);
+		resource->unlock();
+	}
+
+	bool Surface::isEntire(const Rect& rect) const
+	{
+		return (rect.x0 == 0 && rect.y0 == 0 && rect.x1 == internal.width && rect.y1 == internal.height && internal.depth == 1);
+	}
+
+	Rect Surface::getRect() const
+	{
+		return Rect(0, 0, internal.width, internal.height);
+	}
+
+	void Surface::clearDepth(float depth, int x0, int y0, int width, int height)
+	{
+		if(width == 0 || height == 0)
+		{
+			return;
+		}
+
+		if(internal.format == FORMAT_NULL)
+		{
+			return;
+		}
+
+		// Not overlapping
+		if(x0 > internal.width) return;
+		if(y0 > internal.height) return;
+		if(x0 + width < 0) return;
+		if(y0 + height < 0) return;
+
+		// Clip against dimensions
+		if(x0 < 0) {width += x0; x0 = 0;}
+		if(x0 + width > internal.width) width = internal.width - x0;
+		if(y0 < 0) {height += y0; y0 = 0;}
+		if(y0 + height > internal.height) height = internal.height - y0;
+
+		const bool entire = x0 == 0 && y0 == 0 && width == internal.width && height == internal.height;
+		const Lock lock = entire ? LOCK_DISCARD : LOCK_WRITEONLY;
+
+		int x1 = x0 + width;
+		int y1 = y0 + height;
+
+		if(!hasQuadLayout(internal.format))
+		{
+			float *target = (float*)lockInternal(x0, y0, 0, lock, PUBLIC);
+
+			for(int z = 0; z < internal.samples; z++)
+			{
+				float *row = target;
+				for(int y = y0; y < y1; y++)
+				{
+					memfill4(row, (int&)depth, width * sizeof(float));
+					row += internal.pitchP;
+				}
+				target += internal.sliceP;
+			}
+
+			unlockInternal();
+		}
+		else   // Quad layout
+		{
+			if(complementaryDepthBuffer)
+			{
+				depth = 1 - depth;
+			}
+
+			float *buffer = (float*)lockInternal(0, 0, 0, lock, PUBLIC);
+
+			int oddX0 = (x0 & ~1) * 2 + (x0 & 1);
+			int oddX1 = (x1 & ~1) * 2;
+			int evenX0 = ((x0 + 1) & ~1) * 2;
+			int evenBytes = (oddX1 - evenX0) * sizeof(float);
+
+			for(int z = 0; z < internal.samples; z++)
+			{
+				for(int y = y0; y < y1; y++)
+				{
+					float *target = buffer + (y & ~1) * internal.pitchP + (y & 1) * 2;
+
+					if((y & 1) == 0 && y + 1 < y1)   // Fill quad line at once
+					{
+						if((x0 & 1) != 0)
+						{
+							target[oddX0 + 0] = depth;
+							target[oddX0 + 2] = depth;
+						}
+
+					//	for(int x2 = evenX0; x2 < x1 * 2; x2 += 4)
+					//	{
+					//		target[x2 + 0] = depth;
+					//		target[x2 + 1] = depth;
+					//		target[x2 + 2] = depth;
+					//		target[x2 + 3] = depth;
+					//	}
+
+					//	__asm
+					//	{
+					//		movss xmm0, depth
+					//		shufps xmm0, xmm0, 0x00
+					//
+					//		mov eax, x0
+					//		add eax, 1
+					//		and eax, 0xFFFFFFFE
+					//		cmp eax, x1
+					//		jge qEnd
+					//
+					//		mov edi, target
+					//
+					//	qLoop:
+					//		movntps [edi+8*eax], xmm0
+					//
+					//		add eax, 2
+					//		cmp eax, x1
+					//		jl qLoop
+					//	qEnd:
+					//	}
+
+						memfill4(&target[evenX0], (int&)depth, evenBytes);
+
+						if((x1 & 1) != 0)
+						{
+							target[oddX1 + 0] = depth;
+							target[oddX1 + 2] = depth;
+						}
+
+						y++;
+					}
+					else
+					{
+						for(int x = x0, i = oddX0; x < x1; x++, i = (x & ~1) * 2 + (x & 1))
+						{
+							target[i] = depth;
+						}
+					}
+				}
+
+				buffer += internal.sliceP;
+			}
+
+			unlockInternal();
+		}
+	}
+
+	void Surface::clearStencil(unsigned char s, unsigned char mask, int x0, int y0, int width, int height)
+	{
+		if(mask == 0 || width == 0 || height == 0)
+		{
+			return;
+		}
+
+		if(stencil.format == FORMAT_NULL)
+		{
+			return;
+		}
+
+		// Not overlapping
+		if(x0 > internal.width) return;
+		if(y0 > internal.height) return;
+		if(x0 + width < 0) return;
+		if(y0 + height < 0) return;
+
+		// Clip against dimensions
+		if(x0 < 0) {width += x0; x0 = 0;}
+		if(x0 + width > internal.width) width = internal.width - x0;
+		if(y0 < 0) {height += y0; y0 = 0;}
+		if(y0 + height > internal.height) height = internal.height - y0;
+
+		int x1 = x0 + width;
+		int y1 = y0 + height;
+
+		int oddX0 = (x0 & ~1) * 2 + (x0 & 1);
+		int oddX1 = (x1 & ~1) * 2;
+		int evenX0 = ((x0 + 1) & ~1) * 2;
+		int evenBytes = oddX1 - evenX0;
+
+		unsigned char maskedS = s & mask;
+		unsigned char invMask = ~mask;
+		unsigned int fill = maskedS;
+		fill = fill | (fill << 8) | (fill << 16) | (fill << 24);
+
+		char *buffer = (char*)lockStencil(0, 0, 0, PUBLIC);
+
+		// Stencil buffers are assumed to use quad layout
+		for(int z = 0; z < stencil.samples; z++)
+		{
+			for(int y = y0; y < y1; y++)
+			{
+				char *target = buffer + (y & ~1) * stencil.pitchP + (y & 1) * 2;
+
+				if((y & 1) == 0 && y + 1 < y1 && mask == 0xFF)   // Fill quad line at once
+				{
+					if((x0 & 1) != 0)
+					{
+						target[oddX0 + 0] = fill;
+						target[oddX0 + 2] = fill;
+					}
+
+					memfill4(&target[evenX0], fill, evenBytes);
+
+					if((x1 & 1) != 0)
+					{
+						target[oddX1 + 0] = fill;
+						target[oddX1 + 2] = fill;
+					}
+
+					y++;
+				}
+				else
+				{
+					for(int x = x0; x < x1; x++)
+					{
+						int i = (x & ~1) * 2 + (x & 1);
+						target[i] = maskedS | (target[i] & invMask);
+					}
+				}
+			}
+
+			buffer += stencil.sliceP;
+		}
+
+		unlockStencil();
+	}
+
+	void Surface::fill(const Color<float> &color, int x0, int y0, int width, int height)
+	{
+		unsigned char *row;
+		Buffer *buffer;
+
+		if(internal.dirty)
+		{
+			row = (unsigned char*)lockInternal(x0, y0, 0, LOCK_WRITEONLY, PUBLIC);
+			buffer = &internal;
+		}
+		else
+		{
+			row = (unsigned char*)lockExternal(x0, y0, 0, LOCK_WRITEONLY, PUBLIC);
+			buffer = &external;
+		}
+
+		if(buffer->bytes <= 4)
+		{
+			int c;
+			buffer->write(&c, color);
+
+			if(buffer->bytes <= 1) c = (c << 8)  | c;
+			if(buffer->bytes <= 2) c = (c << 16) | c;
+
+			for(int y = 0; y < height; y++)
+			{
+				memfill4(row, c, width * buffer->bytes);
+
+				row += buffer->pitchB;
+			}
+		}
+		else   // Generic
+		{
+			for(int y = 0; y < height; y++)
+			{
+				unsigned char *element = row;
+
+				for(int x = 0; x < width; x++)
+				{
+					buffer->write(element, color);
+
+					element += buffer->bytes;
+				}
+
+				row += buffer->pitchB;
+			}
+		}
+
+		if(buffer == &internal)
+		{
+			unlockInternal();
+		}
+		else
+		{
+			unlockExternal();
+		}
+	}
+
+	void Surface::copyInternal(const Surface *source, int x, int y, float srcX, float srcY, bool filter)
+	{
+		ASSERT(internal.lock != LOCK_UNLOCKED && source && source->internal.lock != LOCK_UNLOCKED);
+
+		sw::Color<float> color;
+
+		if(!filter)
+		{
+			color = source->internal.read((int)srcX, (int)srcY, 0);
+		}
+		else   // Bilinear filtering
+		{
+			color = source->internal.sample(srcX, srcY, 0);
+		}
+
+		internal.write(x, y, color);
+	}
+
+	void Surface::copyInternal(const Surface *source, int x, int y, int z, float srcX, float srcY, float srcZ, bool filter)
+	{
+		ASSERT(internal.lock != LOCK_UNLOCKED && source && source->internal.lock != LOCK_UNLOCKED);
+
+		sw::Color<float> color;
+
+		if(!filter)
+		{
+			color = source->internal.read((int)srcX, (int)srcY, int(srcZ));
+		}
+		else   // Bilinear filtering
+		{
+			color = source->internal.sample(srcX, srcY, srcZ);
+		}
+
+		internal.write(x, y, z, color);
+	}
+
+	void Surface::copyCubeEdge(Edge dstEdge, Surface *src, Edge srcEdge)
+	{
+		Surface *dst = this;
+
+		// Figure out if the edges to be copied in reverse order respectively from one another
+		// The copy should be reversed whenever the same edges are contiguous or if we're
+		// copying top <-> right or bottom <-> left. This is explained by the layout, which is:
+		//
+		//      | +y |
+		// | -x | +z | +x | -z |
+		//      | -y |
+
+		bool reverse = (srcEdge == dstEdge) ||
+		               ((srcEdge == TOP) && (dstEdge == RIGHT)) ||
+		               ((srcEdge == RIGHT) && (dstEdge == TOP)) ||
+		               ((srcEdge == BOTTOM) && (dstEdge == LEFT)) ||
+		               ((srcEdge == LEFT) && (dstEdge == BOTTOM));
+
+		int srcBytes = src->bytes(src->Surface::getInternalFormat());
+		int srcPitch = src->getInternalPitchB();
+		int dstBytes = dst->bytes(dst->Surface::getInternalFormat());
+		int dstPitch = dst->getInternalPitchB();
+
+		int srcW = src->getWidth();
+		int srcH = src->getHeight();
+		int dstW = dst->getWidth();
+		int dstH = dst->getHeight();
+
+		ASSERT(srcW == srcH && dstW == dstH && srcW == dstW && srcBytes == dstBytes);
+
+		// Src is expressed in the regular [0, width-1], [0, height-1] space
+		int srcDelta = ((srcEdge == TOP) || (srcEdge == BOTTOM)) ? srcBytes : srcPitch;
+		int srcStart = ((srcEdge == BOTTOM) ? srcPitch * (srcH - 1) : ((srcEdge == RIGHT) ? srcBytes * (srcW - 1) : 0));
+
+		// Dst contains borders, so it is expressed in the [-1, width+1], [-1, height+1] space
+		int dstDelta = (((dstEdge == TOP) || (dstEdge == BOTTOM)) ? dstBytes : dstPitch) * (reverse ? -1 : 1);
+		int dstStart = ((dstEdge == BOTTOM) ? dstPitch * (dstH + 1) : ((dstEdge == RIGHT) ? dstBytes * (dstW + 1) : 0)) + (reverse ? dstW * -dstDelta : dstDelta);
+
+		char *srcBuf = (char*)src->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PRIVATE) + srcStart;
+		char *dstBuf = (char*)dst->lockInternal(-1, -1, 0, sw::LOCK_READWRITE, sw::PRIVATE) + dstStart;
+
+		for(int i = 0; i < srcW; ++i, dstBuf += dstDelta, srcBuf += srcDelta)
+		{
+			memcpy(dstBuf, srcBuf, srcBytes);
+		}
+
+		if(dstEdge == LEFT || dstEdge == RIGHT)
+		{
+			// TOP and BOTTOM are already set, let's average out the corners
+			int x0 = (dstEdge == RIGHT) ? dstW : -1;
+			int y0 = -1;
+			int x1 = (dstEdge == RIGHT) ? dstW - 1 : 0;
+			int y1 = 0;
+			dst->computeCubeCorner(x0, y0, x1, y1);
+			y0 = dstH;
+			y1 = dstH - 1;
+			dst->computeCubeCorner(x0, y0, x1, y1);
+		}
+
+		src->unlockInternal();
+		dst->unlockInternal();
+	}
+
+	void Surface::computeCubeCorner(int x0, int y0, int x1, int y1)
+	{
+		ASSERT(internal.lock != LOCK_UNLOCKED);
+
+		sw::Color<float> color = internal.read(x0, y1);
+		color += internal.read(x1, y0);
+		color += internal.read(x1, y1);
+		color *= (1.0f / 3.0f);
+
+		internal.write(x0, y0, color);
+	}
+
+	bool Surface::hasStencil() const
+	{
+		return isStencil(external.format);
+	}
+
+	bool Surface::hasDepth() const
+	{
+		return isDepth(external.format);
+	}
+
+	bool Surface::hasPalette() const
+	{
+		return isPalette(external.format);
+	}
+
+	bool Surface::isRenderTarget() const
+	{
+		return renderTarget;
+	}
+
+	bool Surface::hasDirtyContents() const
+	{
+		return dirtyContents;
+	}
+
+	void Surface::markContentsClean()
+	{
+		dirtyContents = false;
+	}
+
+	Resource *Surface::getResource()
+	{
+		return resource;
+	}
+
+	bool Surface::identicalBuffers() const
+	{
+		return external.format == internal.format &&
+		       external.width  == internal.width &&
+		       external.height == internal.height &&
+		       external.depth  == internal.depth &&
+		       external.pitchB == internal.pitchB &&
+		       external.sliceB == internal.sliceB &&
+		       external.border == internal.border &&
+		       external.samples == internal.samples;
+	}
+
+	Format Surface::selectInternalFormat(Format format) const
+	{
+		switch(format)
+		{
+		case FORMAT_NULL:
+			return FORMAT_NULL;
+		case FORMAT_P8:
+		case FORMAT_A8P8:
+		case FORMAT_A4R4G4B4:
+		case FORMAT_A1R5G5B5:
+		case FORMAT_A8R3G3B2:
+			return FORMAT_A8R8G8B8;
+		case FORMAT_A8:
+			return FORMAT_A8;
+		case FORMAT_R8I:
+			return FORMAT_R8I;
+		case FORMAT_R8UI:
+			return FORMAT_R8UI;
+		case FORMAT_R8_SNORM:
+			return FORMAT_R8_SNORM;
+		case FORMAT_R8:
+			return FORMAT_R8;
+		case FORMAT_R16I:
+			return FORMAT_R16I;
+		case FORMAT_R16UI:
+			return FORMAT_R16UI;
+		case FORMAT_R32I:
+			return FORMAT_R32I;
+		case FORMAT_R32UI:
+			return FORMAT_R32UI;
+		case FORMAT_X16B16G16R16I:
+			return FORMAT_X16B16G16R16I;
+		case FORMAT_A16B16G16R16I:
+			return FORMAT_A16B16G16R16I;
+		case FORMAT_X16B16G16R16UI:
+			return FORMAT_X16B16G16R16UI;
+		case FORMAT_A16B16G16R16UI:
+			return FORMAT_A16B16G16R16UI;
+		case FORMAT_A2R10G10B10:
+		case FORMAT_A2B10G10R10:
+		case FORMAT_A16B16G16R16:
+			return FORMAT_A16B16G16R16;
+		case FORMAT_A2B10G10R10UI:
+			return FORMAT_A16B16G16R16UI;
+		case FORMAT_X32B32G32R32I:
+			return FORMAT_X32B32G32R32I;
+		case FORMAT_A32B32G32R32I:
+			return FORMAT_A32B32G32R32I;
+		case FORMAT_X32B32G32R32UI:
+			return FORMAT_X32B32G32R32UI;
+		case FORMAT_A32B32G32R32UI:
+			return FORMAT_A32B32G32R32UI;
+		case FORMAT_G8R8I:
+			return FORMAT_G8R8I;
+		case FORMAT_G8R8UI:
+			return FORMAT_G8R8UI;
+		case FORMAT_G8R8_SNORM:
+			return FORMAT_G8R8_SNORM;
+		case FORMAT_G8R8:
+			return FORMAT_G8R8;
+		case FORMAT_G16R16I:
+			return FORMAT_G16R16I;
+		case FORMAT_G16R16UI:
+			return FORMAT_G16R16UI;
+		case FORMAT_G16R16:
+			return FORMAT_G16R16;
+		case FORMAT_G32R32I:
+			return FORMAT_G32R32I;
+		case FORMAT_G32R32UI:
+			return FORMAT_G32R32UI;
+		case FORMAT_A8R8G8B8:
+			if(lockable || !quadLayoutEnabled)
+			{
+				return FORMAT_A8R8G8B8;
+			}
+			else
+			{
+				return FORMAT_A8G8R8B8Q;
+			}
+		case FORMAT_A8B8G8R8I:
+			return FORMAT_A8B8G8R8I;
+		case FORMAT_A8B8G8R8UI:
+			return FORMAT_A8B8G8R8UI;
+		case FORMAT_A8B8G8R8_SNORM:
+			return FORMAT_A8B8G8R8_SNORM;
+		case FORMAT_R5G5B5A1:
+		case FORMAT_R4G4B4A4:
+		case FORMAT_A8B8G8R8:
+			return FORMAT_A8B8G8R8;
+		case FORMAT_R5G6B5:
+			return FORMAT_R5G6B5;
+		case FORMAT_R3G3B2:
+		case FORMAT_R8G8B8:
+		case FORMAT_X4R4G4B4:
+		case FORMAT_X1R5G5B5:
+		case FORMAT_X8R8G8B8:
+			if(lockable || !quadLayoutEnabled)
+			{
+				return FORMAT_X8R8G8B8;
+			}
+			else
+			{
+				return FORMAT_X8G8R8B8Q;
+			}
+		case FORMAT_X8B8G8R8I:
+			return FORMAT_X8B8G8R8I;
+		case FORMAT_X8B8G8R8UI:
+			return FORMAT_X8B8G8R8UI;
+		case FORMAT_X8B8G8R8_SNORM:
+			return FORMAT_X8B8G8R8_SNORM;
+		case FORMAT_B8G8R8:
+		case FORMAT_X8B8G8R8:
+			return FORMAT_X8B8G8R8;
+		case FORMAT_SRGB8_X8:
+			return FORMAT_SRGB8_X8;
+		case FORMAT_SRGB8_A8:
+			return FORMAT_SRGB8_A8;
+		// Compressed formats
+		case FORMAT_DXT1:
+		case FORMAT_DXT3:
+		case FORMAT_DXT5:
+		case FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+		case FORMAT_RGBA8_ETC2_EAC:
+		case FORMAT_SRGB8_ALPHA8_ETC2_EAC:
+		case FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR:
+		case FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR:
+			return FORMAT_A8R8G8B8;
+		case FORMAT_RGBA_ASTC_4x4_KHR:
+		case FORMAT_RGBA_ASTC_5x4_KHR:
+		case FORMAT_RGBA_ASTC_5x5_KHR:
+		case FORMAT_RGBA_ASTC_6x5_KHR:
+		case FORMAT_RGBA_ASTC_6x6_KHR:
+		case FORMAT_RGBA_ASTC_8x5_KHR:
+		case FORMAT_RGBA_ASTC_8x6_KHR:
+		case FORMAT_RGBA_ASTC_8x8_KHR:
+		case FORMAT_RGBA_ASTC_10x5_KHR:
+		case FORMAT_RGBA_ASTC_10x6_KHR:
+		case FORMAT_RGBA_ASTC_10x8_KHR:
+		case FORMAT_RGBA_ASTC_10x10_KHR:
+		case FORMAT_RGBA_ASTC_12x10_KHR:
+		case FORMAT_RGBA_ASTC_12x12_KHR:
+			// ASTC supports HDR, so a floating point format is required to represent it properly
+			return FORMAT_A32B32G32R32F; // FIXME: 16FP is probably sufficient, but it's currently unsupported
+		case FORMAT_ATI1:
+			return FORMAT_R8;
+		case FORMAT_R11_EAC:
+		case FORMAT_SIGNED_R11_EAC:
+			return FORMAT_R32F; // FIXME: Signed 8bit format would be sufficient
+		case FORMAT_ATI2:
+			return FORMAT_G8R8;
+		case FORMAT_RG11_EAC:
+		case FORMAT_SIGNED_RG11_EAC:
+			return FORMAT_G32R32F; // FIXME: Signed 8bit format would be sufficient
+		case FORMAT_ETC1:
+		case FORMAT_RGB8_ETC2:
+		case FORMAT_SRGB8_ETC2:
+			return FORMAT_X8R8G8B8;
+		// Bumpmap formats
+		case FORMAT_V8U8:			return FORMAT_V8U8;
+		case FORMAT_L6V5U5:			return FORMAT_X8L8V8U8;
+		case FORMAT_Q8W8V8U8:		return FORMAT_Q8W8V8U8;
+		case FORMAT_X8L8V8U8:		return FORMAT_X8L8V8U8;
+		case FORMAT_V16U16:			return FORMAT_V16U16;
+		case FORMAT_A2W10V10U10:	return FORMAT_A16W16V16U16;
+		case FORMAT_Q16W16V16U16:	return FORMAT_Q16W16V16U16;
+		// Floating-point formats
+		case FORMAT_A16F:			return FORMAT_A32B32G32R32F;
+		case FORMAT_R16F:			return FORMAT_R32F;
+		case FORMAT_G16R16F:		return FORMAT_G32R32F;
+		case FORMAT_B16G16R16F:     return FORMAT_X32B32G32R32F;
+		case FORMAT_X16B16G16R16F:	return FORMAT_X32B32G32R32F;
+		case FORMAT_A16B16G16R16F:	return FORMAT_A32B32G32R32F;
+		case FORMAT_X16B16G16R16F_UNSIGNED: return FORMAT_X32B32G32R32F_UNSIGNED;
+		case FORMAT_A32F:			return FORMAT_A32B32G32R32F;
+		case FORMAT_R32F:			return FORMAT_R32F;
+		case FORMAT_G32R32F:		return FORMAT_G32R32F;
+		case FORMAT_B32G32R32F:     return FORMAT_X32B32G32R32F;
+		case FORMAT_X32B32G32R32F:  return FORMAT_X32B32G32R32F;
+		case FORMAT_A32B32G32R32F:	return FORMAT_A32B32G32R32F;
+		case FORMAT_X32B32G32R32F_UNSIGNED: return FORMAT_X32B32G32R32F_UNSIGNED;
+		// Luminance formats
+		case FORMAT_L8:				return FORMAT_L8;
+		case FORMAT_A4L4:			return FORMAT_A8L8;
+		case FORMAT_L16:			return FORMAT_L16;
+		case FORMAT_A8L8:			return FORMAT_A8L8;
+		case FORMAT_L16F:           return FORMAT_X32B32G32R32F;
+		case FORMAT_A16L16F:        return FORMAT_A32B32G32R32F;
+		case FORMAT_L32F:           return FORMAT_X32B32G32R32F;
+		case FORMAT_A32L32F:        return FORMAT_A32B32G32R32F;
+		// Depth/stencil formats
+		case FORMAT_D16:
+		case FORMAT_D32:
+		case FORMAT_D24X8:
+			if(hasParent)   // Texture
+			{
+				return FORMAT_D32F_SHADOW;
+			}
+			else if(complementaryDepthBuffer)
+			{
+				return FORMAT_D32F_COMPLEMENTARY;
+			}
+			else
+			{
+				return FORMAT_D32F;
+			}
+		case FORMAT_D24S8:
+		case FORMAT_D24FS8:
+			if(hasParent)   // Texture
+			{
+				return FORMAT_D32FS8_SHADOW;
+			}
+			else if(complementaryDepthBuffer)
+			{
+				return FORMAT_D32FS8_COMPLEMENTARY;
+			}
+			else
+			{
+				return FORMAT_D32FS8;
+			}
+		case FORMAT_D32F:           return FORMAT_D32F;
+		case FORMAT_D32FS8:         return FORMAT_D32FS8;
+		case FORMAT_D32F_LOCKABLE:  return FORMAT_D32F_LOCKABLE;
+		case FORMAT_D32FS8_TEXTURE: return FORMAT_D32FS8_TEXTURE;
+		case FORMAT_INTZ:           return FORMAT_D32FS8_TEXTURE;
+		case FORMAT_DF24S8:         return FORMAT_D32FS8_SHADOW;
+		case FORMAT_DF16S8:         return FORMAT_D32FS8_SHADOW;
+		case FORMAT_S8:             return FORMAT_S8;
+		// YUV formats
+		case FORMAT_YV12_BT601:     return FORMAT_YV12_BT601;
+		case FORMAT_YV12_BT709:     return FORMAT_YV12_BT709;
+		case FORMAT_YV12_JFIF:      return FORMAT_YV12_JFIF;
+		default:
+			ASSERT(false);
+		}
+
+		return FORMAT_NULL;
+	}
+
+	void Surface::setTexturePalette(unsigned int *palette)
+	{
+		Surface::palette = palette;
+		Surface::paletteID++;
+	}
+
+	void Surface::resolve()
+	{
+		if(internal.samples <= 1 || !internal.dirty || !renderTarget || internal.format == FORMAT_NULL)
+		{
+			return;
+		}
+
+		ASSERT(internal.depth == 1);  // Unimplemented
+
+		void *source = internal.lockRect(0, 0, 0, LOCK_READWRITE);
+
+		int width = internal.width;
+		int height = internal.height;
+		int pitch = internal.pitchB;
+		int slice = internal.sliceB;
+
+		unsigned char *source0 = (unsigned char*)source;
+		unsigned char *source1 = source0 + slice;
+		unsigned char *source2 = source1 + slice;
+		unsigned char *source3 = source2 + slice;
+		unsigned char *source4 = source3 + slice;
+		unsigned char *source5 = source4 + slice;
+		unsigned char *source6 = source5 + slice;
+		unsigned char *source7 = source6 + slice;
+		unsigned char *source8 = source7 + slice;
+		unsigned char *source9 = source8 + slice;
+		unsigned char *sourceA = source9 + slice;
+		unsigned char *sourceB = sourceA + slice;
+		unsigned char *sourceC = sourceB + slice;
+		unsigned char *sourceD = sourceC + slice;
+		unsigned char *sourceE = sourceD + slice;
+		unsigned char *sourceF = sourceE + slice;
+
+		if(internal.format == FORMAT_X8R8G8B8 || internal.format == FORMAT_A8R8G8B8 ||
+		   internal.format == FORMAT_X8B8G8R8 || internal.format == FORMAT_A8B8G8R8 ||
+		   internal.format == FORMAT_SRGB8_X8 || internal.format == FORMAT_SRGB8_A8)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE2() && (width % 4) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+
+								c0 = _mm_avg_epu8(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+
+								c0 = _mm_avg_epu8(c0, c1);
+								c2 = _mm_avg_epu8(c2, c3);
+								c0 = _mm_avg_epu8(c0, c2);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 4 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 4 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 4 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 4 * x));
+
+								c0 = _mm_avg_epu8(c0, c1);
+								c2 = _mm_avg_epu8(c2, c3);
+								c4 = _mm_avg_epu8(c4, c5);
+								c6 = _mm_avg_epu8(c6, c7);
+								c0 = _mm_avg_epu8(c0, c2);
+								c4 = _mm_avg_epu8(c4, c6);
+								c0 = _mm_avg_epu8(c0, c4);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 4 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 4 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 4 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 4 * x));
+								__m128i c8 = _mm_load_si128((__m128i*)(source8 + 4 * x));
+								__m128i c9 = _mm_load_si128((__m128i*)(source9 + 4 * x));
+								__m128i cA = _mm_load_si128((__m128i*)(sourceA + 4 * x));
+								__m128i cB = _mm_load_si128((__m128i*)(sourceB + 4 * x));
+								__m128i cC = _mm_load_si128((__m128i*)(sourceC + 4 * x));
+								__m128i cD = _mm_load_si128((__m128i*)(sourceD + 4 * x));
+								__m128i cE = _mm_load_si128((__m128i*)(sourceE + 4 * x));
+								__m128i cF = _mm_load_si128((__m128i*)(sourceF + 4 * x));
+
+								c0 = _mm_avg_epu8(c0, c1);
+								c2 = _mm_avg_epu8(c2, c3);
+								c4 = _mm_avg_epu8(c4, c5);
+								c6 = _mm_avg_epu8(c6, c7);
+								c8 = _mm_avg_epu8(c8, c9);
+								cA = _mm_avg_epu8(cA, cB);
+								cC = _mm_avg_epu8(cC, cD);
+								cE = _mm_avg_epu8(cE, cF);
+								c0 = _mm_avg_epu8(c0, c2);
+								c4 = _mm_avg_epu8(c4, c6);
+								c8 = _mm_avg_epu8(c8, cA);
+								cC = _mm_avg_epu8(cC, cE);
+								c0 = _mm_avg_epu8(c0, c4);
+								c8 = _mm_avg_epu8(c8, cC);
+								c0 = _mm_avg_epu8(c0, c8);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				#define AVERAGE(x, y) (((x) & (y)) + ((((x) ^ (y)) >> 1) & 0x7F7F7F7F) + (((x) ^ (y)) & 0x01010101))
+
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c0 = AVERAGE(c0, c2);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c0 = AVERAGE(c0, c4);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+							unsigned int c8 = *(unsigned int*)(source8 + 4 * x);
+							unsigned int c9 = *(unsigned int*)(source9 + 4 * x);
+							unsigned int cA = *(unsigned int*)(sourceA + 4 * x);
+							unsigned int cB = *(unsigned int*)(sourceB + 4 * x);
+							unsigned int cC = *(unsigned int*)(sourceC + 4 * x);
+							unsigned int cD = *(unsigned int*)(sourceD + 4 * x);
+							unsigned int cE = *(unsigned int*)(sourceE + 4 * x);
+							unsigned int cF = *(unsigned int*)(sourceF + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c8 = AVERAGE(c8, c9);
+							cA = AVERAGE(cA, cB);
+							cC = AVERAGE(cC, cD);
+							cE = AVERAGE(cE, cF);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c8 = AVERAGE(c8, cA);
+							cC = AVERAGE(cC, cE);
+							c0 = AVERAGE(c0, c4);
+							c8 = AVERAGE(c8, cC);
+							c0 = AVERAGE(c0, c8);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+
+				#undef AVERAGE
+			}
+		}
+		else if(internal.format == FORMAT_G16R16)
+		{
+
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE2() && (width % 4) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c0 = _mm_avg_epu16(c0, c2);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 4 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 4 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 4 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 4 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c4 = _mm_avg_epu16(c4, c5);
+								c6 = _mm_avg_epu16(c6, c7);
+								c0 = _mm_avg_epu16(c0, c2);
+								c4 = _mm_avg_epu16(c4, c6);
+								c0 = _mm_avg_epu16(c0, c4);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 4 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 4 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 4 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 4 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 4 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 4 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 4 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 4 * x));
+								__m128i c8 = _mm_load_si128((__m128i*)(source8 + 4 * x));
+								__m128i c9 = _mm_load_si128((__m128i*)(source9 + 4 * x));
+								__m128i cA = _mm_load_si128((__m128i*)(sourceA + 4 * x));
+								__m128i cB = _mm_load_si128((__m128i*)(sourceB + 4 * x));
+								__m128i cC = _mm_load_si128((__m128i*)(sourceC + 4 * x));
+								__m128i cD = _mm_load_si128((__m128i*)(sourceD + 4 * x));
+								__m128i cE = _mm_load_si128((__m128i*)(sourceE + 4 * x));
+								__m128i cF = _mm_load_si128((__m128i*)(sourceF + 4 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c4 = _mm_avg_epu16(c4, c5);
+								c6 = _mm_avg_epu16(c6, c7);
+								c8 = _mm_avg_epu16(c8, c9);
+								cA = _mm_avg_epu16(cA, cB);
+								cC = _mm_avg_epu16(cC, cD);
+								cE = _mm_avg_epu16(cE, cF);
+								c0 = _mm_avg_epu16(c0, c2);
+								c4 = _mm_avg_epu16(c4, c6);
+								c8 = _mm_avg_epu16(c8, cA);
+								cC = _mm_avg_epu16(cC, cE);
+								c0 = _mm_avg_epu16(c0, c4);
+								c8 = _mm_avg_epu16(c8, cC);
+								c0 = _mm_avg_epu16(c0, c8);
+
+								_mm_store_si128((__m128i*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				#define AVERAGE(x, y) (((x) & (y)) + ((((x) ^ (y)) >> 1) & 0x7FFF7FFF) + (((x) ^ (y)) & 0x00010001))
+
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c0 = AVERAGE(c0, c2);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c0 = AVERAGE(c0, c4);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+							unsigned int c8 = *(unsigned int*)(source8 + 4 * x);
+							unsigned int c9 = *(unsigned int*)(source9 + 4 * x);
+							unsigned int cA = *(unsigned int*)(sourceA + 4 * x);
+							unsigned int cB = *(unsigned int*)(sourceB + 4 * x);
+							unsigned int cC = *(unsigned int*)(sourceC + 4 * x);
+							unsigned int cD = *(unsigned int*)(sourceD + 4 * x);
+							unsigned int cE = *(unsigned int*)(sourceE + 4 * x);
+							unsigned int cF = *(unsigned int*)(sourceF + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c8 = AVERAGE(c8, c9);
+							cA = AVERAGE(cA, cB);
+							cC = AVERAGE(cC, cD);
+							cE = AVERAGE(cE, cF);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c8 = AVERAGE(c8, cA);
+							cC = AVERAGE(cC, cE);
+							c0 = AVERAGE(c0, c4);
+							c8 = AVERAGE(c8, cC);
+							c0 = AVERAGE(c0, c8);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+
+				#undef AVERAGE
+			}
+		}
+		else if(internal.format == FORMAT_A16B16G16R16)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE2() && (width % 2) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 8 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 8 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 8 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 8 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 8 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 8 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c0 = _mm_avg_epu16(c0, c2);
+
+								_mm_store_si128((__m128i*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 8 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 8 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 8 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 8 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 8 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 8 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 8 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 8 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c4 = _mm_avg_epu16(c4, c5);
+								c6 = _mm_avg_epu16(c6, c7);
+								c0 = _mm_avg_epu16(c0, c2);
+								c4 = _mm_avg_epu16(c4, c6);
+								c0 = _mm_avg_epu16(c0, c4);
+
+								_mm_store_si128((__m128i*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 8 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 8 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 8 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 8 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 8 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 8 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 8 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 8 * x));
+								__m128i c8 = _mm_load_si128((__m128i*)(source8 + 8 * x));
+								__m128i c9 = _mm_load_si128((__m128i*)(source9 + 8 * x));
+								__m128i cA = _mm_load_si128((__m128i*)(sourceA + 8 * x));
+								__m128i cB = _mm_load_si128((__m128i*)(sourceB + 8 * x));
+								__m128i cC = _mm_load_si128((__m128i*)(sourceC + 8 * x));
+								__m128i cD = _mm_load_si128((__m128i*)(sourceD + 8 * x));
+								__m128i cE = _mm_load_si128((__m128i*)(sourceE + 8 * x));
+								__m128i cF = _mm_load_si128((__m128i*)(sourceF + 8 * x));
+
+								c0 = _mm_avg_epu16(c0, c1);
+								c2 = _mm_avg_epu16(c2, c3);
+								c4 = _mm_avg_epu16(c4, c5);
+								c6 = _mm_avg_epu16(c6, c7);
+								c8 = _mm_avg_epu16(c8, c9);
+								cA = _mm_avg_epu16(cA, cB);
+								cC = _mm_avg_epu16(cC, cD);
+								cE = _mm_avg_epu16(cE, cF);
+								c0 = _mm_avg_epu16(c0, c2);
+								c4 = _mm_avg_epu16(c4, c6);
+								c8 = _mm_avg_epu16(c8, cA);
+								cC = _mm_avg_epu16(cC, cE);
+								c0 = _mm_avg_epu16(c0, c4);
+								c8 = _mm_avg_epu16(c8, cC);
+								c0 = _mm_avg_epu16(c0, c8);
+
+								_mm_store_si128((__m128i*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				#define AVERAGE(x, y) (((x) & (y)) + ((((x) ^ (y)) >> 1) & 0x7FFF7FFF) + (((x) ^ (y)) & 0x00010001))
+
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c0 = AVERAGE(c0, c2);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c0 = AVERAGE(c0, c4);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							unsigned int c0 = *(unsigned int*)(source0 + 4 * x);
+							unsigned int c1 = *(unsigned int*)(source1 + 4 * x);
+							unsigned int c2 = *(unsigned int*)(source2 + 4 * x);
+							unsigned int c3 = *(unsigned int*)(source3 + 4 * x);
+							unsigned int c4 = *(unsigned int*)(source4 + 4 * x);
+							unsigned int c5 = *(unsigned int*)(source5 + 4 * x);
+							unsigned int c6 = *(unsigned int*)(source6 + 4 * x);
+							unsigned int c7 = *(unsigned int*)(source7 + 4 * x);
+							unsigned int c8 = *(unsigned int*)(source8 + 4 * x);
+							unsigned int c9 = *(unsigned int*)(source9 + 4 * x);
+							unsigned int cA = *(unsigned int*)(sourceA + 4 * x);
+							unsigned int cB = *(unsigned int*)(sourceB + 4 * x);
+							unsigned int cC = *(unsigned int*)(sourceC + 4 * x);
+							unsigned int cD = *(unsigned int*)(sourceD + 4 * x);
+							unsigned int cE = *(unsigned int*)(sourceE + 4 * x);
+							unsigned int cF = *(unsigned int*)(sourceF + 4 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c8 = AVERAGE(c8, c9);
+							cA = AVERAGE(cA, cB);
+							cC = AVERAGE(cC, cD);
+							cE = AVERAGE(cE, cF);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c8 = AVERAGE(c8, cA);
+							cC = AVERAGE(cC, cE);
+							c0 = AVERAGE(c0, c4);
+							c8 = AVERAGE(c8, cC);
+							c0 = AVERAGE(c0, c8);
+
+							*(unsigned int*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+
+				#undef AVERAGE
+			}
+		}
+		else if(internal.format == FORMAT_R32F)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE() && (width % 4) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 4 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 4 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 2.0f));
+
+								_mm_store_ps((float*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 4 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 4 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 4 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 4 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c0 = _mm_add_ps(c0, c2);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 4.0f));
+
+								_mm_store_ps((float*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 4 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 4 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 4 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 4 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 4 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 4 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 4 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 4 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c0 = _mm_add_ps(c0, c4);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 8.0f));
+
+								_mm_store_ps((float*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 4)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 4 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 4 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 4 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 4 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 4 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 4 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 4 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 4 * x));
+								__m128 c8 = _mm_load_ps((float*)(source8 + 4 * x));
+								__m128 c9 = _mm_load_ps((float*)(source9 + 4 * x));
+								__m128 cA = _mm_load_ps((float*)(sourceA + 4 * x));
+								__m128 cB = _mm_load_ps((float*)(sourceB + 4 * x));
+								__m128 cC = _mm_load_ps((float*)(sourceC + 4 * x));
+								__m128 cD = _mm_load_ps((float*)(sourceD + 4 * x));
+								__m128 cE = _mm_load_ps((float*)(sourceE + 4 * x));
+								__m128 cF = _mm_load_ps((float*)(sourceF + 4 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c8 = _mm_add_ps(c8, c9);
+								cA = _mm_add_ps(cA, cB);
+								cC = _mm_add_ps(cC, cD);
+								cE = _mm_add_ps(cE, cF);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c8 = _mm_add_ps(c8, cA);
+								cC = _mm_add_ps(cC, cE);
+								c0 = _mm_add_ps(c0, c4);
+								c8 = _mm_add_ps(c8, cC);
+								c0 = _mm_add_ps(c0, c8);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 16.0f));
+
+								_mm_store_ps((float*)(source0 + 4 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+
+							c0 = c0 + c1;
+							c0 *= 1.0f / 2.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c0 = c0 + c2;
+							c0 *= 1.0f / 4.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c0 = c0 + c4;
+							c0 *= 1.0f / 8.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+							float c8 = *(float*)(source8 + 4 * x);
+							float c9 = *(float*)(source9 + 4 * x);
+							float cA = *(float*)(sourceA + 4 * x);
+							float cB = *(float*)(sourceB + 4 * x);
+							float cC = *(float*)(sourceC + 4 * x);
+							float cD = *(float*)(sourceD + 4 * x);
+							float cE = *(float*)(sourceE + 4 * x);
+							float cF = *(float*)(sourceF + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c8 = c8 + c9;
+							cA = cA + cB;
+							cC = cC + cD;
+							cE = cE + cF;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c8 = c8 + cA;
+							cC = cC + cE;
+							c0 = c0 + c4;
+							c8 = c8 + cC;
+							c0 = c0 + c8;
+							c0 *= 1.0f / 16.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+			}
+		}
+		else if(internal.format == FORMAT_G32R32F)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE() && (width % 2) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 8 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 8 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 2.0f));
+
+								_mm_store_ps((float*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 8 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 8 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 8 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 8 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c0 = _mm_add_ps(c0, c2);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 4.0f));
+
+								_mm_store_ps((float*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 8 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 8 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 8 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 8 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 8 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 8 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 8 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 8 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c0 = _mm_add_ps(c0, c4);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 8.0f));
+
+								_mm_store_ps((float*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 2)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 8 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 8 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 8 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 8 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 8 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 8 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 8 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 8 * x));
+								__m128 c8 = _mm_load_ps((float*)(source8 + 8 * x));
+								__m128 c9 = _mm_load_ps((float*)(source9 + 8 * x));
+								__m128 cA = _mm_load_ps((float*)(sourceA + 8 * x));
+								__m128 cB = _mm_load_ps((float*)(sourceB + 8 * x));
+								__m128 cC = _mm_load_ps((float*)(sourceC + 8 * x));
+								__m128 cD = _mm_load_ps((float*)(sourceD + 8 * x));
+								__m128 cE = _mm_load_ps((float*)(sourceE + 8 * x));
+								__m128 cF = _mm_load_ps((float*)(sourceF + 8 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c8 = _mm_add_ps(c8, c9);
+								cA = _mm_add_ps(cA, cB);
+								cC = _mm_add_ps(cC, cD);
+								cE = _mm_add_ps(cE, cF);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c8 = _mm_add_ps(c8, cA);
+								cC = _mm_add_ps(cC, cE);
+								c0 = _mm_add_ps(c0, c4);
+								c8 = _mm_add_ps(c8, cC);
+								c0 = _mm_add_ps(c0, c8);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 16.0f));
+
+								_mm_store_ps((float*)(source0 + 8 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+
+							c0 = c0 + c1;
+							c0 *= 1.0f / 2.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c0 = c0 + c2;
+							c0 *= 1.0f / 4.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c0 = c0 + c4;
+							c0 *= 1.0f / 8.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 2 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+							float c8 = *(float*)(source8 + 4 * x);
+							float c9 = *(float*)(source9 + 4 * x);
+							float cA = *(float*)(sourceA + 4 * x);
+							float cB = *(float*)(sourceB + 4 * x);
+							float cC = *(float*)(sourceC + 4 * x);
+							float cD = *(float*)(sourceD + 4 * x);
+							float cE = *(float*)(sourceE + 4 * x);
+							float cF = *(float*)(sourceF + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c8 = c8 + c9;
+							cA = cA + cB;
+							cC = cC + cD;
+							cE = cE + cF;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c8 = c8 + cA;
+							cC = cC + cE;
+							c0 = c0 + c4;
+							c8 = c8 + cC;
+							c0 = c0 + c8;
+							c0 *= 1.0f / 16.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+			}
+		}
+		else if(internal.format == FORMAT_A32B32G32R32F ||
+		        internal.format == FORMAT_X32B32G32R32F ||
+		        internal.format == FORMAT_X32B32G32R32F_UNSIGNED)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE())
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x++)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 16 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 16 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 2.0f));
+
+								_mm_store_ps((float*)(source0 + 16 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x++)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 16 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 16 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 16 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 16 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c0 = _mm_add_ps(c0, c2);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 4.0f));
+
+								_mm_store_ps((float*)(source0 + 16 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x++)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 16 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 16 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 16 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 16 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 16 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 16 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 16 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 16 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c0 = _mm_add_ps(c0, c4);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 8.0f));
+
+								_mm_store_ps((float*)(source0 + 16 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x++)
+							{
+								__m128 c0 = _mm_load_ps((float*)(source0 + 16 * x));
+								__m128 c1 = _mm_load_ps((float*)(source1 + 16 * x));
+								__m128 c2 = _mm_load_ps((float*)(source2 + 16 * x));
+								__m128 c3 = _mm_load_ps((float*)(source3 + 16 * x));
+								__m128 c4 = _mm_load_ps((float*)(source4 + 16 * x));
+								__m128 c5 = _mm_load_ps((float*)(source5 + 16 * x));
+								__m128 c6 = _mm_load_ps((float*)(source6 + 16 * x));
+								__m128 c7 = _mm_load_ps((float*)(source7 + 16 * x));
+								__m128 c8 = _mm_load_ps((float*)(source8 + 16 * x));
+								__m128 c9 = _mm_load_ps((float*)(source9 + 16 * x));
+								__m128 cA = _mm_load_ps((float*)(sourceA + 16 * x));
+								__m128 cB = _mm_load_ps((float*)(sourceB + 16 * x));
+								__m128 cC = _mm_load_ps((float*)(sourceC + 16 * x));
+								__m128 cD = _mm_load_ps((float*)(sourceD + 16 * x));
+								__m128 cE = _mm_load_ps((float*)(sourceE + 16 * x));
+								__m128 cF = _mm_load_ps((float*)(sourceF + 16 * x));
+
+								c0 = _mm_add_ps(c0, c1);
+								c2 = _mm_add_ps(c2, c3);
+								c4 = _mm_add_ps(c4, c5);
+								c6 = _mm_add_ps(c6, c7);
+								c8 = _mm_add_ps(c8, c9);
+								cA = _mm_add_ps(cA, cB);
+								cC = _mm_add_ps(cC, cD);
+								cE = _mm_add_ps(cE, cF);
+								c0 = _mm_add_ps(c0, c2);
+								c4 = _mm_add_ps(c4, c6);
+								c8 = _mm_add_ps(c8, cA);
+								cC = _mm_add_ps(cC, cE);
+								c0 = _mm_add_ps(c0, c4);
+								c8 = _mm_add_ps(c8, cC);
+								c0 = _mm_add_ps(c0, c8);
+								c0 = _mm_mul_ps(c0, _mm_set1_ps(1.0f / 16.0f));
+
+								_mm_store_ps((float*)(source0 + 16 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 4 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+
+							c0 = c0 + c1;
+							c0 *= 1.0f / 2.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 4 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c0 = c0 + c2;
+							c0 *= 1.0f / 4.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 4 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c0 = c0 + c4;
+							c0 *= 1.0f / 8.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < 4 * width; x++)
+						{
+							float c0 = *(float*)(source0 + 4 * x);
+							float c1 = *(float*)(source1 + 4 * x);
+							float c2 = *(float*)(source2 + 4 * x);
+							float c3 = *(float*)(source3 + 4 * x);
+							float c4 = *(float*)(source4 + 4 * x);
+							float c5 = *(float*)(source5 + 4 * x);
+							float c6 = *(float*)(source6 + 4 * x);
+							float c7 = *(float*)(source7 + 4 * x);
+							float c8 = *(float*)(source8 + 4 * x);
+							float c9 = *(float*)(source9 + 4 * x);
+							float cA = *(float*)(sourceA + 4 * x);
+							float cB = *(float*)(sourceB + 4 * x);
+							float cC = *(float*)(sourceC + 4 * x);
+							float cD = *(float*)(sourceD + 4 * x);
+							float cE = *(float*)(sourceE + 4 * x);
+							float cF = *(float*)(sourceF + 4 * x);
+
+							c0 = c0 + c1;
+							c2 = c2 + c3;
+							c4 = c4 + c5;
+							c6 = c6 + c7;
+							c8 = c8 + c9;
+							cA = cA + cB;
+							cC = cC + cD;
+							cE = cE + cF;
+							c0 = c0 + c2;
+							c4 = c4 + c6;
+							c8 = c8 + cA;
+							cC = cC + cE;
+							c0 = c0 + c4;
+							c8 = c8 + cC;
+							c0 = c0 + c8;
+							c0 *= 1.0f / 16.0f;
+
+							*(float*)(source0 + 4 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+			}
+		}
+		else if(internal.format == FORMAT_R5G6B5)
+		{
+			#if defined(__i386__) || defined(__x86_64__)
+				if(CPUID::supportsSSE2() && (width % 8) == 0)
+				{
+					if(internal.samples == 2)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 8)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 2 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 2 * x));
+
+								static const ushort8 r_b = {0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F};
+								static const ushort8 _g_ = {0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0};
+								__m128i c0_r_b = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c0__g_ = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c1_r_b = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c1__g_ = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+
+								c0 = _mm_avg_epu8(c0_r_b, c1_r_b);
+								c0 = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								c1 = _mm_avg_epu16(c0__g_, c1__g_);
+								c1 = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								c0 = _mm_or_si128(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 2 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+						}
+					}
+					else if(internal.samples == 4)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 8)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 2 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 2 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 2 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 2 * x));
+
+								static const ushort8 r_b = {0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F};
+								static const ushort8 _g_ = {0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0};
+								__m128i c0_r_b = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c0__g_ = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c1_r_b = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c1__g_ = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c2_r_b = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c2__g_ = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c3_r_b = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c3__g_ = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(_g_));
+
+								c0 = _mm_avg_epu8(c0_r_b, c1_r_b);
+								c2 = _mm_avg_epu8(c2_r_b, c3_r_b);
+								c0 = _mm_avg_epu8(c0, c2);
+								c0 = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								c1 = _mm_avg_epu16(c0__g_, c1__g_);
+								c3 = _mm_avg_epu16(c2__g_, c3__g_);
+								c1 = _mm_avg_epu16(c1, c3);
+								c1 = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								c0 = _mm_or_si128(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 2 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+						}
+					}
+					else if(internal.samples == 8)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 8)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 2 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 2 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 2 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 2 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 2 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 2 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 2 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 2 * x));
+
+								static const ushort8 r_b = {0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F};
+								static const ushort8 _g_ = {0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0};
+								__m128i c0_r_b = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c0__g_ = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c1_r_b = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c1__g_ = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c2_r_b = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c2__g_ = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c3_r_b = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c3__g_ = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c4_r_b = _mm_and_si128(c4, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c4__g_ = _mm_and_si128(c4, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c5_r_b = _mm_and_si128(c5, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c5__g_ = _mm_and_si128(c5, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c6_r_b = _mm_and_si128(c6, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c6__g_ = _mm_and_si128(c6, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c7_r_b = _mm_and_si128(c7, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c7__g_ = _mm_and_si128(c7, reinterpret_cast<const __m128i&>(_g_));
+
+								c0 = _mm_avg_epu8(c0_r_b, c1_r_b);
+								c2 = _mm_avg_epu8(c2_r_b, c3_r_b);
+								c4 = _mm_avg_epu8(c4_r_b, c5_r_b);
+								c6 = _mm_avg_epu8(c6_r_b, c7_r_b);
+								c0 = _mm_avg_epu8(c0, c2);
+								c4 = _mm_avg_epu8(c4, c6);
+								c0 = _mm_avg_epu8(c0, c4);
+								c0 = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								c1 = _mm_avg_epu16(c0__g_, c1__g_);
+								c3 = _mm_avg_epu16(c2__g_, c3__g_);
+								c5 = _mm_avg_epu16(c4__g_, c5__g_);
+								c7 = _mm_avg_epu16(c6__g_, c7__g_);
+								c1 = _mm_avg_epu16(c1, c3);
+								c5 = _mm_avg_epu16(c5, c7);
+								c1 = _mm_avg_epu16(c1, c5);
+								c1 = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								c0 = _mm_or_si128(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 2 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+						}
+					}
+					else if(internal.samples == 16)
+					{
+						for(int y = 0; y < height; y++)
+						{
+							for(int x = 0; x < width; x += 8)
+							{
+								__m128i c0 = _mm_load_si128((__m128i*)(source0 + 2 * x));
+								__m128i c1 = _mm_load_si128((__m128i*)(source1 + 2 * x));
+								__m128i c2 = _mm_load_si128((__m128i*)(source2 + 2 * x));
+								__m128i c3 = _mm_load_si128((__m128i*)(source3 + 2 * x));
+								__m128i c4 = _mm_load_si128((__m128i*)(source4 + 2 * x));
+								__m128i c5 = _mm_load_si128((__m128i*)(source5 + 2 * x));
+								__m128i c6 = _mm_load_si128((__m128i*)(source6 + 2 * x));
+								__m128i c7 = _mm_load_si128((__m128i*)(source7 + 2 * x));
+								__m128i c8 = _mm_load_si128((__m128i*)(source8 + 2 * x));
+								__m128i c9 = _mm_load_si128((__m128i*)(source9 + 2 * x));
+								__m128i cA = _mm_load_si128((__m128i*)(sourceA + 2 * x));
+								__m128i cB = _mm_load_si128((__m128i*)(sourceB + 2 * x));
+								__m128i cC = _mm_load_si128((__m128i*)(sourceC + 2 * x));
+								__m128i cD = _mm_load_si128((__m128i*)(sourceD + 2 * x));
+								__m128i cE = _mm_load_si128((__m128i*)(sourceE + 2 * x));
+								__m128i cF = _mm_load_si128((__m128i*)(sourceF + 2 * x));
+
+								static const ushort8 r_b = {0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F, 0xF81F};
+								static const ushort8 _g_ = {0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0, 0x07E0};
+								__m128i c0_r_b = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c0__g_ = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c1_r_b = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c1__g_ = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c2_r_b = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c2__g_ = _mm_and_si128(c2, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c3_r_b = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c3__g_ = _mm_and_si128(c3, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c4_r_b = _mm_and_si128(c4, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c4__g_ = _mm_and_si128(c4, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c5_r_b = _mm_and_si128(c5, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c5__g_ = _mm_and_si128(c5, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c6_r_b = _mm_and_si128(c6, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c6__g_ = _mm_and_si128(c6, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c7_r_b = _mm_and_si128(c7, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c7__g_ = _mm_and_si128(c7, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c8_r_b = _mm_and_si128(c8, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c8__g_ = _mm_and_si128(c8, reinterpret_cast<const __m128i&>(_g_));
+								__m128i c9_r_b = _mm_and_si128(c9, reinterpret_cast<const __m128i&>(r_b));
+								__m128i c9__g_ = _mm_and_si128(c9, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cA_r_b = _mm_and_si128(cA, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cA__g_ = _mm_and_si128(cA, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cB_r_b = _mm_and_si128(cB, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cB__g_ = _mm_and_si128(cB, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cC_r_b = _mm_and_si128(cC, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cC__g_ = _mm_and_si128(cC, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cD_r_b = _mm_and_si128(cD, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cD__g_ = _mm_and_si128(cD, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cE_r_b = _mm_and_si128(cE, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cE__g_ = _mm_and_si128(cE, reinterpret_cast<const __m128i&>(_g_));
+								__m128i cF_r_b = _mm_and_si128(cF, reinterpret_cast<const __m128i&>(r_b));
+								__m128i cF__g_ = _mm_and_si128(cF, reinterpret_cast<const __m128i&>(_g_));
+
+								c0 = _mm_avg_epu8(c0_r_b, c1_r_b);
+								c2 = _mm_avg_epu8(c2_r_b, c3_r_b);
+								c4 = _mm_avg_epu8(c4_r_b, c5_r_b);
+								c6 = _mm_avg_epu8(c6_r_b, c7_r_b);
+								c8 = _mm_avg_epu8(c8_r_b, c9_r_b);
+								cA = _mm_avg_epu8(cA_r_b, cB_r_b);
+								cC = _mm_avg_epu8(cC_r_b, cD_r_b);
+								cE = _mm_avg_epu8(cE_r_b, cF_r_b);
+								c0 = _mm_avg_epu8(c0, c2);
+								c4 = _mm_avg_epu8(c4, c6);
+								c8 = _mm_avg_epu8(c8, cA);
+								cC = _mm_avg_epu8(cC, cE);
+								c0 = _mm_avg_epu8(c0, c4);
+								c8 = _mm_avg_epu8(c8, cC);
+								c0 = _mm_avg_epu8(c0, c8);
+								c0 = _mm_and_si128(c0, reinterpret_cast<const __m128i&>(r_b));
+								c1 = _mm_avg_epu16(c0__g_, c1__g_);
+								c3 = _mm_avg_epu16(c2__g_, c3__g_);
+								c5 = _mm_avg_epu16(c4__g_, c5__g_);
+								c7 = _mm_avg_epu16(c6__g_, c7__g_);
+								c9 = _mm_avg_epu16(c8__g_, c9__g_);
+								cB = _mm_avg_epu16(cA__g_, cB__g_);
+								cD = _mm_avg_epu16(cC__g_, cD__g_);
+								cF = _mm_avg_epu16(cE__g_, cF__g_);
+								c1 = _mm_avg_epu8(c1, c3);
+								c5 = _mm_avg_epu8(c5, c7);
+								c9 = _mm_avg_epu8(c9, cB);
+								cD = _mm_avg_epu8(cD, cF);
+								c1 = _mm_avg_epu8(c1, c5);
+								c9 = _mm_avg_epu8(c9, cD);
+								c1 = _mm_avg_epu8(c1, c9);
+								c1 = _mm_and_si128(c1, reinterpret_cast<const __m128i&>(_g_));
+								c0 = _mm_or_si128(c0, c1);
+
+								_mm_store_si128((__m128i*)(source0 + 2 * x), c0);
+							}
+
+							source0 += pitch;
+							source1 += pitch;
+							source2 += pitch;
+							source3 += pitch;
+							source4 += pitch;
+							source5 += pitch;
+							source6 += pitch;
+							source7 += pitch;
+							source8 += pitch;
+							source9 += pitch;
+							sourceA += pitch;
+							sourceB += pitch;
+							sourceC += pitch;
+							sourceD += pitch;
+							sourceE += pitch;
+							sourceF += pitch;
+						}
+					}
+					else ASSERT(false);
+				}
+				else
+			#endif
+			{
+				#define AVERAGE(x, y) (((x) & (y)) + ((((x) ^ (y)) >> 1) & 0x7BEF) + (((x) ^ (y)) & 0x0821))
+
+				if(internal.samples == 2)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned short c0 = *(unsigned short*)(source0 + 2 * x);
+							unsigned short c1 = *(unsigned short*)(source1 + 2 * x);
+
+							c0 = AVERAGE(c0, c1);
+
+							*(unsigned short*)(source0 + 2 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+					}
+				}
+				else if(internal.samples == 4)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned short c0 = *(unsigned short*)(source0 + 2 * x);
+							unsigned short c1 = *(unsigned short*)(source1 + 2 * x);
+							unsigned short c2 = *(unsigned short*)(source2 + 2 * x);
+							unsigned short c3 = *(unsigned short*)(source3 + 2 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c0 = AVERAGE(c0, c2);
+
+							*(unsigned short*)(source0 + 2 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+					}
+				}
+				else if(internal.samples == 8)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned short c0 = *(unsigned short*)(source0 + 2 * x);
+							unsigned short c1 = *(unsigned short*)(source1 + 2 * x);
+							unsigned short c2 = *(unsigned short*)(source2 + 2 * x);
+							unsigned short c3 = *(unsigned short*)(source3 + 2 * x);
+							unsigned short c4 = *(unsigned short*)(source4 + 2 * x);
+							unsigned short c5 = *(unsigned short*)(source5 + 2 * x);
+							unsigned short c6 = *(unsigned short*)(source6 + 2 * x);
+							unsigned short c7 = *(unsigned short*)(source7 + 2 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c0 = AVERAGE(c0, c4);
+
+							*(unsigned short*)(source0 + 2 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+					}
+				}
+				else if(internal.samples == 16)
+				{
+					for(int y = 0; y < height; y++)
+					{
+						for(int x = 0; x < width; x++)
+						{
+							unsigned short c0 = *(unsigned short*)(source0 + 2 * x);
+							unsigned short c1 = *(unsigned short*)(source1 + 2 * x);
+							unsigned short c2 = *(unsigned short*)(source2 + 2 * x);
+							unsigned short c3 = *(unsigned short*)(source3 + 2 * x);
+							unsigned short c4 = *(unsigned short*)(source4 + 2 * x);
+							unsigned short c5 = *(unsigned short*)(source5 + 2 * x);
+							unsigned short c6 = *(unsigned short*)(source6 + 2 * x);
+							unsigned short c7 = *(unsigned short*)(source7 + 2 * x);
+							unsigned short c8 = *(unsigned short*)(source8 + 2 * x);
+							unsigned short c9 = *(unsigned short*)(source9 + 2 * x);
+							unsigned short cA = *(unsigned short*)(sourceA + 2 * x);
+							unsigned short cB = *(unsigned short*)(sourceB + 2 * x);
+							unsigned short cC = *(unsigned short*)(sourceC + 2 * x);
+							unsigned short cD = *(unsigned short*)(sourceD + 2 * x);
+							unsigned short cE = *(unsigned short*)(sourceE + 2 * x);
+							unsigned short cF = *(unsigned short*)(sourceF + 2 * x);
+
+							c0 = AVERAGE(c0, c1);
+							c2 = AVERAGE(c2, c3);
+							c4 = AVERAGE(c4, c5);
+							c6 = AVERAGE(c6, c7);
+							c8 = AVERAGE(c8, c9);
+							cA = AVERAGE(cA, cB);
+							cC = AVERAGE(cC, cD);
+							cE = AVERAGE(cE, cF);
+							c0 = AVERAGE(c0, c2);
+							c4 = AVERAGE(c4, c6);
+							c8 = AVERAGE(c8, cA);
+							cC = AVERAGE(cC, cE);
+							c0 = AVERAGE(c0, c4);
+							c8 = AVERAGE(c8, cC);
+							c0 = AVERAGE(c0, c8);
+
+							*(unsigned short*)(source0 + 2 * x) = c0;
+						}
+
+						source0 += pitch;
+						source1 += pitch;
+						source2 += pitch;
+						source3 += pitch;
+						source4 += pitch;
+						source5 += pitch;
+						source6 += pitch;
+						source7 += pitch;
+						source8 += pitch;
+						source9 += pitch;
+						sourceA += pitch;
+						sourceB += pitch;
+						sourceC += pitch;
+						sourceD += pitch;
+						sourceE += pitch;
+						sourceF += pitch;
+					}
+				}
+				else ASSERT(false);
+
+				#undef AVERAGE
+			}
+		}
+		else
+		{
+		//	UNIMPLEMENTED();
+		}
+	}
+}
diff --git a/src/Device/Surface.hpp b/src/Device/Surface.hpp
new file mode 100644
index 0000000..10c5364
--- /dev/null
+++ b/src/Device/Surface.hpp
@@ -0,0 +1,665 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Surface_hpp
+#define sw_Surface_hpp
+
+#include "Color.hpp"
+#include "Main/Config.hpp"
+#include "Common/Resource.hpp"
+
+namespace sw
+{
+	class Resource;
+
+	template <typename T> struct RectT
+	{
+		RectT() {}
+		RectT(T x0i, T y0i, T x1i, T y1i) : x0(x0i), y0(y0i), x1(x1i), y1(y1i) {}
+
+		void clip(T minX, T minY, T maxX, T maxY)
+		{
+			x0 = clamp(x0, minX, maxX);
+			y0 = clamp(y0, minY, maxY);
+			x1 = clamp(x1, minX, maxX);
+			y1 = clamp(y1, minY, maxY);
+		}
+
+		T width() const  { return x1 - x0; }
+		T height() const { return y1 - y0; }
+
+		T x0;   // Inclusive
+		T y0;   // Inclusive
+		T x1;   // Exclusive
+		T y1;   // Exclusive
+	};
+
+	typedef RectT<int> Rect;
+	typedef RectT<float> RectF;
+
+	template<typename T> struct SliceRectT : public RectT<T>
+	{
+		SliceRectT() : slice(0) {}
+		SliceRectT(const RectT<T>& rect) : RectT<T>(rect), slice(0) {}
+		SliceRectT(const RectT<T>& rect, int s) : RectT<T>(rect), slice(s) {}
+		SliceRectT(T x0, T y0, T x1, T y1, int s) : RectT<T>(x0, y0, x1, y1), slice(s) {}
+		int slice;
+	};
+
+	typedef SliceRectT<int> SliceRect;
+	typedef SliceRectT<float> SliceRectF;
+
+	enum Format : unsigned char
+	{
+		FORMAT_NULL,
+
+		FORMAT_A8,
+		FORMAT_R8I,
+		FORMAT_R8UI,
+		FORMAT_R8_SNORM,
+		FORMAT_R8,
+		FORMAT_R16I,
+		FORMAT_R16UI,
+		FORMAT_R32I,
+		FORMAT_R32UI,
+		FORMAT_R3G3B2,
+		FORMAT_A8R3G3B2,
+		FORMAT_X4R4G4B4,
+		FORMAT_A4R4G4B4,
+		FORMAT_R4G4B4A4,
+		FORMAT_R5G6B5,
+		FORMAT_R8G8B8,
+		FORMAT_B8G8R8,
+		FORMAT_X8R8G8B8,
+		FORMAT_A8R8G8B8,
+		FORMAT_X8B8G8R8I,
+		FORMAT_X8B8G8R8UI,
+		FORMAT_X8B8G8R8_SNORM,
+		FORMAT_X8B8G8R8,
+		FORMAT_A8B8G8R8I,
+		FORMAT_A8B8G8R8UI,
+		FORMAT_A8B8G8R8_SNORM,
+		FORMAT_A8B8G8R8,
+		FORMAT_SRGB8_X8,
+		FORMAT_SRGB8_A8,
+		FORMAT_X1R5G5B5,
+		FORMAT_A1R5G5B5,
+		FORMAT_R5G5B5A1,
+		FORMAT_G8R8I,
+		FORMAT_G8R8UI,
+		FORMAT_G8R8_SNORM,
+		FORMAT_G8R8,
+		FORMAT_G16R16,
+		FORMAT_G16R16I,
+		FORMAT_G16R16UI,
+		FORMAT_G32R32I,
+		FORMAT_G32R32UI,
+		FORMAT_A2R10G10B10,
+		FORMAT_A2B10G10R10,
+		FORMAT_A2B10G10R10UI,
+		FORMAT_A16B16G16R16,
+		FORMAT_X16B16G16R16I,
+		FORMAT_X16B16G16R16UI,
+		FORMAT_A16B16G16R16I,
+		FORMAT_A16B16G16R16UI,
+		FORMAT_X32B32G32R32I,
+		FORMAT_X32B32G32R32UI,
+		FORMAT_A32B32G32R32I,
+		FORMAT_A32B32G32R32UI,
+		// Paletted formats
+		FORMAT_P8,
+		FORMAT_A8P8,
+		// Compressed formats
+		FORMAT_DXT1,
+		FORMAT_DXT3,
+		FORMAT_DXT5,
+		FORMAT_ATI1,
+		FORMAT_ATI2,
+		FORMAT_ETC1,
+		FORMAT_R11_EAC,
+		FORMAT_SIGNED_R11_EAC,
+		FORMAT_RG11_EAC,
+		FORMAT_SIGNED_RG11_EAC,
+		FORMAT_RGB8_ETC2,
+		FORMAT_SRGB8_ETC2,
+		FORMAT_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+		FORMAT_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+		FORMAT_RGBA8_ETC2_EAC,
+		FORMAT_SRGB8_ALPHA8_ETC2_EAC,
+		FORMAT_RGBA_ASTC_4x4_KHR,
+		FORMAT_RGBA_ASTC_5x4_KHR,
+		FORMAT_RGBA_ASTC_5x5_KHR,
+		FORMAT_RGBA_ASTC_6x5_KHR,
+		FORMAT_RGBA_ASTC_6x6_KHR,
+		FORMAT_RGBA_ASTC_8x5_KHR,
+		FORMAT_RGBA_ASTC_8x6_KHR,
+		FORMAT_RGBA_ASTC_8x8_KHR,
+		FORMAT_RGBA_ASTC_10x5_KHR,
+		FORMAT_RGBA_ASTC_10x6_KHR,
+		FORMAT_RGBA_ASTC_10x8_KHR,
+		FORMAT_RGBA_ASTC_10x10_KHR,
+		FORMAT_RGBA_ASTC_12x10_KHR,
+		FORMAT_RGBA_ASTC_12x12_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_4x4_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_5x4_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_5x5_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_6x5_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_6x6_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_8x5_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_8x6_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_8x8_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_10x5_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_10x6_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_10x8_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_10x10_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_12x10_KHR,
+		FORMAT_SRGB8_ALPHA8_ASTC_12x12_KHR,
+		// Floating-point formats
+		FORMAT_A16F,
+		FORMAT_R16F,
+		FORMAT_G16R16F,
+		FORMAT_B16G16R16F,
+		FORMAT_X16B16G16R16F,
+		FORMAT_A16B16G16R16F,
+		FORMAT_X16B16G16R16F_UNSIGNED,
+		FORMAT_A32F,
+		FORMAT_R32F,
+		FORMAT_G32R32F,
+		FORMAT_B32G32R32F,
+		FORMAT_X32B32G32R32F,
+		FORMAT_A32B32G32R32F,
+		FORMAT_X32B32G32R32F_UNSIGNED,
+		// Bump map formats
+		FORMAT_V8U8,
+		FORMAT_L6V5U5,
+		FORMAT_Q8W8V8U8,
+		FORMAT_X8L8V8U8,
+		FORMAT_A2W10V10U10,
+		FORMAT_V16U16,
+		FORMAT_A16W16V16U16,
+		FORMAT_Q16W16V16U16,
+		// Luminance formats
+		FORMAT_L8,
+		FORMAT_A4L4,
+		FORMAT_L16,
+		FORMAT_A8L8,
+		FORMAT_L16F,
+		FORMAT_A16L16F,
+		FORMAT_L32F,
+		FORMAT_A32L32F,
+		// Depth/stencil formats
+		FORMAT_D16,
+		FORMAT_D32,
+		FORMAT_D24X8,
+		FORMAT_D24S8,
+		FORMAT_D24FS8,
+		FORMAT_D32F,                 // Quad layout
+		FORMAT_D32FS8,               // Quad layout
+		FORMAT_D32F_COMPLEMENTARY,   // Quad layout, 1 - z
+		FORMAT_D32FS8_COMPLEMENTARY, // Quad layout, 1 - z
+		FORMAT_D32F_LOCKABLE,        // Linear layout
+		FORMAT_D32FS8_TEXTURE,       // Linear layout, no PCF
+		FORMAT_D32F_SHADOW,          // Linear layout, PCF
+		FORMAT_D32FS8_SHADOW,        // Linear layout, PCF
+		FORMAT_DF24S8,
+		FORMAT_DF16S8,
+		FORMAT_INTZ,
+		FORMAT_S8,
+		// Quad layout framebuffer
+		FORMAT_X8G8R8B8Q,
+		FORMAT_A8G8R8B8Q,
+		// YUV formats
+		FORMAT_YV12_BT601,
+		FORMAT_YV12_BT709,
+		FORMAT_YV12_JFIF,    // Full-swing BT.601
+
+		FORMAT_LAST = FORMAT_YV12_JFIF
+	};
+
+	enum Lock
+	{
+		LOCK_UNLOCKED,
+		LOCK_READONLY,
+		LOCK_WRITEONLY,
+		LOCK_READWRITE,
+		LOCK_DISCARD,
+		LOCK_UPDATE   // Write access which doesn't dirty the buffer, because it's being updated with the sibling's data.
+	};
+
+	class [[clang::lto_visibility_public]] Surface
+	{
+	private:
+		struct Buffer
+		{
+			friend Surface;
+
+		private:
+			void write(int x, int y, int z, const Color<float> &color);
+			void write(int x, int y, const Color<float> &color);
+			void write(void *element, const Color<float> &color);
+			Color<float> read(int x, int y, int z) const;
+			Color<float> read(int x, int y) const;
+			Color<float> read(void *element) const;
+			Color<float> sample(float x, float y, float z) const;
+			Color<float> sample(float x, float y, int layer) const;
+
+			void *lockRect(int x, int y, int z, Lock lock);
+			void unlockRect();
+
+			void *buffer;
+			int width;
+			int height;
+			int depth;
+			short border;
+			short samples;
+
+			int bytes;
+			int pitchB;
+			int pitchP;
+			int sliceB;
+			int sliceP;
+
+			Format format;
+			AtomicInt lock;
+
+			bool dirty;   // Sibling internal/external buffer doesn't match.
+		};
+
+	protected:
+		Surface(int width, int height, int depth, Format format, void *pixels, int pitch, int slice);
+		Surface(Resource *texture, int width, int height, int depth, int border, int samples, Format format, bool lockable, bool renderTarget, int pitchP = 0);
+
+	public:
+		static Surface *create(int width, int height, int depth, Format format, void *pixels, int pitch, int slice);
+		static Surface *create(Resource *texture, int width, int height, int depth, int border, int samples, Format format, bool lockable, bool renderTarget, int pitchP = 0);
+
+		virtual ~Surface() = 0;
+
+		inline void *lock(int x, int y, int z, Lock lock, Accessor client, bool internal = false);
+		inline void unlock(bool internal = false);
+		inline int getWidth() const;
+		inline int getHeight() const;
+		inline int getDepth() const;
+		inline int getBorder() const;
+		inline Format getFormat(bool internal = false) const;
+		inline int getPitchB(bool internal = false) const;
+		inline int getPitchP(bool internal = false) const;
+		inline int getSliceB(bool internal = false) const;
+		inline int getSliceP(bool internal = false) const;
+
+		void *lockExternal(int x, int y, int z, Lock lock, Accessor client);
+		void unlockExternal();
+		inline Format getExternalFormat() const;
+		inline int getExternalPitchB() const;
+		inline int getExternalPitchP() const;
+		inline int getExternalSliceB() const;
+		inline int getExternalSliceP() const;
+
+		virtual void *lockInternal(int x, int y, int z, Lock lock, Accessor client) = 0;
+		virtual void unlockInternal() = 0;
+		inline Format getInternalFormat() const;
+		inline int getInternalPitchB() const;
+		inline int getInternalPitchP() const;
+		inline int getInternalSliceB() const;
+		inline int getInternalSliceP() const;
+
+		void *lockStencil(int x, int y, int front, Accessor client);
+		void unlockStencil();
+		inline Format getStencilFormat() const;
+		inline int getStencilPitchB() const;
+		inline int getStencilSliceB() const;
+
+		void sync();                      // Wait for lock(s) to be released.
+		virtual bool requiresSync() const { return false; }
+		inline bool isUnlocked() const;   // Only reliable after sync().
+
+		inline int getSamples() const;
+		inline int getMultiSampleCount() const;
+		inline int getSuperSampleCount() const;
+
+		bool isEntire(const Rect& rect) const;
+		Rect getRect() const;
+		void clearDepth(float depth, int x0, int y0, int width, int height);
+		void clearStencil(unsigned char stencil, unsigned char mask, int x0, int y0, int width, int height);
+		void fill(const Color<float> &color, int x0, int y0, int width, int height);
+
+		Color<float> readExternal(int x, int y, int z) const;
+		Color<float> readExternal(int x, int y) const;
+		Color<float> sampleExternal(float x, float y, float z) const;
+		Color<float> sampleExternal(float x, float y) const;
+		void writeExternal(int x, int y, int z, const Color<float> &color);
+		void writeExternal(int x, int y, const Color<float> &color);
+
+		void copyInternal(const Surface* src, int x, int y, float srcX, float srcY, bool filter);
+		void copyInternal(const Surface* src, int x, int y, int z, float srcX, float srcY, float srcZ, bool filter);
+
+		enum Edge { TOP, BOTTOM, RIGHT, LEFT };
+		void copyCubeEdge(Edge dstEdge, Surface *src, Edge srcEdge);
+		void computeCubeCorner(int x0, int y0, int x1, int y1);
+
+		bool hasStencil() const;
+		bool hasDepth() const;
+		bool hasPalette() const;
+		bool isRenderTarget() const;
+
+		bool hasDirtyContents() const;
+		void markContentsClean();
+		inline bool isExternalDirty() const;
+		Resource *getResource();
+
+		static int bytes(Format format);
+		static int pitchB(int width, int border, Format format, bool target);
+		static int pitchP(int width, int border, Format format, bool target);
+		static int sliceB(int width, int height, int border, Format format, bool target);
+		static int sliceP(int width, int height, int border, Format format, bool target);
+		static size_t size(int width, int height, int depth, int border, int samples, Format format);
+
+		static bool isStencil(Format format);
+		static bool isDepth(Format format);
+		static bool hasQuadLayout(Format format);
+		static bool isPalette(Format format);
+
+		static bool isFloatFormat(Format format);
+		static bool isUnsignedComponent(Format format, int component);
+		static bool isSRGBreadable(Format format);
+		static bool isSRGBwritable(Format format);
+		static bool isSRGBformat(Format format);
+		static bool isCompressed(Format format);
+		static bool isSignedNonNormalizedInteger(Format format);
+		static bool isUnsignedNonNormalizedInteger(Format format);
+		static bool isNonNormalizedInteger(Format format);
+		static bool isNormalizedInteger(Format format);
+		static int componentCount(Format format);
+
+		static void setTexturePalette(unsigned int *palette);
+
+	private:
+		sw::Resource *resource;
+
+		typedef unsigned char byte;
+		typedef unsigned short word;
+		typedef unsigned int dword;
+		typedef uint64_t qword;
+
+		struct DXT1
+		{
+			word c0;
+			word c1;
+			dword lut;
+		};
+
+		struct DXT3
+		{
+			qword a;
+
+			word c0;
+			word c1;
+			dword lut;
+		};
+
+		struct DXT5
+		{
+			union
+			{
+				struct
+				{
+					byte a0;
+					byte a1;
+				};
+
+				qword alut;   // Skip first 16 bit
+			};
+
+			word c0;
+			word c1;
+			dword clut;
+		};
+
+		struct ATI2
+		{
+			union
+			{
+				struct
+				{
+					byte y0;
+					byte y1;
+				};
+
+				qword ylut;   // Skip first 16 bit
+			};
+
+			union
+			{
+				struct
+				{
+					byte x0;
+					byte x1;
+				};
+
+				qword xlut;   // Skip first 16 bit
+			};
+		};
+
+		struct ATI1
+		{
+			union
+			{
+				struct
+				{
+					byte r0;
+					byte r1;
+				};
+
+				qword rlut;   // Skip first 16 bit
+			};
+		};
+
+		static void decodeR8G8B8(Buffer &destination, Buffer &source);
+		static void decodeX1R5G5B5(Buffer &destination, Buffer &source);
+		static void decodeA1R5G5B5(Buffer &destination, Buffer &source);
+		static void decodeX4R4G4B4(Buffer &destination, Buffer &source);
+		static void decodeA4R4G4B4(Buffer &destination, Buffer &source);
+		static void decodeP8(Buffer &destination, Buffer &source);
+
+		static void decodeDXT1(Buffer &internal, Buffer &external);
+		static void decodeDXT3(Buffer &internal, Buffer &external);
+		static void decodeDXT5(Buffer &internal, Buffer &external);
+		static void decodeATI1(Buffer &internal, Buffer &external);
+		static void decodeATI2(Buffer &internal, Buffer &external);
+		static void decodeEAC(Buffer &internal, Buffer &external, int nbChannels, bool isSigned);
+		static void decodeETC2(Buffer &internal, Buffer &external, int nbAlphaBits, bool isSRGB);
+		static void decodeASTC(Buffer &internal, Buffer &external, int xSize, int ySize, int zSize, bool isSRGB);
+
+		static void update(Buffer &destination, Buffer &source);
+		static void genericUpdate(Buffer &destination, Buffer &source);
+		static void *allocateBuffer(int width, int height, int depth, int border, int samples, Format format);
+		static void memfill4(void *buffer, int pattern, int bytes);
+
+		bool identicalBuffers() const;
+		Format selectInternalFormat(Format format) const;
+
+		void resolve();
+
+		Buffer external;
+		Buffer internal;
+		Buffer stencil;
+
+		const bool lockable;
+		const bool renderTarget;
+
+		bool dirtyContents;   // Sibling surfaces need updating (mipmaps / cube borders).
+		unsigned int paletteUsed;
+
+		static unsigned int *palette;   // FIXME: Not multi-device safe
+		static unsigned int paletteID;
+
+		bool hasParent;
+		bool ownExternal;
+	};
+}
+
+#undef min
+#undef max
+
+namespace sw
+{
+	void *Surface::lock(int x, int y, int z, Lock lock, Accessor client, bool internal)
+	{
+		return internal ? lockInternal(x, y, z, lock, client) : lockExternal(x, y, z, lock, client);
+	}
+
+	void Surface::unlock(bool internal)
+	{
+		return internal ? unlockInternal() : unlockExternal();
+	}
+
+	int Surface::getWidth() const
+	{
+		return external.width;
+	}
+
+	int Surface::getHeight() const
+	{
+		return external.height;
+	}
+
+	int Surface::getDepth() const
+	{
+		return external.depth;
+	}
+
+	int Surface::getBorder() const
+	{
+		return internal.border;
+	}
+
+	Format Surface::getFormat(bool internal) const
+	{
+		return internal ? getInternalFormat() : getExternalFormat();
+	}
+
+	int Surface::getPitchB(bool internal) const
+	{
+		return internal ? getInternalPitchB() : getExternalPitchB();
+	}
+
+	int Surface::getPitchP(bool internal) const
+	{
+		return internal ? getInternalPitchP() : getExternalPitchP();
+	}
+
+	int Surface::getSliceB(bool internal) const
+	{
+		return internal ? getInternalSliceB() : getExternalSliceB();
+	}
+
+	int Surface::getSliceP(bool internal) const
+	{
+		return internal ? getInternalSliceP() : getExternalSliceP();
+	}
+
+	Format Surface::getExternalFormat() const
+	{
+		return external.format;
+	}
+
+	int Surface::getExternalPitchB() const
+	{
+		return external.pitchB;
+	}
+
+	int Surface::getExternalPitchP() const
+	{
+		return external.pitchP;
+	}
+
+	int Surface::getExternalSliceB() const
+	{
+		return external.sliceB;
+	}
+
+	int Surface::getExternalSliceP() const
+	{
+		return external.sliceP;
+	}
+
+	Format Surface::getInternalFormat() const
+	{
+		return internal.format;
+	}
+
+	int Surface::getInternalPitchB() const
+	{
+		return internal.pitchB;
+	}
+
+	int Surface::getInternalPitchP() const
+	{
+		return internal.pitchP;
+	}
+
+	int Surface::getInternalSliceB() const
+	{
+		return internal.sliceB;
+	}
+
+	int Surface::getInternalSliceP() const
+	{
+		return internal.sliceP;
+	}
+
+	Format Surface::getStencilFormat() const
+	{
+		return stencil.format;
+	}
+
+	int Surface::getStencilPitchB() const
+	{
+		return stencil.pitchB;
+	}
+
+	int Surface::getStencilSliceB() const
+	{
+		return stencil.sliceB;
+	}
+
+	int Surface::getSamples() const
+	{
+		return internal.samples;
+	}
+
+	int Surface::getMultiSampleCount() const
+	{
+		return sw::min((int)internal.samples, 4);
+	}
+
+	int Surface::getSuperSampleCount() const
+	{
+		return internal.samples > 4 ? internal.samples / 4 : 1;
+	}
+
+	bool Surface::isUnlocked() const
+	{
+		return external.lock == LOCK_UNLOCKED &&
+		       internal.lock == LOCK_UNLOCKED &&
+		       stencil.lock == LOCK_UNLOCKED;
+	}
+
+	bool Surface::isExternalDirty() const
+	{
+		return external.buffer && external.buffer != internal.buffer && external.dirty;
+	}
+}
+
+#endif   // sw_Surface_hpp
diff --git a/src/Device/SwiftConfig.cpp b/src/Device/SwiftConfig.cpp
new file mode 100644
index 0000000..1c22394
--- /dev/null
+++ b/src/Device/SwiftConfig.cpp
@@ -0,0 +1,822 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "SwiftConfig.hpp"
+
+#include "Config.hpp"
+#include "Common/Configurator.hpp"
+#include "Common/Debug.hpp"
+#include "Common/Version.h"
+
+#include <sstream>
+#include <stdio.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <algorithm>
+
+namespace sw
+{
+	extern Profiler profiler;
+
+	std::string itoa(int number)
+	{
+		std::stringstream ss;
+		ss << number;
+		return ss.str();
+	}
+
+	std::string ftoa(double number)
+	{
+		std::stringstream ss;
+		ss << number;
+		return ss.str();
+	}
+
+	SwiftConfig::SwiftConfig(bool disableServerOverride) : listenSocket(0)
+	{
+		readConfiguration(disableServerOverride);
+
+		if(!disableServerOverride)
+		{
+			writeConfiguration();
+		}
+
+		receiveBuffer = 0;
+
+		if(!config.disableServer)
+		{
+			createServer();
+		}
+	}
+
+	SwiftConfig::~SwiftConfig()
+	{
+		destroyServer();
+	}
+
+	void SwiftConfig::createServer()
+	{
+		bufferLength = 16 * 1024;
+		receiveBuffer = new char[bufferLength];
+
+		Socket::startup();
+		listenSocket = new Socket("localhost", "8080");
+		listenSocket->listen();
+
+		terminate = false;
+		serverThread = new Thread(serverRoutine, this);
+	}
+
+	void SwiftConfig::destroyServer()
+	{
+		if(receiveBuffer)
+		{
+			terminate = true;
+			serverThread->join();
+			delete serverThread;
+
+			delete listenSocket;
+			listenSocket = 0;
+
+			Socket::cleanup();
+
+			delete[] receiveBuffer;
+			receiveBuffer = 0;
+		}
+	}
+
+	bool SwiftConfig::hasNewConfiguration(bool reset)
+	{
+		bool value = newConfig;
+
+		if(reset)
+		{
+			newConfig = false;
+		}
+
+		return value;
+	}
+
+	void SwiftConfig::getConfiguration(Configuration &configuration)
+	{
+		criticalSection.lock();
+		configuration = config;
+		criticalSection.unlock();
+	}
+
+	void SwiftConfig::serverRoutine(void *parameters)
+	{
+		SwiftConfig *swiftConfig = (SwiftConfig*)parameters;
+
+		swiftConfig->serverLoop();
+	}
+
+	void SwiftConfig::serverLoop()
+	{
+		readConfiguration();
+
+		while(!terminate)
+		{
+			if(listenSocket->select(100000))
+			{
+				Socket *clientSocket = listenSocket->accept();
+				int bytesReceived = 1;
+
+				while(bytesReceived > 0 && !terminate)
+				{
+					if(clientSocket->select(10))
+					{
+						bytesReceived = clientSocket->receive(receiveBuffer, bufferLength);
+
+						if(bytesReceived > 0)
+						{
+							receiveBuffer[bytesReceived] = 0;
+
+							respond(clientSocket, receiveBuffer);
+						}
+					}
+				}
+
+				delete clientSocket;
+			}
+		}
+	}
+
+	bool match(const char **url, const char *string)
+	{
+		size_t length = strlen(string);
+
+		if(strncmp(*url, string, length) == 0)
+		{
+			*url += length;
+
+			return true;
+		}
+
+		return false;
+	}
+
+	void SwiftConfig::respond(Socket *clientSocket, const char *request)
+	{
+		if(match(&request, "GET /"))
+		{
+			if(match(&request, "swiftshader") || match(&request, "swiftconfig"))
+			{
+				if(match(&request, " ") || match(&request, "/ "))
+				{
+					return send(clientSocket, OK, page());
+				}
+			}
+		}
+		else if(match(&request, "POST /"))
+		{
+			if(match(&request, "swiftshader") || match(&request, "swiftconfig"))
+			{
+				if(match(&request, " ") || match(&request, "/ "))
+				{
+					criticalSection.lock();
+
+					const char *postData = strstr(request, "\r\n\r\n");
+					postData = postData ? postData + 4 : 0;
+
+					if(postData && strlen(postData) > 0)
+					{
+						parsePost(postData);
+					}
+					else   // POST data in next packet
+					{
+						int bytesReceived = clientSocket->receive(receiveBuffer, bufferLength);
+
+						if(bytesReceived > 0)
+						{
+							receiveBuffer[bytesReceived] = 0;
+							parsePost(receiveBuffer);
+						}
+					}
+
+					writeConfiguration();
+					newConfig = true;
+
+					if(config.disableServer)
+					{
+						destroyServer();
+					}
+
+					criticalSection.unlock();
+
+					return send(clientSocket, OK, page());
+				}
+				else if(match(&request, "/profile "))
+				{
+					return send(clientSocket, OK, profile());
+				}
+			}
+		}
+
+		return send(clientSocket, NotFound);
+	}
+
+	std::string SwiftConfig::page()
+	{
+		std::string html;
+
+		const std::string selected = "selected='selected'";
+		const std::string checked = "checked='checked'";
+		const std::string empty = "";
+
+		html += "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01//EN' 'http://www.w3.org/TR/html4/strict.dtd'>\n";
+		html += "<html>\n";
+		html += "<head>\n";
+		html += "<meta http-equiv='content-type' content='text/html; charset=UTF-8'>\n";
+		html += "<title>SwiftShader Configuration Panel</title>\n";
+		html += "</head>\n";
+		html += "<body>\n";
+		html += "<script type='text/javascript'>\n";
+		html += "request();\n";
+		html += "function request()\n";
+		html += "{\n";
+		html += "var xhr = new XMLHttpRequest();\n";
+		html += "xhr.open('POST', '/swiftshader/profile', true);\n";
+		html += "xhr.onreadystatechange = function()\n";
+		html += "{\n";
+		html += "if(xhr.readyState == 4 && xhr.status == 200)\n";
+		html += "{\n";
+		html += "document.getElementById('profile').innerHTML = xhr.responseText;\n";
+		html += "setTimeout('request()', 1000);\n";
+		html += "}\n";
+		html += "}\n";
+		html += "xhr.send();\n";
+		html += "}\n";
+		html += "</script>\n";
+		html += "<form method='POST' action=''>\n";
+		html += "<h1>SwiftShader Configuration Panel</h1>\n";
+		html += "<div id='profile'>" + profile() + "</div>\n";
+		html += "<hr><p>\n";
+		html += "<input type='submit' value='Apply changes' title='Click to apply all settings.'>\n";
+	//	html += "<input type='reset' value='Reset changes' title='Click to reset your changes to the previous value.'>\n";
+		html += "</p><hr>\n";
+		html += "<h2><em>Device capabilities</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Build revision:</td><td>" REVISION_STRING "</td></tr>\n";
+		html += "<tr><td>Pixel shader model:</td><td><select name='pixelShaderVersion' title='The highest version of pixel shader supported by SwiftShader. Lower versions might be faster if supported by the application. Only effective after restarting the application.'>\n";
+		html += "<option value='0'"  + (config.pixelShaderVersion ==  0 ? selected : empty) + ">0.0</option>\n";
+		html += "<option value='11'" + (config.pixelShaderVersion == 11 ? selected : empty) + ">1.1</option>\n";
+		html += "<option value='12'" + (config.pixelShaderVersion == 12 ? selected : empty) + ">1.2</option>\n";
+		html += "<option value='13'" + (config.pixelShaderVersion == 13 ? selected : empty) + ">1.3</option>\n";
+		html += "<option value='14'" + (config.pixelShaderVersion == 14 ? selected : empty) + ">1.4</option>\n";
+		html += "<option value='20'" + (config.pixelShaderVersion == 20 ? selected : empty) + ">2.0</option>\n";
+		html += "<option value='21'" + (config.pixelShaderVersion == 21 ? selected : empty) + ">2.x</option>\n";
+		html += "<option value='30'" + (config.pixelShaderVersion == 30 ? selected : empty) + ">3.0 (default)</option>\n";
+		html += "</select></td></tr>\n";
+		html += "<tr><td>Vertex shader model:</td><td><select name='vertexShaderVersion' title='The highest version of vertex shader supported by SwiftShader. Lower versions might be faster if supported by the application. Only effective after restarting the application.'>\n";
+		html += "<option value='0'"  + (config.vertexShaderVersion ==  0 ? selected : empty) + ">0.0</option>\n";
+		html += "<option value='11'" + (config.vertexShaderVersion == 11 ? selected : empty) + ">1.1</option>\n";
+		html += "<option value='20'" + (config.vertexShaderVersion == 20 ? selected : empty) + ">2.0</option>\n";
+		html += "<option value='21'" + (config.vertexShaderVersion == 21 ? selected : empty) + ">2.x</option>\n";
+		html += "<option value='30'" + (config.vertexShaderVersion == 30 ? selected : empty) + ">3.0 (default)</option>\n";
+		html += "</select></td></tr>\n";
+		html += "<tr><td>Texture memory:</td><td><select name='textureMemory' title='The maximum amount of memory used for textures and other resources.'>\n";
+		html += "<option value='128'"  + (config.textureMemory == 128  ? selected : empty) + ">128 MB</option>\n";
+		html += "<option value='256'"  + (config.textureMemory == 256  ? selected : empty) + ">256 MB (default)</option>\n";
+		html += "<option value='512'"  + (config.textureMemory == 512  ? selected : empty) + ">512 MB</option>\n";
+		html += "<option value='1024'" + (config.textureMemory == 1024 ? selected : empty) + ">1024 MB</option>\n";
+		html += "<option value='2048'" + (config.textureMemory == 2048 ? selected : empty) + ">2048 MB</option>\n";
+		html += "</select></td></tr>\n";
+		html += "<tr><td>Device identifier:</td><td><select name='identifier' title='The information used by some applications to determine device capabilities.'>\n";
+		html += "<option value='0'" + (config.identifier == 0 ? selected : empty) + ">Google SwiftShader (default)</option>\n";
+		html += "<option value='1'" + (config.identifier == 1 ? selected : empty) + ">NVIDIA GeForce 7900 GS</option>\n";
+		html += "<option value='2'" + (config.identifier == 2 ? selected : empty) + ">ATI Mobility Radeon X1600</option>\n";
+		html += "<option value='3'" + (config.identifier == 3 ? selected : empty) + ">Intel GMA X3100</option>\n";
+		html += "<option value='4'" + (config.identifier == 4 ? selected : empty) + ">System device</option>\n";
+		html += "</select></td></tr>\n";
+		html += "</table>\n";
+		html += "<h2><em>Cache sizes</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Vertex routine cache size:</td><td><select name='vertexRoutineCacheSize' title='The number of dynamically generated vertex processing routines being cached for reuse. Lower numbers save memory but require more routines to be regenerated.'>\n";
+		html += "<option value='64'"   + (config.vertexRoutineCacheSize == 64   ? selected : empty) + ">64</option>\n";
+		html += "<option value='128'"  + (config.vertexRoutineCacheSize == 128  ? selected : empty) + ">128</option>\n";
+		html += "<option value='256'"  + (config.vertexRoutineCacheSize == 256  ? selected : empty) + ">256</option>\n";
+		html += "<option value='512'"  + (config.vertexRoutineCacheSize == 512  ? selected : empty) + ">512</option>\n";
+		html += "<option value='1024'" + (config.vertexRoutineCacheSize == 1024 ? selected : empty) + ">1024 (default)</option>\n";
+		html += "<option value='2048'" + (config.vertexRoutineCacheSize == 2048 ? selected : empty) + ">2048</option>\n";
+		html += "<option value='4096'" + (config.vertexRoutineCacheSize == 4096 ? selected : empty) + ">4096</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Pixel routine cache size:</td><td><select name='pixelRoutineCacheSize' title='The number of dynamically generated pixel processing routines being cached for reuse. Lower numbers save memory but require more routines to be regenerated.'>\n";
+		html += "<option value='64'"   + (config.pixelRoutineCacheSize == 64   ? selected : empty) + ">64</option>\n";
+		html += "<option value='128'"  + (config.pixelRoutineCacheSize == 128  ? selected : empty) + ">128</option>\n";
+		html += "<option value='256'"  + (config.pixelRoutineCacheSize == 256  ? selected : empty) + ">256</option>\n";
+		html += "<option value='512'"  + (config.pixelRoutineCacheSize == 512  ? selected : empty) + ">512</option>\n";
+		html += "<option value='1024'" + (config.pixelRoutineCacheSize == 1024 ? selected : empty) + ">1024 (default)</option>\n";
+		html += "<option value='2048'" + (config.pixelRoutineCacheSize == 2048 ? selected : empty) + ">2048</option>\n";
+		html += "<option value='4096'" + (config.pixelRoutineCacheSize == 4096 ? selected : empty) + ">4096</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Setup routine cache size:</td><td><select name='setupRoutineCacheSize' title='The number of dynamically generated primitive setup routines being cached for reuse. Lower numbers save memory but require more routines to be regenerated.'>\n";
+		html += "<option value='64'"   + (config.setupRoutineCacheSize == 64   ? selected : empty) + ">64</option>\n";
+		html += "<option value='128'"  + (config.setupRoutineCacheSize == 128  ? selected : empty) + ">128</option>\n";
+		html += "<option value='256'"  + (config.setupRoutineCacheSize == 256  ? selected : empty) + ">256</option>\n";
+		html += "<option value='512'"  + (config.setupRoutineCacheSize == 512  ? selected : empty) + ">512</option>\n";
+		html += "<option value='1024'" + (config.setupRoutineCacheSize == 1024 ? selected : empty) + ">1024 (default)</option>\n";
+		html += "<option value='2048'" + (config.setupRoutineCacheSize == 2048 ? selected : empty) + ">2048</option>\n";
+		html += "<option value='4096'" + (config.setupRoutineCacheSize == 4096 ? selected : empty) + ">4096</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Vertex cache size:</td><td><select name='vertexCacheSize' title='The number of processed vertices being cached for reuse. Lower numbers save memory but require more vertices to be reprocessed.'>\n";
+		html += "<option value='64'"   + (config.vertexCacheSize == 64   ? selected : empty) + ">64 (default)</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "</table>\n";
+		html += "<h2><em>Quality</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Maximum texture sampling quality:</td><td><select name='textureSampleQuality' title='The maximum texture filtering quality. Lower settings can be faster but cause visual artifacts.'>\n";
+		html += "<option value='0'" + (config.textureSampleQuality == 0 ? selected : empty) + ">Point</option>\n";
+		html += "<option value='1'" + (config.textureSampleQuality == 1 ? selected : empty) + ">Linear</option>\n";
+		html += "<option value='2'" + (config.textureSampleQuality == 2 ? selected : empty) + ">Anisotropic (default)</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Maximum mipmapping quality:</td><td><select name='mipmapQuality' title='The maximum mipmap filtering quality. Higher settings can be more visually appealing but are slower.'>\n";
+		html += "<option value='0'" + (config.mipmapQuality == 0 ? selected : empty) + ">Point</option>\n";
+		html += "<option value='1'" + (config.mipmapQuality == 1 ? selected : empty) + ">Linear (default)</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Perspective correction:</td><td><select name='perspectiveCorrection' title='Enables or disables perspective correction. Disabling it is faster but can causes distortion. Recommended for 2D applications only.'>\n";
+		html += "<option value='0'" + (config.perspectiveCorrection == 0 ? selected : empty) + ">Off</option>\n";
+		html += "<option value='1'" + (config.perspectiveCorrection == 1 ? selected : empty) + ">On (default)</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Transcendental function precision:</td><td><select name='transcendentalPrecision' title='The precision at which log/exp/pow/rcp/rsq/nrm shader instructions are computed. Lower settings can be faster but cause visual artifacts.'>\n";
+		html += "<option value='0'" + (config.transcendentalPrecision == 0 ? selected : empty) + ">Approximate</option>\n";
+		html += "<option value='1'" + (config.transcendentalPrecision == 1 ? selected : empty) + ">Partial</option>\n";
+		html += "<option value='2'" + (config.transcendentalPrecision == 2 ? selected : empty) + ">Accurate (default)</option>\n";
+		html += "<option value='3'" + (config.transcendentalPrecision == 3 ? selected : empty) + ">WHQL</option>\n";
+		html += "<option value='4'" + (config.transcendentalPrecision == 4 ? selected : empty) + ">IEEE</option>\n";
+		html += "</select></td>\n";
+		html += "</tr>\n";
+		html += "<tr><td>Transparency anti-aliasing:</td><td><select name='transparencyAntialiasing' title='The technique used to anti-alias alpha-tested transparent textures.'>\n";
+		html += "<option value='0'" + (config.transparencyAntialiasing == 0 ? selected : empty) + ">None (default)</option>\n";
+		html += "<option value='1'" + (config.transparencyAntialiasing == 1 ? selected : empty) + ">Alpha-to-Coverage</option>\n";
+		html += "</select></td>\n";
+		html += "</table>\n";
+		html += "<h2><em>Processor settings</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Number of threads:</td><td><select name='threadCount' title='The number of rendering threads to be used.'>\n";
+		html += "<option value='-1'" + (config.threadCount == -1 ? selected : empty) + ">Core count</option>\n";
+		html += "<option value='0'"  + (config.threadCount == 0  ? selected : empty) + ">Process affinity (default)</option>\n";
+		html += "<option value='1'"  + (config.threadCount == 1  ? selected : empty) + ">1</option>\n";
+		html += "<option value='2'"  + (config.threadCount == 2  ? selected : empty) + ">2</option>\n";
+		html += "<option value='3'"  + (config.threadCount == 3  ? selected : empty) + ">3</option>\n";
+		html += "<option value='4'"  + (config.threadCount == 4  ? selected : empty) + ">4</option>\n";
+		html += "<option value='5'"  + (config.threadCount == 5  ? selected : empty) + ">5</option>\n";
+		html += "<option value='6'"  + (config.threadCount == 6  ? selected : empty) + ">6</option>\n";
+		html += "<option value='7'"  + (config.threadCount == 7  ? selected : empty) + ">7</option>\n";
+		html += "<option value='8'"  + (config.threadCount == 8  ? selected : empty) + ">8</option>\n";
+		html += "<option value='9'"  + (config.threadCount == 9  ? selected : empty) + ">9</option>\n";
+		html += "<option value='10'" + (config.threadCount == 10 ? selected : empty) + ">10</option>\n";
+		html += "<option value='11'" + (config.threadCount == 11 ? selected : empty) + ">11</option>\n";
+		html += "<option value='12'" + (config.threadCount == 12 ? selected : empty) + ">12</option>\n";
+		html += "<option value='13'" + (config.threadCount == 13 ? selected : empty) + ">13</option>\n";
+		html += "<option value='14'" + (config.threadCount == 14 ? selected : empty) + ">14</option>\n";
+		html += "<option value='15'" + (config.threadCount == 15 ? selected : empty) + ">15</option>\n";
+		html += "<option value='16'" + (config.threadCount == 16 ? selected : empty) + ">16</option>\n";
+		html += "</select></td></tr>\n";
+		html += "<tr><td>Enable SSE:</td><td><input name = 'enableSSE' type='checkbox'" + (config.enableSSE ? checked : empty) + " disabled='disabled' title='If checked enables the use of SSE instruction set extentions if supported by the CPU.'></td></tr>";
+		html += "<tr><td>Enable SSE2:</td><td><input name = 'enableSSE2' type='checkbox'" + (config.enableSSE2 ? checked : empty) + " title='If checked enables the use of SSE2 instruction set extentions if supported by the CPU.'></td></tr>";
+		html += "<tr><td>Enable SSE3:</td><td><input name = 'enableSSE3' type='checkbox'" + (config.enableSSE3 ? checked : empty) + " title='If checked enables the use of SSE3 instruction set extentions if supported by the CPU.'></td></tr>";
+		html += "<tr><td>Enable SSSE3:</td><td><input name = 'enableSSSE3' type='checkbox'" + (config.enableSSSE3 ? checked : empty) + " title='If checked enables the use of SSSE3 instruction set extentions if supported by the CPU.'></td></tr>";
+		html += "<tr><td>Enable SSE4.1:</td><td><input name = 'enableSSE4_1' type='checkbox'" + (config.enableSSE4_1 ? checked : empty) + " title='If checked enables the use of SSE4.1 instruction set extentions if supported by the CPU.'></td></tr>";
+		html += "</table>\n";
+		html += "<h2><em>Compiler optimizations</em></h2>\n";
+		html += "<table>\n";
+
+		for(int pass = 0; pass < 10; pass++)
+		{
+			html += "<tr><td>Optimization pass " + itoa(pass + 1) + ":</td><td><select name='optimization" + itoa(pass + 1) + "' title='An optimization pass for the shader compiler.'>\n";
+			html += "<option value='0'"  + (config.optimization[pass] == 0  ? selected : empty) + ">Disabled" + (pass > 0 ? " (default)" : "") + "</option>\n";
+			html += "<option value='1'"  + (config.optimization[pass] == 1  ? selected : empty) + ">Instruction Combining" + (pass == 0 ? " (default)" : "") + "</option>\n";
+			html += "<option value='2'"  + (config.optimization[pass] == 2  ? selected : empty) + ">Control Flow Simplification</option>\n";
+			html += "<option value='3'"  + (config.optimization[pass] == 3  ? selected : empty) + ">Loop Invariant Code Motion</option>\n";
+			html += "<option value='4'"  + (config.optimization[pass] == 4  ? selected : empty) + ">Aggressive Dead Code Elimination</option>\n";
+			html += "<option value='5'"  + (config.optimization[pass] == 5  ? selected : empty) + ">Global Value Numbering</option>\n";
+			html += "<option value='6'"  + (config.optimization[pass] == 6  ? selected : empty) + ">Commutative Expressions Reassociation</option>\n";
+			html += "<option value='7'"  + (config.optimization[pass] == 7  ? selected : empty) + ">Dead Store Elimination</option>\n";
+			html += "<option value='8'"  + (config.optimization[pass] == 8  ? selected : empty) + ">Sparse Conditional Copy Propagation</option>\n";
+			html += "<option value='9'"  + (config.optimization[pass] == 9  ? selected : empty) + ">Scalar Replacement of Aggregates</option>\n";
+			html += "</select></td></tr>\n";
+		}
+
+		html += "</table>\n";
+		html += "<h2><em>Testing & Experimental</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Disable SwiftConfig server:</td><td><input name = 'disableServer' type='checkbox'" + (config.disableServer == true ? checked : empty) + " title='If checked disables the web browser based control panel.'></td></tr>";
+		html += "<tr><td>Force windowed mode:</td><td><input name = 'forceWindowed' type='checkbox'" + (config.forceWindowed == true ? checked : empty) + " title='If checked prevents the application from switching to full-screen mode.'></td></tr>";
+		html += "<tr><td>Complementary depth buffer:</td><td><input name = 'complementaryDepthBuffer' type='checkbox'" + (config.complementaryDepthBuffer == true ? checked : empty) + " title='If checked causes 1 - z to be stored in the depth buffer.'></td></tr>";
+		html += "<tr><td>Post alpha blend sRGB conversion:</td><td><input name = 'postBlendSRGB' type='checkbox'" + (config.postBlendSRGB == true ? checked : empty) + " title='If checked alpha blending is performed in linear color space.'></td></tr>";
+		html += "<tr><td>Exact color rounding:</td><td><input name = 'exactColorRounding' type='checkbox'" + (config.exactColorRounding == true ? checked : empty) + " title='If checked color rounding is done at high accuracy.'></td></tr>";
+		html += "<tr><td>Disable alpha display formats:</td><td><input name = 'disableAlphaMode' type='checkbox'" + (config.disableAlphaMode == true ? checked : empty) + " title='If checked the device does not advertise the A8R8G8B8 display mode.'></td></tr>";
+		html += "<tr><td>Disable 10-bit display formats:</td><td><input name = 'disable10BitMode' type='checkbox'" + (config.disable10BitMode == true ? checked : empty) + " title='If checked the device does not advertise the A2R10G10B10 display mode.'></td></tr>";
+		html += "<tr><td>Frame-buffer API:</td><td><select name='frameBufferAPI' title='The API used for displaying the rendered result on screen (requires restart).'>\n";
+		html += "<option value='0'" + (config.frameBufferAPI == 0 ? selected : empty) + ">DirectDraw (default)</option>\n";
+		html += "<option value='1'" + (config.frameBufferAPI == 1 ? selected : empty) + ">GDI</option>\n";
+		html += "</select></td>\n";
+		html += "<tr><td>DLL precaching:</td><td><input name = 'precache' type='checkbox'" + (config.precache == true ? checked : empty) + " title='If checked dynamically generated routines will be stored in a DLL for faster loading on application restart.'></td></tr>";
+		html += "<tr><td>Shadow mapping extensions:</td><td><select name='shadowMapping' title='Features that may accelerate or improve the quality of shadow mapping.'>\n";
+		html += "<option value='0'" + (config.shadowMapping == 0 ? selected : empty) + ">None</option>\n";
+		html += "<option value='1'" + (config.shadowMapping == 1 ? selected : empty) + ">Fetch4</option>\n";
+		html += "<option value='2'" + (config.shadowMapping == 2 ? selected : empty) + ">DST</option>\n";
+		html += "<option value='3'" + (config.shadowMapping == 3 ? selected : empty) + ">Fetch4 & DST (default)</option>\n";
+		html += "</select></td>\n";
+		html += "<tr><td>Force clearing registers that have no default value:</td><td><input name = 'forceClearRegisters' type='checkbox'" + (config.forceClearRegisters == true ? checked : empty) + " title='Initializes shader register values to 0 even if they have no default.'></td></tr>";
+		html += "</table>\n";
+	#ifndef NDEBUG
+		html += "<h2><em>Debugging</em></h2>\n";
+		html += "<table>\n";
+		html += "<tr><td>Minimum primitives:</td><td><input type='text' size='10' maxlength='10' name='minPrimitives' value='" + itoa(config.minPrimitives) + "'></td></tr>\n";
+		html += "<tr><td>Maximum primitives:</td><td><input type='text' size='10' maxlength='10' name='maxPrimitives' value='" + itoa(config.maxPrimitives) + "'></td></tr>\n";
+		html += "</table>\n";
+	#endif
+		html += "<hr><p>\n";
+		html += "<span style='font-size:10pt'>Hover the mouse pointer over a control to get additional information.</span><br>\n";
+		html += "<span style='font-size:10pt'>Some settings can be applied interactively, some need a restart of the application.</span><br>\n";
+		html += "<span style='font-size:10pt'>Removing the SwiftShader.ini file results in resetting the options to their default.</span></p>\n";
+		html += "</form>\n";
+		html += "</body>\n";
+		html += "</html>\n";
+
+		profiler.reset();
+
+		return html;
+	}
+
+	std::string SwiftConfig::profile()
+	{
+		std::string html;
+
+		html += "<p>FPS: " + ftoa(profiler.FPS) + "</p>\n";
+		html += "<p>Frame: " + itoa(profiler.framesTotal) + "</p>\n";
+
+		#if PERF_PROFILE
+			int texTime = (int)(1000 * profiler.cycles[PERF_TEX] / profiler.cycles[PERF_PIXEL] + 0.5);
+			int shaderTime = (int)(1000 * profiler.cycles[PERF_SHADER] / profiler.cycles[PERF_PIXEL] + 0.5);
+			int pipeTime = (int)(1000 * profiler.cycles[PERF_PIPE] / profiler.cycles[PERF_PIXEL] + 0.5);
+			int ropTime = (int)(1000 * profiler.cycles[PERF_ROP] / profiler.cycles[PERF_PIXEL] + 0.5);
+			int interpTime = (int)(1000 * profiler.cycles[PERF_INTERP] / profiler.cycles[PERF_PIXEL] + 0.5);
+			int rastTime = 1000 - pipeTime;
+
+			pipeTime -= shaderTime + ropTime + interpTime;
+			shaderTime -= texTime;
+
+			double texTimeF = (double)texTime / 10;
+			double shaderTimeF = (double)shaderTime / 10;
+			double pipeTimeF = (double)pipeTime / 10;
+			double ropTimeF = (double)ropTime / 10;
+			double interpTimeF = (double)interpTime / 10;
+			double rastTimeF = (double)rastTime / 10;
+
+			double averageRopOperations = profiler.ropOperationsTotal / std::max(profiler.framesTotal, 1) / 1.0e6f;
+			double averageCompressedTex = profiler.compressedTexTotal / std::max(profiler.framesTotal, 1) / 1.0e6f;
+			double averageTexOperations = profiler.texOperationsTotal / std::max(profiler.framesTotal, 1) / 1.0e6f;
+
+			html += "<p>Raster operations (million): " + ftoa(profiler.ropOperationsFrame / 1.0e6f) + " (current), " + ftoa(averageRopOperations) + " (average)</p>\n";
+			html += "<p>Texture operations (million): " + ftoa(profiler.texOperationsFrame / 1.0e6f) + " (current), " + ftoa(averageTexOperations) + " (average)</p>\n";
+			html += "<p>Compressed texture operations (million): " + ftoa(profiler.compressedTexFrame / 1.0e6f) + " (current), " + ftoa(averageCompressedTex) + " (average)</p>\n";
+			html += "<div id='profile' style='position:relative; width:1010px; height:50px; background-color:silver;'>";
+			html += "<div style='position:relative; width:1000px; height:40px; background-color:white; left:5px; top:5px;'>";
+			html += "<div style='position:relative; float:left; width:" + itoa(rastTime)   + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#FFFF7F; overflow:hidden;'>" + ftoa(rastTimeF)   + "% rast</div>\n";
+			html += "<div style='position:relative; float:left; width:" + itoa(pipeTime)   + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#FF7F7F; overflow:hidden;'>" + ftoa(pipeTimeF)   + "% pipe</div>\n";
+			html += "<div style='position:relative; float:left; width:" + itoa(interpTime) + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#7FFFFF; overflow:hidden;'>" + ftoa(interpTimeF) + "% interp</div>\n";
+			html += "<div style='position:relative; float:left; width:" + itoa(shaderTime) + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#7FFF7F; overflow:hidden;'>" + ftoa(shaderTimeF) + "% shader</div>\n";
+			html += "<div style='position:relative; float:left; width:" + itoa(texTime)    + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#FF7FFF; overflow:hidden;'>" + ftoa(texTimeF)    + "% tex</div>\n";
+			html += "<div style='position:relative; float:left; width:" + itoa(ropTime)    + "px; height:40px; border-style:none; text-align:center; line-height:40px; background-color:#7F7FFF; overflow:hidden;'>" + ftoa(ropTimeF)    + "% rop</div>\n";
+			html += "</div></div>\n";
+
+			for(int i = 0; i < PERF_TIMERS; i++)
+			{
+				profiler.cycles[i] = 0;
+			}
+		#endif
+
+		return html;
+	}
+
+	void SwiftConfig::send(Socket *clientSocket, Status code, std::string body)
+	{
+		std::string status;
+		char header[1024];
+
+		switch(code)
+		{
+		case OK:       status += "HTTP/1.1 200 OK\r\n";        break;
+		case NotFound: status += "HTTP/1.1 404 Not Found\r\n"; break;
+		}
+
+		sprintf(header, "Content-Type: text/html; charset=UTF-8\r\n"
+						"Content-Length: %zd\r\n"
+						"Host: localhost\r\n"
+						"\r\n", body.size());
+
+		std::string message = status + header + body;
+		clientSocket->send(message.c_str(), (int)message.length());
+	}
+
+	void SwiftConfig::parsePost(const char *post)
+	{
+		// Only enabled checkboxes appear in the POST
+		config.enableSSE = true;
+		config.enableSSE2 = false;
+		config.enableSSE3 = false;
+		config.enableSSSE3 = false;
+		config.enableSSE4_1 = false;
+		config.disableServer = false;
+		config.forceWindowed = false;
+		config.complementaryDepthBuffer = false;
+		config.postBlendSRGB = false;
+		config.exactColorRounding = false;
+		config.disableAlphaMode = false;
+		config.disable10BitMode = false;
+		config.precache = false;
+		config.forceClearRegisters = false;
+
+		while(*post != 0)
+		{
+			int integer;
+			int index;
+
+			if(sscanf(post, "pixelShaderVersion=%d", &integer))
+			{
+				config.pixelShaderVersion = integer;
+			}
+			else if(sscanf(post, "vertexShaderVersion=%d", &integer))
+			{
+				config.vertexShaderVersion = integer;
+			}
+			else if(sscanf(post, "textureMemory=%d", &integer))
+			{
+				config.textureMemory = integer;
+			}
+			else if(sscanf(post, "identifier=%d", &integer))
+			{
+				config.identifier = integer;
+			}
+			else if(sscanf(post, "vertexRoutineCacheSize=%d", &integer))
+			{
+				config.vertexRoutineCacheSize = integer;
+			}
+			else if(sscanf(post, "pixelRoutineCacheSize=%d", &integer))
+			{
+				config.pixelRoutineCacheSize = integer;
+			}
+			else if(sscanf(post, "setupRoutineCacheSize=%d", &integer))
+			{
+				config.setupRoutineCacheSize = integer;
+			}
+			else if(sscanf(post, "vertexCacheSize=%d", &integer))
+			{
+				config.vertexCacheSize = integer;
+			}
+			else if(sscanf(post, "textureSampleQuality=%d", &integer))
+			{
+				config.textureSampleQuality = integer;
+			}
+			else if(sscanf(post, "mipmapQuality=%d", &integer))
+			{
+				config.mipmapQuality = integer;
+			}
+			else if(sscanf(post, "perspectiveCorrection=%d", &integer))
+			{
+				config.perspectiveCorrection = integer != 0;
+			}
+			else if(sscanf(post, "transcendentalPrecision=%d", &integer))
+			{
+				config.transcendentalPrecision = integer;
+			}
+			else if(sscanf(post, "transparencyAntialiasing=%d", &integer))
+			{
+				config.transparencyAntialiasing = integer;
+			}
+			else if(sscanf(post, "threadCount=%d", &integer))
+			{
+				config.threadCount = integer;
+			}
+			else if(sscanf(post, "frameBufferAPI=%d", &integer))
+			{
+				config.frameBufferAPI = integer;
+			}
+			else if(sscanf(post, "shadowMapping=%d", &integer))
+			{
+				config.shadowMapping = integer;
+			}
+			else if(strstr(post, "enableSSE=on"))
+			{
+				config.enableSSE = true;
+			}
+			else if(strstr(post, "enableSSE2=on"))
+			{
+				if(config.enableSSE)
+				{
+					config.enableSSE2 = true;
+				}
+			}
+			else if(strstr(post, "enableSSE3=on"))
+			{
+				if(config.enableSSE2)
+				{
+					config.enableSSE3 = true;
+				}
+			}
+			else if(strstr(post, "enableSSSE3=on"))
+			{
+				if(config.enableSSE3)
+				{
+					config.enableSSSE3 = true;
+				}
+			}
+			else if(strstr(post, "enableSSE4_1=on"))
+			{
+				if(config.enableSSSE3)
+				{
+					config.enableSSE4_1 = true;
+				}
+			}
+			else if(sscanf(post, "optimization%d=%d", &index, &integer))
+			{
+				config.optimization[index - 1] = (Optimization)integer;
+			}
+			else if(strstr(post, "disableServer=on"))
+			{
+				config.disableServer = true;
+			}
+			else if(strstr(post, "forceWindowed=on"))
+			{
+				config.forceWindowed = true;
+			}
+			else if(strstr(post, "complementaryDepthBuffer=on"))
+			{
+				config.complementaryDepthBuffer = true;
+			}
+			else if(strstr(post, "postBlendSRGB=on"))
+			{
+				config.postBlendSRGB = true;
+			}
+			else if(strstr(post, "exactColorRounding=on"))
+			{
+				config.exactColorRounding = true;
+			}
+			else if(strstr(post, "disableAlphaMode=on"))
+			{
+				config.disableAlphaMode = true;
+			}
+			else if(strstr(post, "disable10BitMode=on"))
+			{
+				config.disable10BitMode = true;
+			}
+			else if(strstr(post, "precache=on"))
+			{
+				config.precache = true;
+			}
+			else if(strstr(post, "forceClearRegisters=on"))
+			{
+				config.forceClearRegisters = true;
+			}
+		#ifndef NDEBUG
+			else if(sscanf(post, "minPrimitives=%d", &integer))
+			{
+				config.minPrimitives = integer;
+			}
+			else if(sscanf(post, "maxPrimitives=%d", &integer))
+			{
+				config.maxPrimitives = integer;
+			}
+		#endif
+			else
+			{
+				ASSERT(false);
+			}
+
+			do
+			{
+				post++;
+			}
+			while(post[-1] != '&' && *post != 0);
+		}
+	}
+
+	void SwiftConfig::readConfiguration(bool disableServerOverride)
+	{
+		Configurator ini("SwiftShader.ini");
+
+		config.pixelShaderVersion = ini.getInteger("Capabilities", "PixelShaderVersion", 30);
+		config.vertexShaderVersion = ini.getInteger("Capabilities", "VertexShaderVersion", 30);
+		config.textureMemory = ini.getInteger("Capabilities", "TextureMemory", 256);
+		config.identifier = ini.getInteger("Capabilities", "Identifier", 0);
+		config.vertexRoutineCacheSize = ini.getInteger("Caches", "VertexRoutineCacheSize", 1024);
+		config.pixelRoutineCacheSize = ini.getInteger("Caches", "PixelRoutineCacheSize", 1024);
+		config.setupRoutineCacheSize = ini.getInteger("Caches", "SetupRoutineCacheSize", 1024);
+		config.vertexCacheSize = ini.getInteger("Caches", "VertexCacheSize", 64);
+		config.textureSampleQuality = ini.getInteger("Quality", "TextureSampleQuality", 2);
+		config.mipmapQuality = ini.getInteger("Quality", "MipmapQuality", 1);
+		config.perspectiveCorrection = ini.getBoolean("Quality", "PerspectiveCorrection", true);
+		config.transcendentalPrecision = ini.getInteger("Quality", "TranscendentalPrecision", 2);
+		config.transparencyAntialiasing = ini.getInteger("Quality", "TransparencyAntialiasing", 0);
+		config.threadCount = ini.getInteger("Processor", "ThreadCount", DEFAULT_THREAD_COUNT);
+		config.enableSSE = ini.getBoolean("Processor", "EnableSSE", true);
+		config.enableSSE2 = ini.getBoolean("Processor", "EnableSSE2", true);
+		config.enableSSE3 = ini.getBoolean("Processor", "EnableSSE3", true);
+		config.enableSSSE3 = ini.getBoolean("Processor", "EnableSSSE3", true);
+		config.enableSSE4_1 = ini.getBoolean("Processor", "EnableSSE4_1", true);
+
+		for(int pass = 0; pass < 10; pass++)
+		{
+			config.optimization[pass] = (Optimization)ini.getInteger("Optimization", "OptimizationPass" + itoa(pass + 1), pass == 0 ? InstructionCombining : Disabled);
+		}
+
+		config.disableServer = ini.getBoolean("Testing", "DisableServer", false);
+		config.forceWindowed = ini.getBoolean("Testing", "ForceWindowed", false);
+		config.complementaryDepthBuffer = ini.getBoolean("Testing", "ComplementaryDepthBuffer", false);
+		config.postBlendSRGB = ini.getBoolean("Testing", "PostBlendSRGB", false);
+		config.exactColorRounding = ini.getBoolean("Testing", "ExactColorRounding", true);
+		config.disableAlphaMode = ini.getBoolean("Testing", "DisableAlphaMode", false);
+		config.disable10BitMode = ini.getBoolean("Testing", "Disable10BitMode", false);
+		config.frameBufferAPI = ini.getInteger("Testing", "FrameBufferAPI", 0);
+		config.precache = ini.getBoolean("Testing", "Precache", false);
+		config.shadowMapping = ini.getInteger("Testing", "ShadowMapping", 3);
+		config.forceClearRegisters = ini.getBoolean("Testing", "ForceClearRegisters", false);
+
+	#ifndef NDEBUG
+		config.minPrimitives = 1;
+		config.maxPrimitives = 1 << 21;
+	#endif
+
+		struct stat status;
+		int lastModified = ini.getInteger("LastModified", "Time", 0);
+
+		bool noConfig = stat("SwiftShader.ini", &status) != 0;
+		newConfig = !noConfig && abs((int)status.st_mtime - lastModified) > 1;
+
+		if(disableServerOverride)
+		{
+			config.disableServer = true;
+		}
+	}
+
+	void SwiftConfig::writeConfiguration()
+	{
+		Configurator ini("SwiftShader.ini");
+
+		ini.addValue("Capabilities", "PixelShaderVersion", itoa(config.pixelShaderVersion));
+		ini.addValue("Capabilities", "VertexShaderVersion", itoa(config.vertexShaderVersion));
+		ini.addValue("Capabilities", "TextureMemory", itoa(config.textureMemory));
+		ini.addValue("Capabilities", "Identifier", itoa(config.identifier));
+		ini.addValue("Caches", "VertexRoutineCacheSize", itoa(config.vertexRoutineCacheSize));
+		ini.addValue("Caches", "PixelRoutineCacheSize", itoa(config.pixelRoutineCacheSize));
+		ini.addValue("Caches", "SetupRoutineCacheSize", itoa(config.setupRoutineCacheSize));
+		ini.addValue("Caches", "VertexCacheSize", itoa(config.vertexCacheSize));
+		ini.addValue("Quality", "TextureSampleQuality", itoa(config.textureSampleQuality));
+		ini.addValue("Quality", "MipmapQuality", itoa(config.mipmapQuality));
+		ini.addValue("Quality", "PerspectiveCorrection", itoa(config.perspectiveCorrection));
+		ini.addValue("Quality", "TranscendentalPrecision", itoa(config.transcendentalPrecision));
+		ini.addValue("Quality", "TransparencyAntialiasing", itoa(config.transparencyAntialiasing));
+		ini.addValue("Processor", "ThreadCount", itoa(config.threadCount));
+	//	ini.addValue("Processor", "EnableSSE", itoa(config.enableSSE));
+		ini.addValue("Processor", "EnableSSE2", itoa(config.enableSSE2));
+		ini.addValue("Processor", "EnableSSE3", itoa(config.enableSSE3));
+		ini.addValue("Processor", "EnableSSSE3", itoa(config.enableSSSE3));
+		ini.addValue("Processor", "EnableSSE4_1", itoa(config.enableSSE4_1));
+
+		for(int pass = 0; pass < 10; pass++)
+		{
+			ini.addValue("Optimization", "OptimizationPass" + itoa(pass + 1), itoa(config.optimization[pass]));
+		}
+
+		ini.addValue("Testing", "DisableServer", itoa(config.disableServer));
+		ini.addValue("Testing", "ForceWindowed", itoa(config.forceWindowed));
+		ini.addValue("Testing", "ComplementaryDepthBuffer", itoa(config.complementaryDepthBuffer));
+		ini.addValue("Testing", "PostBlendSRGB", itoa(config.postBlendSRGB));
+		ini.addValue("Testing", "ExactColorRounding", itoa(config.exactColorRounding));
+		ini.addValue("Testing", "DisableAlphaMode", itoa(config.disableAlphaMode));
+		ini.addValue("Testing", "Disable10BitMode", itoa(config.disable10BitMode));
+		ini.addValue("Testing", "FrameBufferAPI", itoa(config.frameBufferAPI));
+		ini.addValue("Testing", "Precache", itoa(config.precache));
+		ini.addValue("Testing", "ShadowMapping", itoa(config.shadowMapping));
+		ini.addValue("Testing", "ForceClearRegisters", itoa(config.forceClearRegisters));
+		ini.addValue("LastModified", "Time", itoa((int)time(0)));
+
+		ini.writeFile("SwiftShader Configuration File\n"
+		              ";\n"
+					  "; To get an overview of the valid settings and their meaning,\n"
+					  "; run the application in windowed mode and open the\n"
+					  "; SwiftConfig application or go to http://localhost:8080/swiftconfig.");
+	}
+}
diff --git a/src/Device/SwiftConfig.hpp b/src/Device/SwiftConfig.hpp
new file mode 100644
index 0000000..233b438
--- /dev/null
+++ b/src/Device/SwiftConfig.hpp
@@ -0,0 +1,115 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_SwiftConfig_hpp
+#define sw_SwiftConfig_hpp
+
+#include "Reactor/Nucleus.hpp"
+
+#include "Common/Thread.hpp"
+#include "Common/MutexLock.hpp"
+#include "Common/Socket.hpp"
+
+#include <string>
+
+namespace sw
+{
+	class SwiftConfig
+	{
+	public:
+		struct Configuration
+		{
+			int pixelShaderVersion;
+			int vertexShaderVersion;
+			int textureMemory;
+			int identifier;
+			int vertexRoutineCacheSize;
+			int pixelRoutineCacheSize;
+			int setupRoutineCacheSize;
+			int vertexCacheSize;
+			int textureSampleQuality;
+			int mipmapQuality;
+			bool perspectiveCorrection;
+			int transcendentalPrecision;
+			int threadCount;
+			bool enableSSE;
+			bool enableSSE2;
+			bool enableSSE3;
+			bool enableSSSE3;
+			bool enableSSE4_1;
+			Optimization optimization[10];
+			bool disableServer;
+			bool keepSystemCursor;
+			bool forceWindowed;
+			bool complementaryDepthBuffer;
+			bool postBlendSRGB;
+			bool exactColorRounding;
+			bool disableAlphaMode;
+			bool disable10BitMode;
+			int transparencyAntialiasing;
+			int frameBufferAPI;
+			bool precache;
+			int shadowMapping;
+			bool forceClearRegisters;
+		#ifndef NDEBUG
+			unsigned int minPrimitives;
+			unsigned int maxPrimitives;
+		#endif
+		};
+
+		SwiftConfig(bool disableServerOverride);
+
+		~SwiftConfig();
+
+		bool hasNewConfiguration(bool reset = true);
+		void getConfiguration(Configuration &configuration);
+
+	private:
+		enum Status
+		{
+			OK = 200,
+			NotFound = 404
+		};
+
+		void createServer();
+		void destroyServer();
+
+		static void serverRoutine(void *parameters);
+
+		void serverLoop();
+		void respond(Socket *clientSocket, const char *request);
+		std::string page();
+		std::string profile();
+		void send(Socket *clientSocket, Status code, std::string body = "");
+		void parsePost(const char *post);
+
+		void readConfiguration(bool disableServerOverride = false);
+		void writeConfiguration();
+
+		Configuration config;
+
+		Thread *serverThread;
+		volatile bool terminate;
+		MutexLock criticalSection;   // Protects reading and writing the configuration settings
+
+		bool newConfig;
+
+		Socket *listenSocket;
+
+		int bufferLength;
+		char *receiveBuffer;
+	};
+}
+
+#endif   // sw_SwiftConfig_hpp
diff --git a/src/Device/TextureStage.cpp b/src/Device/TextureStage.cpp
new file mode 100644
index 0000000..0327478
--- /dev/null
+++ b/src/Device/TextureStage.cpp
@@ -0,0 +1,412 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "TextureStage.hpp"
+
+#include "Sampler.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	TextureStage::State::State()
+	{
+		memset(this, 0, sizeof(State));
+	}
+
+	TextureStage::TextureStage() : sampler(0), previousStage(0)
+	{
+	}
+
+	TextureStage::~TextureStage()
+	{
+	}
+
+	void TextureStage::init(int stage, const Sampler *sampler, const TextureStage *previousStage)
+	{
+		this->stage = stage;
+
+		stageOperation = (stage == 0 ? STAGE_MODULATE : STAGE_DISABLE);
+		firstArgument = SOURCE_TEXTURE;
+		secondArgument = SOURCE_CURRENT;
+		thirdArgument = SOURCE_CURRENT;
+		stageOperationAlpha = (stage == 0 ? STAGE_SELECTARG1 : STAGE_DISABLE);
+		firstArgumentAlpha = SOURCE_DIFFUSE;
+		secondArgumentAlpha = SOURCE_CURRENT;
+		thirdArgumentAlpha = SOURCE_CURRENT;
+		firstModifier = MODIFIER_COLOR;
+		secondModifier = MODIFIER_COLOR;
+		thirdModifier = MODIFIER_COLOR;
+	    firstModifierAlpha = MODIFIER_COLOR;
+		secondModifierAlpha = MODIFIER_COLOR;
+		thirdModifierAlpha = MODIFIER_COLOR;
+		destinationArgument = DESTINATION_CURRENT;
+
+		texCoordIndex = stage;
+		this->sampler = sampler;
+		this->previousStage = previousStage;
+	}
+
+	TextureStage::State TextureStage::textureStageState() const
+	{
+		State state;
+
+		if(!isStageDisabled())
+		{
+			state.stageOperation = stageOperation;
+			state.firstArgument = firstArgument;
+			state.secondArgument = secondArgument;
+			state.thirdArgument = thirdArgument;
+			state.stageOperationAlpha = stageOperationAlpha;
+			state.firstArgumentAlpha = firstArgumentAlpha;
+			state.secondArgumentAlpha = secondArgumentAlpha;
+			state.thirdArgumentAlpha = thirdArgumentAlpha;
+			state.firstModifier = firstModifier;
+			state.secondModifier = secondModifier;
+			state.thirdModifier = thirdModifier;
+			state.firstModifierAlpha = firstModifierAlpha;
+			state.secondModifierAlpha = secondModifierAlpha;
+			state.thirdModifierAlpha = thirdModifierAlpha;
+			state.destinationArgument = destinationArgument;
+			state.texCoordIndex = texCoordIndex;
+
+			state.cantUnderflow = sampler->hasUnsignedTexture() || !usesTexture();
+			state.usesTexture = usesTexture();
+		}
+
+		return state;
+	}
+
+	void TextureStage::setConstantColor(const Color<float> &constantColor)
+	{
+		// FIXME: Compact into generic function   // FIXME: Clamp
+		short r = iround(4095 * constantColor.r);
+		short g = iround(4095 * constantColor.g);
+		short b = iround(4095 * constantColor.b);
+		short a = iround(4095 * constantColor.a);
+
+		uniforms.constantColor4[0][0] = uniforms.constantColor4[0][1] = uniforms.constantColor4[0][2] = uniforms.constantColor4[0][3] = r;
+		uniforms.constantColor4[1][0] = uniforms.constantColor4[1][1] = uniforms.constantColor4[1][2] = uniforms.constantColor4[1][3] = g;
+		uniforms.constantColor4[2][0] = uniforms.constantColor4[2][1] = uniforms.constantColor4[2][2] = uniforms.constantColor4[2][3] = b;
+		uniforms.constantColor4[3][0] = uniforms.constantColor4[3][1] = uniforms.constantColor4[3][2] = uniforms.constantColor4[3][3] = a;
+	}
+
+	void TextureStage::setBumpmapMatrix(int element, float value)
+	{
+		uniforms.bumpmapMatrix4F[element / 2][element % 2][0] = value;
+		uniforms.bumpmapMatrix4F[element / 2][element % 2][1] = value;
+		uniforms.bumpmapMatrix4F[element / 2][element % 2][2] = value;
+		uniforms.bumpmapMatrix4F[element / 2][element % 2][3] = value;
+
+		uniforms.bumpmapMatrix4W[element / 2][element % 2][0] = iround(4095 * value);
+		uniforms.bumpmapMatrix4W[element / 2][element % 2][1] = iround(4095 * value);
+		uniforms.bumpmapMatrix4W[element / 2][element % 2][2] = iround(4095 * value);
+		uniforms.bumpmapMatrix4W[element / 2][element % 2][3] = iround(4095 * value);
+	}
+
+	void TextureStage::setLuminanceScale(float value)
+	{
+		short scale = iround(4095 * value);
+
+		uniforms.luminanceScale4[0] = uniforms.luminanceScale4[1] = uniforms.luminanceScale4[2] = uniforms.luminanceScale4[3] = scale;
+	}
+
+	void TextureStage::setLuminanceOffset(float value)
+	{
+		short offset = iround(4095 * value);
+
+		uniforms.luminanceOffset4[0] = uniforms.luminanceOffset4[1] = uniforms.luminanceOffset4[2] = uniforms.luminanceOffset4[3] = offset;
+	}
+
+	void TextureStage::setTexCoordIndex(unsigned int texCoordIndex)
+	{
+		ASSERT(texCoordIndex < 8);
+
+		this->texCoordIndex = texCoordIndex;
+	}
+
+	void TextureStage::setStageOperation(StageOperation stageOperation)
+	{
+		this->stageOperation = stageOperation;
+	}
+
+	void TextureStage::setFirstArgument(SourceArgument firstArgument)
+	{
+		this->firstArgument = firstArgument;
+	}
+
+	void TextureStage::setSecondArgument(SourceArgument secondArgument)
+	{
+		this->secondArgument = secondArgument;
+	}
+
+	void TextureStage::setThirdArgument(SourceArgument thirdArgument)
+	{
+		this->thirdArgument = thirdArgument;
+	}
+
+	void TextureStage::setStageOperationAlpha(StageOperation stageOperationAlpha)
+	{
+		this->stageOperationAlpha = stageOperationAlpha;
+	}
+
+	void TextureStage::setFirstArgumentAlpha(SourceArgument firstArgumentAlpha)
+	{
+		this->firstArgumentAlpha = firstArgumentAlpha;
+	}
+
+	void TextureStage::setSecondArgumentAlpha(SourceArgument secondArgumentAlpha)
+	{
+		this->secondArgumentAlpha = secondArgumentAlpha;
+	}
+
+	void TextureStage::setThirdArgumentAlpha(SourceArgument thirdArgumentAlpha)
+	{
+		this->thirdArgumentAlpha= thirdArgumentAlpha;
+	}
+
+	void TextureStage::setFirstModifier(ArgumentModifier firstModifier)
+	{
+		this->firstModifier = firstModifier;
+	}
+
+	void TextureStage::setSecondModifier(ArgumentModifier secondModifier)
+	{
+		this->secondModifier = secondModifier;
+	}
+
+	void TextureStage::setThirdModifier(ArgumentModifier thirdModifier)
+	{
+		this->thirdModifier = thirdModifier;
+	}
+
+	void TextureStage::setFirstModifierAlpha(ArgumentModifier firstModifierAlpha)
+	{
+		this->firstModifierAlpha = firstModifierAlpha;
+	}
+
+	void TextureStage::setSecondModifierAlpha(ArgumentModifier secondModifierAlpha)
+	{
+		this->secondModifierAlpha = secondModifierAlpha;
+	}
+
+	void TextureStage::setThirdModifierAlpha(ArgumentModifier thirdModifierAlpha)
+	{
+		this->thirdModifierAlpha = thirdModifierAlpha;
+	}
+
+	void TextureStage::setDestinationArgument(DestinationArgument destinationArgument)
+	{
+		this->destinationArgument = destinationArgument;
+	}
+
+	bool TextureStage::usesColor(SourceArgument source) const
+	{
+		// One argument
+		if(stageOperation == STAGE_SELECTARG1 || stageOperation == STAGE_PREMODULATE)
+		{
+			return firstArgument == source;
+		}
+		else if(stageOperation == STAGE_SELECTARG2)
+		{
+			return secondArgument == source;
+		}
+		else if(stageOperation == STAGE_SELECTARG3)
+		{
+			return thirdArgument == source;
+		}
+		else
+		{
+			// Two arguments or more
+			if(firstArgument == source || secondArgument == source)
+			{
+				return true;
+			}
+
+			// Three arguments
+			if(stageOperation == STAGE_MULTIPLYADD || stageOperation == STAGE_LERP)
+			{
+				return thirdArgument == source;
+			}
+		}
+	
+		return false;
+	}
+
+	bool TextureStage::usesAlpha(SourceArgument source) const
+	{
+		if(stageOperationAlpha == STAGE_DISABLE)
+		{
+			return false;
+		}
+
+		if(source == SOURCE_TEXTURE)
+		{
+			if(stageOperation == STAGE_BLENDTEXTUREALPHA ||	stageOperation == STAGE_BLENDTEXTUREALPHAPM)
+			{
+				return true;
+			}
+		}
+		else if(source == SOURCE_CURRENT)
+		{
+			if(stageOperation == STAGE_BLENDCURRENTALPHA)
+			{
+				return true;
+			}
+		}
+		else if(source == SOURCE_DIFFUSE)
+		{
+			if(stageOperation == STAGE_BLENDDIFFUSEALPHA)
+			{
+				return true;
+			}
+		}
+		else if(source == SOURCE_TFACTOR)
+		{
+			if(stageOperation == STAGE_BLENDFACTORALPHA)
+			{
+				return true;
+			}
+		}
+
+		// One argument
+		if(stageOperation == STAGE_SELECTARG1 || stageOperation == STAGE_PREMODULATE)
+		{
+			if(firstArgument == source && (firstModifier == MODIFIER_ALPHA || firstModifier == MODIFIER_INVALPHA))
+			{
+				return true;
+			}
+		}
+		else if(stageOperation == STAGE_SELECTARG2)
+		{
+			if(secondArgument == source && (secondModifier == MODIFIER_ALPHA || secondModifier == MODIFIER_INVALPHA))
+			{
+				return true;
+			}
+		}
+		else if(stageOperation == STAGE_SELECTARG3)
+		{
+			if(thirdArgument == source && (thirdModifier == MODIFIER_ALPHA || thirdModifier == MODIFIER_INVALPHA))
+			{
+				return true;
+			}
+		}
+		else
+		{
+			// Two arguments or more
+			if(firstArgument == source || secondArgument == source)
+			{
+				if(firstArgument == source && (firstModifier == MODIFIER_ALPHA || firstModifier == MODIFIER_INVALPHA))
+				{
+					return true;
+				}
+
+				if(secondArgument == source && (secondModifier == MODIFIER_ALPHA || secondModifier == MODIFIER_INVALPHA))
+				{
+					return true;
+				}
+			}
+
+			// Three arguments
+			if(stageOperation == STAGE_MULTIPLYADD || stageOperation == STAGE_LERP)
+			{
+				if(thirdArgument == source && (thirdModifier == MODIFIER_ALPHA || thirdModifier == MODIFIER_INVALPHA))
+				{
+					return true;
+				}
+			}
+		}
+
+		// One argument
+		if(stageOperationAlpha == STAGE_SELECTARG1 || stageOperationAlpha == STAGE_PREMODULATE)
+		{
+			return firstArgumentAlpha == source;
+		}
+		else if(stageOperationAlpha == STAGE_SELECTARG2)
+		{
+			return secondArgumentAlpha == source;
+		}
+		else if(stageOperationAlpha == STAGE_SELECTARG3)
+		{
+			return thirdArgumentAlpha == source;
+		}
+		else
+		{
+			// Two arguments or more
+			if(firstArgumentAlpha == source || secondArgumentAlpha == source)
+			{
+				return true;
+			}
+
+			// Three arguments
+			if(stageOperationAlpha == STAGE_MULTIPLYADD || stageOperationAlpha == STAGE_LERP)
+			{
+				return thirdArgumentAlpha == source;
+			}
+		}
+		
+		return false;
+	}
+
+	bool TextureStage::uses(SourceArgument source) const
+	{
+		return usesColor(source) || usesAlpha(source);
+	}
+
+	bool TextureStage::usesCurrent() const
+	{
+		return uses(SOURCE_CURRENT) || (stageOperation == STAGE_BLENDCURRENTALPHA || stageOperationAlpha == STAGE_BLENDCURRENTALPHA);
+	}
+
+	bool TextureStage::usesDiffuse() const
+	{
+		return uses(SOURCE_DIFFUSE) || (stageOperation == STAGE_BLENDDIFFUSEALPHA || stageOperationAlpha == STAGE_BLENDDIFFUSEALPHA);
+	}
+
+	bool TextureStage::usesSpecular() const
+	{
+		return uses(SOURCE_SPECULAR);
+	}
+
+	bool TextureStage::usesTexture() const
+	{
+		return uses(SOURCE_TEXTURE) ||
+		       stageOperation == STAGE_BLENDTEXTUREALPHA ||
+		       stageOperationAlpha == STAGE_BLENDTEXTUREALPHA ||
+		       stageOperation == STAGE_BLENDTEXTUREALPHAPM ||
+		       stageOperationAlpha == STAGE_BLENDTEXTUREALPHAPM ||
+		       (previousStage && previousStage->stageOperation == STAGE_PREMODULATE) ||
+		       (previousStage && previousStage->stageOperationAlpha == STAGE_PREMODULATE);
+	}
+
+	bool TextureStage::isStageDisabled() const
+	{
+		bool disabled = (stageOperation == STAGE_DISABLE) || (!sampler->hasTexture() && usesTexture());
+
+		if(!previousStage || disabled)
+		{
+			return disabled;
+		}
+		else
+		{
+			return previousStage->isStageDisabled();
+		}
+	}
+
+	bool TextureStage::writesCurrent() const
+	{
+		return !isStageDisabled() && destinationArgument == DESTINATION_CURRENT && stageOperation != STAGE_BUMPENVMAP && stageOperation != STAGE_BUMPENVMAPLUMINANCE;
+	}
+}
diff --git a/src/Device/TextureStage.hpp b/src/Device/TextureStage.hpp
new file mode 100644
index 0000000..2c9ecbd
--- /dev/null
+++ b/src/Device/TextureStage.hpp
@@ -0,0 +1,198 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_TextureStage_hpp
+#define sw_TextureStage_hpp
+
+#include "Common/Types.hpp"
+#include "Common/Math.hpp"
+#include "Renderer/Color.hpp"
+
+namespace sw
+{
+	class Sampler;
+	class PixelRoutine;
+	class Context;
+
+	class TextureStage
+	{
+		friend class Context;   // FIXME
+
+	public:
+		enum StageOperation
+		{
+			STAGE_DISABLE,
+			STAGE_SELECTARG1,
+			STAGE_SELECTARG2,
+			STAGE_SELECTARG3,
+			STAGE_MODULATE,
+			STAGE_MODULATE2X,
+			STAGE_MODULATE4X,
+			STAGE_ADD,
+			STAGE_ADDSIGNED,
+			STAGE_ADDSIGNED2X,
+			STAGE_SUBTRACT,
+			STAGE_ADDSMOOTH,
+			STAGE_MULTIPLYADD,
+			STAGE_LERP,
+			STAGE_DOT3,
+			STAGE_BLENDCURRENTALPHA,
+			STAGE_BLENDDIFFUSEALPHA,
+			STAGE_BLENDFACTORALPHA,
+			STAGE_BLENDTEXTUREALPHA,
+			STAGE_BLENDTEXTUREALPHAPM,
+			STAGE_PREMODULATE,
+			STAGE_MODULATEALPHA_ADDCOLOR,
+			STAGE_MODULATECOLOR_ADDALPHA,
+			STAGE_MODULATEINVALPHA_ADDCOLOR,
+			STAGE_MODULATEINVCOLOR_ADDALPHA,
+			STAGE_BUMPENVMAP,
+			STAGE_BUMPENVMAPLUMINANCE,
+
+			STAGE_LAST = STAGE_BUMPENVMAPLUMINANCE
+		};
+
+		enum SourceArgument
+		{
+			SOURCE_TEXTURE,
+			SOURCE_CONSTANT,
+			SOURCE_CURRENT,
+			SOURCE_DIFFUSE,
+			SOURCE_SPECULAR,
+			SOURCE_TEMP,
+			SOURCE_TFACTOR,
+
+			SOURCE_LAST = SOURCE_TFACTOR
+		};
+
+		enum DestinationArgument
+		{
+			DESTINATION_CURRENT,
+			DESTINATION_TEMP,
+
+			DESTINATION_LAST = DESTINATION_TEMP
+		};
+
+		enum ArgumentModifier
+		{
+			MODIFIER_COLOR,
+			MODIFIER_INVCOLOR,
+			MODIFIER_ALPHA,
+			MODIFIER_INVALPHA,
+
+			MODIFIER_LAST = MODIFIER_INVALPHA
+		};
+
+		struct State
+		{
+			State();
+
+			unsigned int stageOperation			: BITS(STAGE_LAST);
+			unsigned int firstArgument			: BITS(SOURCE_LAST);
+			unsigned int secondArgument			: BITS(SOURCE_LAST);
+			unsigned int thirdArgument			: BITS(SOURCE_LAST);
+			unsigned int stageOperationAlpha	: BITS(STAGE_LAST);
+			unsigned int firstArgumentAlpha		: BITS(SOURCE_LAST);
+			unsigned int secondArgumentAlpha	: BITS(SOURCE_LAST);
+			unsigned int thirdArgumentAlpha		: BITS(SOURCE_LAST);
+			unsigned int firstModifier			: BITS(MODIFIER_LAST);
+			unsigned int secondModifier			: BITS(MODIFIER_LAST);
+			unsigned int thirdModifier			: BITS(MODIFIER_LAST);
+			unsigned int firstModifierAlpha		: BITS(MODIFIER_LAST);
+			unsigned int secondModifierAlpha	: BITS(MODIFIER_LAST);
+			unsigned int thirdModifierAlpha		: BITS(MODIFIER_LAST);
+			unsigned int destinationArgument	: BITS(DESTINATION_LAST);
+			unsigned int texCoordIndex			: BITS(7);
+
+			unsigned int cantUnderflow			: 1;
+			unsigned int usesTexture			: 1;
+		};
+
+		struct Uniforms
+		{
+			word4 constantColor4[4];
+			float4 bumpmapMatrix4F[2][2];
+			word4 bumpmapMatrix4W[2][2];
+			word4 luminanceScale4;
+			word4 luminanceOffset4;
+		};
+
+		TextureStage();
+
+		~TextureStage();
+
+		void init(int stage, const Sampler *sampler, const TextureStage *previousStage);
+
+		State textureStageState() const;
+
+		void setConstantColor(const Color<float> &constantColor);
+		void setBumpmapMatrix(int element, float value);
+		void setLuminanceScale(float value);
+		void setLuminanceOffset(float value);
+
+		void setTexCoordIndex(unsigned int texCoordIndex);
+		void setStageOperation(StageOperation stageOperation);
+		void setFirstArgument(SourceArgument firstArgument);
+		void setSecondArgument(SourceArgument secondArgument);
+		void setThirdArgument(SourceArgument thirdArgument);
+		void setStageOperationAlpha(StageOperation stageOperationAlpha);
+		void setFirstArgumentAlpha(SourceArgument firstArgumentAlpha);
+		void setSecondArgumentAlpha(SourceArgument secondArgumentAlpha);
+		void setThirdArgumentAlpha(SourceArgument thirdArgumentAlpha);
+		void setFirstModifier(ArgumentModifier firstModifier);
+		void setSecondModifier(ArgumentModifier secondModifier);
+		void setThirdModifier(ArgumentModifier thirdModifier);
+		void setFirstModifierAlpha(ArgumentModifier firstModifierAlpha);
+		void setSecondModifierAlpha(ArgumentModifier secondModifierAlpha);
+		void setThirdModifierAlpha(ArgumentModifier thirdModifierAlpha);
+		void setDestinationArgument(DestinationArgument destinationArgument);
+
+		Uniforms uniforms;   // FIXME: Private
+
+	private:
+		bool usesColor(SourceArgument source) const;
+		bool usesAlpha(SourceArgument source) const;
+		bool uses(SourceArgument source) const;
+		bool usesCurrent() const;
+		bool usesDiffuse() const;
+		bool usesSpecular() const;
+		bool usesTexture() const;
+		bool isStageDisabled() const;
+		bool writesCurrent() const;
+
+		int stage;
+
+		StageOperation stageOperation;
+		SourceArgument firstArgument;
+		SourceArgument secondArgument;
+		SourceArgument thirdArgument;
+		StageOperation stageOperationAlpha;
+		SourceArgument firstArgumentAlpha;
+		SourceArgument secondArgumentAlpha;
+		SourceArgument thirdArgumentAlpha;
+		ArgumentModifier firstModifier;
+		ArgumentModifier secondModifier;
+		ArgumentModifier thirdModifier;
+		ArgumentModifier firstModifierAlpha;
+		ArgumentModifier secondModifierAlpha;
+		ArgumentModifier thirdModifierAlpha;
+		DestinationArgument destinationArgument;
+
+		int texCoordIndex;
+		const Sampler *sampler;
+		const TextureStage *previousStage;
+	};
+}
+
+#endif  // sw_TextureStage_hpp
diff --git a/src/Device/Triangle.hpp b/src/Device/Triangle.hpp
new file mode 100644
index 0000000..8a91fab
--- /dev/null
+++ b/src/Device/Triangle.hpp
@@ -0,0 +1,30 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Triangle_hpp
+#define sw_Triangle_hpp
+
+#include "Vertex.hpp"
+
+namespace sw
+{
+	struct Triangle
+	{
+		Vertex V0;
+		Vertex V1;
+		Vertex V2;
+	};
+}
+
+#endif   // sw_Triangle_hpp
diff --git a/src/Device/Vector.cpp b/src/Device/Vector.cpp
new file mode 100644
index 0000000..4a02534
--- /dev/null
+++ b/src/Device/Vector.cpp
@@ -0,0 +1,175 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Vector.hpp"
+
+#include "Matrix.hpp"
+#include "Common/Math.hpp"
+
+namespace sw
+{
+	Vector Vector::operator+() const
+	{
+		return *this;
+	}
+
+	Vector Vector::operator-() const
+	{
+		return Vector(-x, -y, -z);
+	}
+
+	Vector &Vector::operator+=(const Vector &v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+
+		return *this;
+	}
+
+	Vector &Vector::operator-=(const Vector &v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+
+		return *this;
+	}
+
+	Vector &Vector::operator*=(float s)
+	{
+		x *= s;
+		y *= s;
+		z *= s;
+
+		return *this;
+	}
+
+	Vector &Vector::operator/=(float s)
+	{
+		float r = 1.0f / s;
+
+		return *this *= r;
+	}
+
+	bool operator==(const Vector &U, const Vector &v)
+	{
+		if(U.x == v.x && U.y == v.y && U.z == v.z)
+			return true;
+		else
+			return false;
+	}
+
+	bool operator!=(const Vector &U, const Vector &v)
+	{
+		if(U.x != v.x || U.y != v.y || U.z != v.z)
+			return true;
+		else
+			return false;
+	}
+
+	bool operator>(const Vector &u, const Vector &v)
+	{
+		if((u^2) > (v^2))
+			return true;
+		else
+			return false;
+	}
+
+	bool operator<(const Vector &u, const Vector &v)
+	{
+		if((u^2) < (v^2))
+			return true;
+		else
+			return false;
+	}
+
+	Vector operator+(const Vector &u, const Vector &v)
+	{
+		return Vector(u.x + v.x, u.y + v.y, u.z + v.z);
+	}
+
+	Vector operator-(const Vector &u, const Vector &v)
+	{
+		return Vector(u.x - v.x, u.y - v.y, u.z - v.z);
+	}
+
+	float operator*(const Vector &u, const Vector &v)
+	{
+		return u.x * v.x + u.y * v.y + u.z * v.z;
+	}
+
+	Vector operator*(float s, const Vector &v)
+	{
+		return Vector(s * v.x, s * v.y, s * v.z);
+	}
+
+	Vector operator*(const Vector &v, float s)
+	{
+		return Vector(v.x * s, v.y * s, v.z * s);
+	}
+
+	Vector operator/(const Vector &v, float s)
+	{
+		float r = 1.0f / s;
+
+		return Vector(v.x * r, v.y * r, v.z * r);
+	}
+
+	float operator^(const Vector &u, const Vector &v)
+	{
+		return acos(u / Vector::N(u) * v / Vector::N(v));
+	}
+
+	Vector operator%(const Vector &u, const Vector &v)
+	{
+		return Vector(u.y * v.z - u.z * v.y, u.z * v.x - u.x * v.z, u.x * v.y - u.y * v.x);
+	}
+
+	Vector operator*(const Matrix &M, const Vector &v)
+	{
+		return Vector(M(1, 1) * v.x + M(1, 2) * v.y + M(1, 3) * v.z,
+		              M(2, 1) * v.x + M(2, 2) * v.y + M(2, 3) * v.z,
+		              M(3, 1) * v.x + M(3, 2) * v.y + M(3, 3) * v.z);
+	}
+
+	Vector operator*(const Vector &v, const Matrix &M)
+	{
+		return Vector(v.x * M(1, 1) + v.y * M(2, 1) + v.z * M(3, 1) + M(4, 1),
+		              v.x * M(1, 2) + v.y * M(2, 2) + v.z * M(3, 2) + M(4, 2),
+		              v.x * M(1, 3) + v.y * M(2, 3) + v.z * M(3, 3) + M(4, 3));
+	}
+
+	Vector &operator*=(Vector &v, const Matrix &M)
+	{
+		return v = v * M;
+	}
+
+	float Vector::N(const Vector &v)
+	{
+		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;
+	}
+
+	Vector lerp(const Vector &u, const Vector &v, float t)
+	{
+		return Vector(u.x + t * (v.x - u.x),
+		              u.y + t * (v.y - u.y),
+					  u.z + t * (v.z - u.x));
+	}
+}
diff --git a/src/Device/Vector.hpp b/src/Device/Vector.hpp
new file mode 100644
index 0000000..e7f261d
--- /dev/null
+++ b/src/Device/Vector.hpp
@@ -0,0 +1,153 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Vector_hpp
+#define Vector_hpp
+
+namespace sw
+{
+	struct Point;
+	struct Matrix;
+	struct Plane;
+
+	struct Vector
+	{
+		Vector();
+		Vector(const int i);
+		Vector(const Vector &v);
+		Vector(const Point &p);
+		Vector(float v_x, float v_y, float v_z);
+
+		Vector &operator=(const Vector &v);
+
+		union
+		{
+			float v[3];
+
+			struct
+			{
+				float x;
+				float y;
+				float z;
+			};
+		};
+
+		float &operator[](int i);
+		float &operator()(int i);
+
+		const float &operator[](int i) const;
+		const float &operator()(int i) const;
+
+		Vector operator+() const;
+		Vector operator-() const;
+
+		Vector &operator+=(const Vector &v);
+		Vector &operator-=(const Vector &v);
+		Vector &operator*=(float s);
+		Vector &operator/=(float s);
+
+		friend bool operator==(const Vector &u, const Vector &v);
+		friend bool operator!=(const Vector &u, const Vector &v);
+
+		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 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 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 Vector mirror(const Vector &v, const Plane &p);
+		static Vector reflect(const Vector &v, const Plane &p);
+		static Vector lerp(const Vector &u, const Vector &v, float t);
+	};
+}
+
+#include "Point.hpp"
+
+namespace sw
+{
+	inline Vector::Vector()
+	{
+	}
+
+	inline Vector::Vector(const int i)
+	{
+		const float s = (float)i;
+
+		x = s;
+		y = s;
+		z = s;
+	}
+
+	inline Vector::Vector(const Vector &v)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+	}
+
+	inline Vector::Vector(const Point &P)
+	{
+		x = P.x;
+		y = P.y;
+		z = P.z;
+	}
+
+	inline Vector::Vector(float v_x, float v_y, float v_z)
+	{
+		x = v_x;
+		y = v_y;
+		z = v_z;
+	}
+
+	inline Vector &Vector::operator=(const Vector &v)
+	{
+		x = v.x;
+		y = v.y;
+		z = v.z;
+
+		return *this;
+	}
+
+	inline float &Vector::operator()(int i)
+	{
+		return v[i];
+	}
+
+	inline float &Vector::operator[](int i)
+	{
+		return v[i];
+	}
+
+	inline const float &Vector::operator()(int i) const
+	{
+		return v[i];
+	}
+
+	inline const float &Vector::operator[](int i) const
+	{
+		return v[i];
+	}
+}
+
+#endif   // Vector_hpp
diff --git a/src/Device/Vertex.hpp b/src/Device/Vertex.hpp
new file mode 100644
index 0000000..9ae8d14
--- /dev/null
+++ b/src/Device/Vertex.hpp
@@ -0,0 +1,98 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Vertex_hpp
+#define Vertex_hpp
+
+#include "Color.hpp"
+#include "Common/Types.hpp"
+#include "Main/Config.hpp"
+
+namespace sw
+{
+	enum Out
+	{
+		// Default vertex output semantics
+		Pos = 0,
+		C0 = 1,   // Diffuse
+		C1 = 2,   // Specular
+		T0 = 3,
+		T1 = 4,
+		T2 = 5,
+		T3 = 6,
+		T4 = 7,
+		T5 = 8,
+		T6 = 9,
+		T7 = 10,
+		Fog = 11,    // x component
+		Pts = Fog,   // y component
+
+		// Variable semantics
+		V0 = 0,
+		Vn_1 = MAX_VERTEX_OUTPUTS - 1,
+
+		Unused,
+		VERTEX_OUTPUT_LAST = Unused,
+	};
+
+	struct UVWQ
+	{
+		float u;
+		float v;
+		float w;
+		float q;
+
+		float &operator[](int i)
+		{
+			return (&u)[i];
+		}
+	};
+
+	ALIGN(16, struct Vertex
+	{
+		union
+		{
+			struct   // Fixed semantics
+			{
+				// Position
+				float x;
+				float y;
+				float z;
+				float w;
+
+				float4 C[2];   // Diffuse and specular color
+
+				UVWQ T[8];           // Texture coordinates
+
+				float f;             // Fog
+				float pSize;         // Point size
+			};
+
+			float4 v[MAX_VERTEX_OUTPUTS];   // Generic components using semantic declaration
+		};
+
+		// Projected coordinates
+		int X;
+		int Y;
+		float Z;
+		float W;
+
+		int clipFlags;
+		int padding[3];
+	});
+
+	static_assert((sizeof(Vertex) & 0x0000000F) == 0, "Vertex size not a multiple of 16 bytes (alignment requirement)");
+}
+
+#endif   // Vertex_hpp
diff --git a/src/Device/VertexProcessor.cpp b/src/Device/VertexProcessor.cpp
new file mode 100644
index 0000000..976ea2b
--- /dev/null
+++ b/src/Device/VertexProcessor.cpp
@@ -0,0 +1,1118 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VertexProcessor.hpp"
+
+#include "Shader/VertexPipeline.hpp"
+#include "Shader/VertexProgram.hpp"
+#include "Shader/VertexShader.hpp"
+#include "Shader/PixelShader.hpp"
+#include "Shader/Constants.hpp"
+#include "Common/Math.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	bool precacheVertex = false;
+
+	void VertexCache::clear()
+	{
+		for(int i = 0; i < 16; i++)
+		{
+			tag[i] = 0x80000000;
+		}
+	}
+
+	unsigned int VertexProcessor::States::computeHash()
+	{
+		unsigned int *state = (unsigned int*)this;
+		unsigned int hash = 0;
+
+		for(unsigned int i = 0; i < sizeof(States) / 4; i++)
+		{
+			hash ^= state[i];
+		}
+
+		return hash;
+	}
+
+	VertexProcessor::State::State()
+	{
+		memset(this, 0, sizeof(State));
+	}
+
+	bool VertexProcessor::State::operator==(const State &state) const
+	{
+		if(hash != state.hash)
+		{
+			return false;
+		}
+
+		return memcmp(static_cast<const States*>(this), static_cast<const States*>(&state), sizeof(States)) == 0;
+	}
+
+	VertexProcessor::TransformFeedbackInfo::TransformFeedbackInfo()
+	{
+		buffer = nullptr;
+		offset = 0;
+		reg = 0;
+		row = 0;
+		col = 0;
+		stride = 0;
+	}
+
+	VertexProcessor::UniformBufferInfo::UniformBufferInfo()
+	{
+		buffer = nullptr;
+		offset = 0;
+	}
+
+	VertexProcessor::VertexProcessor(Context *context) : context(context)
+	{
+		for(int i = 0; i < 12; i++)
+		{
+			M[i] = 1;
+		}
+
+		V = 1;
+		B = 1;
+		P = 0;
+		PB = 0;
+		PBV = 0;
+
+		for(int i = 0; i < 12; i++)
+		{
+			PBVM[i] = 0;
+		}
+
+		setLightingEnable(true);
+		setSpecularEnable(false);
+
+		for(int i = 0; i < 8; i++)
+		{
+			setLightEnable(i, false);
+			setLightPosition(i, 0);
+		}
+
+		updateMatrix = true;
+		updateViewMatrix = true;
+		updateBaseMatrix = true;
+		updateProjectionMatrix = true;
+		updateLighting = true;
+
+		for(int i = 0; i < 12; i++)
+		{
+			updateModelMatrix[i] = true;
+		}
+
+		routineCache = 0;
+		setRoutineCacheSize(1024);
+	}
+
+	VertexProcessor::~VertexProcessor()
+	{
+		delete routineCache;
+		routineCache = 0;
+	}
+
+	void VertexProcessor::setInputStream(int index, const Stream &stream)
+	{
+		context->input[index] = stream;
+	}
+
+	void VertexProcessor::resetInputStreams(bool preTransformed)
+	{
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			context->input[i].defaults();
+		}
+
+		context->preTransformed = preTransformed;
+	}
+
+	void VertexProcessor::setFloatConstant(unsigned int index, const float value[4])
+	{
+		if(index < VERTEX_UNIFORM_VECTORS)
+		{
+			c[index][0] = value[0];
+			c[index][1] = value[1];
+			c[index][2] = value[2];
+			c[index][3] = value[3];
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setIntegerConstant(unsigned int index, const int integer[4])
+	{
+		if(index < 16)
+		{
+			i[index][0] = integer[0];
+			i[index][1] = integer[1];
+			i[index][2] = integer[2];
+			i[index][3] = integer[3];
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setBooleanConstant(unsigned int index, int boolean)
+	{
+		if(index < 16)
+		{
+			b[index] = boolean != 0;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setUniformBuffer(int index, sw::Resource* buffer, int offset)
+	{
+		uniformBufferInfo[index].buffer = buffer;
+		uniformBufferInfo[index].offset = offset;
+	}
+
+	void VertexProcessor::lockUniformBuffers(byte** u, sw::Resource* uniformBuffers[])
+	{
+		for(int i = 0; i < MAX_UNIFORM_BUFFER_BINDINGS; ++i)
+		{
+			u[i] = uniformBufferInfo[i].buffer ? static_cast<byte*>(uniformBufferInfo[i].buffer->lock(PUBLIC, PRIVATE)) + uniformBufferInfo[i].offset : nullptr;
+			uniformBuffers[i] = uniformBufferInfo[i].buffer;
+		}
+	}
+
+	void VertexProcessor::setTransformFeedbackBuffer(int index, sw::Resource* buffer, int offset, unsigned int reg, unsigned int row, unsigned int col, unsigned int stride)
+	{
+		transformFeedbackInfo[index].buffer = buffer;
+		transformFeedbackInfo[index].offset = offset;
+		transformFeedbackInfo[index].reg = reg;
+		transformFeedbackInfo[index].row = row;
+		transformFeedbackInfo[index].col = col;
+		transformFeedbackInfo[index].stride = stride;
+	}
+
+	void VertexProcessor::lockTransformFeedbackBuffers(byte** t, unsigned int* v, unsigned int* r, unsigned int* c, unsigned int* s, sw::Resource* transformFeedbackBuffers[])
+	{
+		for(int i = 0; i < MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; ++i)
+		{
+			t[i] = transformFeedbackInfo[i].buffer ? static_cast<byte*>(transformFeedbackInfo[i].buffer->lock(PUBLIC, PRIVATE)) + transformFeedbackInfo[i].offset : nullptr;
+			transformFeedbackBuffers[i] = transformFeedbackInfo[i].buffer;
+			v[i] = transformFeedbackInfo[i].reg;
+			r[i] = transformFeedbackInfo[i].row;
+			c[i] = transformFeedbackInfo[i].col;
+			s[i] = transformFeedbackInfo[i].stride;
+		}
+	}
+
+	void VertexProcessor::setModelMatrix(const Matrix &M, int i)
+	{
+		if(i < 12)
+		{
+			this->M[i] = M;
+
+			updateMatrix = true;
+			updateModelMatrix[i] = true;
+			updateLighting = true;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setViewMatrix(const Matrix &V)
+	{
+		this->V = V;
+
+		updateMatrix = true;
+		updateViewMatrix = true;
+	}
+
+	void VertexProcessor::setBaseMatrix(const Matrix &B)
+	{
+		this->B = B;
+
+		updateMatrix = true;
+		updateBaseMatrix = true;
+	}
+
+	void VertexProcessor::setProjectionMatrix(const Matrix &P)
+	{
+		this->P = P;
+		context->wBasedFog = (P[3][0] != 0.0f) || (P[3][1] != 0.0f) || (P[3][2] != 0.0f) || (P[3][3] != 1.0f);
+
+		updateMatrix = true;
+		updateProjectionMatrix = true;
+	}
+
+	void VertexProcessor::setLightingEnable(bool lightingEnable)
+	{
+		context->setLightingEnable(lightingEnable);
+
+		updateLighting = true;
+	}
+
+	void VertexProcessor::setLightEnable(unsigned int light, bool lightEnable)
+	{
+		if(light < 8)
+		{
+			context->setLightEnable(light, lightEnable);
+		}
+		else ASSERT(false);
+
+		updateLighting = true;
+	}
+
+	void VertexProcessor::setSpecularEnable(bool specularEnable)
+	{
+		context->setSpecularEnable(specularEnable);
+
+		updateLighting = true;
+	}
+
+	void VertexProcessor::setLightPosition(unsigned int light, const Point &lightPosition)
+	{
+		if(light < 8)
+		{
+			context->setLightPosition(light, lightPosition);
+		}
+		else ASSERT(false);
+
+		updateLighting = true;
+	}
+
+	void VertexProcessor::setLightDiffuse(unsigned int light, const Color<float> &lightDiffuse)
+	{
+		if(light < 8)
+		{
+			ff.lightDiffuse[light][0] = lightDiffuse.r;
+			ff.lightDiffuse[light][1] = lightDiffuse.g;
+			ff.lightDiffuse[light][2] = lightDiffuse.b;
+			ff.lightDiffuse[light][3] = lightDiffuse.a;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setLightSpecular(unsigned int light, const Color<float> &lightSpecular)
+	{
+		if(light < 8)
+		{
+			ff.lightSpecular[light][0] = lightSpecular.r;
+			ff.lightSpecular[light][1] = lightSpecular.g;
+			ff.lightSpecular[light][2] = lightSpecular.b;
+			ff.lightSpecular[light][3] = lightSpecular.a;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setLightAmbient(unsigned int light, const Color<float> &lightAmbient)
+	{
+		if(light < 8)
+		{
+			ff.lightAmbient[light][0] = lightAmbient.r;
+			ff.lightAmbient[light][1] = lightAmbient.g;
+			ff.lightAmbient[light][2] = lightAmbient.b;
+			ff.lightAmbient[light][3] = lightAmbient.a;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setLightAttenuation(unsigned int light, float constant, float linear, float quadratic)
+	{
+		if(light < 8)
+		{
+			ff.attenuationConstant[light] = replicate(constant);
+			ff.attenuationLinear[light] = replicate(linear);
+			ff.attenuationQuadratic[light] = replicate(quadratic);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setLightRange(unsigned int light, float lightRange)
+	{
+		if(light < 8)
+		{
+			ff.lightRange[light] = lightRange;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setFogEnable(bool fogEnable)
+	{
+		context->fogEnable = fogEnable;
+	}
+
+	void VertexProcessor::setVertexFogMode(FogMode fogMode)
+	{
+		context->vertexFogMode = fogMode;
+	}
+
+	void VertexProcessor::setInstanceID(int instanceID)
+	{
+		context->instanceID = instanceID;
+	}
+
+	void VertexProcessor::setColorVertexEnable(bool colorVertexEnable)
+	{
+		context->setColorVertexEnable(colorVertexEnable);
+	}
+
+	void VertexProcessor::setDiffuseMaterialSource(MaterialSource diffuseMaterialSource)
+	{
+		context->setDiffuseMaterialSource(diffuseMaterialSource);
+	}
+
+	void VertexProcessor::setSpecularMaterialSource(MaterialSource specularMaterialSource)
+	{
+		context->setSpecularMaterialSource(specularMaterialSource);
+	}
+
+	void VertexProcessor::setAmbientMaterialSource(MaterialSource ambientMaterialSource)
+	{
+		context->setAmbientMaterialSource(ambientMaterialSource);
+	}
+
+	void VertexProcessor::setEmissiveMaterialSource(MaterialSource emissiveMaterialSource)
+	{
+		context->setEmissiveMaterialSource(emissiveMaterialSource);
+	}
+
+	void VertexProcessor::setGlobalAmbient(const Color<float> &globalAmbient)
+	{
+		ff.globalAmbient[0] = globalAmbient.r;
+		ff.globalAmbient[1] = globalAmbient.g;
+		ff.globalAmbient[2] = globalAmbient.b;
+		ff.globalAmbient[3] = globalAmbient.a;
+	}
+
+	void VertexProcessor::setMaterialEmission(const Color<float> &emission)
+	{
+		ff.materialEmission[0] = emission.r;
+		ff.materialEmission[1] = emission.g;
+		ff.materialEmission[2] = emission.b;
+		ff.materialEmission[3] = emission.a;
+	}
+
+	void VertexProcessor::setMaterialAmbient(const Color<float> &materialAmbient)
+	{
+		ff.materialAmbient[0] = materialAmbient.r;
+		ff.materialAmbient[1] = materialAmbient.g;
+		ff.materialAmbient[2] = materialAmbient.b;
+		ff.materialAmbient[3] = materialAmbient.a;
+	}
+
+	void VertexProcessor::setMaterialDiffuse(const Color<float> &diffuseColor)
+	{
+		ff.materialDiffuse[0] = diffuseColor.r;
+		ff.materialDiffuse[1] = diffuseColor.g;
+		ff.materialDiffuse[2] = diffuseColor.b;
+		ff.materialDiffuse[3] = diffuseColor.a;
+	}
+
+	void VertexProcessor::setMaterialSpecular(const Color<float> &specularColor)
+	{
+		ff.materialSpecular[0] = specularColor.r;
+		ff.materialSpecular[1] = specularColor.g;
+		ff.materialSpecular[2] = specularColor.b;
+		ff.materialSpecular[3] = specularColor.a;
+	}
+
+	void VertexProcessor::setMaterialShininess(float specularPower)
+	{
+		ff.materialShininess = specularPower;
+	}
+
+	void VertexProcessor::setLightViewPosition(unsigned int light, const Point &P)
+	{
+		if(light < 8)
+		{
+			ff.lightPosition[light][0] = P.x;
+			ff.lightPosition[light][1] = P.y;
+			ff.lightPosition[light][2] = P.z;
+			ff.lightPosition[light][3] = 1;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setRangeFogEnable(bool enable)
+	{
+		context->rangeFogEnable = enable;
+	}
+
+	void VertexProcessor::setIndexedVertexBlendEnable(bool indexedVertexBlendEnable)
+	{
+		context->indexedVertexBlendEnable = indexedVertexBlendEnable;
+	}
+
+	void VertexProcessor::setVertexBlendMatrixCount(unsigned int vertexBlendMatrixCount)
+	{
+		if(vertexBlendMatrixCount <= 4)
+		{
+			context->vertexBlendMatrixCount = vertexBlendMatrixCount;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setTextureWrap(unsigned int stage, int mask)
+	{
+		if(stage < TEXTURE_IMAGE_UNITS)
+		{
+			context->textureWrap[stage] = mask;
+		}
+		else ASSERT(false);
+
+		context->textureWrapActive = false;
+
+		for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
+		{
+			context->textureWrapActive |= (context->textureWrap[i] != 0x00);
+		}
+	}
+
+	void VertexProcessor::setTexGen(unsigned int stage, TexGen texGen)
+	{
+		if(stage < 8)
+		{
+			context->texGen[stage] = texGen;
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setLocalViewer(bool localViewer)
+	{
+		context->localViewer = localViewer;
+	}
+
+	void VertexProcessor::setNormalizeNormals(bool normalizeNormals)
+	{
+		context->normalizeNormals = normalizeNormals;
+	}
+
+	void VertexProcessor::setTextureMatrix(int stage, const Matrix &T)
+	{
+		for(int i = 0; i < 4; i++)
+		{
+			for(int j = 0; j < 4; j++)
+			{
+				ff.textureTransform[stage][i][j] = T[i][j];
+			}
+		}
+	}
+
+	void VertexProcessor::setTextureTransform(int stage, int count, bool project)
+	{
+		context->textureTransformCount[stage] = count;
+		context->textureTransformProject[stage] = project;
+	}
+
+	void VertexProcessor::setTextureFilter(unsigned int sampler, FilterType textureFilter)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setTextureFilter(textureFilter);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMipmapFilter(unsigned int sampler, MipmapType mipmapFilter)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMipmapFilter(mipmapFilter);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setGatherEnable(unsigned int sampler, bool enable)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setGatherEnable(enable);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setAddressingModeU(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setAddressingModeU(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setAddressingModeV(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setAddressingModeV(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setAddressingModeW(unsigned int sampler, AddressingMode addressMode)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setAddressingModeW(addressMode);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setReadSRGB(unsigned int sampler, bool sRGB)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setReadSRGB(sRGB);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMipmapLOD(unsigned int sampler, float bias)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMipmapLOD(bias);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setBorderColor(unsigned int sampler, const Color<float> &borderColor)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setBorderColor(borderColor);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMaxAnisotropy(unsigned int sampler, float maxAnisotropy)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMaxAnisotropy(maxAnisotropy);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setHighPrecisionFiltering(highPrecisionFiltering);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setSwizzleR(unsigned int sampler, SwizzleType swizzleR)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setSwizzleR(swizzleR);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setSwizzleG(unsigned int sampler, SwizzleType swizzleG)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setSwizzleG(swizzleG);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setSwizzleB(unsigned int sampler, SwizzleType swizzleB)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setSwizzleB(swizzleB);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setSwizzleA(unsigned int sampler, SwizzleType swizzleA)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setSwizzleA(swizzleA);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setCompareFunc(unsigned int sampler, CompareFunc compFunc)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setCompareFunc(compFunc);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setBaseLevel(unsigned int sampler, int baseLevel)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setBaseLevel(baseLevel);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMaxLevel(unsigned int sampler, int maxLevel)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMaxLevel(maxLevel);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMinLod(unsigned int sampler, float minLod)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMinLod(minLod);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setMaxLod(unsigned int sampler, float maxLod)
+	{
+		if(sampler < VERTEX_TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[TEXTURE_IMAGE_UNITS + sampler].setMaxLod(maxLod);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setSyncRequired(unsigned int sampler, bool isSincRequired)
+	{
+		if(sampler < TEXTURE_IMAGE_UNITS)
+		{
+			context->sampler[sampler].setSyncRequired(isSincRequired);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProcessor::setPointSize(float pointSize)
+	{
+		point.pointSize = replicate(pointSize);
+	}
+
+	void VertexProcessor::setPointSizeMin(float pointSizeMin)
+	{
+		point.pointSizeMin = pointSizeMin;
+	}
+
+	void VertexProcessor::setPointSizeMax(float pointSizeMax)
+	{
+		point.pointSizeMax = pointSizeMax;
+	}
+
+	void VertexProcessor::setPointScaleA(float pointScaleA)
+	{
+		point.pointScaleA = pointScaleA;
+	}
+
+	void VertexProcessor::setPointScaleB(float pointScaleB)
+	{
+		point.pointScaleB = pointScaleB;
+	}
+
+	void VertexProcessor::setPointScaleC(float pointScaleC)
+	{
+		point.pointScaleC = pointScaleC;
+	}
+
+	void VertexProcessor::setTransformFeedbackQueryEnabled(bool enable)
+	{
+		context->transformFeedbackQueryEnabled = enable;
+	}
+
+	void VertexProcessor::enableTransformFeedback(uint64_t enable)
+	{
+		context->transformFeedbackEnabled = enable;
+	}
+
+	const Matrix &VertexProcessor::getModelTransform(int i)
+	{
+		updateTransform();
+		return PBVM[i];
+	}
+
+	const Matrix &VertexProcessor::getViewTransform()
+	{
+		updateTransform();
+		return PBV;
+	}
+
+	bool VertexProcessor::isFixedFunction()
+	{
+		return !context->vertexShader;
+	}
+
+	void VertexProcessor::setTransform(const Matrix &M, int i)
+	{
+		ff.transformT[i][0][0] = M[0][0];
+		ff.transformT[i][0][1] = M[1][0];
+		ff.transformT[i][0][2] = M[2][0];
+		ff.transformT[i][0][3] = M[3][0];
+
+		ff.transformT[i][1][0] = M[0][1];
+		ff.transformT[i][1][1] = M[1][1];
+		ff.transformT[i][1][2] = M[2][1];
+		ff.transformT[i][1][3] = M[3][1];
+
+		ff.transformT[i][2][0] = M[0][2];
+		ff.transformT[i][2][1] = M[1][2];
+		ff.transformT[i][2][2] = M[2][2];
+		ff.transformT[i][2][3] = M[3][2];
+
+		ff.transformT[i][3][0] = M[0][3];
+		ff.transformT[i][3][1] = M[1][3];
+		ff.transformT[i][3][2] = M[2][3];
+		ff.transformT[i][3][3] = M[3][3];
+	}
+
+	void VertexProcessor::setCameraTransform(const Matrix &M, int i)
+	{
+		ff.cameraTransformT[i][0][0] = M[0][0];
+		ff.cameraTransformT[i][0][1] = M[1][0];
+		ff.cameraTransformT[i][0][2] = M[2][0];
+		ff.cameraTransformT[i][0][3] = M[3][0];
+
+		ff.cameraTransformT[i][1][0] = M[0][1];
+		ff.cameraTransformT[i][1][1] = M[1][1];
+		ff.cameraTransformT[i][1][2] = M[2][1];
+		ff.cameraTransformT[i][1][3] = M[3][1];
+
+		ff.cameraTransformT[i][2][0] = M[0][2];
+		ff.cameraTransformT[i][2][1] = M[1][2];
+		ff.cameraTransformT[i][2][2] = M[2][2];
+		ff.cameraTransformT[i][2][3] = M[3][2];
+
+		ff.cameraTransformT[i][3][0] = M[0][3];
+		ff.cameraTransformT[i][3][1] = M[1][3];
+		ff.cameraTransformT[i][3][2] = M[2][3];
+		ff.cameraTransformT[i][3][3] = M[3][3];
+	}
+
+	void VertexProcessor::setNormalTransform(const Matrix &M, int i)
+	{
+		ff.normalTransformT[i][0][0] = M[0][0];
+		ff.normalTransformT[i][0][1] = M[1][0];
+		ff.normalTransformT[i][0][2] = M[2][0];
+		ff.normalTransformT[i][0][3] = M[3][0];
+
+		ff.normalTransformT[i][1][0] = M[0][1];
+		ff.normalTransformT[i][1][1] = M[1][1];
+		ff.normalTransformT[i][1][2] = M[2][1];
+		ff.normalTransformT[i][1][3] = M[3][1];
+
+		ff.normalTransformT[i][2][0] = M[0][2];
+		ff.normalTransformT[i][2][1] = M[1][2];
+		ff.normalTransformT[i][2][2] = M[2][2];
+		ff.normalTransformT[i][2][3] = M[3][2];
+
+		ff.normalTransformT[i][3][0] = M[0][3];
+		ff.normalTransformT[i][3][1] = M[1][3];
+		ff.normalTransformT[i][3][2] = M[2][3];
+		ff.normalTransformT[i][3][3] = M[3][3];
+	}
+
+	void VertexProcessor::updateTransform()
+	{
+		if(!updateMatrix) return;
+
+		int activeMatrices = context->indexedVertexBlendEnable ? 12 : max(context->vertexBlendMatrixCount, 1);
+
+		if(updateProjectionMatrix)
+		{
+			PB = P * B;
+			PBV = PB * V;
+
+			for(int i = 0; i < activeMatrices; i++)
+			{
+				PBVM[i] = PBV * M[i];
+				updateModelMatrix[i] = false;
+			}
+
+			updateProjectionMatrix = false;
+			updateBaseMatrix = false;
+			updateViewMatrix = false;
+		}
+
+		if(updateBaseMatrix)
+		{
+			PB = P * B;
+			PBV = PB * V;
+
+			for(int i = 0; i < activeMatrices; i++)
+			{
+				PBVM[i] = PBV * M[i];
+				updateModelMatrix[i] = false;
+			}
+
+			updateBaseMatrix = false;
+			updateViewMatrix = false;
+		}
+
+		if(updateViewMatrix)
+		{
+			PBV = PB * V;
+
+			for(int i = 0; i < activeMatrices; i++)
+			{
+				PBVM[i] = PBV * M[i];
+				updateModelMatrix[i] = false;
+			}
+
+			updateViewMatrix = false;
+		}
+
+		for(int i = 0; i < activeMatrices; i++)
+		{
+			if(updateModelMatrix[i])
+			{
+				PBVM[i] = PBV * M[i];
+				updateModelMatrix[i] = false;
+			}
+		}
+
+		for(int i = 0; i < activeMatrices; i++)
+		{
+			setTransform(PBVM[i], i);
+			setCameraTransform(B * V * M[i], i);
+			setNormalTransform(~!(B * V * M[i]), i);
+		}
+
+		updateMatrix = false;
+	}
+
+	void VertexProcessor::setRoutineCacheSize(int cacheSize)
+	{
+		delete routineCache;
+		routineCache = new RoutineCache<State>(clamp(cacheSize, 1, 65536), precacheVertex ? "sw-vertex" : 0);
+	}
+
+	const VertexProcessor::State VertexProcessor::update(DrawType drawType)
+	{
+		if(isFixedFunction())
+		{
+			updateTransform();
+
+			if(updateLighting)
+			{
+				for(int i = 0; i < 8; i++)
+				{
+					if(context->vertexLightActive(i))
+					{
+						// Light position in camera coordinates
+						setLightViewPosition(i, B * V * context->getLightPosition(i));
+					}
+				}
+
+				updateLighting = false;
+			}
+		}
+
+		State state;
+
+		if(context->vertexShader)
+		{
+			state.shaderID = context->vertexShader->getSerialID();
+		}
+		else
+		{
+			state.shaderID = 0;
+		}
+
+		state.fixedFunction = !context->vertexShader && context->pixelShaderModel() < 0x0300;
+		state.textureSampling = context->vertexShader ? context->vertexShader->containsTextureSampling() : false;
+		state.positionRegister = context->vertexShader ? context->vertexShader->getPositionRegister() : Pos;
+		state.pointSizeRegister = context->vertexShader ? context->vertexShader->getPointSizeRegister() : Pts;
+
+		state.vertexBlendMatrixCount = context->vertexBlendMatrixCountActive();
+		state.indexedVertexBlendEnable = context->indexedVertexBlendActive();
+		state.vertexNormalActive = context->vertexNormalActive();
+		state.normalizeNormals = context->normalizeNormalsActive();
+		state.vertexLightingActive = context->vertexLightingActive();
+		state.diffuseActive = context->diffuseActive();
+		state.specularActive = context->specularActive();
+		state.vertexSpecularActive = context->vertexSpecularActive();
+
+		state.vertexLightActive = context->vertexLightActive(0) << 0 |
+		                          context->vertexLightActive(1) << 1 |
+		                          context->vertexLightActive(2) << 2 |
+		                          context->vertexLightActive(3) << 3 |
+		                          context->vertexLightActive(4) << 4 |
+		                          context->vertexLightActive(5) << 5 |
+		                          context->vertexLightActive(6) << 6 |
+		                          context->vertexLightActive(7) << 7;
+
+		state.vertexDiffuseMaterialSourceActive = context->vertexDiffuseMaterialSourceActive();
+		state.vertexSpecularMaterialSourceActive = context->vertexSpecularMaterialSourceActive();
+		state.vertexAmbientMaterialSourceActive = context->vertexAmbientMaterialSourceActive();
+		state.vertexEmissiveMaterialSourceActive = context->vertexEmissiveMaterialSourceActive();
+		state.fogActive = context->fogActive();
+		state.vertexFogMode = context->vertexFogModeActive();
+		state.rangeFogActive = context->rangeFogActive();
+		state.localViewerActive = context->localViewerActive();
+		state.pointSizeActive = context->pointSizeActive();
+		state.pointScaleActive = context->pointScaleActive();
+
+		state.preTransformed = context->preTransformed;
+		state.superSampling = context->getSuperSampleCount() > 1;
+		state.multiSampling = context->getMultiSampleCount() > 1;
+
+		state.transformFeedbackQueryEnabled = context->transformFeedbackQueryEnabled;
+		state.transformFeedbackEnabled = context->transformFeedbackEnabled;
+
+		// Note: Quads aren't handled for verticesPerPrimitive, but verticesPerPrimitive is used for transform feedback,
+		//       which is an OpenGL ES 3.0 feature, and OpenGL ES 3.0 doesn't support quads as a primitive type.
+		DrawType type = static_cast<DrawType>(static_cast<unsigned int>(drawType) & 0xF);
+		state.verticesPerPrimitive = 1 + (type >= DRAW_LINELIST) + (type >= DRAW_TRIANGLELIST);
+
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			state.input[i].type = context->input[i].type;
+			state.input[i].count = context->input[i].count;
+			state.input[i].normalized = context->input[i].normalized;
+			state.input[i].attribType = context->vertexShader ? context->vertexShader->getAttribType(i) : VertexShader::ATTRIBTYPE_FLOAT;
+		}
+
+		if(!context->vertexShader)
+		{
+			for(int i = 0; i < 8; i++)
+			{
+			//	state.textureState[i].vertexTextureActive = context->vertexTextureActive(i, 0);
+				state.textureState[i].texGenActive = context->texGenActive(i);
+				state.textureState[i].textureTransformCountActive = context->textureTransformCountActive(i);
+				state.textureState[i].texCoordIndexActive = context->texCoordIndexActive(i);
+			}
+		}
+		else
+		{
+			for(unsigned int i = 0; i < VERTEX_TEXTURE_IMAGE_UNITS; i++)
+			{
+				if(context->vertexShader->usesSampler(i))
+				{
+					state.sampler[i] = context->sampler[TEXTURE_IMAGE_UNITS + i].samplerState();
+				}
+			}
+		}
+
+		if(context->vertexShader)   // FIXME: Also when pre-transformed?
+		{
+			for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
+			{
+				state.output[i].xWrite = context->vertexShader->getOutput(i, 0).active();
+				state.output[i].yWrite = context->vertexShader->getOutput(i, 1).active();
+				state.output[i].zWrite = context->vertexShader->getOutput(i, 2).active();
+				state.output[i].wWrite = context->vertexShader->getOutput(i, 3).active();
+			}
+		}
+		else if(!context->preTransformed || context->pixelShaderModel() < 0x0300)
+		{
+			state.output[Pos].write = 0xF;
+
+			if(context->diffuseActive() && (context->lightingEnable || context->input[Color0]))
+			{
+				state.output[C0].write = 0xF;
+			}
+
+			if(context->specularActive())
+			{
+				state.output[C1].write = 0xF;
+			}
+
+			for(int stage = 0; stage < 8; stage++)
+			{
+				if(context->texCoordActive(stage, 0)) state.output[T0 + stage].write |= 0x01;
+				if(context->texCoordActive(stage, 1)) state.output[T0 + stage].write |= 0x02;
+				if(context->texCoordActive(stage, 2)) state.output[T0 + stage].write |= 0x04;
+				if(context->texCoordActive(stage, 3)) state.output[T0 + stage].write |= 0x08;
+			}
+
+			if(context->fogActive())
+			{
+				state.output[Fog].xWrite = true;
+			}
+
+			if(context->pointSizeActive())
+			{
+				state.output[Pts].yWrite = true;
+			}
+		}
+		else
+		{
+			state.output[Pos].write = 0xF;
+
+			for(int i = 0; i < 2; i++)
+			{
+				if(context->input[Color0 + i])
+				{
+					state.output[C0 + i].write = 0xF;
+				}
+			}
+
+			for(int i = 0; i < 8; i++)
+			{
+				if(context->input[TexCoord0 + i])
+				{
+					state.output[T0 + i].write = 0xF;
+				}
+			}
+
+			if(context->input[PointSize])
+			{
+				state.output[Pts].yWrite = true;
+			}
+		}
+
+		if(context->vertexShaderModel() < 0x0300)
+		{
+			state.output[C0].clamp = 0xF;
+			state.output[C1].clamp = 0xF;
+			state.output[Fog].xClamp = true;
+		}
+
+		state.hash = state.computeHash();
+
+		return state;
+	}
+
+	Routine *VertexProcessor::routine(const State &state)
+	{
+		Routine *routine = routineCache->query(state);
+
+		if(!routine)   // Create one
+		{
+			VertexRoutine *generator = nullptr;
+
+			if(state.fixedFunction)
+			{
+				generator = new VertexPipeline(state);
+			}
+			else
+			{
+				generator = new VertexProgram(state, context->vertexShader);
+			}
+
+			generator->generate();
+			routine = (*generator)(L"VertexRoutine_%0.8X", state.shaderID);
+			delete generator;
+
+			routineCache->add(state, routine);
+		}
+
+		return routine;
+	}
+}
diff --git a/src/Device/VertexProcessor.hpp b/src/Device/VertexProcessor.hpp
new file mode 100644
index 0000000..277a155
--- /dev/null
+++ b/src/Device/VertexProcessor.hpp
@@ -0,0 +1,352 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_VertexProcessor_hpp
+#define sw_VertexProcessor_hpp
+
+#include "Matrix.hpp"
+#include "Context.hpp"
+#include "RoutineCache.hpp"
+#include "Shader/VertexShader.hpp"
+
+namespace sw
+{
+	struct DrawData;
+
+	struct VertexCache   // FIXME: Variable size
+	{
+		void clear();
+
+		Vertex vertex[16][4];
+		unsigned int tag[16];
+
+		int drawCall;
+	};
+
+	struct VertexTask
+	{
+		unsigned int vertexCount;
+		unsigned int primitiveStart;
+		VertexCache vertexCache;
+	};
+
+	class VertexProcessor
+	{
+	public:
+		struct States
+		{
+			unsigned int computeHash();
+
+			uint64_t shaderID;
+
+			bool fixedFunction             : 1;   // TODO: Eliminate by querying shader.
+			bool textureSampling           : 1;   // TODO: Eliminate by querying shader.
+			unsigned int positionRegister  : BITS(MAX_VERTEX_OUTPUTS);   // TODO: Eliminate by querying shader.
+			unsigned int pointSizeRegister : BITS(MAX_VERTEX_OUTPUTS);   // TODO: Eliminate by querying shader.
+
+			unsigned int vertexBlendMatrixCount               : 3;
+			bool indexedVertexBlendEnable                     : 1;
+			bool vertexNormalActive                           : 1;
+			bool normalizeNormals                             : 1;
+			bool vertexLightingActive                         : 1;
+			bool diffuseActive                                : 1;
+			bool specularActive                               : 1;
+			bool vertexSpecularActive                         : 1;
+			unsigned int vertexLightActive                    : 8;
+			MaterialSource vertexDiffuseMaterialSourceActive  : BITS(MATERIAL_LAST);
+			MaterialSource vertexSpecularMaterialSourceActive : BITS(MATERIAL_LAST);
+			MaterialSource vertexAmbientMaterialSourceActive  : BITS(MATERIAL_LAST);
+			MaterialSource vertexEmissiveMaterialSourceActive : BITS(MATERIAL_LAST);
+			bool fogActive                                    : 1;
+			FogMode vertexFogMode                             : BITS(FOG_LAST);
+			bool rangeFogActive                               : 1;
+			bool localViewerActive                            : 1;
+			bool pointSizeActive                              : 1;
+			bool pointScaleActive                             : 1;
+			bool transformFeedbackQueryEnabled                : 1;
+			uint64_t transformFeedbackEnabled                 : 64;
+			unsigned char verticesPerPrimitive                : 2; // 1 (points), 2 (lines) or 3 (triangles)
+
+			bool preTransformed : 1;
+			bool superSampling  : 1;
+			bool multiSampling  : 1;
+
+			struct TextureState
+			{
+				TexGen texGenActive                       : BITS(TEXGEN_LAST);
+				unsigned char textureTransformCountActive : 3;
+				unsigned char texCoordIndexActive         : 3;
+			};
+
+			TextureState textureState[8];
+
+			Sampler::State sampler[VERTEX_TEXTURE_IMAGE_UNITS];
+
+			struct Input
+			{
+				operator bool() const   // Returns true if stream contains data
+				{
+					return count != 0;
+				}
+
+				StreamType type    : BITS(STREAMTYPE_LAST);
+				unsigned int count : 3;
+				bool normalized    : 1;
+				unsigned int attribType : BITS(VertexShader::ATTRIBTYPE_LAST);
+			};
+
+			struct Output
+			{
+				union
+				{
+					unsigned char write : 4;
+
+					struct
+					{
+						unsigned char xWrite : 1;
+						unsigned char yWrite : 1;
+						unsigned char zWrite : 1;
+						unsigned char wWrite : 1;
+					};
+				};
+
+				union
+				{
+					unsigned char clamp : 4;
+
+					struct
+					{
+						unsigned char xClamp : 1;
+						unsigned char yClamp : 1;
+						unsigned char zClamp : 1;
+						unsigned char wClamp : 1;
+					};
+				};
+			};
+
+			Input input[MAX_VERTEX_INPUTS];
+			Output output[MAX_VERTEX_OUTPUTS];
+		};
+
+		struct State : States
+		{
+			State();
+
+			bool operator==(const State &state) const;
+
+			unsigned int hash;
+		};
+
+		struct FixedFunction
+		{
+			float4 transformT[12][4];
+			float4 cameraTransformT[12][4];
+			float4 normalTransformT[12][4];
+			float4 textureTransform[8][4];
+
+			float4 lightPosition[8];
+			float4 lightAmbient[8];
+			float4 lightSpecular[8];
+			float4 lightDiffuse[8];
+			float4 attenuationConstant[8];
+			float4 attenuationLinear[8];
+			float4 attenuationQuadratic[8];
+			float lightRange[8];
+			float4 materialDiffuse;
+			float4 materialSpecular;
+			float materialShininess;
+			float4 globalAmbient;
+			float4 materialEmission;
+			float4 materialAmbient;
+		};
+
+		struct PointSprite
+		{
+			float4 pointSize;
+			float pointSizeMin;
+			float pointSizeMax;
+			float pointScaleA;
+			float pointScaleB;
+			float pointScaleC;
+		};
+
+		typedef void (*RoutinePointer)(Vertex *output, unsigned int *batch, VertexTask *vertexTask, DrawData *draw);
+
+		VertexProcessor(Context *context);
+
+		virtual ~VertexProcessor();
+
+		void setInputStream(int index, const Stream &stream);
+		void resetInputStreams(bool preTransformed);
+
+		void setFloatConstant(unsigned int index, const float value[4]);
+		void setIntegerConstant(unsigned int index, const int integer[4]);
+		void setBooleanConstant(unsigned int index, int boolean);
+
+		void setUniformBuffer(int index, sw::Resource* uniformBuffer, int offset);
+		void lockUniformBuffers(byte** u, sw::Resource* uniformBuffers[]);
+
+		void setTransformFeedbackBuffer(int index, sw::Resource* transformFeedbackBuffer, int offset, unsigned int reg, unsigned int row, unsigned int col, unsigned int stride);
+		void lockTransformFeedbackBuffers(byte** t, unsigned int* v, unsigned int* r, unsigned int* c, unsigned int* s, sw::Resource* transformFeedbackBuffers[]);
+
+		// Transformations
+		void setModelMatrix(const Matrix &M, int i = 0);
+		void setViewMatrix(const Matrix &V);
+		void setBaseMatrix(const Matrix &B);
+		void setProjectionMatrix(const Matrix &P);
+
+		// Lighting
+		void setLightingEnable(bool lightingEnable);
+		void setLightEnable(unsigned int light, bool lightEnable);
+		void setSpecularEnable(bool specularEnable);
+
+		void setGlobalAmbient(const Color<float> &globalAmbient);
+		void setLightPosition(unsigned int light, const Point &lightPosition);
+		void setLightViewPosition(unsigned int light, const Point &lightPosition);
+		void setLightDiffuse(unsigned int light, const Color<float> &lightDiffuse);
+		void setLightSpecular(unsigned int light, const Color<float> &lightSpecular);
+		void setLightAmbient(unsigned int light, const Color<float> &lightAmbient);
+		void setLightAttenuation(unsigned int light, float constant, float linear, float quadratic);
+		void setLightRange(unsigned int light, float lightRange);
+
+		void setInstanceID(int instanceID);
+
+		void setFogEnable(bool fogEnable);
+		void setVertexFogMode(FogMode fogMode);
+		void setRangeFogEnable(bool enable);
+
+		void setColorVertexEnable(bool colorVertexEnable);
+		void setDiffuseMaterialSource(MaterialSource diffuseMaterialSource);
+		void setSpecularMaterialSource(MaterialSource specularMaterialSource);
+		void setAmbientMaterialSource(MaterialSource ambientMaterialSource);
+		void setEmissiveMaterialSource(MaterialSource emissiveMaterialSource);
+
+		void setMaterialEmission(const Color<float> &emission);
+		void setMaterialAmbient(const Color<float> &materialAmbient);
+		void setMaterialDiffuse(const Color<float> &diffuseColor);
+		void setMaterialSpecular(const Color<float> &specularColor);
+		void setMaterialShininess(float specularPower);
+
+		void setIndexedVertexBlendEnable(bool indexedVertexBlendEnable);
+		void setVertexBlendMatrixCount(unsigned int vertexBlendMatrixCount);
+
+		void setTextureWrap(unsigned int stage, int mask);
+		void setTexGen(unsigned int stage, TexGen texGen);
+		void setLocalViewer(bool localViewer);
+		void setNormalizeNormals(bool normalizeNormals);
+		void setTextureMatrix(int stage, const Matrix &T);
+		void setTextureTransform(int stage, int count, bool project);
+
+		void setTextureFilter(unsigned int sampler, FilterType textureFilter);
+		void setMipmapFilter(unsigned int sampler, MipmapType mipmapFilter);
+		void setGatherEnable(unsigned int sampler, bool enable);
+		void setAddressingModeU(unsigned int sampler, AddressingMode addressingMode);
+		void setAddressingModeV(unsigned int sampler, AddressingMode addressingMode);
+		void setAddressingModeW(unsigned int sampler, AddressingMode addressingMode);
+		void setReadSRGB(unsigned int sampler, bool sRGB);
+		void setMipmapLOD(unsigned int sampler, float bias);
+		void setBorderColor(unsigned int sampler, const Color<float> &borderColor);
+		void setMaxAnisotropy(unsigned int stage, float maxAnisotropy);
+		void setHighPrecisionFiltering(unsigned int sampler, bool highPrecisionFiltering);
+		void setSwizzleR(unsigned int sampler, SwizzleType swizzleR);
+		void setSwizzleG(unsigned int sampler, SwizzleType swizzleG);
+		void setSwizzleB(unsigned int sampler, SwizzleType swizzleB);
+		void setSwizzleA(unsigned int sampler, SwizzleType swizzleA);
+		void setCompareFunc(unsigned int sampler, CompareFunc compare);
+		void setBaseLevel(unsigned int sampler, int baseLevel);
+		void setMaxLevel(unsigned int sampler, int maxLevel);
+		void setMinLod(unsigned int sampler, float minLod);
+		void setMaxLod(unsigned int sampler, float maxLod);
+		void setSyncRequired(unsigned int sampler, bool isSincRequired);
+
+		void setPointSize(float pointSize);
+		void setPointSizeMin(float pointSizeMin);
+		void setPointSizeMax(float pointSizeMax);
+		void setPointScaleA(float pointScaleA);
+		void setPointScaleB(float pointScaleB);
+		void setPointScaleC(float pointScaleC);
+
+		void setTransformFeedbackQueryEnabled(bool enable);
+		void enableTransformFeedback(uint64_t enable);
+
+	protected:
+		const Matrix &getModelTransform(int i);
+		const Matrix &getViewTransform();
+
+		const State update(DrawType drawType);
+		Routine *routine(const State &state);
+
+		bool isFixedFunction();
+		void setRoutineCacheSize(int cacheSize);
+
+		// Shader constants
+		float4 c[VERTEX_UNIFORM_VECTORS + 1];   // One extra for indices out of range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0}
+		int4 i[16];
+		bool b[16];
+
+		PointSprite point;
+		FixedFunction ff;
+
+	private:
+		struct UniformBufferInfo
+		{
+			UniformBufferInfo();
+
+			Resource* buffer;
+			int offset;
+		};
+		UniformBufferInfo uniformBufferInfo[MAX_UNIFORM_BUFFER_BINDINGS];
+
+		struct TransformFeedbackInfo
+		{
+			TransformFeedbackInfo();
+
+			Resource* buffer;
+			unsigned int offset;
+			unsigned int reg;
+			unsigned int row;
+			unsigned int col;
+			unsigned int stride;
+		};
+		TransformFeedbackInfo transformFeedbackInfo[MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS];
+
+		void updateTransform();
+		void setTransform(const Matrix &M, int i);
+		void setCameraTransform(const Matrix &M, int i);
+		void setNormalTransform(const Matrix &M, int i);
+
+		Context *const context;
+
+		RoutineCache<State> *routineCache;
+
+	protected:
+		Matrix M[12];      // Model/Geometry/World matrix
+		Matrix V;          // View/Camera/Eye matrix
+		Matrix B;          // Base matrix
+		Matrix P;          // Projection matrix
+		Matrix PB;         // P * B
+		Matrix PBV;        // P * B * V
+		Matrix PBVM[12];   // P * B * V * M
+
+		// Update hierarchy
+		bool updateMatrix;
+		bool updateModelMatrix[12];
+		bool updateViewMatrix;
+		bool updateBaseMatrix;
+		bool updateProjectionMatrix;
+		bool updateLighting;
+	};
+}
+
+#endif   // sw_VertexProcessor_hpp
diff --git a/src/Pipeline/Constants.cpp b/src/Pipeline/Constants.cpp
new file mode 100644
index 0000000..06dda32
--- /dev/null
+++ b/src/Pipeline/Constants.cpp
@@ -0,0 +1,362 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Constants.hpp"
+
+#include "Common/Math.hpp"
+#include "Common/Half.hpp"
+
+#include <memory.h>
+
+namespace sw
+{
+	Constants constants;
+
+	Constants::Constants()
+	{
+		static const unsigned int transposeBit0[16] =
+		{
+			0x00000000,
+			0x00000001,
+			0x00000010,
+			0x00000011,
+			0x00000100,
+			0x00000101,
+			0x00000110,
+			0x00000111,
+			0x00001000,
+			0x00001001,
+			0x00001010,
+			0x00001011,
+			0x00001100,
+			0x00001101,
+			0x00001110,
+			0x00001111
+		};
+
+		static const unsigned int transposeBit1[16] =
+		{
+			0x00000000,
+			0x00000002,
+			0x00000020,
+			0x00000022,
+			0x00000200,
+			0x00000202,
+			0x00000220,
+			0x00000222,
+			0x00002000,
+			0x00002002,
+			0x00002020,
+			0x00002022,
+			0x00002200,
+			0x00002202,
+			0x00002220,
+			0x00002222
+		};
+
+		static const unsigned int transposeBit2[16] =
+		{
+			0x00000000,
+			0x00000004,
+			0x00000040,
+			0x00000044,
+			0x00000400,
+			0x00000404,
+			0x00000440,
+			0x00000444,
+			0x00004000,
+			0x00004004,
+			0x00004040,
+			0x00004044,
+			0x00004400,
+			0x00004404,
+			0x00004440,
+			0x00004444
+		};
+
+		memcpy(&this->transposeBit0, transposeBit0, sizeof(transposeBit0));
+		memcpy(&this->transposeBit1, transposeBit1, sizeof(transposeBit1));
+		memcpy(&this->transposeBit2, transposeBit2, sizeof(transposeBit2));
+
+		static const ushort4 cWeight[17] =
+		{
+			{0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF},   // 0xFFFF / 1  = 0xFFFF
+			{0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF},   // 0xFFFF / 1  = 0xFFFF
+			{0x8000, 0x8000, 0x8000, 0x8000},   // 0xFFFF / 2  = 0x8000
+			{0x5555, 0x5555, 0x5555, 0x5555},   // 0xFFFF / 3  = 0x5555
+			{0x4000, 0x4000, 0x4000, 0x4000},   // 0xFFFF / 4  = 0x4000
+			{0x3333, 0x3333, 0x3333, 0x3333},   // 0xFFFF / 5  = 0x3333
+			{0x2AAA, 0x2AAA, 0x2AAA, 0x2AAA},   // 0xFFFF / 6  = 0x2AAA
+			{0x2492, 0x2492, 0x2492, 0x2492},   // 0xFFFF / 7  = 0x2492
+			{0x2000, 0x2000, 0x2000, 0x2000},   // 0xFFFF / 8  = 0x2000
+			{0x1C71, 0x1C71, 0x1C71, 0x1C71},   // 0xFFFF / 9  = 0x1C71
+			{0x1999, 0x1999, 0x1999, 0x1999},   // 0xFFFF / 10 = 0x1999
+			{0x1745, 0x1745, 0x1745, 0x1745},   // 0xFFFF / 11 = 0x1745
+			{0x1555, 0x1555, 0x1555, 0x1555},   // 0xFFFF / 12 = 0x1555
+			{0x13B1, 0x13B1, 0x13B1, 0x13B1},   // 0xFFFF / 13 = 0x13B1
+			{0x1249, 0x1249, 0x1249, 0x1249},   // 0xFFFF / 14 = 0x1249
+			{0x1111, 0x1111, 0x1111, 0x1111},   // 0xFFFF / 15 = 0x1111
+			{0x1000, 0x1000, 0x1000, 0x1000},   // 0xFFFF / 16 = 0x1000
+		};
+
+		static const float4 uvWeight[17] =
+		{
+			{1.0f / 1.0f,  1.0f / 1.0f,  1.0f / 1.0f,  1.0f / 1.0f},
+			{1.0f / 1.0f,  1.0f / 1.0f,  1.0f / 1.0f,  1.0f / 1.0f},
+			{1.0f / 2.0f,  1.0f / 2.0f,  1.0f / 2.0f,  1.0f / 2.0f},
+			{1.0f / 3.0f,  1.0f / 3.0f,  1.0f / 3.0f,  1.0f / 3.0f},
+			{1.0f / 4.0f,  1.0f / 4.0f,  1.0f / 4.0f,  1.0f / 4.0f},
+			{1.0f / 5.0f,  1.0f / 5.0f,  1.0f / 5.0f,  1.0f / 5.0f},
+			{1.0f / 6.0f,  1.0f / 6.0f,  1.0f / 6.0f,  1.0f / 6.0f},
+			{1.0f / 7.0f,  1.0f / 7.0f,  1.0f / 7.0f,  1.0f / 7.0f},
+			{1.0f / 8.0f,  1.0f / 8.0f,  1.0f / 8.0f,  1.0f / 8.0f},
+			{1.0f / 9.0f,  1.0f / 9.0f,  1.0f / 9.0f,  1.0f / 9.0f},
+			{1.0f / 10.0f, 1.0f / 10.0f, 1.0f / 10.0f, 1.0f / 10.0f},
+			{1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f},
+			{1.0f / 12.0f, 1.0f / 12.0f, 1.0f / 12.0f, 1.0f / 12.0f},
+			{1.0f / 13.0f, 1.0f / 13.0f, 1.0f / 13.0f, 1.0f / 13.0f},
+			{1.0f / 14.0f, 1.0f / 14.0f, 1.0f / 14.0f, 1.0f / 14.0f},
+			{1.0f / 15.0f, 1.0f / 15.0f, 1.0f / 15.0f, 1.0f / 15.0f},
+			{1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f, 1.0f / 16.0f},
+		};
+
+		static const float4 uvStart[17] =
+		{
+			{-0.0f / 2.0f,   -0.0f / 2.0f,   -0.0f / 2.0f,   -0.0f / 2.0f},
+			{-0.0f / 2.0f,   -0.0f / 2.0f,   -0.0f / 2.0f,   -0.0f / 2.0f},
+			{-1.0f / 4.0f,   -1.0f / 4.0f,   -1.0f / 4.0f,   -1.0f / 4.0f},
+			{-2.0f / 6.0f,   -2.0f / 6.0f,   -2.0f / 6.0f,   -2.0f / 6.0f},
+			{-3.0f / 8.0f,   -3.0f / 8.0f,   -3.0f / 8.0f,   -3.0f / 8.0f},
+			{-4.0f / 10.0f,  -4.0f / 10.0f,  -4.0f / 10.0f,  -4.0f / 10.0f},
+			{-5.0f / 12.0f,  -5.0f / 12.0f,  -5.0f / 12.0f,  -5.0f / 12.0f},
+			{-6.0f / 14.0f,  -6.0f / 14.0f,  -6.0f / 14.0f,  -6.0f / 14.0f},
+			{-7.0f / 16.0f,  -7.0f / 16.0f,  -7.0f / 16.0f,  -7.0f / 16.0f},
+			{-8.0f / 18.0f,  -8.0f / 18.0f,  -8.0f / 18.0f,  -8.0f / 18.0f},
+			{-9.0f / 20.0f,  -9.0f / 20.0f,  -9.0f / 20.0f,  -9.0f / 20.0f},
+			{-10.0f / 22.0f, -10.0f / 22.0f, -10.0f / 22.0f, -10.0f / 22.0f},
+			{-11.0f / 24.0f, -11.0f / 24.0f, -11.0f / 24.0f, -11.0f / 24.0f},
+			{-12.0f / 26.0f, -12.0f / 26.0f, -12.0f / 26.0f, -12.0f / 26.0f},
+			{-13.0f / 28.0f, -13.0f / 28.0f, -13.0f / 28.0f, -13.0f / 28.0f},
+			{-14.0f / 30.0f, -14.0f / 30.0f, -14.0f / 30.0f, -14.0f / 30.0f},
+			{-15.0f / 32.0f, -15.0f / 32.0f, -15.0f / 32.0f, -15.0f / 32.0f},
+		};
+
+		memcpy(&this->cWeight, cWeight, sizeof(cWeight));
+		memcpy(&this->uvWeight, uvWeight, sizeof(uvWeight));
+		memcpy(&this->uvStart, uvStart, sizeof(uvStart));
+
+		static const unsigned int occlusionCount[16] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+
+		memcpy(&this->occlusionCount, &occlusionCount, sizeof(occlusionCount));
+
+		for(int i = 0; i < 16; i++)
+		{
+			maskB4Q[i][0] = -(i >> 0 & 1);
+			maskB4Q[i][1] = -(i >> 1 & 1);
+			maskB4Q[i][2] = -(i >> 2 & 1);
+			maskB4Q[i][3] = -(i >> 3 & 1);
+			maskB4Q[i][4] = -(i >> 0 & 1);
+			maskB4Q[i][5] = -(i >> 1 & 1);
+			maskB4Q[i][6] = -(i >> 2 & 1);
+			maskB4Q[i][7] = -(i >> 3 & 1);
+
+			invMaskB4Q[i][0] = ~maskB4Q[i][0];
+			invMaskB4Q[i][1] = ~maskB4Q[i][1];
+			invMaskB4Q[i][2] = ~maskB4Q[i][2];
+			invMaskB4Q[i][3] = ~maskB4Q[i][3];
+			invMaskB4Q[i][4] = ~maskB4Q[i][4];
+			invMaskB4Q[i][5] = ~maskB4Q[i][5];
+			invMaskB4Q[i][6] = ~maskB4Q[i][6];
+			invMaskB4Q[i][7] = ~maskB4Q[i][7];
+
+			maskW4Q[i][0] = -(i >> 0 & 1);
+			maskW4Q[i][1] = -(i >> 1 & 1);
+			maskW4Q[i][2] = -(i >> 2 & 1);
+			maskW4Q[i][3] = -(i >> 3 & 1);
+
+			invMaskW4Q[i][0] = ~maskW4Q[i][0];
+			invMaskW4Q[i][1] = ~maskW4Q[i][1];
+			invMaskW4Q[i][2] = ~maskW4Q[i][2];
+			invMaskW4Q[i][3] = ~maskW4Q[i][3];
+
+			maskD4X[i][0] = -(i >> 0 & 1);
+			maskD4X[i][1] = -(i >> 1 & 1);
+			maskD4X[i][2] = -(i >> 2 & 1);
+			maskD4X[i][3] = -(i >> 3 & 1);
+
+			invMaskD4X[i][0] = ~maskD4X[i][0];
+			invMaskD4X[i][1] = ~maskD4X[i][1];
+			invMaskD4X[i][2] = ~maskD4X[i][2];
+			invMaskD4X[i][3] = ~maskD4X[i][3];
+
+			maskQ0Q[i] = -(i >> 0 & 1);
+			maskQ1Q[i] = -(i >> 1 & 1);
+			maskQ2Q[i] = -(i >> 2 & 1);
+			maskQ3Q[i] = -(i >> 3 & 1);
+
+			invMaskQ0Q[i] = ~maskQ0Q[i];
+			invMaskQ1Q[i] = ~maskQ1Q[i];
+			invMaskQ2Q[i] = ~maskQ2Q[i];
+			invMaskQ3Q[i] = ~maskQ3Q[i];
+
+			maskX0X[i][0] = maskX0X[i][1] = maskX0X[i][2] = maskX0X[i][3] = -(i >> 0 & 1);
+			maskX1X[i][0] = maskX1X[i][1] = maskX1X[i][2] = maskX1X[i][3] = -(i >> 1 & 1);
+			maskX2X[i][0] = maskX2X[i][1] = maskX2X[i][2] = maskX2X[i][3] = -(i >> 2 & 1);
+			maskX3X[i][0] = maskX3X[i][1] = maskX3X[i][2] = maskX3X[i][3] = -(i >> 3 & 1);
+
+			invMaskX0X[i][0] = invMaskX0X[i][1] = invMaskX0X[i][2] = invMaskX0X[i][3] = ~maskX0X[i][0];
+			invMaskX1X[i][0] = invMaskX1X[i][1] = invMaskX1X[i][2] = invMaskX1X[i][3] = ~maskX1X[i][0];
+			invMaskX2X[i][0] = invMaskX2X[i][1] = invMaskX2X[i][2] = invMaskX2X[i][3] = ~maskX2X[i][0];
+			invMaskX3X[i][0] = invMaskX3X[i][1] = invMaskX3X[i][2] = invMaskX3X[i][3] = ~maskX3X[i][0];
+
+			maskD01Q[i][0] = -(i >> 0 & 1);
+			maskD01Q[i][1] = -(i >> 1 & 1);
+			maskD23Q[i][0] = -(i >> 2 & 1);
+			maskD23Q[i][1] = -(i >> 3 & 1);
+
+			invMaskD01Q[i][0] = ~maskD01Q[i][0];
+			invMaskD01Q[i][1] = ~maskD01Q[i][1];
+			invMaskD23Q[i][0] = ~maskD23Q[i][0];
+			invMaskD23Q[i][1] = ~maskD23Q[i][1];
+
+			maskQ01X[i][0] = -(i >> 0 & 1);
+			maskQ01X[i][1] = -(i >> 1 & 1);
+			maskQ23X[i][0] = -(i >> 2 & 1);
+			maskQ23X[i][1] = -(i >> 3 & 1);
+
+			invMaskQ01X[i][0] = ~maskQ01X[i][0];
+			invMaskQ01X[i][1] = ~maskQ01X[i][1];
+			invMaskQ23X[i][0] = ~maskQ23X[i][0];
+			invMaskQ23X[i][1] = ~maskQ23X[i][1];
+		}
+
+		for(int i = 0; i < 8; i++)
+		{
+			mask565Q[i][0] =
+			mask565Q[i][1] =
+			mask565Q[i][2] =
+			mask565Q[i][3] = (i & 0x1 ? 0x001F : 0) | (i & 0x2 ? 0x07E0 : 0) | (i & 0x4 ? 0xF800 : 0);
+		}
+
+		for(int i = 0; i < 4; i++)
+		{
+			maskW01Q[i][0] =  -(i >> 0 & 1);
+			maskW01Q[i][1] =  -(i >> 1 & 1);
+			maskW01Q[i][2] =  -(i >> 0 & 1);
+			maskW01Q[i][3] =  -(i >> 1 & 1);
+
+			maskD01X[i][0] =  -(i >> 0 & 1);
+			maskD01X[i][1] =  -(i >> 1 & 1);
+			maskD01X[i][2] =  -(i >> 0 & 1);
+			maskD01X[i][3] =  -(i >> 1 & 1);
+		}
+
+		for(int i = 0; i < 256; i++)
+		{
+			sRGBtoLinear8_16[i] = (unsigned short)(sw::sRGBtoLinear((float)i / 0xFF) * 0xFFFF + 0.5f);
+		}
+
+		for(int i = 0; i < 64; i++)
+		{
+			sRGBtoLinear6_16[i] = (unsigned short)(sw::sRGBtoLinear((float)i / 0x3F) * 0xFFFF + 0.5f);
+		}
+
+		for(int i = 0; i < 32; i++)
+		{
+			sRGBtoLinear5_16[i] = (unsigned short)(sw::sRGBtoLinear((float)i / 0x1F) * 0xFFFF + 0.5f);
+		}
+
+		for(int i = 0; i < 0x1000; i++)
+		{
+			linearToSRGB12_16[i] = (unsigned short)(clamp(sw::linearToSRGB((float)i / 0x0FFF) * 0xFFFF + 0.5f, 0.0f, (float)0xFFFF));
+			sRGBtoLinear12_16[i] = (unsigned short)(clamp(sw::sRGBtoLinear((float)i / 0x0FFF) * 0xFFFF + 0.5f, 0.0f, (float)0xFFFF));
+		}
+
+		for(int q = 0; q < 4; q++)
+		{
+			for(int c = 0; c < 16; c++)
+			{
+				for(int i = 0; i < 4; i++)
+				{
+					const float X[4] = {+0.3125f, -0.3125f, -0.1250f, +0.1250f};
+					const float Y[4] = {+0.1250f, -0.1250f, +0.3125f, -0.3125f};
+
+					sampleX[q][c][i] = c & (1 << i) ? X[q] : 0.0f;
+					sampleY[q][c][i] = c & (1 << i) ? Y[q] : 0.0f;
+					weight[c][i] = c & (1 << i) ? 1.0f : 0.0f;
+				}
+			}
+		}
+
+		const int Xf[4] = {-5, +5, +2, -2};   // Fragment offsets
+		const int Yf[4] = {-2, +2, -5, +5};   // Fragment offsets
+
+		memcpy(&this->Xf, &Xf, sizeof(Xf));
+		memcpy(&this->Yf, &Yf, sizeof(Yf));
+
+		static const float4 X[4] = {{-0.3125f, -0.3125f, -0.3125f, -0.3125f},
+					                {+0.3125f, +0.3125f, +0.3125f, +0.3125f},
+					                {+0.1250f, +0.1250f, +0.1250f, +0.1250f},
+					                {-0.1250f, -0.1250f, -0.1250f, -0.1250f}};
+
+		static const float4 Y[4] = {{-0.1250f, -0.1250f, -0.1250f, -0.1250f},
+		                            {+0.1250f, +0.1250f, +0.1250f, +0.1250f},
+		                            {-0.3125f, -0.3125f, -0.3125f, -0.3125f},
+		                            {+0.3125f, +0.3125f, +0.3125f, +0.3125f}};
+
+		memcpy(&this->X, &X, sizeof(X));
+		memcpy(&this->Y, &Y, sizeof(Y));
+
+		const dword maxX[16] = {0x00000000, 0x00000001, 0x00000100, 0x00000101, 0x00010000, 0x00010001, 0x00010100, 0x00010101, 0x01000000, 0x01000001, 0x01000100, 0x01000101, 0x01010000, 0x01010001, 0x01010100, 0x01010101};
+		const dword maxY[16] = {0x00000000, 0x00000002, 0x00000200, 0x00000202, 0x00020000, 0x00020002, 0x00020200, 0x00020202, 0x02000000, 0x02000002, 0x02000200, 0x02000202, 0x02020000, 0x02020002, 0x02020200, 0x02020202};
+		const dword maxZ[16] = {0x00000000, 0x00000004, 0x00000400, 0x00000404, 0x00040000, 0x00040004, 0x00040400, 0x00040404, 0x04000000, 0x04000004, 0x04000400, 0x04000404, 0x04040000, 0x04040004, 0x04040400, 0x04040404};
+		const dword minX[16] = {0x00000000, 0x00000008, 0x00000800, 0x00000808, 0x00080000, 0x00080008, 0x00080800, 0x00080808, 0x08000000, 0x08000008, 0x08000800, 0x08000808, 0x08080000, 0x08080008, 0x08080800, 0x08080808};
+		const dword minY[16] = {0x00000000, 0x00000010, 0x00001000, 0x00001010, 0x00100000, 0x00100010, 0x00101000, 0x00101010, 0x10000000, 0x10000010, 0x10001000, 0x10001010, 0x10100000, 0x10100010, 0x10101000, 0x10101010};
+		const dword minZ[16] = {0x00000000, 0x00000020, 0x00002000, 0x00002020, 0x00200000, 0x00200020, 0x00202000, 0x00202020, 0x20000000, 0x20000020, 0x20002000, 0x20002020, 0x20200000, 0x20200020, 0x20202000, 0x20202020};
+		const dword fini[16] = {0x00000000, 0x00000080, 0x00008000, 0x00008080, 0x00800000, 0x00800080, 0x00808000, 0x00808080, 0x80000000, 0x80000080, 0x80008000, 0x80008080, 0x80800000, 0x80800080, 0x80808000, 0x80808080};
+
+		memcpy(&this->maxX, &maxX, sizeof(maxX));
+		memcpy(&this->maxY, &maxY, sizeof(maxY));
+		memcpy(&this->maxZ, &maxZ, sizeof(maxZ));
+		memcpy(&this->minX, &minX, sizeof(minX));
+		memcpy(&this->minY, &minY, sizeof(minY));
+		memcpy(&this->minZ, &minZ, sizeof(minZ));
+		memcpy(&this->fini, &fini, sizeof(fini));
+
+		static const dword4 maxPos = {0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFF, 0x7F7FFFFE};
+
+		memcpy(&this->maxPos, &maxPos, sizeof(maxPos));
+
+		static const float4 unscaleByte = {1.0f / 0xFF, 1.0f / 0xFF, 1.0f / 0xFF, 1.0f / 0xFF};
+		static const float4 unscaleSByte = {1.0f / 0x7F, 1.0f / 0x7F, 1.0f / 0x7F, 1.0f / 0x7F};
+		static const float4 unscaleShort = {1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF, 1.0f / 0x7FFF};
+		static const float4 unscaleUShort = {1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF, 1.0f / 0xFFFF};
+		static const float4 unscaleInt = {1.0f / 0x7FFFFFFF, 1.0f / 0x7FFFFFFF, 1.0f / 0x7FFFFFFF, 1.0f / 0x7FFFFFFF};
+		static const float4 unscaleUInt = {1.0f / 0xFFFFFFFF, 1.0f / 0xFFFFFFFF, 1.0f / 0xFFFFFFFF, 1.0f / 0xFFFFFFFF};
+		static const float4 unscaleFixed = {1.0f / 0x00010000, 1.0f / 0x00010000, 1.0f / 0x00010000, 1.0f / 0x00010000};
+
+		memcpy(&this->unscaleByte, &unscaleByte, sizeof(unscaleByte));
+		memcpy(&this->unscaleSByte, &unscaleSByte, sizeof(unscaleSByte));
+		memcpy(&this->unscaleShort, &unscaleShort, sizeof(unscaleShort));
+		memcpy(&this->unscaleUShort, &unscaleUShort, sizeof(unscaleUShort));
+		memcpy(&this->unscaleInt, &unscaleInt, sizeof(unscaleInt));
+		memcpy(&this->unscaleUInt, &unscaleUInt, sizeof(unscaleUInt));
+		memcpy(&this->unscaleFixed, &unscaleFixed, sizeof(unscaleFixed));
+
+		for(int i = 0; i <= 0xFFFF; i++)
+		{
+			half2float[i] = (float)reinterpret_cast<half&>(i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Pipeline/Constants.hpp b/src/Pipeline/Constants.hpp
new file mode 100644
index 0000000..6b70e04
--- /dev/null
+++ b/src/Pipeline/Constants.hpp
@@ -0,0 +1,113 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Constants_hpp
+#define sw_Constants_hpp
+
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	struct Constants
+	{
+		Constants();
+
+		unsigned int transposeBit0[16];
+		unsigned int transposeBit1[16];
+		unsigned int transposeBit2[16];
+
+		ushort4 cWeight[17];
+		float4 uvWeight[17];
+		float4 uvStart[17];
+
+		unsigned int occlusionCount[16];
+
+		byte8 maskB4Q[16];
+		byte8 invMaskB4Q[16];
+		word4 maskW4Q[16];
+		word4 invMaskW4Q[16];
+		dword4 maskD4X[16];
+		dword4 invMaskD4X[16];
+		qword maskQ0Q[16];
+		qword maskQ1Q[16];
+		qword maskQ2Q[16];
+		qword maskQ3Q[16];
+		qword invMaskQ0Q[16];
+		qword invMaskQ1Q[16];
+		qword invMaskQ2Q[16];
+		qword invMaskQ3Q[16];
+		dword4 maskX0X[16];
+		dword4 maskX1X[16];
+		dword4 maskX2X[16];
+		dword4 maskX3X[16];
+		dword4 invMaskX0X[16];
+		dword4 invMaskX1X[16];
+		dword4 invMaskX2X[16];
+		dword4 invMaskX3X[16];
+		dword2 maskD01Q[16];
+		dword2 maskD23Q[16];
+		dword2 invMaskD01Q[16];
+		dword2 invMaskD23Q[16];
+		qword2 maskQ01X[16];
+		qword2 maskQ23X[16];
+		qword2 invMaskQ01X[16];
+		qword2 invMaskQ23X[16];
+		word4 maskW01Q[4];
+		dword4 maskD01X[4];
+		word4 mask565Q[8];
+
+		unsigned short sRGBtoLinear8_16[256];
+		unsigned short sRGBtoLinear6_16[64];
+		unsigned short sRGBtoLinear5_16[32];
+
+		unsigned short linearToSRGB12_16[4096];
+		unsigned short sRGBtoLinear12_16[4096];
+
+		// Centroid parameters
+		float4 sampleX[4][16];
+		float4 sampleY[4][16];
+		float4 weight[16];
+
+		// Fragment offsets
+		int Xf[4];
+		int Yf[4];
+
+		float4 X[4];
+		float4 Y[4];
+
+		dword maxX[16];
+		dword maxY[16];
+		dword maxZ[16];
+		dword minX[16];
+		dword minY[16];
+		dword minZ[16];
+		dword fini[16];
+
+		dword4 maxPos;
+
+		float4 unscaleByte;
+		float4 unscaleSByte;
+		float4 unscaleShort;
+		float4 unscaleUShort;
+		float4 unscaleInt;
+		float4 unscaleUInt;
+		float4 unscaleFixed;
+
+		float half2float[65536];
+	};
+
+	extern Constants constants;
+}
+
+#endif   // sw_Constants_hpp
diff --git a/src/Pipeline/PixelPipeline.cpp b/src/Pipeline/PixelPipeline.cpp
new file mode 100644
index 0000000..d4faebd
--- /dev/null
+++ b/src/Pipeline/PixelPipeline.cpp
@@ -0,0 +1,1959 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelPipeline.hpp"
+#include "SamplerCore.hpp"
+#include "Renderer/Renderer.hpp"
+
+namespace sw
+{
+	extern bool postBlendSRGB;
+
+	void PixelPipeline::setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w)
+	{
+		if(state.color[0].component & 0x1) diffuse.x = convertFixed12(v[0].x); else diffuse.x = Short4(0x1000);
+		if(state.color[0].component & 0x2) diffuse.y = convertFixed12(v[0].y); else diffuse.y = Short4(0x1000);
+		if(state.color[0].component & 0x4) diffuse.z = convertFixed12(v[0].z); else diffuse.z = Short4(0x1000);
+		if(state.color[0].component & 0x8) diffuse.w = convertFixed12(v[0].w); else diffuse.w = Short4(0x1000);
+
+		if(state.color[1].component & 0x1) specular.x = convertFixed12(v[1].x); else specular.x = Short4(0x0000);
+		if(state.color[1].component & 0x2) specular.y = convertFixed12(v[1].y); else specular.y = Short4(0x0000);
+		if(state.color[1].component & 0x4) specular.z = convertFixed12(v[1].z); else specular.z = Short4(0x0000);
+		if(state.color[1].component & 0x8) specular.w = convertFixed12(v[1].w); else specular.w = Short4(0x0000);
+	}
+
+	void PixelPipeline::fixedFunction()
+	{
+		current = diffuse;
+		Vector4s temp(0x0000, 0x0000, 0x0000, 0x0000);
+
+		for(int stage = 0; stage < 8; stage++)
+		{
+			if(state.textureStage[stage].stageOperation == TextureStage::STAGE_DISABLE)
+			{
+				break;
+			}
+
+			Vector4s texture;
+
+			if(state.textureStage[stage].usesTexture)
+			{
+				texture = sampleTexture(stage, stage);
+			}
+
+			blendTexture(temp, texture, stage);
+		}
+
+		specularPixel(current, specular);
+	}
+
+	void PixelPipeline::applyShader(Int cMask[4])
+	{
+		if(!shader)
+		{
+			fixedFunction();
+			return;
+		}
+
+		int pad = 0;        // Count number of texm3x3pad instructions
+		Vector4s dPairing;   // Destination for first pairing instruction
+
+		for(size_t i = 0; i < shader->getLength(); i++)
+		{
+			const Shader::Instruction *instruction = shader->getInstruction(i);
+			Shader::Opcode opcode = instruction->opcode;
+
+			//	#ifndef NDEBUG   // FIXME: Centralize debug output control
+			//		shader->printInstruction(i, "debug.txt");
+			//	#endif
+
+			if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB)
+			{
+				continue;
+			}
+
+			const Dst &dst = instruction->dst;
+			const Src &src0 = instruction->src[0];
+			const Src &src1 = instruction->src[1];
+			const Src &src2 = instruction->src[2];
+
+			unsigned short shaderModel = shader->getShaderModel();
+			bool pairing = i + 1 < shader->getLength() && shader->getInstruction(i + 1)->coissue;   // First instruction of pair
+			bool coissue = instruction->coissue;                                                              // Second instruction of pair
+
+			Vector4s d;
+			Vector4s s0;
+			Vector4s s1;
+			Vector4s s2;
+
+			if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegister(src0);
+			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegister(src1);
+			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegister(src2);
+
+			Float4 x = shaderModel < 0x0104 ? v[2 + dst.index].x : v[2 + src0.index].x;
+			Float4 y = shaderModel < 0x0104 ? v[2 + dst.index].y : v[2 + src0.index].y;
+			Float4 z = shaderModel < 0x0104 ? v[2 + dst.index].z : v[2 + src0.index].z;
+			Float4 w = shaderModel < 0x0104 ? v[2 + dst.index].w : v[2 + src0.index].w;
+
+			switch(opcode)
+			{
+			case Shader::OPCODE_PS_1_0: break;
+			case Shader::OPCODE_PS_1_1: break;
+			case Shader::OPCODE_PS_1_2: break;
+			case Shader::OPCODE_PS_1_3: break;
+			case Shader::OPCODE_PS_1_4: break;
+
+			case Shader::OPCODE_DEF:    break;
+
+			case Shader::OPCODE_NOP:    break;
+			case Shader::OPCODE_MOV: MOV(d, s0);         break;
+			case Shader::OPCODE_ADD: ADD(d, s0, s1);     break;
+			case Shader::OPCODE_SUB: SUB(d, s0, s1);     break;
+			case Shader::OPCODE_MAD: MAD(d, s0, s1, s2); break;
+			case Shader::OPCODE_MUL: MUL(d, s0, s1);     break;
+			case Shader::OPCODE_DP3: DP3(d, s0, s1);     break;
+			case Shader::OPCODE_DP4: DP4(d, s0, s1);     break;
+			case Shader::OPCODE_LRP: LRP(d, s0, s1, s2); break;
+			case Shader::OPCODE_TEXCOORD:
+				if(shaderModel < 0x0104)
+				{
+					TEXCOORD(d, x, y, z, dst.index);
+			}
+				else
+				{
+					if((src0.swizzle & 0x30) == 0x20)   // .xyz
+					{
+						TEXCRD(d, x, y, z, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+					else   // .xwy
+					{
+						TEXCRD(d, x, y, w, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+				}
+				break;
+			case Shader::OPCODE_TEXKILL:
+				if(shaderModel < 0x0104)
+				{
+					TEXKILL(cMask, x, y, z);
+				}
+				else if(shaderModel == 0x0104)
+				{
+					if(dst.type == Shader::PARAMETER_TEXTURE)
+					{
+						TEXKILL(cMask, x, y, z);
+					}
+					else
+					{
+						TEXKILL(cMask, rs[dst.index]);
+					}
+				}
+				else ASSERT(false);
+				break;
+			case Shader::OPCODE_TEX:
+				if(shaderModel < 0x0104)
+				{
+					TEX(d, x, y, z, dst.index, false);
+				}
+				else if(shaderModel == 0x0104)
+				{
+					if(src0.type == Shader::PARAMETER_TEXTURE)
+					{
+						if((src0.swizzle & 0x30) == 0x20)   // .xyz
+						{
+							TEX(d, x, y, z, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+						}
+						else   // .xyw
+						{
+							TEX(d, x, y, w, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+						}
+					}
+					else
+					{
+						TEXLD(d, s0, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+				}
+				else ASSERT(false);
+				break;
+			case Shader::OPCODE_TEXBEM:       TEXBEM(d, s0, x, y, z, dst.index);                                             break;
+			case Shader::OPCODE_TEXBEML:      TEXBEML(d, s0, x, y, z, dst.index);                                            break;
+			case Shader::OPCODE_TEXREG2AR:    TEXREG2AR(d, s0, dst.index);                                                   break;
+			case Shader::OPCODE_TEXREG2GB:    TEXREG2GB(d, s0, dst.index);                                                   break;
+			case Shader::OPCODE_TEXM3X2PAD:   TEXM3X2PAD(x, y, z, s0, 0, src0.modifier == Shader::MODIFIER_SIGN);            break;
+			case Shader::OPCODE_TEXM3X2TEX:   TEXM3X2TEX(d, x, y, z, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN); break;
+			case Shader::OPCODE_TEXM3X3PAD:   TEXM3X3PAD(x, y, z, s0, pad++ % 2, src0.modifier == Shader::MODIFIER_SIGN);    break;
+			case Shader::OPCODE_TEXM3X3TEX:   TEXM3X3TEX(d, x, y, z, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN); break;
+			case Shader::OPCODE_TEXM3X3SPEC:  TEXM3X3SPEC(d, x, y, z, dst.index, s0, s1);                                    break;
+			case Shader::OPCODE_TEXM3X3VSPEC: TEXM3X3VSPEC(d, x, y, z, dst.index, s0);                                       break;
+			case Shader::OPCODE_CND:          CND(d, s0, s1, s2);                                                            break;
+			case Shader::OPCODE_TEXREG2RGB:   TEXREG2RGB(d, s0, dst.index);                                                  break;
+			case Shader::OPCODE_TEXDP3TEX:    TEXDP3TEX(d, x, y, z, dst.index, s0);                                          break;
+			case Shader::OPCODE_TEXM3X2DEPTH: TEXM3X2DEPTH(d, x, y, z, s0, src0.modifier == Shader::MODIFIER_SIGN);          break;
+			case Shader::OPCODE_TEXDP3:       TEXDP3(d, x, y, z, s0);                                                        break;
+			case Shader::OPCODE_TEXM3X3:      TEXM3X3(d, x, y, z, s0, src0.modifier == Shader::MODIFIER_SIGN);               break;
+			case Shader::OPCODE_TEXDEPTH:     TEXDEPTH();                                                                    break;
+			case Shader::OPCODE_CMP0:         CMP(d, s0, s1, s2);                                                            break;
+			case Shader::OPCODE_BEM:          BEM(d, s0, s1, dst.index);                                                     break;
+			case Shader::OPCODE_PHASE:                                                                                       break;
+			case Shader::OPCODE_END:                                                                                         break;
+			default:
+				ASSERT(false);
+			}
+
+			if(dst.type != Shader::PARAMETER_VOID && opcode != Shader::OPCODE_TEXKILL)
+			{
+				if(dst.shift > 0)
+				{
+					if(dst.mask & 0x1) { d.x = AddSat(d.x, d.x); if(dst.shift > 1) d.x = AddSat(d.x, d.x); if(dst.shift > 2) d.x = AddSat(d.x, d.x); }
+					if(dst.mask & 0x2) { d.y = AddSat(d.y, d.y); if(dst.shift > 1) d.y = AddSat(d.y, d.y); if(dst.shift > 2) d.y = AddSat(d.y, d.y); }
+					if(dst.mask & 0x4) { d.z = AddSat(d.z, d.z); if(dst.shift > 1) d.z = AddSat(d.z, d.z); if(dst.shift > 2) d.z = AddSat(d.z, d.z); }
+					if(dst.mask & 0x8) { d.w = AddSat(d.w, d.w); if(dst.shift > 1) d.w = AddSat(d.w, d.w); if(dst.shift > 2) d.w = AddSat(d.w, d.w); }
+				}
+				else if(dst.shift < 0)
+				{
+					if(dst.mask & 0x1) d.x = d.x >> -dst.shift;
+					if(dst.mask & 0x2) d.y = d.y >> -dst.shift;
+					if(dst.mask & 0x4) d.z = d.z >> -dst.shift;
+					if(dst.mask & 0x8) d.w = d.w >> -dst.shift;
+				}
+
+				if(dst.saturate)
+				{
+					if(dst.mask & 0x1) { d.x = Min(d.x, Short4(0x1000)); d.x = Max(d.x, Short4(0x0000)); }
+					if(dst.mask & 0x2) { d.y = Min(d.y, Short4(0x1000)); d.y = Max(d.y, Short4(0x0000)); }
+					if(dst.mask & 0x4) { d.z = Min(d.z, Short4(0x1000)); d.z = Max(d.z, Short4(0x0000)); }
+					if(dst.mask & 0x8) { d.w = Min(d.w, Short4(0x1000)); d.w = Max(d.w, Short4(0x0000)); }
+				}
+
+				if(pairing)
+				{
+					if(dst.mask & 0x1) dPairing.x = d.x;
+					if(dst.mask & 0x2) dPairing.y = d.y;
+					if(dst.mask & 0x4) dPairing.z = d.z;
+					if(dst.mask & 0x8) dPairing.w = d.w;
+				}
+
+				if(coissue)
+				{
+					const Dst &dst = shader->getInstruction(i - 1)->dst;
+
+					writeDestination(dPairing, dst);
+				}
+
+				if(!pairing)
+				{
+					writeDestination(d, dst);
+				}
+			}
+		}
+
+		current.x = Min(current.x, Short4(0x0FFF)); current.x = Max(current.x, Short4(0x0000));
+		current.y = Min(current.y, Short4(0x0FFF)); current.y = Max(current.y, Short4(0x0000));
+		current.z = Min(current.z, Short4(0x0FFF)); current.z = Max(current.z, Short4(0x0000));
+		current.w = Min(current.w, Short4(0x0FFF)); current.w = Max(current.w, Short4(0x0000));
+	}
+
+	Bool PixelPipeline::alphaTest(Int cMask[4])
+	{
+		if(!state.alphaTestActive())
+		{
+			return true;
+		}
+
+		Int aMask;
+
+		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
+		{
+			PixelRoutine::alphaTest(aMask, current.w);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				cMask[q] &= aMask;
+			}
+		}
+		else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
+		{
+			Float4 alpha = Float4(current.w) * Float4(1.0f / 0x1000);
+
+			alphaToCoverage(cMask, alpha);
+		}
+		else ASSERT(false);
+
+		Int pass = cMask[0];
+
+		for(unsigned int q = 1; q < state.multiSample; q++)
+		{
+			pass = pass | cMask[q];
+		}
+
+		return pass != 0x0;
+	}
+
+	void PixelPipeline::rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+	{
+		if(!state.colorWriteActive(0))
+		{
+			return;
+		}
+
+		Vector4f oC;
+
+		switch(state.targetFormat[0])
+		{
+		case FORMAT_R5G6B5:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_A8:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+			if(!postBlendSRGB && state.writeSRGB)
+			{
+				linearToSRGB12_16(current);
+			}
+			else
+			{
+				current.x <<= 4;
+				current.y <<= 4;
+				current.z <<= 4;
+				current.w <<= 4;
+			}
+
+			if(state.targetFormat[0] == FORMAT_R5G6B5)
+			{
+				current.x &= Short4(0xF800u);
+				current.y &= Short4(0xFC00u);
+				current.z &= Short4(0xF800u);
+			}
+
+			fogBlend(current, fog);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				Pointer<Byte> buffer = cBuffer[0] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[0]));
+				Vector4s color = current;
+
+				if(state.multiSampleMask & (1 << q))
+				{
+					alphaBlend(0, buffer, color, x);
+					logicOperation(0, buffer, color, x);
+					writeColor(0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+				}
+			}
+			break;
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+	//	case FORMAT_X32B32G32R32F_UNSIGNED:   // Not renderable in any fixed-function API.
+			convertSigned12(oC, current);
+			PixelRoutine::fogBlend(oC, fog);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				Pointer<Byte> buffer = cBuffer[0] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[0]));
+				Vector4f color = oC;
+
+				if(state.multiSampleMask & (1 << q))
+				{
+					alphaBlend(0, buffer, color, x);
+					writeColor(0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+				}
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelPipeline::blendTexture(Vector4s &temp, Vector4s &texture, int stage)
+	{
+		Vector4s *arg1 = nullptr;
+		Vector4s *arg2 = nullptr;
+		Vector4s *arg3 = nullptr;
+		Vector4s res;
+
+		Vector4s constant;
+		Vector4s tfactor;
+
+		const TextureStage::State &textureStage = state.textureStage[stage];
+
+		if(textureStage.firstArgument == TextureStage::SOURCE_CONSTANT ||
+		   textureStage.firstArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
+		   textureStage.secondArgument == TextureStage::SOURCE_CONSTANT ||
+		   textureStage.secondArgumentAlpha == TextureStage::SOURCE_CONSTANT ||
+		   textureStage.thirdArgument == TextureStage::SOURCE_CONSTANT ||
+		   textureStage.thirdArgumentAlpha == TextureStage::SOURCE_CONSTANT)
+		{
+			constant.x = *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].constantColor4[0]));
+			constant.y = *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].constantColor4[1]));
+			constant.z = *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].constantColor4[2]));
+			constant.w = *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].constantColor4[3]));
+		}
+
+		if(textureStage.firstArgument == TextureStage::SOURCE_TFACTOR ||
+		   textureStage.firstArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
+		   textureStage.secondArgument == TextureStage::SOURCE_TFACTOR ||
+		   textureStage.secondArgumentAlpha == TextureStage::SOURCE_TFACTOR ||
+		   textureStage.thirdArgument == TextureStage::SOURCE_TFACTOR ||
+		   textureStage.thirdArgumentAlpha == TextureStage::SOURCE_TFACTOR)
+		{
+			tfactor.x = *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[0]));
+			tfactor.y = *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[1]));
+			tfactor.z = *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[2]));
+			tfactor.w = *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[3]));
+		}
+
+		// Premodulate
+		if(stage > 0 && textureStage.usesTexture)
+		{
+			if(state.textureStage[stage - 1].stageOperation == TextureStage::STAGE_PREMODULATE)
+			{
+				current.x = MulHigh(current.x, texture.x) << 4;
+				current.y = MulHigh(current.y, texture.y) << 4;
+				current.z = MulHigh(current.z, texture.z) << 4;
+			}
+
+			if(state.textureStage[stage - 1].stageOperationAlpha == TextureStage::STAGE_PREMODULATE)
+			{
+				current.w = MulHigh(current.w, texture.w) << 4;
+			}
+		}
+
+		if(luminance)
+		{
+			texture.x = MulHigh(texture.x, L) << 4;
+			texture.y = MulHigh(texture.y, L) << 4;
+			texture.z = MulHigh(texture.z, L) << 4;
+
+			luminance = false;
+		}
+
+		switch(textureStage.firstArgument)
+		{
+		case TextureStage::SOURCE_TEXTURE:	arg1 = &texture;    break;
+		case TextureStage::SOURCE_CONSTANT:	arg1 = &constant;   break;
+		case TextureStage::SOURCE_CURRENT:	arg1 = &current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg1 = &diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg1 = &specular; break;
+		case TextureStage::SOURCE_TEMP:		arg1 = &temp;       break;
+		case TextureStage::SOURCE_TFACTOR:	arg1 = &tfactor;    break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.secondArgument)
+		{
+		case TextureStage::SOURCE_TEXTURE:	arg2 = &texture;    break;
+		case TextureStage::SOURCE_CONSTANT:	arg2 = &constant;   break;
+		case TextureStage::SOURCE_CURRENT:	arg2 = &current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg2 = &diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg2 = &specular; break;
+		case TextureStage::SOURCE_TEMP:		arg2 = &temp;       break;
+		case TextureStage::SOURCE_TFACTOR:	arg2 = &tfactor;    break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.thirdArgument)
+		{
+		case TextureStage::SOURCE_TEXTURE:	arg3 = &texture;    break;
+		case TextureStage::SOURCE_CONSTANT:	arg3 = &constant;   break;
+		case TextureStage::SOURCE_CURRENT:	arg3 = &current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg3 = &diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg3 = &specular; break;
+		case TextureStage::SOURCE_TEMP:		arg3 = &temp;       break;
+		case TextureStage::SOURCE_TFACTOR:	arg3 = &tfactor;    break;
+		default:
+			ASSERT(false);
+		}
+
+		Vector4s mod1;
+		Vector4s mod2;
+		Vector4s mod3;
+
+		switch(textureStage.firstModifier)
+		{
+		case TextureStage::MODIFIER_COLOR:
+			break;
+		case TextureStage::MODIFIER_INVCOLOR:
+			mod1.x = SubSat(Short4(0x1000), arg1->x);
+			mod1.y = SubSat(Short4(0x1000), arg1->y);
+			mod1.z = SubSat(Short4(0x1000), arg1->z);
+			mod1.w = SubSat(Short4(0x1000), arg1->w);
+
+			arg1 = &mod1;
+			break;
+		case TextureStage::MODIFIER_ALPHA:
+			mod1.x = arg1->w;
+			mod1.y = arg1->w;
+			mod1.z = arg1->w;
+			mod1.w = arg1->w;
+
+			arg1 = &mod1;
+			break;
+		case TextureStage::MODIFIER_INVALPHA:
+			mod1.x = SubSat(Short4(0x1000), arg1->w);
+			mod1.y = SubSat(Short4(0x1000), arg1->w);
+			mod1.z = SubSat(Short4(0x1000), arg1->w);
+			mod1.w = SubSat(Short4(0x1000), arg1->w);
+
+			arg1 = &mod1;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.secondModifier)
+		{
+		case TextureStage::MODIFIER_COLOR:
+			break;
+		case TextureStage::MODIFIER_INVCOLOR:
+			mod2.x = SubSat(Short4(0x1000), arg2->x);
+			mod2.y = SubSat(Short4(0x1000), arg2->y);
+			mod2.z = SubSat(Short4(0x1000), arg2->z);
+			mod2.w = SubSat(Short4(0x1000), arg2->w);
+
+			arg2 = &mod2;
+			break;
+		case TextureStage::MODIFIER_ALPHA:
+			mod2.x = arg2->w;
+			mod2.y = arg2->w;
+			mod2.z = arg2->w;
+			mod2.w = arg2->w;
+
+			arg2 = &mod2;
+			break;
+		case TextureStage::MODIFIER_INVALPHA:
+			mod2.x = SubSat(Short4(0x1000), arg2->w);
+			mod2.y = SubSat(Short4(0x1000), arg2->w);
+			mod2.z = SubSat(Short4(0x1000), arg2->w);
+			mod2.w = SubSat(Short4(0x1000), arg2->w);
+
+			arg2 = &mod2;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.thirdModifier)
+		{
+		case TextureStage::MODIFIER_COLOR:
+			break;
+		case TextureStage::MODIFIER_INVCOLOR:
+			mod3.x = SubSat(Short4(0x1000), arg3->x);
+			mod3.y = SubSat(Short4(0x1000), arg3->y);
+			mod3.z = SubSat(Short4(0x1000), arg3->z);
+			mod3.w = SubSat(Short4(0x1000), arg3->w);
+
+			arg3 = &mod3;
+			break;
+		case TextureStage::MODIFIER_ALPHA:
+			mod3.x = arg3->w;
+			mod3.y = arg3->w;
+			mod3.z = arg3->w;
+			mod3.w = arg3->w;
+
+			arg3 = &mod3;
+			break;
+		case TextureStage::MODIFIER_INVALPHA:
+			mod3.x = SubSat(Short4(0x1000), arg3->w);
+			mod3.y = SubSat(Short4(0x1000), arg3->w);
+			mod3.z = SubSat(Short4(0x1000), arg3->w);
+			mod3.w = SubSat(Short4(0x1000), arg3->w);
+
+			arg3 = &mod3;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.stageOperation)
+		{
+		case TextureStage::STAGE_DISABLE:
+			break;
+		case TextureStage::STAGE_SELECTARG1: // Arg1
+			res.x = arg1->x;
+			res.y = arg1->y;
+			res.z = arg1->z;
+			break;
+		case TextureStage::STAGE_SELECTARG2: // Arg2
+			res.x = arg2->x;
+			res.y = arg2->y;
+			res.z = arg2->z;
+			break;
+		case TextureStage::STAGE_SELECTARG3: // Arg3
+			res.x = arg3->x;
+			res.y = arg3->y;
+			res.z = arg3->z;
+			break;
+		case TextureStage::STAGE_MODULATE: // Arg1 * Arg2
+			res.x = MulHigh(arg1->x, arg2->x) << 4;
+			res.y = MulHigh(arg1->y, arg2->y) << 4;
+			res.z = MulHigh(arg1->z, arg2->z) << 4;
+			break;
+		case TextureStage::STAGE_MODULATE2X: // Arg1 * Arg2 * 2
+			res.x = MulHigh(arg1->x, arg2->x) << 5;
+			res.y = MulHigh(arg1->y, arg2->y) << 5;
+			res.z = MulHigh(arg1->z, arg2->z) << 5;
+			break;
+		case TextureStage::STAGE_MODULATE4X: // Arg1 * Arg2 * 4
+			res.x = MulHigh(arg1->x, arg2->x) << 6;
+			res.y = MulHigh(arg1->y, arg2->y) << 6;
+			res.z = MulHigh(arg1->z, arg2->z) << 6;
+			break;
+		case TextureStage::STAGE_ADD: // Arg1 + Arg2
+			res.x = AddSat(arg1->x, arg2->x);
+			res.y = AddSat(arg1->y, arg2->y);
+			res.z = AddSat(arg1->z, arg2->z);
+			break;
+		case TextureStage::STAGE_ADDSIGNED: // Arg1 + Arg2 - 0.5
+			res.x = AddSat(arg1->x, arg2->x);
+			res.y = AddSat(arg1->y, arg2->y);
+			res.z = AddSat(arg1->z, arg2->z);
+
+			res.x = SubSat(res.x, Short4(0x0800));
+			res.y = SubSat(res.y, Short4(0x0800));
+			res.z = SubSat(res.z, Short4(0x0800));
+			break;
+		case TextureStage::STAGE_ADDSIGNED2X: // (Arg1 + Arg2 - 0.5) << 1
+			res.x = AddSat(arg1->x, arg2->x);
+			res.y = AddSat(arg1->y, arg2->y);
+			res.z = AddSat(arg1->z, arg2->z);
+
+			res.x = SubSat(res.x, Short4(0x0800));
+			res.y = SubSat(res.y, Short4(0x0800));
+			res.z = SubSat(res.z, Short4(0x0800));
+
+			res.x = AddSat(res.x, res.x);
+			res.y = AddSat(res.y, res.y);
+			res.z = AddSat(res.z, res.z);
+			break;
+		case TextureStage::STAGE_SUBTRACT: // Arg1 - Arg2
+			res.x = SubSat(arg1->x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z);
+			break;
+		case TextureStage::STAGE_ADDSMOOTH: // Arg1 + Arg2 - Arg1 * Arg2
+			{
+				Short4 tmp;
+
+				tmp = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(arg1->x, arg2->x); res.x = SubSat(res.x, tmp);
+				tmp = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(arg1->y, arg2->y); res.y = SubSat(res.y, tmp);
+				tmp = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(arg1->z, arg2->z); res.z = SubSat(res.z, tmp);
+			}
+			break;
+		case TextureStage::STAGE_MULTIPLYADD: // Arg3 + Arg1 * Arg2
+			res.x = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(res.x, arg3->x);
+			res.y = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(res.y, arg3->y);
+			res.z = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(res.z, arg3->z);
+			break;
+		case TextureStage::STAGE_LERP: // Arg3 * (Arg1 - Arg2) + Arg2
+			res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, arg3->x) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, arg3->y) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, arg3->z) << 4; res.z = AddSat(res.z, arg2->z);
+			break;
+		case TextureStage::STAGE_DOT3: // 2 * (Arg1.x - 0.5) * 2 * (Arg2.x - 0.5) + 2 * (Arg1.y - 0.5) * 2 * (Arg2.y - 0.5) + 2 * (Arg1.z - 0.5) * 2 * (Arg2.z - 0.5)
+			{
+				Short4 tmp;
+
+				res.x = SubSat(arg1->x, Short4(0x0800)); tmp = SubSat(arg2->x, Short4(0x0800)); res.x = MulHigh(res.x, tmp);
+				res.y = SubSat(arg1->y, Short4(0x0800)); tmp = SubSat(arg2->y, Short4(0x0800)); res.y = MulHigh(res.y, tmp);
+				res.z = SubSat(arg1->z, Short4(0x0800)); tmp = SubSat(arg2->z, Short4(0x0800)); res.z = MulHigh(res.z, tmp);
+
+				res.x = res.x << 6;
+				res.y = res.y << 6;
+				res.z = res.z << 6;
+
+				res.x = AddSat(res.x, res.y);
+				res.x = AddSat(res.x, res.z);
+
+				// Clamp to [0, 1]
+				res.x = Max(res.x, Short4(0x0000));
+				res.x = Min(res.x, Short4(0x1000));
+
+				res.y = res.x;
+				res.z = res.x;
+				res.w = res.x;
+			}
+			break;
+		case TextureStage::STAGE_BLENDCURRENTALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+			res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, current.w) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, current.w) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, current.w) << 4; res.z = AddSat(res.z, arg2->z);
+			break;
+		case TextureStage::STAGE_BLENDDIFFUSEALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+			res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, diffuse.w) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, diffuse.w) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, diffuse.w) << 4; res.z = AddSat(res.z, arg2->z);
+			break;
+		case TextureStage::STAGE_BLENDFACTORALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+			res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[3]))) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[3]))) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[3]))) << 4; res.z = AddSat(res.z, arg2->z);
+			break;
+		case TextureStage::STAGE_BLENDTEXTUREALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+			res.x = SubSat(arg1->x, arg2->x); res.x = MulHigh(res.x, texture.w) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, texture.w) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, texture.w) << 4; res.z = AddSat(res.z, arg2->z);
+			break;
+		case TextureStage::STAGE_BLENDTEXTUREALPHAPM: // Arg1 + Arg2 * (1 - Alpha)
+			res.x = SubSat(Short4(0x1000), texture.w); res.x = MulHigh(res.x, arg2->x) << 4; res.x = AddSat(res.x, arg1->x);
+			res.y = SubSat(Short4(0x1000), texture.w); res.y = MulHigh(res.y, arg2->y) << 4; res.y = AddSat(res.y, arg1->y);
+			res.z = SubSat(Short4(0x1000), texture.w); res.z = MulHigh(res.z, arg2->z) << 4; res.z = AddSat(res.z, arg1->z);
+			break;
+		case TextureStage::STAGE_PREMODULATE:
+			res.x = arg1->x;
+			res.y = arg1->y;
+			res.z = arg1->z;
+			break;
+		case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR: // Arg1 + Arg1.w * Arg2
+			res.x = MulHigh(arg1->w, arg2->x) << 4; res.x = AddSat(res.x, arg1->x);
+			res.y = MulHigh(arg1->w, arg2->y) << 4; res.y = AddSat(res.y, arg1->y);
+			res.z = MulHigh(arg1->w, arg2->z) << 4; res.z = AddSat(res.z, arg1->z);
+			break;
+		case TextureStage::STAGE_MODULATECOLOR_ADDALPHA: // Arg1 * Arg2 + Arg1.w
+			res.x = MulHigh(arg1->x, arg2->x) << 4; res.x = AddSat(res.x, arg1->w);
+			res.y = MulHigh(arg1->y, arg2->y) << 4; res.y = AddSat(res.y, arg1->w);
+			res.z = MulHigh(arg1->z, arg2->z) << 4; res.z = AddSat(res.z, arg1->w);
+			break;
+		case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR: // (1 - Arg1.w) * Arg2 + Arg1
+			{
+				Short4 tmp;
+
+				res.x = AddSat(arg1->x, arg2->x); tmp = MulHigh(arg1->w, arg2->x) << 4; res.x = SubSat(res.x, tmp);
+				res.y = AddSat(arg1->y, arg2->y); tmp = MulHigh(arg1->w, arg2->y) << 4; res.y = SubSat(res.y, tmp);
+				res.z = AddSat(arg1->z, arg2->z); tmp = MulHigh(arg1->w, arg2->z) << 4; res.z = SubSat(res.z, tmp);
+			}
+			break;
+		case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA: // (1 - Arg1) * Arg2 + Arg1.w
+			{
+				Short4 tmp;
+
+				res.x = AddSat(arg1->w, arg2->x); tmp = MulHigh(arg1->x, arg2->x) << 4; res.x = SubSat(res.x, tmp);
+				res.y = AddSat(arg1->w, arg2->y); tmp = MulHigh(arg1->y, arg2->y) << 4; res.y = SubSat(res.y, tmp);
+				res.z = AddSat(arg1->w, arg2->z); tmp = MulHigh(arg1->z, arg2->z) << 4; res.z = SubSat(res.z, tmp);
+			}
+			break;
+		case TextureStage::STAGE_BUMPENVMAP:
+			{
+				du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
+				dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
+
+				Float4 du2;
+				Float4 dv2;
+
+				du2 = du;
+				dv2 = dv;
+				du *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+				dv2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+				du += dv2;
+				dv *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+				du2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+				dv += du2;
+
+				perturbate = true;
+
+				res.x = current.x;
+				res.y = current.y;
+				res.z = current.z;
+				res.w = current.w;
+			}
+			break;
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			{
+				du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
+				dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
+
+				Float4 du2;
+				Float4 dv2;
+
+				du2 = du;
+				dv2 = dv;
+
+				du *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+				dv2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+				du += dv2;
+				dv *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+				du2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+				dv += du2;
+
+				perturbate = true;
+
+				L = texture.z;
+				L = MulHigh(L, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].luminanceScale4)));
+				L = L << 4;
+				L = AddSat(L, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].luminanceOffset4)));
+				L = Max(L, Short4(0x0000));
+				L = Min(L, Short4(0x1000));
+
+				luminance = true;
+
+				res.x = current.x;
+				res.y = current.y;
+				res.z = current.z;
+				res.w = current.w;
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(textureStage.stageOperation != TextureStage::STAGE_DOT3)
+		{
+			switch(textureStage.firstArgumentAlpha)
+			{
+			case TextureStage::SOURCE_TEXTURE:	arg1 = &texture;		break;
+			case TextureStage::SOURCE_CONSTANT:	arg1 = &constant;		break;
+			case TextureStage::SOURCE_CURRENT:	arg1 = &current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg1 = &diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg1 = &specular;		break;
+			case TextureStage::SOURCE_TEMP:		arg1 = &temp;			break;
+			case TextureStage::SOURCE_TFACTOR:	arg1 = &tfactor;		break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.secondArgumentAlpha)
+			{
+			case TextureStage::SOURCE_TEXTURE:	arg2 = &texture;		break;
+			case TextureStage::SOURCE_CONSTANT:	arg2 = &constant;		break;
+			case TextureStage::SOURCE_CURRENT:	arg2 = &current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg2 = &diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg2 = &specular;		break;
+			case TextureStage::SOURCE_TEMP:		arg2 = &temp;			break;
+			case TextureStage::SOURCE_TFACTOR:	arg2 = &tfactor;		break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.thirdArgumentAlpha)
+			{
+			case TextureStage::SOURCE_TEXTURE:	arg3 = &texture;		break;
+			case TextureStage::SOURCE_CONSTANT:	arg3 = &constant;		break;
+			case TextureStage::SOURCE_CURRENT:	arg3 = &current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg3 = &diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg3 = &specular;		break;
+			case TextureStage::SOURCE_TEMP:		arg3 = &temp;			break;
+			case TextureStage::SOURCE_TFACTOR:	arg3 = &tfactor;		break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.firstModifierAlpha)   // FIXME: Check if actually used
+			{
+			case TextureStage::MODIFIER_COLOR:
+				break;
+			case TextureStage::MODIFIER_INVCOLOR:
+				mod1.w = SubSat(Short4(0x1000), arg1->w);
+
+				arg1 = &mod1;
+				break;
+			case TextureStage::MODIFIER_ALPHA:
+				// Redudant
+				break;
+			case TextureStage::MODIFIER_INVALPHA:
+				mod1.w = SubSat(Short4(0x1000), arg1->w);
+
+				arg1 = &mod1;
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.secondModifierAlpha)   // FIXME: Check if actually used
+			{
+			case TextureStage::MODIFIER_COLOR:
+				break;
+			case TextureStage::MODIFIER_INVCOLOR:
+				mod2.w = SubSat(Short4(0x1000), arg2->w);
+
+				arg2 = &mod2;
+				break;
+			case TextureStage::MODIFIER_ALPHA:
+				// Redudant
+				break;
+			case TextureStage::MODIFIER_INVALPHA:
+				mod2.w = SubSat(Short4(0x1000), arg2->w);
+
+				arg2 = &mod2;
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.thirdModifierAlpha)   // FIXME: Check if actually used
+			{
+			case TextureStage::MODIFIER_COLOR:
+				break;
+			case TextureStage::MODIFIER_INVCOLOR:
+				mod3.w = SubSat(Short4(0x1000), arg3->w);
+
+				arg3 = &mod3;
+				break;
+			case TextureStage::MODIFIER_ALPHA:
+				// Redudant
+				break;
+			case TextureStage::MODIFIER_INVALPHA:
+				mod3.w = SubSat(Short4(0x1000), arg3->w);
+
+				arg3 = &mod3;
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			switch(textureStage.stageOperationAlpha)
+			{
+			case TextureStage::STAGE_DISABLE:
+				break;
+			case TextureStage::STAGE_SELECTARG1: // Arg1
+				res.w = arg1->w;
+				break;
+			case TextureStage::STAGE_SELECTARG2: // Arg2
+				res.w = arg2->w;
+				break;
+			case TextureStage::STAGE_SELECTARG3: // Arg3
+				res.w = arg3->w;
+				break;
+			case TextureStage::STAGE_MODULATE: // Arg1 * Arg2
+				res.w = MulHigh(arg1->w, arg2->w) << 4;
+				break;
+			case TextureStage::STAGE_MODULATE2X: // Arg1 * Arg2 * 2
+				res.w = MulHigh(arg1->w, arg2->w) << 5;
+				break;
+			case TextureStage::STAGE_MODULATE4X: // Arg1 * Arg2 * 4
+				res.w = MulHigh(arg1->w, arg2->w) << 6;
+				break;
+			case TextureStage::STAGE_ADD: // Arg1 + Arg2
+				res.w = AddSat(arg1->w, arg2->w);
+				break;
+			case TextureStage::STAGE_ADDSIGNED: // Arg1 + Arg2 - 0.5
+				res.w = AddSat(arg1->w, arg2->w);
+				res.w = SubSat(res.w, Short4(0x0800));
+				break;
+			case TextureStage::STAGE_ADDSIGNED2X: // (Arg1 + Arg2 - 0.5) << 1
+				res.w = AddSat(arg1->w, arg2->w);
+				res.w = SubSat(res.w, Short4(0x0800));
+				res.w = AddSat(res.w, res.w);
+				break;
+			case TextureStage::STAGE_SUBTRACT: // Arg1 - Arg2
+				res.w = SubSat(arg1->w, arg2->w);
+				break;
+			case TextureStage::STAGE_ADDSMOOTH: // Arg1 + Arg2 - Arg1 * Arg2
+				{
+					Short4 tmp;
+
+					tmp = MulHigh(arg1->w, arg2->w) << 4; res.w = AddSat(arg1->w, arg2->w); res.w = SubSat(res.w, tmp);
+				}
+				break;
+			case TextureStage::STAGE_MULTIPLYADD: // Arg3 + Arg1 * Arg2
+				res.w = MulHigh(arg1->w, arg2->w) << 4; res.w = AddSat(res.w, arg3->w);
+				break;
+			case TextureStage::STAGE_LERP: // Arg3 * (Arg1 - Arg2) + Arg2
+				res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, arg3->w) << 4; res.w = AddSat(res.w, arg2->w);
+				break;
+			case TextureStage::STAGE_DOT3:
+				break;   // Already computed in color channel
+			case TextureStage::STAGE_BLENDCURRENTALPHA: // Alpha * (Arg1 - Arg2) + Arg2
+				res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, current.w) << 4; res.w = AddSat(res.w, arg2->w);
+				break;
+			case TextureStage::STAGE_BLENDDIFFUSEALPHA: // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
+				res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, diffuse.w) << 4; res.w = AddSat(res.w, arg2->w);
+				break;
+			case TextureStage::STAGE_BLENDFACTORALPHA:
+				res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, *Pointer<Short4>(data + OFFSET(DrawData, factor.textureFactor4[3]))) << 4; res.w = AddSat(res.w, arg2->w);
+				break;
+			case TextureStage::STAGE_BLENDTEXTUREALPHA: // Arg1 * (Alpha) + Arg2 * (1 - Alpha)
+				res.w = SubSat(arg1->w, arg2->w); res.w = MulHigh(res.w, texture.w) << 4; res.w = AddSat(res.w, arg2->w);
+				break;
+			case TextureStage::STAGE_BLENDTEXTUREALPHAPM: // Arg1 + Arg2 * (1 - Alpha)
+				res.w = SubSat(Short4(0x1000), texture.w); res.w = MulHigh(res.w, arg2->w) << 4; res.w = AddSat(res.w, arg1->w);
+				break;
+			case TextureStage::STAGE_PREMODULATE:
+				res.w = arg1->w;
+				break;
+			case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+			case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+			case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+			case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+			case TextureStage::STAGE_BUMPENVMAP:
+			case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+				break;   // Invalid alpha operations
+			default:
+				ASSERT(false);
+			}
+		}
+
+		// Clamp result to [0, 1]
+
+		switch(textureStage.stageOperation)
+		{
+		case TextureStage::STAGE_DISABLE:
+		case TextureStage::STAGE_SELECTARG1:
+		case TextureStage::STAGE_SELECTARG2:
+		case TextureStage::STAGE_SELECTARG3:
+		case TextureStage::STAGE_MODULATE:
+		case TextureStage::STAGE_MODULATE2X:
+		case TextureStage::STAGE_MODULATE4X:
+		case TextureStage::STAGE_ADD:
+		case TextureStage::STAGE_MULTIPLYADD:
+		case TextureStage::STAGE_LERP:
+		case TextureStage::STAGE_BLENDCURRENTALPHA:
+		case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+		case TextureStage::STAGE_BLENDFACTORALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+		case TextureStage::STAGE_DOT3:   // Already clamped
+		case TextureStage::STAGE_PREMODULATE:
+		case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+		case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+		case TextureStage::STAGE_BUMPENVMAP:
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			if(state.textureStage[stage].cantUnderflow)
+			{
+				break;   // Can't go below zero
+			}
+		case TextureStage::STAGE_ADDSIGNED:
+		case TextureStage::STAGE_ADDSIGNED2X:
+		case TextureStage::STAGE_SUBTRACT:
+		case TextureStage::STAGE_ADDSMOOTH:
+			res.x = Max(res.x, Short4(0x0000));
+			res.y = Max(res.y, Short4(0x0000));
+			res.z = Max(res.z, Short4(0x0000));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.stageOperationAlpha)
+		{
+		case TextureStage::STAGE_DISABLE:
+		case TextureStage::STAGE_SELECTARG1:
+		case TextureStage::STAGE_SELECTARG2:
+		case TextureStage::STAGE_SELECTARG3:
+		case TextureStage::STAGE_MODULATE:
+		case TextureStage::STAGE_MODULATE2X:
+		case TextureStage::STAGE_MODULATE4X:
+		case TextureStage::STAGE_ADD:
+		case TextureStage::STAGE_MULTIPLYADD:
+		case TextureStage::STAGE_LERP:
+		case TextureStage::STAGE_BLENDCURRENTALPHA:
+		case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+		case TextureStage::STAGE_BLENDFACTORALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+		case TextureStage::STAGE_DOT3:   // Already clamped
+		case TextureStage::STAGE_PREMODULATE:
+		case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+		case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+		case TextureStage::STAGE_BUMPENVMAP:
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			if(state.textureStage[stage].cantUnderflow)
+			{
+				break;   // Can't go below zero
+			}
+		case TextureStage::STAGE_ADDSIGNED:
+		case TextureStage::STAGE_ADDSIGNED2X:
+		case TextureStage::STAGE_SUBTRACT:
+		case TextureStage::STAGE_ADDSMOOTH:
+			res.w = Max(res.w, Short4(0x0000));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.stageOperation)
+		{
+		case TextureStage::STAGE_DISABLE:
+		case TextureStage::STAGE_SELECTARG1:
+		case TextureStage::STAGE_SELECTARG2:
+		case TextureStage::STAGE_SELECTARG3:
+		case TextureStage::STAGE_MODULATE:
+		case TextureStage::STAGE_SUBTRACT:
+		case TextureStage::STAGE_ADDSMOOTH:
+		case TextureStage::STAGE_LERP:
+		case TextureStage::STAGE_BLENDCURRENTALPHA:
+		case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+		case TextureStage::STAGE_BLENDFACTORALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHA:
+		case TextureStage::STAGE_DOT3:   // Already clamped
+		case TextureStage::STAGE_PREMODULATE:
+		case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+		case TextureStage::STAGE_BUMPENVMAP:
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			break;   // Can't go above one
+		case TextureStage::STAGE_MODULATE2X:
+		case TextureStage::STAGE_MODULATE4X:
+		case TextureStage::STAGE_ADD:
+		case TextureStage::STAGE_ADDSIGNED:
+		case TextureStage::STAGE_ADDSIGNED2X:
+		case TextureStage::STAGE_MULTIPLYADD:
+		case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+		case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+			res.x = Min(res.x, Short4(0x1000));
+			res.y = Min(res.y, Short4(0x1000));
+			res.z = Min(res.z, Short4(0x1000));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.stageOperationAlpha)
+		{
+		case TextureStage::STAGE_DISABLE:
+		case TextureStage::STAGE_SELECTARG1:
+		case TextureStage::STAGE_SELECTARG2:
+		case TextureStage::STAGE_SELECTARG3:
+		case TextureStage::STAGE_MODULATE:
+		case TextureStage::STAGE_SUBTRACT:
+		case TextureStage::STAGE_ADDSMOOTH:
+		case TextureStage::STAGE_LERP:
+		case TextureStage::STAGE_BLENDCURRENTALPHA:
+		case TextureStage::STAGE_BLENDDIFFUSEALPHA:
+		case TextureStage::STAGE_BLENDFACTORALPHA:
+		case TextureStage::STAGE_BLENDTEXTUREALPHA:
+		case TextureStage::STAGE_DOT3:   // Already clamped
+		case TextureStage::STAGE_PREMODULATE:
+		case TextureStage::STAGE_MODULATEINVALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATEINVCOLOR_ADDALPHA:
+		case TextureStage::STAGE_BUMPENVMAP:
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			break;   // Can't go above one
+		case TextureStage::STAGE_MODULATE2X:
+		case TextureStage::STAGE_MODULATE4X:
+		case TextureStage::STAGE_ADD:
+		case TextureStage::STAGE_ADDSIGNED:
+		case TextureStage::STAGE_ADDSIGNED2X:
+		case TextureStage::STAGE_MULTIPLYADD:
+		case TextureStage::STAGE_BLENDTEXTUREALPHAPM:
+		case TextureStage::STAGE_MODULATEALPHA_ADDCOLOR:
+		case TextureStage::STAGE_MODULATECOLOR_ADDALPHA:
+			res.w = Min(res.w, Short4(0x1000));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(textureStage.destinationArgument)
+		{
+		case TextureStage::DESTINATION_CURRENT:
+			current.x = res.x;
+			current.y = res.y;
+			current.z = res.z;
+			current.w = res.w;
+			break;
+		case TextureStage::DESTINATION_TEMP:
+			temp.x = res.x;
+			temp.y = res.y;
+			temp.z = res.z;
+			temp.w = res.w;
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelPipeline::fogBlend(Vector4s &current, Float4 &f)
+	{
+		if(!state.fogActive)
+		{
+			return;
+		}
+
+		if(state.pixelFogMode != FOG_NONE)
+		{
+			pixelFog(f);
+		}
+
+		UShort4 fog = convertFixed16(f, true);
+
+		current.x = As<Short4>(MulHigh(As<UShort4>(current.x), fog));
+		current.y = As<Short4>(MulHigh(As<UShort4>(current.y), fog));
+		current.z = As<Short4>(MulHigh(As<UShort4>(current.z), fog));
+
+		UShort4 invFog = UShort4(0xFFFFu) - fog;
+
+		current.x += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(data + OFFSET(DrawData, fog.color4[0]))));
+		current.y += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(data + OFFSET(DrawData, fog.color4[1]))));
+		current.z += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(data + OFFSET(DrawData, fog.color4[2]))));
+	}
+
+	void PixelPipeline::specularPixel(Vector4s &current, Vector4s &specular)
+	{
+		if(!state.specularAdd)
+		{
+			return;
+		}
+
+		current.x = AddSat(current.x, specular.x);
+		current.y = AddSat(current.y, specular.y);
+		current.z = AddSat(current.z, specular.z);
+	}
+
+	Vector4s PixelPipeline::sampleTexture(int coordinates, int stage, bool project)
+	{
+		Float4 x = v[2 + coordinates].x;
+		Float4 y = v[2 + coordinates].y;
+		Float4 z = v[2 + coordinates].z;
+		Float4 w = v[2 + coordinates].w;
+
+		if(perturbate)
+		{
+			x += du;
+			y += dv;
+
+			perturbate = false;
+		}
+
+		return sampleTexture(stage, x, y, z, w, project);
+	}
+
+	Vector4s PixelPipeline::sampleTexture(int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project)
+	{
+		Vector4s c;
+
+		#if PERF_PROFILE
+			Long texTime = Ticks();
+		#endif
+
+		Vector4f dsx;
+		Vector4f dsy;
+
+		Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + stage * sizeof(Texture);
+
+		if(!project)
+		{
+			c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u, v, w, q, q, dsx, dsy);
+		}
+		else
+		{
+			Float4 rq = reciprocal(q);
+
+			Float4 u_q = u * rq;
+			Float4 v_q = v * rq;
+			Float4 w_q = w * rq;
+
+			c = SamplerCore(constants, state.sampler[stage]).sampleTexture(texture, u_q, v_q, w_q, q, q, dsx, dsy);
+		}
+
+		#if PERF_PROFILE
+			cycles[PERF_TEX] += Ticks() - texTime;
+		#endif
+
+		return c;
+	}
+
+	Short4 PixelPipeline::convertFixed12(RValue<Float4> cf)
+	{
+		return RoundShort4(cf * Float4(0x1000));
+	}
+
+	void PixelPipeline::convertFixed12(Vector4s &cs, Vector4f &cf)
+	{
+		cs.x = convertFixed12(cf.x);
+		cs.y = convertFixed12(cf.y);
+		cs.z = convertFixed12(cf.z);
+		cs.w = convertFixed12(cf.w);
+	}
+
+	Float4 PixelPipeline::convertSigned12(Short4 &cs)
+	{
+		return Float4(cs) * Float4(1.0f / 0x0FFE);
+	}
+
+	void PixelPipeline::convertSigned12(Vector4f &cf, Vector4s &cs)
+	{
+		cf.x = convertSigned12(cs.x);
+		cf.y = convertSigned12(cs.y);
+		cf.z = convertSigned12(cs.z);
+		cf.w = convertSigned12(cs.w);
+	}
+
+	void PixelPipeline::writeDestination(Vector4s &d, const Dst &dst)
+	{
+		switch(dst.type)
+		{
+		case Shader::PARAMETER_TEMP:
+			if(dst.mask & 0x1) rs[dst.index].x = d.x;
+			if(dst.mask & 0x2) rs[dst.index].y = d.y;
+			if(dst.mask & 0x4) rs[dst.index].z = d.z;
+			if(dst.mask & 0x8) rs[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_INPUT:
+			if(dst.mask & 0x1) vs[dst.index].x = d.x;
+			if(dst.mask & 0x2) vs[dst.index].y = d.y;
+			if(dst.mask & 0x4) vs[dst.index].z = d.z;
+			if(dst.mask & 0x8) vs[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_CONST: ASSERT(false); break;
+		case Shader::PARAMETER_TEXTURE:
+			if(dst.mask & 0x1) ts[dst.index].x = d.x;
+			if(dst.mask & 0x2) ts[dst.index].y = d.y;
+			if(dst.mask & 0x4) ts[dst.index].z = d.z;
+			if(dst.mask & 0x8) ts[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_COLOROUT:
+			if(dst.mask & 0x1) vs[dst.index].x = d.x;
+			if(dst.mask & 0x2) vs[dst.index].y = d.y;
+			if(dst.mask & 0x4) vs[dst.index].z = d.z;
+			if(dst.mask & 0x8) vs[dst.index].w = d.w;
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	Vector4s PixelPipeline::fetchRegister(const Src &src)
+	{
+		Vector4s *reg;
+		int i = src.index;
+
+		Vector4s c;
+
+		if(src.type == Shader::PARAMETER_CONST)
+		{
+			c.x = *Pointer<Short4>(data + OFFSET(DrawData, ps.cW[i][0]));
+			c.y = *Pointer<Short4>(data + OFFSET(DrawData, ps.cW[i][1]));
+			c.z = *Pointer<Short4>(data + OFFSET(DrawData, ps.cW[i][2]));
+			c.w = *Pointer<Short4>(data + OFFSET(DrawData, ps.cW[i][3]));
+		}
+
+		switch(src.type)
+		{
+		case Shader::PARAMETER_TEMP:          reg = &rs[i]; break;
+		case Shader::PARAMETER_INPUT:         reg = &vs[i]; break;
+		case Shader::PARAMETER_CONST:         reg = &c;       break;
+		case Shader::PARAMETER_TEXTURE:       reg = &ts[i]; break;
+		case Shader::PARAMETER_VOID:          return rs[0]; // Dummy
+		case Shader::PARAMETER_FLOAT4LITERAL: return rs[0]; // Dummy
+		default: ASSERT(false); return rs[0];
+		}
+
+		const Short4 &x = (*reg)[(src.swizzle >> 0) & 0x3];
+		const Short4 &y = (*reg)[(src.swizzle >> 2) & 0x3];
+		const Short4 &z = (*reg)[(src.swizzle >> 4) & 0x3];
+		const Short4 &w = (*reg)[(src.swizzle >> 6) & 0x3];
+
+		Vector4s mod;
+
+		switch(src.modifier)
+		{
+		case Shader::MODIFIER_NONE:
+			mod.x = x;
+			mod.y = y;
+			mod.z = z;
+			mod.w = w;
+			break;
+		case Shader::MODIFIER_BIAS:
+			mod.x = SubSat(x, Short4(0x0800));
+			mod.y = SubSat(y, Short4(0x0800));
+			mod.z = SubSat(z, Short4(0x0800));
+			mod.w = SubSat(w, Short4(0x0800));
+			break;
+		case Shader::MODIFIER_BIAS_NEGATE:
+			mod.x = SubSat(Short4(0x0800), x);
+			mod.y = SubSat(Short4(0x0800), y);
+			mod.z = SubSat(Short4(0x0800), z);
+			mod.w = SubSat(Short4(0x0800), w);
+			break;
+		case Shader::MODIFIER_COMPLEMENT:
+			mod.x = SubSat(Short4(0x1000), x);
+			mod.y = SubSat(Short4(0x1000), y);
+			mod.z = SubSat(Short4(0x1000), z);
+			mod.w = SubSat(Short4(0x1000), w);
+			break;
+		case Shader::MODIFIER_NEGATE:
+			mod.x = -x;
+			mod.y = -y;
+			mod.z = -z;
+			mod.w = -w;
+			break;
+		case Shader::MODIFIER_X2:
+			mod.x = AddSat(x, x);
+			mod.y = AddSat(y, y);
+			mod.z = AddSat(z, z);
+			mod.w = AddSat(w, w);
+			break;
+		case Shader::MODIFIER_X2_NEGATE:
+			mod.x = -AddSat(x, x);
+			mod.y = -AddSat(y, y);
+			mod.z = -AddSat(z, z);
+			mod.w = -AddSat(w, w);
+			break;
+		case Shader::MODIFIER_SIGN:
+			mod.x = SubSat(x, Short4(0x0800));
+			mod.y = SubSat(y, Short4(0x0800));
+			mod.z = SubSat(z, Short4(0x0800));
+			mod.w = SubSat(w, Short4(0x0800));
+			mod.x = AddSat(mod.x, mod.x);
+			mod.y = AddSat(mod.y, mod.y);
+			mod.z = AddSat(mod.z, mod.z);
+			mod.w = AddSat(mod.w, mod.w);
+			break;
+		case Shader::MODIFIER_SIGN_NEGATE:
+			mod.x = SubSat(Short4(0x0800), x);
+			mod.y = SubSat(Short4(0x0800), y);
+			mod.z = SubSat(Short4(0x0800), z);
+			mod.w = SubSat(Short4(0x0800), w);
+			mod.x = AddSat(mod.x, mod.x);
+			mod.y = AddSat(mod.y, mod.y);
+			mod.z = AddSat(mod.z, mod.z);
+			mod.w = AddSat(mod.w, mod.w);
+			break;
+		case Shader::MODIFIER_DZ:
+			mod.x = x;
+			mod.y = y;
+			mod.z = z;
+			mod.w = w;
+			// Projection performed by texture sampler
+			break;
+		case Shader::MODIFIER_DW:
+			mod.x = x;
+			mod.y = y;
+			mod.z = z;
+			mod.w = w;
+			// Projection performed by texture sampler
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(src.type == Shader::PARAMETER_CONST && (src.modifier == Shader::MODIFIER_X2 || src.modifier == Shader::MODIFIER_X2_NEGATE))
+		{
+			mod.x = Min(mod.x, Short4(0x1000)); mod.x = Max(mod.x, Short4(-0x1000));
+			mod.y = Min(mod.y, Short4(0x1000)); mod.y = Max(mod.y, Short4(-0x1000));
+			mod.z = Min(mod.z, Short4(0x1000)); mod.z = Max(mod.z, Short4(-0x1000));
+			mod.w = Min(mod.w, Short4(0x1000)); mod.w = Max(mod.w, Short4(-0x1000));
+		}
+
+		return mod;
+	}
+
+	void PixelPipeline::MOV(Vector4s &dst, Vector4s &src0)
+	{
+		dst.x = src0.x;
+		dst.y = src0.y;
+		dst.z = src0.z;
+		dst.w = src0.w;
+	}
+
+	void PixelPipeline::ADD(Vector4s &dst, Vector4s &src0, Vector4s &src1)
+	{
+		dst.x = AddSat(src0.x, src1.x);
+		dst.y = AddSat(src0.y, src1.y);
+		dst.z = AddSat(src0.z, src1.z);
+		dst.w = AddSat(src0.w, src1.w);
+	}
+
+	void PixelPipeline::SUB(Vector4s &dst, Vector4s &src0, Vector4s &src1)
+	{
+		dst.x = SubSat(src0.x, src1.x);
+		dst.y = SubSat(src0.y, src1.y);
+		dst.z = SubSat(src0.z, src1.z);
+		dst.w = SubSat(src0.w, src1.w);
+	}
+
+	void PixelPipeline::MAD(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
+	{
+		// FIXME: Long fixed-point multiply fixup
+		{ dst.x = MulHigh(src0.x, src1.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, src2.x); }
+		{ dst.y = MulHigh(src0.y, src1.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, src2.y); }
+		{ dst.z = MulHigh(src0.z, src1.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, src2.z); }
+		{ dst.w = MulHigh(src0.w, src1.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, src2.w); }
+	}
+
+	void PixelPipeline::MUL(Vector4s &dst, Vector4s &src0, Vector4s &src1)
+	{
+		// FIXME: Long fixed-point multiply fixup
+		{ dst.x = MulHigh(src0.x, src1.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); }
+		{ dst.y = MulHigh(src0.y, src1.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); }
+		{ dst.z = MulHigh(src0.z, src1.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); }
+		{ dst.w = MulHigh(src0.w, src1.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); }
+	}
+
+	void PixelPipeline::DP3(Vector4s &dst, Vector4s &src0, Vector4s &src1)
+	{
+		Short4 t0;
+		Short4 t1;
+
+		// FIXME: Long fixed-point multiply fixup
+		t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
+		t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+		t0 = AddSat(t0, t1);
+		t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+		t0 = AddSat(t0, t1);
+
+		dst.x = t0;
+		dst.y = t0;
+		dst.z = t0;
+		dst.w = t0;
+	}
+
+	void PixelPipeline::DP4(Vector4s &dst, Vector4s &src0, Vector4s &src1)
+	{
+		Short4 t0;
+		Short4 t1;
+
+		// FIXME: Long fixed-point multiply fixup
+		t0 = MulHigh(src0.x, src1.x); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0); t0 = AddSat(t0, t0);
+		t1 = MulHigh(src0.y, src1.y); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+		t0 = AddSat(t0, t1);
+		t1 = MulHigh(src0.z, src1.z); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+		t0 = AddSat(t0, t1);
+		t1 = MulHigh(src0.w, src1.w); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1); t1 = AddSat(t1, t1);
+		t0 = AddSat(t0, t1);
+
+		dst.x = t0;
+		dst.y = t0;
+		dst.z = t0;
+		dst.w = t0;
+	}
+
+	void PixelPipeline::LRP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
+	{
+		// FIXME: Long fixed-point multiply fixup
+		{ dst.x = SubSat(src1.x, src2.x); dst.x = MulHigh(dst.x, src0.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, dst.x); dst.x = AddSat(dst.x, src2.x); }
+		{
+		dst.y = SubSat(src1.y, src2.y); dst.y = MulHigh(dst.y, src0.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, dst.y); dst.y = AddSat(dst.y, src2.y);
+	}
+		{dst.z = SubSat(src1.z, src2.z); dst.z = MulHigh(dst.z, src0.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, dst.z); dst.z = AddSat(dst.z, src2.z); }
+		{dst.w = SubSat(src1.w, src2.w); dst.w = MulHigh(dst.w, src0.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, dst.w); dst.w = AddSat(dst.w, src2.w); }
+	}
+
+	void PixelPipeline::TEXCOORD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate)
+	{
+		Float4 uw;
+		Float4 vw;
+		Float4 sw;
+
+		if(state.interpolant[2 + coordinate].component & 0x01)
+		{
+			uw = Max(u, Float4(0.0f));
+			uw = Min(uw, Float4(1.0f));
+			dst.x = convertFixed12(uw);
+		}
+		else
+		{
+			dst.x = Short4(0x0000);
+		}
+
+		if(state.interpolant[2 + coordinate].component & 0x02)
+		{
+			vw = Max(v, Float4(0.0f));
+			vw = Min(vw, Float4(1.0f));
+			dst.y = convertFixed12(vw);
+		}
+		else
+		{
+			dst.y = Short4(0x0000);
+		}
+
+		if(state.interpolant[2 + coordinate].component & 0x04)
+		{
+			sw = Max(s, Float4(0.0f));
+			sw = Min(sw, Float4(1.0f));
+			dst.z = convertFixed12(sw);
+		}
+		else
+		{
+			dst.z = Short4(0x0000);
+		}
+
+		dst.w = Short4(0x1000);
+	}
+
+	void PixelPipeline::TEXCRD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate, bool project)
+	{
+		Float4 uw = u;
+		Float4 vw = v;
+		Float4 sw = s;
+
+		if(project)
+		{
+			uw *= Rcp_pp(s);
+			vw *= Rcp_pp(s);
+		}
+
+		if(state.interpolant[2 + coordinate].component & 0x01)
+		{
+			uw *= Float4(0x1000);
+			uw = Max(uw, Float4(-0x8000));
+			uw = Min(uw, Float4(0x7FFF));
+			dst.x = RoundShort4(uw);
+		}
+		else
+		{
+			dst.x = Short4(0x0000);
+		}
+
+		if(state.interpolant[2 + coordinate].component & 0x02)
+		{
+			vw *= Float4(0x1000);
+			vw = Max(vw, Float4(-0x8000));
+			vw = Min(vw, Float4(0x7FFF));
+			dst.y = RoundShort4(vw);
+		}
+		else
+		{
+			dst.y = Short4(0x0000);
+		}
+
+		if(state.interpolant[2 + coordinate].component & 0x04)
+		{
+			sw *= Float4(0x1000);
+			sw = Max(sw, Float4(-0x8000));
+			sw = Min(sw, Float4(0x7FFF));
+			dst.z = RoundShort4(sw);
+		}
+		else
+		{
+			dst.z = Short4(0x0000);
+		}
+	}
+
+	void PixelPipeline::TEXDP3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src)
+	{
+		TEXM3X3PAD(u, v, s, src, 0, false);
+
+		Short4 t0 = RoundShort4(u_ * Float4(0x1000));
+
+		dst.x = t0;
+		dst.y = t0;
+		dst.z = t0;
+		dst.w = t0;
+	}
+
+	void PixelPipeline::TEXDP3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
+	{
+		TEXM3X3PAD(u, v, s, src0, 0, false);
+
+		v_ = Float4(0.0f);
+		w_ = Float4(0.0f);
+
+		dst = sampleTexture(stage, u_, v_, w_, w_);
+	}
+
+	void PixelPipeline::TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s)
+	{
+		Int kill = SignMask(CmpNLT(u, Float4(0.0f))) &
+			SignMask(CmpNLT(v, Float4(0.0f))) &
+			SignMask(CmpNLT(s, Float4(0.0f)));
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+	}
+
+	void PixelPipeline::TEXKILL(Int cMask[4], Vector4s &src)
+	{
+		Short4 test = src.x | src.y | src.z;
+		Int kill = SignMask(PackSigned(test, test)) ^ 0x0000000F;
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+	}
+
+	void PixelPipeline::TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int sampler, bool project)
+	{
+		dst = sampleTexture(sampler, u, v, s, s, project);
+	}
+
+	void PixelPipeline::TEXLD(Vector4s &dst, Vector4s &src, int sampler, bool project)
+	{
+		Float4 u = Float4(src.x) * Float4(1.0f / 0x0FFE);
+		Float4 v = Float4(src.y) * Float4(1.0f / 0x0FFE);
+		Float4 s = Float4(src.z) * Float4(1.0f / 0x0FFE);
+
+		dst = sampleTexture(sampler, u, v, s, s, project);
+	}
+
+	void PixelPipeline::TEXBEM(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage)
+	{
+		Float4 du = Float4(src.x) * Float4(1.0f / 0x0FFE);
+		Float4 dv = Float4(src.y) * Float4(1.0f / 0x0FFE);
+
+		Float4 du2 = du;
+		Float4 dv2 = dv;
+
+		du *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+		dv2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+		du += dv2;
+		dv *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+		du2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+		dv += du2;
+
+		Float4 u_ = u + du;
+		Float4 v_ = v + dv;
+
+		dst = sampleTexture(stage, u_, v_, s, s);
+	}
+
+	void PixelPipeline::TEXBEML(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage)
+	{
+		Float4 du = Float4(src.x) * Float4(1.0f / 0x0FFE);
+		Float4 dv = Float4(src.y) * Float4(1.0f / 0x0FFE);
+
+		Float4 du2 = du;
+		Float4 dv2 = dv;
+
+		du *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+		dv2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+		du += dv2;
+		dv *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+		du2 *= *Pointer<Float4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+		dv += du2;
+
+		Float4 u_ = u + du;
+		Float4 v_ = v + dv;
+
+		dst = sampleTexture(stage, u_, v_, s, s);
+
+		Short4 L;
+
+		L = src.z;
+		L = MulHigh(L, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].luminanceScale4)));
+		L = L << 4;
+		L = AddSat(L, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].luminanceOffset4)));
+		L = Max(L, Short4(0x0000));
+		L = Min(L, Short4(0x1000));
+
+		dst.x = MulHigh(dst.x, L); dst.x = dst.x << 4;
+		dst.y = MulHigh(dst.y, L); dst.y = dst.y << 4;
+		dst.z = MulHigh(dst.z, L); dst.z = dst.z << 4;
+	}
+
+	void PixelPipeline::TEXREG2AR(Vector4s &dst, Vector4s &src0, int stage)
+	{
+		Float4 u = Float4(src0.w) * Float4(1.0f / 0x0FFE);
+		Float4 v = Float4(src0.x) * Float4(1.0f / 0x0FFE);
+		Float4 s = Float4(src0.z) * Float4(1.0f / 0x0FFE);
+
+		dst = sampleTexture(stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXREG2GB(Vector4s &dst, Vector4s &src0, int stage)
+	{
+		Float4 u = Float4(src0.y) * Float4(1.0f / 0x0FFE);
+		Float4 v = Float4(src0.z) * Float4(1.0f / 0x0FFE);
+		Float4 s = v;
+
+		dst = sampleTexture(stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXREG2RGB(Vector4s &dst, Vector4s &src0, int stage)
+	{
+		Float4 u = Float4(src0.x) * Float4(1.0f / 0x0FFE);
+		Float4 v = Float4(src0.y) * Float4(1.0f / 0x0FFE);
+		Float4 s = Float4(src0.z) * Float4(1.0f / 0x0FFE);
+
+		dst = sampleTexture(stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXM3X2DEPTH(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling)
+	{
+		TEXM3X2PAD(u, v, s, src, 1, signedScaling);
+
+		// z / w
+		u_ *= Rcp_pp(v_);   // FIXME: Set result to 1.0 when division by zero
+
+		oDepth = u_;
+	}
+
+	void PixelPipeline::TEXM3X2PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
+	{
+		TEXM3X3PAD(u, v, s, src0, component, signedScaling);
+	}
+
+	void PixelPipeline::TEXM3X2TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X2PAD(u, v, s, src0, 1, signedScaling);
+
+		w_ = Float4(0.0f);
+
+		dst = sampleTexture(stage, u_, v_, w_, w_);
+	}
+
+	void PixelPipeline::TEXM3X3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X3PAD(u, v, s, src0, 2, signedScaling);
+
+		dst.x = RoundShort4(u_ * Float4(0x1000));
+		dst.y = RoundShort4(v_ * Float4(0x1000));
+		dst.z = RoundShort4(w_ * Float4(0x1000));
+		dst.w = Short4(0x1000);
+	}
+
+	void PixelPipeline::TEXM3X3PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
+	{
+		if(component == 0 || previousScaling != signedScaling)   // FIXME: Other source modifiers?
+		{
+			U = Float4(src0.x);
+			V = Float4(src0.y);
+			W = Float4(src0.z);
+
+			previousScaling = signedScaling;
+		}
+
+		Float4 x = U * u + V * v + W * s;
+
+		x *= Float4(1.0f / 0x1000);
+
+		switch(component)
+		{
+		case 0:	u_ = x; break;
+		case 1:	v_ = x; break;
+		case 2: w_ = x; break;
+		default: ASSERT(false);
+		}
+	}
+
+	void PixelPipeline::TEXM3X3SPEC(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1)
+	{
+		TEXM3X3PAD(u, v, s, src0, 2, false);
+
+		Float4 E[3];   // Eye vector
+
+		E[0] = Float4(src1.x) * Float4(1.0f / 0x0FFE);
+		E[1] = Float4(src1.y) * Float4(1.0f / 0x0FFE);
+		E[2] = Float4(src1.z) * Float4(1.0f / 0x0FFE);
+
+		// Reflection
+		Float4 u__;
+		Float4 v__;
+		Float4 w__;
+
+		// (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
+		u__ = u_ * E[0];
+		v__ = v_ * E[1];
+		w__ = w_ * E[2];
+		u__ += v__ + w__;
+		u__ += u__;
+		v__ = u__;
+		w__ = u__;
+		u__ *= u_;
+		v__ *= v_;
+		w__ *= w_;
+		u_ *= u_;
+		v_ *= v_;
+		w_ *= w_;
+		u_ += v_ + w_;
+		u__ -= E[0] * u_;
+		v__ -= E[1] * u_;
+		w__ -= E[2] * u_;
+
+		dst = sampleTexture(stage, u__, v__, w__, w__);
+	}
+
+	void PixelPipeline::TEXM3X3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X3PAD(u, v, s, src0, 2, signedScaling);
+
+		dst = sampleTexture(stage, u_, v_, w_, w_);
+	}
+
+	void PixelPipeline::TEXM3X3VSPEC(Vector4s &dst, Float4 &x, Float4 &y, Float4 &z, int stage, Vector4s &src0)
+	{
+		TEXM3X3PAD(x, y, z, src0, 2, false);
+
+		Float4 E[3];   // Eye vector
+
+		E[0] = v[2 + stage - 2].w;
+		E[1] = v[2 + stage - 1].w;
+		E[2] = v[2 + stage - 0].w;
+
+		// Reflection
+		Float4 u__;
+		Float4 v__;
+		Float4 w__;
+
+		// (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
+		u__ = u_ * E[0];
+		v__ = v_ * E[1];
+		w__ = w_ * E[2];
+		u__ += v__ + w__;
+		u__ += u__;
+		v__ = u__;
+		w__ = u__;
+		u__ *= u_;
+		v__ *= v_;
+		w__ *= w_;
+		u_ *= u_;
+		v_ *= v_;
+		w_ *= w_;
+		u_ += v_ + w_;
+		u__ -= E[0] * u_;
+		v__ -= E[1] * u_;
+		w__ -= E[2] * u_;
+
+		dst = sampleTexture(stage, u__, v__, w__, w__);
+	}
+
+	void PixelPipeline::TEXDEPTH()
+	{
+		u_ = Float4(rs[5].x);
+		v_ = Float4(rs[5].y);
+
+		// z / w
+		u_ *= Rcp_pp(v_);   // FIXME: Set result to 1.0 when division by zero
+
+		oDepth = u_;
+	}
+
+	void PixelPipeline::CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
+	{
+		{Short4 t0; t0 = src0.x; t0 = CmpGT(t0, Short4(0x0800)); Short4 t1; t1 = src1.x; t1 = t1 & t0; t0 = ~t0 & src2.x; t0 = t0 | t1; dst.x = t0; };
+		{Short4 t0; t0 = src0.y; t0 = CmpGT(t0, Short4(0x0800)); Short4 t1; t1 = src1.y; t1 = t1 & t0; t0 = ~t0 & src2.y; t0 = t0 | t1; dst.y = t0; };
+		{Short4 t0; t0 = src0.z; t0 = CmpGT(t0, Short4(0x0800)); Short4 t1; t1 = src1.z; t1 = t1 & t0; t0 = ~t0 & src2.z; t0 = t0 | t1; dst.z = t0; };
+		{Short4 t0; t0 = src0.w; t0 = CmpGT(t0, Short4(0x0800)); Short4 t1; t1 = src1.w; t1 = t1 & t0; t0 = ~t0 & src2.w; t0 = t0 | t1; dst.w = t0; };
+	}
+
+	void PixelPipeline::CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
+	{
+		{Short4 t0 = CmpGT(Short4(0x0000), src0.x); Short4 t1; t1 = src2.x; t1 &= t0; t0 = ~t0 & src1.x; t0 |= t1; dst.x = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000), src0.y); Short4 t1; t1 = src2.y; t1 &= t0; t0 = ~t0 & src1.y; t0 |= t1; dst.y = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000), src0.z); Short4 t1; t1 = src2.z; t1 &= t0; t0 = ~t0 & src1.z; t0 |= t1; dst.z = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000), src0.w); Short4 t1; t1 = src2.w; t1 &= t0; t0 = ~t0 & src1.w; t0 |= t1; dst.w = t0; };
+	}
+
+	void PixelPipeline::BEM(Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage)
+	{
+		Short4 t0;
+		Short4 t1;
+
+		// dst.x = src0.x + BUMPENVMAT00(stage) * src1.x + BUMPENVMAT10(stage) * src1.y
+		t0 = MulHigh(src1.x, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[0][0]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t1 = MulHigh(src1.y, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[1][0]))); t1 = t1 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t0 = AddSat(t0, t1);
+		t0 = AddSat(t0, src0.x);
+		dst.x = t0;
+
+		// dst.y = src0.y + BUMPENVMAT01(stage) * src1.x + BUMPENVMAT11(stage) * src1.y
+		t0 = MulHigh(src1.x, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[0][1]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t1 = MulHigh(src1.y, *Pointer<Short4>(data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[1][1]))); t1 = t1 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t0 = AddSat(t0, t1);
+		t0 = AddSat(t0, src0.y);
+		dst.y = t0;
+	}
+}
+
diff --git a/src/Pipeline/PixelPipeline.hpp b/src/Pipeline/PixelPipeline.hpp
new file mode 100644
index 0000000..66f0ec7
--- /dev/null
+++ b/src/Pipeline/PixelPipeline.hpp
@@ -0,0 +1,114 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_PixelPipeline_hpp
+#define sw_PixelPipeline_hpp
+
+#include "PixelRoutine.hpp"
+
+namespace sw
+{
+	class PixelPipeline : public PixelRoutine
+	{
+	public:
+		PixelPipeline(const PixelProcessor::State &state, const PixelShader *shader) :
+			PixelRoutine(state, shader), current(rs[0]), diffuse(vs[0]), specular(vs[1]), perturbate(false), luminance(false), previousScaling(false) {}
+		virtual ~PixelPipeline() {}
+
+	protected:
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(Int cMask[4]);
+		virtual Bool alphaTest(Int cMask[4]);
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+
+	private:
+		Vector4s &current;
+		Vector4s &diffuse;
+		Vector4s &specular;
+
+		Vector4s rs[6];
+		Vector4s vs[2];
+		Vector4s ts[6];
+
+		// bem(l) offsets and luminance
+		Float4 du;
+		Float4 dv;
+		Short4 L;
+
+		// texm3x3 temporaries
+		Float4 u_; // FIXME
+		Float4 v_; // FIXME
+		Float4 w_; // FIXME
+		Float4 U;  // FIXME
+		Float4 V;  // FIXME
+		Float4 W;  // FIXME
+
+		void fixedFunction();
+		void blendTexture(Vector4s &temp, Vector4s &texture, int stage);
+		void fogBlend(Vector4s &current, Float4 &fog);
+		void specularPixel(Vector4s &current, Vector4s &specular);
+
+		Vector4s sampleTexture(int coordinates, int sampler, bool project = false);
+		Vector4s sampleTexture(int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project = false);
+
+		Short4 convertFixed12(RValue<Float4> cf);
+		void convertFixed12(Vector4s &cs, Vector4f &cf);
+		Float4 convertSigned12(Short4 &cs);
+		void convertSigned12(Vector4f &cf, Vector4s &cs);
+
+		void writeDestination(Vector4s &d, const Dst &dst);
+		Vector4s fetchRegister(const Src &src);
+
+		// Instructions
+		void MOV(Vector4s &dst, Vector4s &src0);
+		void ADD(Vector4s &dst, Vector4s &src0, Vector4s &src1);
+		void SUB(Vector4s &dst, Vector4s &src0, Vector4s &src1);
+		void MAD(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void MUL(Vector4s &dst, Vector4s &src0, Vector4s &src1);
+		void DP3(Vector4s &dst, Vector4s &src0, Vector4s &src1);
+		void DP4(Vector4s &dst, Vector4s &src0, Vector4s &src1);
+		void LRP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void TEXCOORD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate);
+		void TEXCRD(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int coordinate, bool project);
+		void TEXDP3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src);
+		void TEXDP3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
+		void TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s);
+		void TEXKILL(Int cMask[4], Vector4s &dst);
+		void TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, bool project);
+		void TEXLD(Vector4s &dst, Vector4s &src, int stage, bool project);
+		void TEXBEM(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXBEML(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXREG2AR(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2GB(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2RGB(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXM3X2DEPTH(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling);
+		void TEXM3X2PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X2TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling);
+		void TEXM3X3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling);
+		void TEXM3X3PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X3SPEC(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1);
+		void TEXM3X3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool singedScaling);
+		void TEXM3X3VSPEC(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
+		void TEXDEPTH();
+		void CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void BEM(Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage);
+
+		bool perturbate;
+		bool luminance;
+		bool previousScaling;
+	};
+}
+
+#endif
diff --git a/src/Pipeline/PixelProgram.cpp b/src/Pipeline/PixelProgram.cpp
new file mode 100644
index 0000000..473712b
--- /dev/null
+++ b/src/Pipeline/PixelProgram.cpp
@@ -0,0 +1,1850 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelProgram.hpp"
+
+#include "SamplerCore.hpp"
+#include "Renderer/Primitive.hpp"
+#include "Renderer/Renderer.hpp"
+
+namespace sw
+{
+	extern bool postBlendSRGB;
+	extern bool booleanFaceRegister;
+	extern bool halfIntegerCoordinates;     // Pixel centers are not at integer coordinates
+	extern bool fullPixelPositionRegister;
+
+	void PixelProgram::setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w)
+	{
+		if(shader->getShaderModel() >= 0x0300)
+		{
+			if(shader->isVPosDeclared())
+			{
+				if(!halfIntegerCoordinates)
+				{
+					vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
+					vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
+				}
+				else
+				{
+					vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
+					vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
+				}
+
+				if(fullPixelPositionRegister)
+				{
+					vPos.z = z[0]; // FIXME: Centroid?
+					vPos.w = w;    // FIXME: Centroid?
+				}
+			}
+
+			if(shader->isVFaceDeclared())
+			{
+				Float4 face = *Pointer<Float>(primitive + OFFSET(Primitive, area));
+
+				if(booleanFaceRegister)
+				{
+					face = As<Float4>(state.frontFaceCCW ? CmpNLT(face, Float4(0.0f)) : CmpLT(face, Float4(0.0f)));
+				}
+
+				vFace.x = face;
+				vFace.y = face;
+				vFace.z = face;
+				vFace.w = face;
+			}
+		}
+	}
+
+	void PixelProgram::applyShader(Int cMask[4])
+	{
+		enableIndex = 0;
+		stackIndex = 0;
+
+		if(shader->containsLeaveInstruction())
+		{
+			enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		}
+
+		for(int i = 0; i < RENDERTARGETS; i++)
+		{
+			if(state.targetFormat[i] != FORMAT_NULL)
+			{
+				oC[i] = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+			}
+		}
+
+		// Create all call site return blocks up front
+		for(size_t i = 0; i < shader->getLength(); i++)
+		{
+			const Shader::Instruction *instruction = shader->getInstruction(i);
+			Shader::Opcode opcode = instruction->opcode;
+
+			if(opcode == Shader::OPCODE_CALL || opcode == Shader::OPCODE_CALLNZ)
+			{
+				const Dst &dst = instruction->dst;
+
+				ASSERT(callRetBlock[dst.label].size() == dst.callSite);
+				callRetBlock[dst.label].push_back(Nucleus::createBasicBlock());
+			}
+		}
+
+		bool broadcastColor0 = true;
+
+		for(size_t i = 0; i < shader->getLength(); i++)
+		{
+			const Shader::Instruction *instruction = shader->getInstruction(i);
+			Shader::Opcode opcode = instruction->opcode;
+
+			if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB)
+			{
+				continue;
+			}
+
+			const Dst &dst = instruction->dst;
+			const Src &src0 = instruction->src[0];
+			const Src &src1 = instruction->src[1];
+			const Src &src2 = instruction->src[2];
+			const Src &src3 = instruction->src[3];
+			const Src &src4 = instruction->src[4];
+
+			bool predicate = instruction->predicate;
+			Control control = instruction->control;
+			bool pp = dst.partialPrecision;
+			bool project = instruction->project;
+			bool bias = instruction->bias;
+
+			Vector4f d;
+			Vector4f s0;
+			Vector4f s1;
+			Vector4f s2;
+			Vector4f s3;
+			Vector4f s4;
+
+			if(opcode == Shader::OPCODE_TEXKILL)   // Takes destination as input
+			{
+				if(dst.type == Shader::PARAMETER_TEXTURE)
+				{
+					d.x = v[2 + dst.index].x;
+					d.y = v[2 + dst.index].y;
+					d.z = v[2 + dst.index].z;
+					d.w = v[2 + dst.index].w;
+				}
+				else
+				{
+					d = r[dst.index];
+				}
+			}
+
+			if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegister(src0);
+			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegister(src1);
+			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegister(src2);
+			if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegister(src3);
+			if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegister(src4);
+
+			switch(opcode)
+			{
+			case Shader::OPCODE_PS_2_0:                                                    break;
+			case Shader::OPCODE_PS_2_x:                                                    break;
+			case Shader::OPCODE_PS_3_0:                                                    break;
+			case Shader::OPCODE_DEF:                                                       break;
+			case Shader::OPCODE_DCL:                                                       break;
+			case Shader::OPCODE_NOP:                                                       break;
+			case Shader::OPCODE_MOV:        mov(d, s0);                                    break;
+			case Shader::OPCODE_NEG:        neg(d, s0);                                    break;
+			case Shader::OPCODE_INEG:       ineg(d, s0);                                   break;
+			case Shader::OPCODE_F2B:        f2b(d, s0);                                    break;
+			case Shader::OPCODE_B2F:        b2f(d, s0);                                    break;
+			case Shader::OPCODE_F2I:        f2i(d, s0);                                    break;
+			case Shader::OPCODE_I2F:        i2f(d, s0);                                    break;
+			case Shader::OPCODE_F2U:        f2u(d, s0);                                    break;
+			case Shader::OPCODE_U2F:        u2f(d, s0);                                    break;
+			case Shader::OPCODE_I2B:        i2b(d, s0);                                    break;
+			case Shader::OPCODE_B2I:        b2i(d, s0);                                    break;
+			case Shader::OPCODE_ADD:        add(d, s0, s1);                                break;
+			case Shader::OPCODE_IADD:       iadd(d, s0, s1);                               break;
+			case Shader::OPCODE_SUB:        sub(d, s0, s1);                                break;
+			case Shader::OPCODE_ISUB:       isub(d, s0, s1);                               break;
+			case Shader::OPCODE_MUL:        mul(d, s0, s1);                                break;
+			case Shader::OPCODE_IMUL:       imul(d, s0, s1);                               break;
+			case Shader::OPCODE_MAD:        mad(d, s0, s1, s2);                            break;
+			case Shader::OPCODE_IMAD:       imad(d, s0, s1, s2);                           break;
+			case Shader::OPCODE_DP1:        dp1(d, s0, s1);                                break;
+			case Shader::OPCODE_DP2:        dp2(d, s0, s1);                                break;
+			case Shader::OPCODE_DP2ADD:     dp2add(d, s0, s1, s2);                         break;
+			case Shader::OPCODE_DP3:        dp3(d, s0, s1);                                break;
+			case Shader::OPCODE_DP4:        dp4(d, s0, s1);                                break;
+			case Shader::OPCODE_DET2:       det2(d, s0, s1);                               break;
+			case Shader::OPCODE_DET3:       det3(d, s0, s1, s2);                           break;
+			case Shader::OPCODE_DET4:       det4(d, s0, s1, s2, s3);                       break;
+			case Shader::OPCODE_CMP0:       cmp0(d, s0, s1, s2);                           break;
+			case Shader::OPCODE_ICMP:       icmp(d, s0, s1, control);                      break;
+			case Shader::OPCODE_UCMP:       ucmp(d, s0, s1, control);                      break;
+			case Shader::OPCODE_SELECT:     select(d, s0, s1, s2);                         break;
+			case Shader::OPCODE_EXTRACT:    extract(d.x, s0, s1.x);                        break;
+			case Shader::OPCODE_INSERT:     insert(d, s0, s1.x, s2.x);                     break;
+			case Shader::OPCODE_FRC:        frc(d, s0);                                    break;
+			case Shader::OPCODE_TRUNC:      trunc(d, s0);                                  break;
+			case Shader::OPCODE_FLOOR:      floor(d, s0);                                  break;
+			case Shader::OPCODE_ROUND:      round(d, s0);                                  break;
+			case Shader::OPCODE_ROUNDEVEN:  roundEven(d, s0);                              break;
+			case Shader::OPCODE_CEIL:       ceil(d, s0);                                   break;
+			case Shader::OPCODE_EXP2X:      exp2x(d, s0, pp);                              break;
+			case Shader::OPCODE_EXP2:       exp2(d, s0, pp);                               break;
+			case Shader::OPCODE_LOG2X:      log2x(d, s0, pp);                              break;
+			case Shader::OPCODE_LOG2:       log2(d, s0, pp);                               break;
+			case Shader::OPCODE_EXP:        exp(d, s0, pp);                                break;
+			case Shader::OPCODE_LOG:        log(d, s0, pp);                                break;
+			case Shader::OPCODE_RCPX:       rcpx(d, s0, pp);                               break;
+			case Shader::OPCODE_DIV:        div(d, s0, s1);                                break;
+			case Shader::OPCODE_IDIV:       idiv(d, s0, s1);                               break;
+			case Shader::OPCODE_UDIV:       udiv(d, s0, s1);                               break;
+			case Shader::OPCODE_MOD:        mod(d, s0, s1);                                break;
+			case Shader::OPCODE_IMOD:       imod(d, s0, s1);                               break;
+			case Shader::OPCODE_UMOD:       umod(d, s0, s1);                               break;
+			case Shader::OPCODE_SHL:        shl(d, s0, s1);                                break;
+			case Shader::OPCODE_ISHR:       ishr(d, s0, s1);                               break;
+			case Shader::OPCODE_USHR:       ushr(d, s0, s1);                               break;
+			case Shader::OPCODE_RSQX:       rsqx(d, s0, pp);                               break;
+			case Shader::OPCODE_SQRT:       sqrt(d, s0, pp);                               break;
+			case Shader::OPCODE_RSQ:        rsq(d, s0, pp);                                break;
+			case Shader::OPCODE_LEN2:       len2(d.x, s0, pp);                             break;
+			case Shader::OPCODE_LEN3:       len3(d.x, s0, pp);                             break;
+			case Shader::OPCODE_LEN4:       len4(d.x, s0, pp);                             break;
+			case Shader::OPCODE_DIST1:      dist1(d.x, s0, s1, pp);                        break;
+			case Shader::OPCODE_DIST2:      dist2(d.x, s0, s1, pp);                        break;
+			case Shader::OPCODE_DIST3:      dist3(d.x, s0, s1, pp);                        break;
+			case Shader::OPCODE_DIST4:      dist4(d.x, s0, s1, pp);                        break;
+			case Shader::OPCODE_MIN:        min(d, s0, s1);                                break;
+			case Shader::OPCODE_IMIN:       imin(d, s0, s1);                               break;
+			case Shader::OPCODE_UMIN:       umin(d, s0, s1);                               break;
+			case Shader::OPCODE_MAX:        max(d, s0, s1);                                break;
+			case Shader::OPCODE_IMAX:       imax(d, s0, s1);                               break;
+			case Shader::OPCODE_UMAX:       umax(d, s0, s1);                               break;
+			case Shader::OPCODE_LRP:        lrp(d, s0, s1, s2);                            break;
+			case Shader::OPCODE_STEP:       step(d, s0, s1);                               break;
+			case Shader::OPCODE_SMOOTH:     smooth(d, s0, s1, s2);                         break;
+			case Shader::OPCODE_ISINF:      isinf(d, s0);                                  break;
+			case Shader::OPCODE_ISNAN:      isnan(d, s0);                                  break;
+			case Shader::OPCODE_FLOATBITSTOINT:
+			case Shader::OPCODE_FLOATBITSTOUINT:
+			case Shader::OPCODE_INTBITSTOFLOAT:
+			case Shader::OPCODE_UINTBITSTOFLOAT: d = s0;                                   break;
+			case Shader::OPCODE_PACKSNORM2x16:   packSnorm2x16(d, s0);                     break;
+			case Shader::OPCODE_PACKUNORM2x16:   packUnorm2x16(d, s0);                     break;
+			case Shader::OPCODE_PACKHALF2x16:    packHalf2x16(d, s0);                      break;
+			case Shader::OPCODE_UNPACKSNORM2x16: unpackSnorm2x16(d, s0);                   break;
+			case Shader::OPCODE_UNPACKUNORM2x16: unpackUnorm2x16(d, s0);                   break;
+			case Shader::OPCODE_UNPACKHALF2x16:  unpackHalf2x16(d, s0);                    break;
+			case Shader::OPCODE_POWX:       powx(d, s0, s1, pp);                           break;
+			case Shader::OPCODE_POW:        pow(d, s0, s1, pp);                            break;
+			case Shader::OPCODE_SGN:        sgn(d, s0);                                    break;
+			case Shader::OPCODE_ISGN:       isgn(d, s0);                                   break;
+			case Shader::OPCODE_CRS:        crs(d, s0, s1);                                break;
+			case Shader::OPCODE_FORWARD1:   forward1(d, s0, s1, s2);                       break;
+			case Shader::OPCODE_FORWARD2:   forward2(d, s0, s1, s2);                       break;
+			case Shader::OPCODE_FORWARD3:   forward3(d, s0, s1, s2);                       break;
+			case Shader::OPCODE_FORWARD4:   forward4(d, s0, s1, s2);                       break;
+			case Shader::OPCODE_REFLECT1:   reflect1(d, s0, s1);                           break;
+			case Shader::OPCODE_REFLECT2:   reflect2(d, s0, s1);                           break;
+			case Shader::OPCODE_REFLECT3:   reflect3(d, s0, s1);                           break;
+			case Shader::OPCODE_REFLECT4:   reflect4(d, s0, s1);                           break;
+			case Shader::OPCODE_REFRACT1:   refract1(d, s0, s1, s2.x);                     break;
+			case Shader::OPCODE_REFRACT2:   refract2(d, s0, s1, s2.x);                     break;
+			case Shader::OPCODE_REFRACT3:   refract3(d, s0, s1, s2.x);                     break;
+			case Shader::OPCODE_REFRACT4:   refract4(d, s0, s1, s2.x);                     break;
+			case Shader::OPCODE_NRM2:       nrm2(d, s0, pp);                               break;
+			case Shader::OPCODE_NRM3:       nrm3(d, s0, pp);                               break;
+			case Shader::OPCODE_NRM4:       nrm4(d, s0, pp);                               break;
+			case Shader::OPCODE_ABS:        abs(d, s0);                                    break;
+			case Shader::OPCODE_IABS:       iabs(d, s0);                                   break;
+			case Shader::OPCODE_SINCOS:     sincos(d, s0, pp);                             break;
+			case Shader::OPCODE_COS:        cos(d, s0, pp);                                break;
+			case Shader::OPCODE_SIN:        sin(d, s0, pp);                                break;
+			case Shader::OPCODE_TAN:        tan(d, s0, pp);                                break;
+			case Shader::OPCODE_ACOS:       acos(d, s0, pp);                               break;
+			case Shader::OPCODE_ASIN:       asin(d, s0, pp);                               break;
+			case Shader::OPCODE_ATAN:       atan(d, s0, pp);                               break;
+			case Shader::OPCODE_ATAN2:      atan2(d, s0, s1, pp);                          break;
+			case Shader::OPCODE_COSH:       cosh(d, s0, pp);                               break;
+			case Shader::OPCODE_SINH:       sinh(d, s0, pp);                               break;
+			case Shader::OPCODE_TANH:       tanh(d, s0, pp);                               break;
+			case Shader::OPCODE_ACOSH:      acosh(d, s0, pp);                              break;
+			case Shader::OPCODE_ASINH:      asinh(d, s0, pp);                              break;
+			case Shader::OPCODE_ATANH:      atanh(d, s0, pp);                              break;
+			case Shader::OPCODE_M4X4:       M4X4(d, s0, src1);                             break;
+			case Shader::OPCODE_M4X3:       M4X3(d, s0, src1);                             break;
+			case Shader::OPCODE_M3X4:       M3X4(d, s0, src1);                             break;
+			case Shader::OPCODE_M3X3:       M3X3(d, s0, src1);                             break;
+			case Shader::OPCODE_M3X2:       M3X2(d, s0, src1);                             break;
+			case Shader::OPCODE_TEX:        TEX(d, s0, src1, project, bias);               break;
+			case Shader::OPCODE_TEXLDD:     TEXGRAD(d, s0, src1, s2, s3);                  break;
+			case Shader::OPCODE_TEXLDL:     TEXLOD(d, s0, src1, s0.w);                     break;
+			case Shader::OPCODE_TEXLOD:     TEXLOD(d, s0, src1, s2.x);                     break;
+			case Shader::OPCODE_TEXSIZE:    TEXSIZE(d, s0.x, src1);                        break;
+			case Shader::OPCODE_TEXKILL:    TEXKILL(cMask, d, dst.mask);                   break;
+			case Shader::OPCODE_TEXOFFSET:  TEXOFFSET(d, s0, src1, s2);                    break;
+			case Shader::OPCODE_TEXLODOFFSET: TEXLODOFFSET(d, s0, src1, s2, s3.x);         break;
+			case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2.x);                 break;
+			case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCHOFFSET(d, s0, src1, s2, s3.x); break;
+			case Shader::OPCODE_TEXGRAD:    TEXGRAD(d, s0, src1, s2, s3);                  break;
+			case Shader::OPCODE_TEXGRADOFFSET: TEXGRADOFFSET(d, s0, src1, s2, s3, s4);     break;
+			case Shader::OPCODE_TEXBIAS:    TEXBIAS(d, s0, src1, s2.x);                    break;
+			case Shader::OPCODE_TEXOFFSETBIAS: TEXOFFSETBIAS(d, s0, src1, s2, s3.x);       break;
+			case Shader::OPCODE_DISCARD:    DISCARD(cMask, instruction);                   break;
+			case Shader::OPCODE_DFDX:       DFDX(d, s0);                                   break;
+			case Shader::OPCODE_DFDY:       DFDY(d, s0);                                   break;
+			case Shader::OPCODE_FWIDTH:     FWIDTH(d, s0);                                 break;
+			case Shader::OPCODE_BREAK:      BREAK();                                       break;
+			case Shader::OPCODE_BREAKC:     BREAKC(s0, s1, control);                       break;
+			case Shader::OPCODE_BREAKP:     BREAKP(src0);                                  break;
+			case Shader::OPCODE_CONTINUE:   CONTINUE();                                    break;
+			case Shader::OPCODE_TEST:       TEST();                                        break;
+			case Shader::OPCODE_CALL:       CALL(dst.label, dst.callSite);                 break;
+			case Shader::OPCODE_CALLNZ:     CALLNZ(dst.label, dst.callSite, src0);         break;
+			case Shader::OPCODE_ELSE:       ELSE();                                        break;
+			case Shader::OPCODE_ENDIF:      ENDIF();                                       break;
+			case Shader::OPCODE_ENDLOOP:    ENDLOOP();                                     break;
+			case Shader::OPCODE_ENDREP:     ENDREP();                                      break;
+			case Shader::OPCODE_ENDWHILE:   ENDWHILE();                                    break;
+			case Shader::OPCODE_ENDSWITCH:  ENDSWITCH();                                   break;
+			case Shader::OPCODE_IF:         IF(src0);                                      break;
+			case Shader::OPCODE_IFC:        IFC(s0, s1, control);                          break;
+			case Shader::OPCODE_LABEL:      LABEL(dst.index);                              break;
+			case Shader::OPCODE_LOOP:       LOOP(src1);                                    break;
+			case Shader::OPCODE_REP:        REP(src0);                                     break;
+			case Shader::OPCODE_WHILE:      WHILE(src0);                                   break;
+			case Shader::OPCODE_SWITCH:     SWITCH();                                      break;
+			case Shader::OPCODE_RET:        RET();                                         break;
+			case Shader::OPCODE_LEAVE:      LEAVE();                                       break;
+			case Shader::OPCODE_CMP:        cmp(d, s0, s1, control);                       break;
+			case Shader::OPCODE_ALL:        all(d.x, s0);                                  break;
+			case Shader::OPCODE_ANY:        any(d.x, s0);                                  break;
+			case Shader::OPCODE_NOT:        bitwise_not(d, s0);                            break;
+			case Shader::OPCODE_OR:         bitwise_or(d, s0, s1);                         break;
+			case Shader::OPCODE_XOR:        bitwise_xor(d, s0, s1);                        break;
+			case Shader::OPCODE_AND:        bitwise_and(d, s0, s1);                        break;
+			case Shader::OPCODE_EQ:         equal(d, s0, s1);                              break;
+			case Shader::OPCODE_NE:         notEqual(d, s0, s1);                           break;
+			case Shader::OPCODE_END:                                                       break;
+			default:
+				ASSERT(false);
+			}
+
+			if(dst.type != Shader::PARAMETER_VOID && dst.type != Shader::PARAMETER_LABEL && opcode != Shader::OPCODE_TEXKILL && opcode != Shader::OPCODE_NOP)
+			{
+				if(dst.saturate)
+				{
+					if(dst.x) d.x = Max(d.x, Float4(0.0f));
+					if(dst.y) d.y = Max(d.y, Float4(0.0f));
+					if(dst.z) d.z = Max(d.z, Float4(0.0f));
+					if(dst.w) d.w = Max(d.w, Float4(0.0f));
+
+					if(dst.x) d.x = Min(d.x, Float4(1.0f));
+					if(dst.y) d.y = Min(d.y, Float4(1.0f));
+					if(dst.z) d.z = Min(d.z, Float4(1.0f));
+					if(dst.w) d.w = Min(d.w, Float4(1.0f));
+				}
+
+				if(instruction->isPredicated())
+				{
+					Vector4f pDst;   // FIXME: Rename
+
+					switch(dst.type)
+					{
+					case Shader::PARAMETER_TEMP:
+						if(dst.rel.type == Shader::PARAMETER_VOID)
+						{
+							if(dst.x) pDst.x = r[dst.index].x;
+							if(dst.y) pDst.y = r[dst.index].y;
+							if(dst.z) pDst.z = r[dst.index].z;
+							if(dst.w) pDst.w = r[dst.index].w;
+						}
+						else if(!dst.rel.dynamic)
+						{
+							Int a = dst.index + relativeAddress(dst.rel);
+
+							if(dst.x) pDst.x = r[a].x;
+							if(dst.y) pDst.y = r[a].y;
+							if(dst.z) pDst.z = r[a].z;
+							if(dst.w) pDst.w = r[a].w;
+						}
+						else
+						{
+							Int4 a = dst.index + dynamicAddress(dst.rel);
+
+							if(dst.x) pDst.x = r[a].x;
+							if(dst.y) pDst.y = r[a].y;
+							if(dst.z) pDst.z = r[a].z;
+							if(dst.w) pDst.w = r[a].w;
+						}
+						break;
+					case Shader::PARAMETER_COLOROUT:
+						if(dst.rel.type == Shader::PARAMETER_VOID)
+						{
+							if(dst.x) pDst.x = oC[dst.index].x;
+							if(dst.y) pDst.y = oC[dst.index].y;
+							if(dst.z) pDst.z = oC[dst.index].z;
+							if(dst.w) pDst.w = oC[dst.index].w;
+						}
+						else if(!dst.rel.dynamic)
+						{
+							Int a = dst.index + relativeAddress(dst.rel);
+
+							if(dst.x) pDst.x = oC[a].x;
+							if(dst.y) pDst.y = oC[a].y;
+							if(dst.z) pDst.z = oC[a].z;
+							if(dst.w) pDst.w = oC[a].w;
+						}
+						else
+						{
+							Int4 a = dst.index + dynamicAddress(dst.rel);
+
+							if(dst.x) pDst.x = oC[a].x;
+							if(dst.y) pDst.y = oC[a].y;
+							if(dst.z) pDst.z = oC[a].z;
+							if(dst.w) pDst.w = oC[a].w;
+						}
+						break;
+					case Shader::PARAMETER_PREDICATE:
+						if(dst.x) pDst.x = p0.x;
+						if(dst.y) pDst.y = p0.y;
+						if(dst.z) pDst.z = p0.z;
+						if(dst.w) pDst.w = p0.w;
+						break;
+					case Shader::PARAMETER_DEPTHOUT:
+						pDst.x = oDepth;
+						break;
+					default:
+						ASSERT(false);
+					}
+
+					Int4 enable = enableMask(instruction);
+
+					Int4 xEnable = enable;
+					Int4 yEnable = enable;
+					Int4 zEnable = enable;
+					Int4 wEnable = enable;
+
+					if(predicate)
+					{
+						unsigned char pSwizzle = instruction->predicateSwizzle;
+
+						Float4 xPredicate = p0[(pSwizzle >> 0) & 0x03];
+						Float4 yPredicate = p0[(pSwizzle >> 2) & 0x03];
+						Float4 zPredicate = p0[(pSwizzle >> 4) & 0x03];
+						Float4 wPredicate = p0[(pSwizzle >> 6) & 0x03];
+
+						if(!instruction->predicateNot)
+						{
+							if(dst.x) xEnable = xEnable & As<Int4>(xPredicate);
+							if(dst.y) yEnable = yEnable & As<Int4>(yPredicate);
+							if(dst.z) zEnable = zEnable & As<Int4>(zPredicate);
+							if(dst.w) wEnable = wEnable & As<Int4>(wPredicate);
+						}
+						else
+						{
+							if(dst.x) xEnable = xEnable & ~As<Int4>(xPredicate);
+							if(dst.y) yEnable = yEnable & ~As<Int4>(yPredicate);
+							if(dst.z) zEnable = zEnable & ~As<Int4>(zPredicate);
+							if(dst.w) wEnable = wEnable & ~As<Int4>(wPredicate);
+						}
+					}
+
+					if(dst.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable);
+					if(dst.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable);
+					if(dst.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable);
+					if(dst.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable);
+
+					if(dst.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable));
+					if(dst.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable));
+					if(dst.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable));
+					if(dst.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable));
+				}
+
+				switch(dst.type)
+				{
+				case Shader::PARAMETER_TEMP:
+					if(dst.rel.type == Shader::PARAMETER_VOID)
+					{
+						if(dst.x) r[dst.index].x = d.x;
+						if(dst.y) r[dst.index].y = d.y;
+						if(dst.z) r[dst.index].z = d.z;
+						if(dst.w) r[dst.index].w = d.w;
+					}
+					else if(!dst.rel.dynamic)
+					{
+						Int a = dst.index + relativeAddress(dst.rel);
+
+						if(dst.x) r[a].x = d.x;
+						if(dst.y) r[a].y = d.y;
+						if(dst.z) r[a].z = d.z;
+						if(dst.w) r[a].w = d.w;
+					}
+					else
+					{
+						Int4 a = dst.index + dynamicAddress(dst.rel);
+
+						if(dst.x) r.scatter_x(a, d.x);
+						if(dst.y) r.scatter_y(a, d.y);
+						if(dst.z) r.scatter_z(a, d.z);
+						if(dst.w) r.scatter_w(a, d.w);
+					}
+					break;
+				case Shader::PARAMETER_COLOROUT:
+					if(dst.rel.type == Shader::PARAMETER_VOID)
+					{
+						broadcastColor0 = (dst.index == 0) && broadcastColor0;
+
+						if(dst.x) oC[dst.index].x = d.x;
+						if(dst.y) oC[dst.index].y = d.y;
+						if(dst.z) oC[dst.index].z = d.z;
+						if(dst.w) oC[dst.index].w = d.w;
+					}
+					else if(!dst.rel.dynamic)
+					{
+						broadcastColor0 = false;
+						Int a = dst.index + relativeAddress(dst.rel);
+
+						if(dst.x) oC[a].x = d.x;
+						if(dst.y) oC[a].y = d.y;
+						if(dst.z) oC[a].z = d.z;
+						if(dst.w) oC[a].w = d.w;
+					}
+					else
+					{
+						broadcastColor0 = false;
+						Int4 a = dst.index + dynamicAddress(dst.rel);
+
+						if(dst.x) oC.scatter_x(a, d.x);
+						if(dst.y) oC.scatter_y(a, d.y);
+						if(dst.z) oC.scatter_z(a, d.z);
+						if(dst.w) oC.scatter_w(a, d.w);
+					}
+					break;
+				case Shader::PARAMETER_PREDICATE:
+					if(dst.x) p0.x = d.x;
+					if(dst.y) p0.y = d.y;
+					if(dst.z) p0.z = d.z;
+					if(dst.w) p0.w = d.w;
+					break;
+				case Shader::PARAMETER_DEPTHOUT:
+					oDepth = d.x;
+					break;
+				default:
+					ASSERT(false);
+				}
+			}
+		}
+
+		if(currentLabel != -1)
+		{
+			Nucleus::setInsertBlock(returnBlock);
+		}
+
+		if(broadcastColor0)
+		{
+			for(int i = 0; i < RENDERTARGETS; i++)
+			{
+				c[i] = oC[0];
+			}
+		}
+		else
+		{
+			for(int i = 0; i < RENDERTARGETS; i++)
+			{
+				c[i] = oC[i];
+			}
+		}
+
+		clampColor(c);
+
+		if(state.depthOverride)
+		{
+			oDepth = Min(Max(oDepth, Float4(0.0f)), Float4(1.0f));
+		}
+	}
+
+	Bool PixelProgram::alphaTest(Int cMask[4])
+	{
+		if(!state.alphaTestActive())
+		{
+			return true;
+		}
+
+		Int aMask;
+
+		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
+		{
+			Short4 alpha = RoundShort4(c[0].w * Float4(0x1000));
+
+			PixelRoutine::alphaTest(aMask, alpha);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				cMask[q] &= aMask;
+			}
+		}
+		else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
+		{
+			alphaToCoverage(cMask, c[0].w);
+		}
+		else ASSERT(false);
+
+		Int pass = cMask[0];
+
+		for(unsigned int q = 1; q < state.multiSample; q++)
+		{
+			pass = pass | cMask[q];
+		}
+
+		return pass != 0x0;
+	}
+
+	void PixelProgram::rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+	{
+		for(int index = 0; index < RENDERTARGETS; index++)
+		{
+			if(!state.colorWriteActive(index))
+			{
+				continue;
+			}
+
+			if(!postBlendSRGB && state.writeSRGB && !isSRGB(index))
+			{
+				c[index].x = linearToSRGB(c[index].x);
+				c[index].y = linearToSRGB(c[index].y);
+				c[index].z = linearToSRGB(c[index].z);
+			}
+
+			if(index == 0)
+			{
+				fogBlend(c[index], fog);
+			}
+
+			switch(state.targetFormat[index])
+			{
+			case FORMAT_R5G6B5:
+			case FORMAT_X8R8G8B8:
+			case FORMAT_X8B8G8R8:
+			case FORMAT_A8R8G8B8:
+			case FORMAT_A8B8G8R8:
+			case FORMAT_SRGB8_X8:
+			case FORMAT_SRGB8_A8:
+			case FORMAT_G8R8:
+			case FORMAT_R8:
+			case FORMAT_A8:
+			case FORMAT_G16R16:
+			case FORMAT_A16B16G16R16:
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[index]));
+					Vector4s color;
+
+					if(state.targetFormat[index] == FORMAT_R5G6B5)
+					{
+						color.x = UShort4(c[index].x * Float4(0xFBFF), false);
+						color.y = UShort4(c[index].y * Float4(0xFDFF), false);
+						color.z = UShort4(c[index].z * Float4(0xFBFF), false);
+						color.w = UShort4(c[index].w * Float4(0xFFFF), false);
+					}
+					else
+					{
+						color.x = convertFixed16(c[index].x, false);
+						color.y = convertFixed16(c[index].y, false);
+						color.z = convertFixed16(c[index].z, false);
+						color.w = convertFixed16(c[index].w, false);
+					}
+
+					if(state.multiSampleMask & (1 << q))
+					{
+						alphaBlend(index, buffer, color, x);
+						logicOperation(index, buffer, color, x);
+						writeColor(index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+					}
+				}
+				break;
+			case FORMAT_R32F:
+			case FORMAT_G32R32F:
+			case FORMAT_X32B32G32R32F:
+			case FORMAT_A32B32G32R32F:
+			case FORMAT_X32B32G32R32F_UNSIGNED:
+			case FORMAT_R32I:
+			case FORMAT_G32R32I:
+			case FORMAT_A32B32G32R32I:
+			case FORMAT_R32UI:
+			case FORMAT_G32R32UI:
+			case FORMAT_A32B32G32R32UI:
+			case FORMAT_R16I:
+			case FORMAT_G16R16I:
+			case FORMAT_A16B16G16R16I:
+			case FORMAT_R16UI:
+			case FORMAT_G16R16UI:
+			case FORMAT_A16B16G16R16UI:
+			case FORMAT_R8I:
+			case FORMAT_G8R8I:
+			case FORMAT_A8B8G8R8I:
+			case FORMAT_R8UI:
+			case FORMAT_G8R8UI:
+			case FORMAT_A8B8G8R8UI:
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(data + OFFSET(DrawData, colorSliceB[index]));
+					Vector4f color = c[index];
+
+					if(state.multiSampleMask & (1 << q))
+					{
+						alphaBlend(index, buffer, color, x);
+						writeColor(index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+					}
+				}
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+	}
+
+	Vector4f PixelProgram::sampleTexture(const Src &sampler, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+	{
+		Vector4f tmp;
+
+		if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
+		{
+			tmp = sampleTexture(sampler.index, uvwq, bias, dsx, dsy, offset, function);
+		}
+		else
+		{
+			Int index = As<Int>(Float(fetchRegister(sampler).x.x));
+
+			for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
+			{
+				if(shader->usesSampler(i))
+				{
+					If(index == i)
+					{
+						tmp = sampleTexture(i, uvwq, bias, dsx, dsy, offset, function);
+						// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
+					}
+				}
+			}
+		}
+
+		Vector4f c;
+		c.x = tmp[(sampler.swizzle >> 0) & 0x3];
+		c.y = tmp[(sampler.swizzle >> 2) & 0x3];
+		c.z = tmp[(sampler.swizzle >> 4) & 0x3];
+		c.w = tmp[(sampler.swizzle >> 6) & 0x3];
+
+		return c;
+	}
+
+	Vector4f PixelProgram::sampleTexture(int samplerIndex, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+	{
+		#if PERF_PROFILE
+			Long texTime = Ticks();
+		#endif
+
+		Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + samplerIndex * sizeof(Texture);
+		Vector4f c = SamplerCore(constants, state.sampler[samplerIndex]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, bias, dsx, dsy, offset, function);
+
+		#if PERF_PROFILE
+			cycles[PERF_TEX] += Ticks() - texTime;
+		#endif
+
+		return c;
+	}
+
+	void PixelProgram::clampColor(Vector4f oC[RENDERTARGETS])
+	{
+		for(int index = 0; index < RENDERTARGETS; index++)
+		{
+			if(!state.colorWriteActive(index) && !(index == 0 && state.alphaTestActive()))
+			{
+				continue;
+			}
+
+			switch(state.targetFormat[index])
+			{
+			case FORMAT_NULL:
+				break;
+			case FORMAT_R5G6B5:
+			case FORMAT_A8R8G8B8:
+			case FORMAT_A8B8G8R8:
+			case FORMAT_X8R8G8B8:
+			case FORMAT_X8B8G8R8:
+			case FORMAT_SRGB8_X8:
+			case FORMAT_SRGB8_A8:
+			case FORMAT_G8R8:
+			case FORMAT_R8:
+			case FORMAT_A8:
+			case FORMAT_G16R16:
+			case FORMAT_A16B16G16R16:
+				oC[index].x = Max(oC[index].x, Float4(0.0f)); oC[index].x = Min(oC[index].x, Float4(1.0f));
+				oC[index].y = Max(oC[index].y, Float4(0.0f)); oC[index].y = Min(oC[index].y, Float4(1.0f));
+				oC[index].z = Max(oC[index].z, Float4(0.0f)); oC[index].z = Min(oC[index].z, Float4(1.0f));
+				oC[index].w = Max(oC[index].w, Float4(0.0f)); oC[index].w = Min(oC[index].w, Float4(1.0f));
+				break;
+			case FORMAT_R32F:
+			case FORMAT_G32R32F:
+			case FORMAT_X32B32G32R32F:
+			case FORMAT_A32B32G32R32F:
+			case FORMAT_R32I:
+			case FORMAT_G32R32I:
+			case FORMAT_A32B32G32R32I:
+			case FORMAT_R32UI:
+			case FORMAT_G32R32UI:
+			case FORMAT_A32B32G32R32UI:
+			case FORMAT_R16I:
+			case FORMAT_G16R16I:
+			case FORMAT_A16B16G16R16I:
+			case FORMAT_R16UI:
+			case FORMAT_G16R16UI:
+			case FORMAT_A16B16G16R16UI:
+			case FORMAT_R8I:
+			case FORMAT_G8R8I:
+			case FORMAT_A8B8G8R8I:
+			case FORMAT_R8UI:
+			case FORMAT_G8R8UI:
+			case FORMAT_A8B8G8R8UI:
+				break;
+			case FORMAT_X32B32G32R32F_UNSIGNED:
+				oC[index].x = Max(oC[index].x, Float4(0.0f));
+				oC[index].y = Max(oC[index].y, Float4(0.0f));
+				oC[index].z = Max(oC[index].z, Float4(0.0f));
+				oC[index].w = Max(oC[index].w, Float4(0.0f));
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+	}
+
+	Int4 PixelProgram::enableMask(const Shader::Instruction *instruction)
+	{
+		Int4 enable = instruction->analysisBranch ? Int4(enableStack[enableIndex]) : Int4(0xFFFFFFFF);
+
+		if(!whileTest)
+		{
+			if(shader->containsBreakInstruction() && instruction->analysisBreak)
+			{
+				enable &= enableBreak;
+			}
+
+			if(shader->containsContinueInstruction() && instruction->analysisContinue)
+			{
+				enable &= enableContinue;
+			}
+
+			if(shader->containsLeaveInstruction() && instruction->analysisLeave)
+			{
+				enable &= enableLeave;
+			}
+		}
+
+		return enable;
+	}
+
+	Vector4f PixelProgram::fetchRegister(const Src &src, unsigned int offset)
+	{
+		Vector4f reg;
+		unsigned int i = src.index + offset;
+
+		switch(src.type)
+		{
+		case Shader::PARAMETER_TEMP:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg = r[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = r[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = r[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_INPUT:
+			if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+			{
+				reg = v[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = v[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = v[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_CONST:
+			reg = readConstant(src, offset);
+			break;
+		case Shader::PARAMETER_TEXTURE:
+			reg = v[2 + i];
+			break;
+		case Shader::PARAMETER_MISCTYPE:
+			if(src.index == Shader::VPosIndex) reg = vPos;
+			if(src.index == Shader::VFaceIndex) reg = vFace;
+			break;
+		case Shader::PARAMETER_SAMPLER:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg.x = As<Float4>(Int4(i));
+			}
+			else if(src.rel.type == Shader::PARAMETER_TEMP)
+			{
+				reg.x = As<Float4>(Int4(i) + As<Int4>(r[src.rel.index].x));
+			}
+			return reg;
+		case Shader::PARAMETER_PREDICATE:   return reg; // Dummy
+		case Shader::PARAMETER_VOID:        return reg; // Dummy
+		case Shader::PARAMETER_FLOAT4LITERAL:
+			reg.x = Float4(src.value[0]);
+			reg.y = Float4(src.value[1]);
+			reg.z = Float4(src.value[2]);
+			reg.w = Float4(src.value[3]);
+			break;
+		case Shader::PARAMETER_CONSTINT:    return reg; // Dummy
+		case Shader::PARAMETER_CONSTBOOL:   return reg; // Dummy
+		case Shader::PARAMETER_LOOP:        return reg; // Dummy
+		case Shader::PARAMETER_COLOROUT:
+			if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+			{
+				reg = oC[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = oC[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = oC[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_DEPTHOUT:
+			reg.x = oDepth;
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		const Float4 &x = reg[(src.swizzle >> 0) & 0x3];
+		const Float4 &y = reg[(src.swizzle >> 2) & 0x3];
+		const Float4 &z = reg[(src.swizzle >> 4) & 0x3];
+		const Float4 &w = reg[(src.swizzle >> 6) & 0x3];
+
+		Vector4f mod;
+
+		switch(src.modifier)
+		{
+		case Shader::MODIFIER_NONE:
+			mod.x = x;
+			mod.y = y;
+			mod.z = z;
+			mod.w = w;
+			break;
+		case Shader::MODIFIER_NEGATE:
+			mod.x = -x;
+			mod.y = -y;
+			mod.z = -z;
+			mod.w = -w;
+			break;
+		case Shader::MODIFIER_ABS:
+			mod.x = Abs(x);
+			mod.y = Abs(y);
+			mod.z = Abs(z);
+			mod.w = Abs(w);
+			break;
+		case Shader::MODIFIER_ABS_NEGATE:
+			mod.x = -Abs(x);
+			mod.y = -Abs(y);
+			mod.z = -Abs(z);
+			mod.w = -Abs(w);
+			break;
+		case Shader::MODIFIER_NOT:
+			mod.x = As<Float4>(As<Int4>(x) ^ Int4(0xFFFFFFFF));
+			mod.y = As<Float4>(As<Int4>(y) ^ Int4(0xFFFFFFFF));
+			mod.z = As<Float4>(As<Int4>(z) ^ Int4(0xFFFFFFFF));
+			mod.w = As<Float4>(As<Int4>(w) ^ Int4(0xFFFFFFFF));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		return mod;
+	}
+
+	RValue<Pointer<Byte>> PixelProgram::uniformAddress(int bufferIndex, unsigned int index)
+	{
+		if(bufferIndex == -1)
+		{
+			return data + OFFSET(DrawData, ps.c[index]);
+		}
+		else
+		{
+			return *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, ps.u[bufferIndex])) + index;
+		}
+	}
+
+	RValue<Pointer<Byte>> PixelProgram::uniformAddress(int bufferIndex, unsigned int index, Int& offset)
+	{
+		return uniformAddress(bufferIndex, index) + offset * sizeof(float4);
+	}
+
+	Vector4f PixelProgram::readConstant(const Src &src, unsigned int offset)
+	{
+		Vector4f c;
+		unsigned int i = src.index + offset;
+
+		if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+		{
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i));
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+
+			if(shader->containsDefineInstruction())   // Constant may be known at compile time
+			{
+				for(size_t j = 0; j < shader->getLength(); j++)
+				{
+					const Shader::Instruction &instruction = *shader->getInstruction(j);
+
+					if(instruction.opcode == Shader::OPCODE_DEF)
+					{
+						if(instruction.dst.index == i)
+						{
+							c.x = Float4(instruction.src[0].value[0]);
+							c.y = Float4(instruction.src[0].value[1]);
+							c.z = Float4(instruction.src[0].value[2]);
+							c.w = Float4(instruction.src[0].value[3]);
+
+							break;
+						}
+					}
+				}
+			}
+		}
+		else if(!src.rel.dynamic || src.rel.type == Shader::PARAMETER_LOOP)
+		{
+			Int a = relativeAddress(src.rel, src.bufferIndex);
+
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i, a));
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+		}
+		else
+		{
+			int component = src.rel.swizzle & 0x03;
+			Float4 a;
+
+			switch(src.rel.type)
+			{
+			case Shader::PARAMETER_TEMP:     a = r[src.rel.index][component]; break;
+			case Shader::PARAMETER_INPUT:    a = v[src.rel.index][component]; break;
+			case Shader::PARAMETER_OUTPUT:   a = oC[src.rel.index][component]; break;
+			case Shader::PARAMETER_CONST:    a = *Pointer<Float>(uniformAddress(src.bufferIndex, src.rel.index) + component * sizeof(float)); break;
+			case Shader::PARAMETER_MISCTYPE:
+				switch(src.rel.index)
+				{
+				case Shader::VPosIndex:  a = vPos.x;  break;
+				case Shader::VFaceIndex: a = vFace.x; break;
+				default: ASSERT(false);
+				}
+				break;
+			default: ASSERT(false);
+			}
+
+			Int4 index = Int4(i) + As<Int4>(a) * Int4(src.rel.scale);
+
+			index = Min(As<UInt4>(index), UInt4(VERTEX_UNIFORM_VECTORS));   // Clamp to constant register range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0}
+
+			Int index0 = Extract(index, 0);
+			Int index1 = Extract(index, 1);
+			Int index2 = Extract(index, 2);
+			Int index3 = Extract(index, 3);
+
+			c.x = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index0), 16);
+			c.y = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index1), 16);
+			c.z = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index2), 16);
+			c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index3), 16);
+
+			transpose4x4(c.x, c.y, c.z, c.w);
+		}
+
+		return c;
+	}
+
+	Int PixelProgram::relativeAddress(const Shader::Relative &rel, int bufferIndex)
+	{
+		ASSERT(!rel.dynamic);
+
+		if(rel.type == Shader::PARAMETER_TEMP)
+		{
+			return As<Int>(Extract(r[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_INPUT)
+		{
+			return As<Int>(Extract(v[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_OUTPUT)
+		{
+			return As<Int>(Extract(oC[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_CONST)
+		{
+			return *Pointer<Int>(uniformAddress(bufferIndex, rel.index)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_LOOP)
+		{
+			return aL[loopDepth];
+		}
+		else ASSERT(false);
+
+		return 0;
+	}
+
+	Int4 PixelProgram::dynamicAddress(const Shader::Relative &rel)
+	{
+		int component = rel.swizzle & 0x03;
+		Float4 a;
+
+		switch(rel.type)
+		{
+		case Shader::PARAMETER_TEMP:     a = r[rel.index][component]; break;
+		case Shader::PARAMETER_INPUT:    a = v[rel.index][component]; break;
+		case Shader::PARAMETER_OUTPUT:   a = oC[rel.index][component]; break;
+		case Shader::PARAMETER_MISCTYPE:
+			switch(rel.index)
+			{
+			case Shader::VPosIndex:  a = vPos.x;  break;
+			case Shader::VFaceIndex: a = vFace.x; break;
+			default: ASSERT(false);
+			}
+			break;
+		default: ASSERT(false);
+		}
+
+		return As<Int4>(a) * Int4(rel.scale);
+	}
+
+	Float4 PixelProgram::linearToSRGB(const Float4 &x)   // Approximates x^(1.0/2.2)
+	{
+		Float4 sqrtx = Rcp_pp(RcpSqrt_pp(x));
+		Float4 sRGB = sqrtx * Float4(1.14f) - x * Float4(0.14f);
+
+		return Min(Max(sRGB, Float4(0.0f)), Float4(1.0f));
+	}
+
+	void PixelProgram::M3X2(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+	}
+
+	void PixelProgram::M3X3(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+		dst.z = dot3(src0, row2);
+	}
+
+	void PixelProgram::M3X4(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+		Vector4f row3 = fetchRegister(src1, 3);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+		dst.z = dot3(src0, row2);
+		dst.w = dot3(src0, row3);
+	}
+
+	void PixelProgram::M4X3(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+	}
+
+	void PixelProgram::M4X4(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+		Vector4f row3 = fetchRegister(src1, 3);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+		dst.w = dot4(src0, row3);
+	}
+
+	void PixelProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+	{
+		if(project)
+		{
+			Vector4f proj;
+			Float4 rw = reciprocal(src0.w);
+			proj.x = src0.x * rw;
+			proj.y = src0.y * rw;
+			proj.z = src0.z * rw;
+
+			dst = sampleTexture(src1, proj, src0.x, (src0), (src0), (src0), Implicit);
+		}
+		else
+		{
+			dst = sampleTexture(src1, src0, src0.x, (src0), (src0), (src0), bias ? Bias : Implicit);
+		}
+	}
+
+	void PixelProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), offset, {Implicit, Offset});
+	}
+
+	void PixelProgram::TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Lod, Offset});
+	}
+
+	void PixelProgram::TEXBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &bias)
+	{
+		dst = sampleTexture(src1, src0, bias, (src0), (src0), (src0), Bias);
+	}
+
+	void PixelProgram::TEXOFFSETBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &bias)
+	{
+		dst = sampleTexture(src1, src0, bias, (src0), (src0), offset, {Bias, Offset});
+	}
+
+	void PixelProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Fetch);
+	}
+
+	void PixelProgram::TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Fetch, Offset});
+	}
+
+	void PixelProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, (src0), Grad);
+	}
+
+	void PixelProgram::TEXGRADOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy, Vector4f &offset)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, offset, {Grad, Offset});
+	}
+
+	void PixelProgram::TEXLOD(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Lod);
+	}
+
+	void PixelProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
+	{
+		Pointer<Byte> texture = data + OFFSET(DrawData, mipmap) + src1.index * sizeof(Texture);
+		dst = SamplerCore::textureSize(texture, lod);
+	}
+
+	void PixelProgram::TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask)
+	{
+		Int kill = -1;
+
+		if(mask & 0x1) kill &= SignMask(CmpNLT(src.x, Float4(0.0f)));
+		if(mask & 0x2) kill &= SignMask(CmpNLT(src.y, Float4(0.0f)));
+		if(mask & 0x4) kill &= SignMask(CmpNLT(src.z, Float4(0.0f)));
+		if(mask & 0x8) kill &= SignMask(CmpNLT(src.w, Float4(0.0f)));
+
+		// FIXME: Dynamic branching affects TEXKILL?
+		//	if(shader->containsDynamicBranching())
+		//	{
+		//		kill = ~SignMask(enableMask());
+		//	}
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+
+		// FIXME: Branch to end of shader if all killed?
+	}
+
+	void PixelProgram::DISCARD(Int cMask[4], const Shader::Instruction *instruction)
+	{
+		Int kill = 0;
+
+		if(shader->containsDynamicBranching())
+		{
+			kill = ~SignMask(enableMask(instruction));
+		}
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+
+		// FIXME: Branch to end of shader if all killed?
+	}
+
+	void PixelProgram::DFDX(Vector4f &dst, Vector4f &src)
+	{
+		dst.x = src.x.yyww - src.x.xxzz;
+		dst.y = src.y.yyww - src.y.xxzz;
+		dst.z = src.z.yyww - src.z.xxzz;
+		dst.w = src.w.yyww - src.w.xxzz;
+	}
+
+	void PixelProgram::DFDY(Vector4f &dst, Vector4f &src)
+	{
+		dst.x = src.x.zwzw - src.x.xyxy;
+		dst.y = src.y.zwzw - src.y.xyxy;
+		dst.z = src.z.zwzw - src.z.xyxy;
+		dst.w = src.w.zwzw - src.w.xyxy;
+	}
+
+	void PixelProgram::FWIDTH(Vector4f &dst, Vector4f &src)
+	{
+		// abs(dFdx(src)) + abs(dFdy(src));
+		dst.x = Abs(src.x.yyww - src.x.xxzz) + Abs(src.x.zwzw - src.x.xyxy);
+		dst.y = Abs(src.y.yyww - src.y.xxzz) + Abs(src.y.zwzw - src.y.xyxy);
+		dst.z = Abs(src.z.yyww - src.z.xxzz) + Abs(src.z.zwzw - src.z.xyxy);
+		dst.w = Abs(src.w.yyww - src.w.xxzz) + Abs(src.w.zwzw - src.w.xyxy);
+	}
+
+	void PixelProgram::BREAK()
+	{
+		enableBreak = enableBreak & ~enableStack[enableIndex];
+	}
+
+	void PixelProgram::BREAKC(Vector4f &src0, Vector4f &src1, Control control)
+	{
+		Int4 condition;
+
+		switch(control)
+		{
+		case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+		case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);  break;
+		case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+		case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x);  break;
+		case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+		case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);  break;
+		default:
+			ASSERT(false);
+		}
+
+		BREAK(condition);
+	}
+
+	void PixelProgram::BREAKP(const Src &predicateRegister)   // FIXME: Factor out parts common with BREAKC
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		BREAK(condition);
+	}
+
+	void PixelProgram::BREAK(Int4 &condition)
+	{
+		condition &= enableStack[enableIndex];
+
+		enableBreak = enableBreak & ~condition;
+	}
+
+	void PixelProgram::CONTINUE()
+	{
+		enableContinue = enableContinue & ~enableStack[enableIndex];
+	}
+
+	void PixelProgram::TEST()
+	{
+		whileTest = true;
+	}
+
+	void PixelProgram::CALL(int labelIndex, int callSiteIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = enableLeave;
+
+		Nucleus::createBr(labelBlock[labelIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::CALLNZ(int labelIndex, int callSiteIndex, const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			CALLNZb(labelIndex, callSiteIndex, src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			CALLNZp(labelIndex, callSiteIndex, src);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProgram::CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister)
+	{
+		Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0));   // FIXME
+
+		if(boolRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = !condition;
+		}
+
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = enableLeave;
+
+		branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		condition &= enableStack[enableIndex];
+
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		enableIndex++;
+		enableStack[enableIndex] = condition;
+		Int4 restoreLeave = enableLeave;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableIndex--;
+		enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::ELSE()
+	{
+		ifDepth--;
+
+		BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		if(isConditionalIf[ifDepth])
+		{
+			Int4 condition = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
+			Bool notAllFalse = SignMask(condition) != 0;
+
+			branch(notAllFalse, falseBlock, endBlock);
+
+			enableStack[enableIndex] = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
+		}
+		else
+		{
+			Nucleus::createBr(endBlock);
+			Nucleus::setInsertBlock(falseBlock);
+		}
+
+		ifFalseBlock[ifDepth] = endBlock;
+
+		ifDepth++;
+	}
+
+	void PixelProgram::ENDIF()
+	{
+		ifDepth--;
+
+		BasicBlock *endBlock = ifFalseBlock[ifDepth];
+
+		Nucleus::createBr(endBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		if(isConditionalIf[ifDepth])
+		{
+			enableIndex--;
+		}
+	}
+
+	void PixelProgram::ENDLOOP()
+	{
+		loopRepDepth--;
+
+		aL[loopDepth] = aL[loopDepth] + increment[loopDepth];   // FIXME: +=
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		loopDepth--;
+		enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void PixelProgram::ENDREP()
+	{
+		loopRepDepth--;
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		loopDepth--;
+		enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void PixelProgram::ENDWHILE()
+	{
+		loopRepDepth--;
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		enableIndex--;
+		whileTest = false;
+	}
+
+	void PixelProgram::ENDSWITCH()
+	{
+		loopRepDepth--;
+
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(endBlock);
+		Nucleus::setInsertBlock(endBlock);
+	}
+
+	void PixelProgram::IF(const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			IFb(src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			IFp(src);
+		}
+		else
+		{
+			Int4 condition = As<Int4>(fetchRegister(src).x);
+			IF(condition);
+		}
+	}
+
+	void PixelProgram::IFb(const Src &boolRegister)
+	{
+		ASSERT(ifDepth < 24 + 4);
+
+		Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0));   // FIXME
+
+		if(boolRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = !condition;
+		}
+
+		BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		branch(condition, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = false;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+	}
+
+	void PixelProgram::IFp(const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		IF(condition);
+	}
+
+	void PixelProgram::IFC(Vector4f &src0, Vector4f &src1, Control control)
+	{
+		Int4 condition;
+
+		switch(control)
+		{
+		case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+		case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);  break;
+		case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+		case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x);  break;
+		case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+		case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);  break;
+		default:
+			ASSERT(false);
+		}
+
+		IF(condition);
+	}
+
+	void PixelProgram::IF(Int4 &condition)
+	{
+		condition &= enableStack[enableIndex];
+
+		enableIndex++;
+		enableStack[enableIndex] = condition;
+
+		BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		Bool notAllFalse = SignMask(condition) != 0;
+
+		branch(notAllFalse, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = true;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+	}
+
+	void PixelProgram::LABEL(int labelIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		Nucleus::setInsertBlock(labelBlock[labelIndex]);
+		currentLabel = labelIndex;
+	}
+
+	void PixelProgram::LOOP(const Src &integerRegister)
+	{
+		loopDepth++;
+
+		iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+		aL[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][1]));
+		increment[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][2]));
+
+		//	If(increment[loopDepth] == 0)
+		//	{
+		//		increment[loopDepth] = 1;
+		//	}
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(iteration[loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		iteration[loopDepth] = iteration[loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+	}
+
+	void PixelProgram::REP(const Src &integerRegister)
+	{
+		loopDepth++;
+
+		iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+		aL[loopDepth] = aL[loopDepth - 1];
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(iteration[loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		iteration[loopDepth] = iteration[loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+	}
+
+	void PixelProgram::WHILE(const Src &temporaryRegister)
+	{
+		enableIndex++;
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		Int4 restoreBreak = enableBreak;
+		Int4 restoreContinue = enableContinue;
+
+		// TODO: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+		enableContinue = restoreContinue;
+
+		const Vector4f &src = fetchRegister(temporaryRegister);
+		Int4 condition = As<Int4>(src.x);
+		condition &= enableStack[enableIndex - 1];
+		if(shader->containsLeaveInstruction()) condition &= enableLeave;
+		if(shader->containsBreakInstruction()) condition &= enableBreak;
+		enableStack[enableIndex] = condition;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, loopBlock, endBlock);
+
+		Nucleus::setInsertBlock(endBlock);
+		enableBreak = restoreBreak;
+
+		Nucleus::setInsertBlock(loopBlock);
+
+		loopRepDepth++;
+	}
+
+	void PixelProgram::SWITCH()
+	{
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = nullptr;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		Int4 restoreBreak = enableBreak;
+
+		BasicBlock *currentBlock = Nucleus::getInsertBlock();
+
+		Nucleus::setInsertBlock(endBlock);
+		enableBreak = restoreBreak;
+
+		Nucleus::setInsertBlock(currentBlock);
+
+		loopRepDepth++;
+	}
+
+	void PixelProgram::RET()
+	{
+		if(currentLabel == -1)
+		{
+			returnBlock = Nucleus::createBasicBlock();
+			Nucleus::createBr(returnBlock);
+		}
+		else
+		{
+			BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+
+			if(callRetBlock[currentLabel].size() > 1)   // Pop the return destination from the call stack
+			{
+				// FIXME: Encapsulate
+				UInt index = callStack[--stackIndex];
+
+				Value *value = index.loadValue();
+				SwitchCases *switchCases = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
+
+				for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
+				{
+					Nucleus::addSwitchCase(switchCases, i, callRetBlock[currentLabel][i]);
+				}
+			}
+			else if(callRetBlock[currentLabel].size() == 1)   // Jump directly to the unique return destination
+			{
+				Nucleus::createBr(callRetBlock[currentLabel][0]);
+			}
+			else   // Function isn't called
+			{
+				Nucleus::createBr(unreachableBlock);
+			}
+
+			Nucleus::setInsertBlock(unreachableBlock);
+			Nucleus::createUnreachable();
+		}
+	}
+
+	void PixelProgram::LEAVE()
+	{
+		enableLeave = enableLeave & ~enableStack[enableIndex];
+
+		// FIXME: Return from function if all instances left
+		// FIXME: Use enableLeave in other control-flow constructs
+	}
+}
diff --git a/src/Pipeline/PixelProgram.hpp b/src/Pipeline/PixelProgram.hpp
new file mode 100644
index 0000000..240938d
--- /dev/null
+++ b/src/Pipeline/PixelProgram.hpp
@@ -0,0 +1,170 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_PixelProgram_hpp
+#define sw_PixelProgram_hpp
+
+#include "PixelRoutine.hpp"
+#include "SamplerCore.hpp"
+
+namespace sw
+{
+	class PixelProgram : public PixelRoutine
+	{
+	public:
+		PixelProgram(const PixelProcessor::State &state, const PixelShader *shader) :
+			PixelRoutine(state, shader), r(shader->indirectAddressableTemporaries),
+			loopDepth(-1), ifDepth(0), loopRepDepth(0), currentLabel(-1), whileTest(false)
+		{
+			for(int i = 0; i < 2048; ++i)
+			{
+				labelBlock[i] = 0;
+			}
+
+			enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+
+			if(shader->containsBreakInstruction())
+			{
+				enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+			}
+
+			if(shader->containsContinueInstruction())
+			{
+				enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+			}
+		}
+
+		virtual ~PixelProgram() {}
+
+	protected:
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(Int cMask[4]);
+		virtual Bool alphaTest(Int cMask[4]);
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+
+	private:
+		// Temporary registers
+		RegisterArray<NUM_TEMPORARY_REGISTERS> r;
+
+		// Color outputs
+		Vector4f c[RENDERTARGETS];
+		RegisterArray<RENDERTARGETS, true> oC;
+
+		// Shader variables
+		Vector4f vPos;
+		Vector4f vFace;
+
+		// DX9 specific variables
+		Vector4f p0;
+		Array<Int, 4> aL;
+		Array<Int, 4> increment;
+		Array<Int, 4> iteration;
+
+		Int loopDepth;    // FIXME: Add support for switch
+		Int stackIndex;   // FIXME: Inc/decrement callStack
+		Array<UInt, 16> callStack;
+
+		// Per pixel based on conditions reached
+		Int enableIndex;
+		Array<Int4, 1 + 24> enableStack;
+		Int4 enableBreak;
+		Int4 enableContinue;
+		Int4 enableLeave;
+
+		Vector4f sampleTexture(const Src &sampler, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+		Vector4f sampleTexture(int samplerIndex, Vector4f &uvwq, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+
+		// Raster operations
+		void clampColor(Vector4f oC[RENDERTARGETS]);
+
+		Int4 enableMask(const Shader::Instruction *instruction);
+
+		Vector4f fetchRegister(const Src &src, unsigned int offset = 0);
+		Vector4f readConstant(const Src &src, unsigned int offset = 0);
+		RValue<Pointer<Byte>> uniformAddress(int bufferIndex, unsigned int index);
+		RValue<Pointer<Byte>> uniformAddress(int bufferIndex, unsigned int index, Int& offset);
+		Int relativeAddress(const Shader::Relative &rel, int bufferIndex = -1);
+		Int4 dynamicAddress(const Shader::Relative &rel);
+
+		Float4 linearToSRGB(const Float4 &x);
+
+		// Instructions
+		typedef Shader::Control Control;
+
+		void M3X2(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X3(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X4(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X3(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X4(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void TEX(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+		void TEXLOD(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &lod);
+		void TEXBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Float4 &bias);
+		void TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1);
+		void TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask);
+		void TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset);
+		void TEXOFFSETBIAS(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &bias);
+		void TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &offset, Float4 &lod);
+		void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src &, Float4 &lod);
+		void TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src, const Src &, Vector4f &offset, Float4 &lod);
+		void TEXGRAD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &dsx, Vector4f &dsy);
+		void TEXGRADOFFSET(Vector4f &dst, Vector4f &src, const Src &, Vector4f &dsx, Vector4f &dsy, Vector4f &offset);
+		void DISCARD(Int cMask[4], const Shader::Instruction *instruction);
+		void DFDX(Vector4f &dst, Vector4f &src);
+		void DFDY(Vector4f &dst, Vector4f &src);
+		void FWIDTH(Vector4f &dst, Vector4f &src);
+		void BREAK();
+		void BREAKC(Vector4f &src0, Vector4f &src1, Control);
+		void BREAKP(const Src &predicateRegister);
+		void BREAK(Int4 &condition);
+		void CONTINUE();
+		void TEST();
+		void CALL(int labelIndex, int callSiteIndex);
+		void CALLNZ(int labelIndex, int callSiteIndex, const Src &src);
+		void CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister);
+		void CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister);
+		void ELSE();
+		void ENDIF();
+		void ENDLOOP();
+		void ENDREP();
+		void ENDWHILE();
+		void ENDSWITCH();
+		void IF(const Src &src);
+		void IFb(const Src &boolRegister);
+		void IFp(const Src &predicateRegister);
+		void IFC(Vector4f &src0, Vector4f &src1, Control);
+		void IF(Int4 &condition);
+		void LABEL(int labelIndex);
+		void LOOP(const Src &integerRegister);
+		void REP(const Src &integerRegister);
+		void WHILE(const Src &temporaryRegister);
+		void SWITCH();
+		void RET();
+		void LEAVE();
+
+		int ifDepth;
+		int loopRepDepth;
+		int currentLabel;
+		bool whileTest;
+
+		BasicBlock *ifFalseBlock[24 + 24];
+		BasicBlock *loopRepTestBlock[4];
+		BasicBlock *loopRepEndBlock[4];
+		BasicBlock *labelBlock[2048];
+		std::vector<BasicBlock*> callRetBlock[2048];
+		BasicBlock *returnBlock;
+		bool isConditionalIf[24 + 24];
+	};
+}
+
+#endif
diff --git a/src/Pipeline/PixelRoutine.cpp b/src/Pipeline/PixelRoutine.cpp
new file mode 100644
index 0000000..146e42d
--- /dev/null
+++ b/src/Pipeline/PixelRoutine.cpp
@@ -0,0 +1,2724 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelRoutine.hpp"
+
+#include "SamplerCore.hpp"
+#include "Constants.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Renderer/QuadRasterizer.hpp"
+#include "Renderer/Surface.hpp"
+#include "Renderer/Primitive.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool complementaryDepthBuffer;
+	extern bool postBlendSRGB;
+	extern bool exactColorRounding;
+	extern bool forceClearRegisters;
+
+	PixelRoutine::PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader)
+		: QuadRasterizer(state, shader), v(shader && shader->indirectAddressableInput)
+	{
+		if(!shader || shader->getShaderModel() < 0x0200 || forceClearRegisters)
+		{
+			for(int i = 0; i < MAX_FRAGMENT_INPUTS; i++)
+			{
+				v[i].x = Float4(0.0f);
+				v[i].y = Float4(0.0f);
+				v[i].z = Float4(0.0f);
+				v[i].w = Float4(0.0f);
+			}
+		}
+	}
+
+	PixelRoutine::~PixelRoutine()
+	{
+	}
+
+	void PixelRoutine::quad(Pointer<Byte> cBuffer[RENDERTARGETS], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
+	{
+		#if PERF_PROFILE
+			Long pipeTime = Ticks();
+		#endif
+
+		const bool earlyDepthTest = !state.depthOverride && !state.alphaTestActive();
+
+		Int zMask[4];   // Depth mask
+		Int sMask[4];   // Stencil mask
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			zMask[q] = cMask[q];
+			sMask[q] = cMask[q];
+		}
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			stencilTest(sBuffer, q, x, sMask[q], cMask[q]);
+		}
+
+		Float4 f;
+		Float4 rhwCentroid;
+
+		Float4 xxxx = Float4(Float(x)) + *Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16);
+
+		if(interpolateZ())
+		{
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				Float4 x = xxxx;
+
+				if(state.multiSample > 1)
+				{
+					x -= *Pointer<Float4>(constants + OFFSET(Constants,X) + q * sizeof(float4));
+				}
+
+				z[q] = interpolate(x, Dz[q], z[q], primitive + OFFSET(Primitive,z), false, false, state.depthClamp);
+			}
+		}
+
+		Bool depthPass = false;
+
+		if(earlyDepthTest)
+		{
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				depthPass = depthPass || depthTest(zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
+			}
+		}
+
+		If(depthPass || Bool(!earlyDepthTest))
+		{
+			#if PERF_PROFILE
+				Long interpTime = Ticks();
+			#endif
+
+			Float4 yyyy = Float4(Float(y)) + *Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16);
+
+			// Centroid locations
+			Float4 XXXX = Float4(0.0f);
+			Float4 YYYY = Float4(0.0f);
+
+			if(state.centroid)
+			{
+				Float4 WWWW(1.0e-9f);
+
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					XXXX += *Pointer<Float4>(constants + OFFSET(Constants,sampleX[q]) + 16 * cMask[q]);
+					YYYY += *Pointer<Float4>(constants + OFFSET(Constants,sampleY[q]) + 16 * cMask[q]);
+					WWWW += *Pointer<Float4>(constants + OFFSET(Constants,weight) + 16 * cMask[q]);
+				}
+
+				WWWW = Rcp_pp(WWWW);
+				XXXX *= WWWW;
+				YYYY *= WWWW;
+
+				XXXX += xxxx;
+				YYYY += yyyy;
+			}
+
+			if(interpolateW())
+			{
+				w = interpolate(xxxx, Dw, rhw, primitive + OFFSET(Primitive,w), false, false, false);
+				rhw = reciprocal(w, false, false, true);
+
+				if(state.centroid)
+				{
+					rhwCentroid = reciprocal(interpolateCentroid(XXXX, YYYY, rhwCentroid, primitive + OFFSET(Primitive,w), false, false));
+				}
+			}
+
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(state.interpolant[interpolant].component & (1 << component))
+					{
+						if(!state.interpolant[interpolant].centroid)
+						{
+							v[interpolant][component] = interpolate(xxxx, Dv[interpolant][component], rhw, primitive + OFFSET(Primitive, V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective, false);
+						}
+						else
+						{
+							v[interpolant][component] = interpolateCentroid(XXXX, YYYY, rhwCentroid, primitive + OFFSET(Primitive, V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
+						}
+					}
+				}
+
+				Float4 rcp;
+
+				switch(state.interpolant[interpolant].project)
+				{
+				case 0:
+					break;
+				case 1:
+					rcp = reciprocal(v[interpolant].y);
+					v[interpolant].x = v[interpolant].x * rcp;
+					break;
+				case 2:
+					rcp = reciprocal(v[interpolant].z);
+					v[interpolant].x = v[interpolant].x * rcp;
+					v[interpolant].y = v[interpolant].y * rcp;
+					break;
+				case 3:
+					rcp = reciprocal(v[interpolant].w);
+					v[interpolant].x = v[interpolant].x * rcp;
+					v[interpolant].y = v[interpolant].y * rcp;
+					v[interpolant].z = v[interpolant].z * rcp;
+					break;
+				}
+			}
+
+			if(state.fog.component)
+			{
+				f = interpolate(xxxx, Df, rhw, primitive + OFFSET(Primitive,f), state.fog.flat & 0x01, state.perspective, false);
+			}
+
+			setBuiltins(x, y, z, w);
+
+			#if PERF_PROFILE
+				cycles[PERF_INTERP] += Ticks() - interpTime;
+			#endif
+
+			Bool alphaPass = true;
+
+			if(colorUsed())
+			{
+				#if PERF_PROFILE
+					Long shaderTime = Ticks();
+				#endif
+
+				applyShader(cMask);
+
+				#if PERF_PROFILE
+					cycles[PERF_SHADER] += Ticks() - shaderTime;
+				#endif
+
+				alphaPass = alphaTest(cMask);
+
+				if((shader && shader->containsKill()) || state.alphaTestActive())
+				{
+					for(unsigned int q = 0; q < state.multiSample; q++)
+					{
+						zMask[q] &= cMask[q];
+						sMask[q] &= cMask[q];
+					}
+				}
+			}
+
+			If(alphaPass)
+			{
+				if(!earlyDepthTest)
+				{
+					for(unsigned int q = 0; q < state.multiSample; q++)
+					{
+						depthPass = depthPass || depthTest(zBuffer, q, x, z[q], sMask[q], zMask[q], cMask[q]);
+					}
+				}
+
+				#if PERF_PROFILE
+					Long ropTime = Ticks();
+				#endif
+
+				If(depthPass || Bool(earlyDepthTest))
+				{
+					for(unsigned int q = 0; q < state.multiSample; q++)
+					{
+						if(state.multiSampleMask & (1 << q))
+						{
+							writeDepth(zBuffer, q, x, z[q], zMask[q]);
+
+							if(state.occlusionEnabled)
+							{
+								occlusion += *Pointer<UInt>(constants + OFFSET(Constants,occlusionCount) + 4 * (zMask[q] & sMask[q]));
+							}
+						}
+					}
+
+					if(colorUsed())
+					{
+						#if PERF_PROFILE
+							AddAtomic(Pointer<Long>(&profiler.ropOperations), 4);
+						#endif
+
+						rasterOperation(f, cBuffer, x, sMask, zMask, cMask);
+					}
+				}
+
+				#if PERF_PROFILE
+					cycles[PERF_ROP] += Ticks() - ropTime;
+				#endif
+			}
+		}
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			if(state.multiSampleMask & (1 << q))
+			{
+				writeStencil(sBuffer, q, x, sMask[q], zMask[q], cMask[q]);
+			}
+		}
+
+		#if PERF_PROFILE
+			cycles[PERF_PIPE] += Ticks() - pipeTime;
+		#endif
+	}
+
+	Float4 PixelRoutine::interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
+	{
+		Float4 interpolant = *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,C), 16);
+
+		if(!flat)
+		{
+			interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16) +
+			               y * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,B), 16);
+
+			if(perspective)
+			{
+				interpolant *= rhw;
+			}
+		}
+
+		return interpolant;
+	}
+
+	void PixelRoutine::stencilTest(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask)
+	{
+		if(!state.stencilActive)
+		{
+			return;
+		}
+
+		// (StencilRef & StencilMask) CompFunc (StencilBufferValue & StencilMask)
+
+		Pointer<Byte> buffer = sBuffer + 2 * x;
+
+		if(q > 0)
+		{
+			buffer += q * *Pointer<Int>(data + OFFSET(DrawData,stencilSliceB));
+		}
+
+		Byte8 value = *Pointer<Byte8>(buffer);
+		Byte8 valueCCW = value;
+
+		if(!state.noStencilMask)
+		{
+			value &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[0].testMaskQ));
+		}
+
+		stencilTest(value, state.stencilCompareMode, false);
+
+		if(state.twoSidedStencil)
+		{
+			if(!state.noStencilMaskCCW)
+			{
+				valueCCW &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[1].testMaskQ));
+			}
+
+			stencilTest(valueCCW, state.stencilCompareModeCCW, true);
+
+			value &= *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask));
+			valueCCW &= *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask));
+			value |= valueCCW;
+		}
+
+		sMask = SignMask(value) & cMask;
+	}
+
+	void PixelRoutine::stencilTest(Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW)
+	{
+		Byte8 equal;
+
+		switch(stencilCompareMode)
+		{
+		case STENCIL_ALWAYS:
+			value = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+		case STENCIL_NEVER:
+			value = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+			break;
+		case STENCIL_LESS:			// a < b ~ b > a
+			value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+			value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+			break;
+		case STENCIL_EQUAL:
+			value = CmpEQ(value, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+			break;
+		case STENCIL_NOTEQUAL:		// a != b ~ !(a == b)
+			value = CmpEQ(value, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+			value ^= Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+		case STENCIL_LESSEQUAL:	// a <= b ~ (b > a) || (a == b)
+			equal = value;
+			equal = CmpEQ(equal, *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedQ)));
+			value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+			value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+			value |= equal;
+			break;
+		case STENCIL_GREATER:		// a > b
+			equal = *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ));
+			value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+			equal = CmpGT(As<SByte8>(equal), As<SByte8>(value));
+			value = equal;
+			break;
+		case STENCIL_GREATEREQUAL:	// a >= b ~ !(a < b) ~ !(b > a)
+			value += Byte8(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80);
+			value = CmpGT(As<SByte8>(value), *Pointer<SByte8>(data + OFFSET(DrawData,stencil[CCW].referenceMaskedSignedQ)));
+			value ^= Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	Bool PixelRoutine::depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask)
+	{
+		if(!state.depthTestActive)
+		{
+			return true;
+		}
+
+		Float4 Z = z;
+
+		if(shader && shader->depthOverride())
+		{
+			if(complementaryDepthBuffer)
+			{
+				Z = Float4(1.0f) - oDepth;
+			}
+			else
+			{
+				Z = oDepth;
+			}
+		}
+
+		Pointer<Byte> buffer;
+		Int pitch;
+
+		if(!state.quadLayoutDepthBuffer)
+		{
+			buffer = zBuffer + 4 * x;
+			pitch = *Pointer<Int>(data + OFFSET(DrawData,depthPitchB));
+		}
+		else
+		{
+			buffer = zBuffer + 8 * x;
+		}
+
+		if(q > 0)
+		{
+			buffer += q * *Pointer<Int>(data + OFFSET(DrawData,depthSliceB));
+		}
+
+		Float4 zValue;
+
+		if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
+		{
+			if(!state.quadLayoutDepthBuffer)
+			{
+				// FIXME: Properly optimizes?
+				zValue.xy = *Pointer<Float4>(buffer);
+				zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
+			}
+			else
+			{
+				zValue = *Pointer<Float4>(buffer, 16);
+			}
+		}
+
+		Int4 zTest;
+
+		switch(state.depthCompareMode)
+		{
+		case DEPTH_ALWAYS:
+			// Optimized
+			break;
+		case DEPTH_NEVER:
+			// Optimized
+			break;
+		case DEPTH_EQUAL:
+			zTest = CmpEQ(zValue, Z);
+			break;
+		case DEPTH_NOTEQUAL:
+			zTest = CmpNEQ(zValue, Z);
+			break;
+		case DEPTH_LESS:
+			if(complementaryDepthBuffer)
+			{
+				zTest = CmpLT(zValue, Z);
+			}
+			else
+			{
+				zTest = CmpNLE(zValue, Z);
+			}
+			break;
+		case DEPTH_GREATEREQUAL:
+			if(complementaryDepthBuffer)
+			{
+				zTest = CmpNLT(zValue, Z);
+			}
+			else
+			{
+				zTest = CmpLE(zValue, Z);
+			}
+			break;
+		case DEPTH_LESSEQUAL:
+			if(complementaryDepthBuffer)
+			{
+				zTest = CmpLE(zValue, Z);
+			}
+			else
+			{
+				zTest = CmpNLT(zValue, Z);
+			}
+			break;
+		case DEPTH_GREATER:
+			if(complementaryDepthBuffer)
+			{
+				zTest = CmpNLE(zValue, Z);
+			}
+			else
+			{
+				zTest = CmpLT(zValue, Z);
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		switch(state.depthCompareMode)
+		{
+		case DEPTH_ALWAYS:
+			zMask = cMask;
+			break;
+		case DEPTH_NEVER:
+			zMask = 0x0;
+			break;
+		default:
+			zMask = SignMask(zTest) & cMask;
+			break;
+		}
+
+		if(state.stencilActive)
+		{
+			zMask &= sMask;
+		}
+
+		return zMask != 0;
+	}
+
+	void PixelRoutine::alphaTest(Int &aMask, Short4 &alpha)
+	{
+		Short4 cmp;
+		Short4 equal;
+
+		switch(state.alphaCompareMode)
+		{
+		case ALPHA_ALWAYS:
+			aMask = 0xF;
+			break;
+		case ALPHA_NEVER:
+			aMask = 0x0;
+			break;
+		case ALPHA_EQUAL:
+			cmp = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		case ALPHA_NOTEQUAL:       // a != b ~ !(a == b)
+			cmp = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4(0xFFFFu);   // FIXME
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		case ALPHA_LESS:           // a < b ~ b > a
+			cmp = CmpGT(*Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)), alpha);
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		case ALPHA_GREATEREQUAL:   // a >= b ~ (a > b) || (a == b) ~ !(b > a)   // TODO: Approximate
+			equal = CmpEQ(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
+			cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
+			cmp |= equal;
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		case ALPHA_LESSEQUAL:      // a <= b ~ !(a > b)
+			cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4))) ^ Short4(0xFFFFu);   // FIXME
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		case ALPHA_GREATER:        // a > b
+			cmp = CmpGT(alpha, *Pointer<Short4>(data + OFFSET(DrawData,factor.alphaReference4)));
+			aMask = SignMask(PackSigned(cmp, Short4(0x0000)));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::alphaToCoverage(Int cMask[4], Float4 &alpha)
+	{
+		Int4 coverage0 = CmpNLT(alpha, *Pointer<Float4>(data + OFFSET(DrawData,a2c0)));
+		Int4 coverage1 = CmpNLT(alpha, *Pointer<Float4>(data + OFFSET(DrawData,a2c1)));
+		Int4 coverage2 = CmpNLT(alpha, *Pointer<Float4>(data + OFFSET(DrawData,a2c2)));
+		Int4 coverage3 = CmpNLT(alpha, *Pointer<Float4>(data + OFFSET(DrawData,a2c3)));
+
+		Int aMask0 = SignMask(coverage0);
+		Int aMask1 = SignMask(coverage1);
+		Int aMask2 = SignMask(coverage2);
+		Int aMask3 = SignMask(coverage3);
+
+		cMask[0] &= aMask0;
+		cMask[1] &= aMask1;
+		cMask[2] &= aMask2;
+		cMask[3] &= aMask3;
+	}
+
+	void PixelRoutine::fogBlend(Vector4f &c0, Float4 &fog)
+	{
+		if(!state.fogActive)
+		{
+			return;
+		}
+
+		if(state.pixelFogMode != FOG_NONE)
+		{
+			pixelFog(fog);
+
+			fog = Min(fog, Float4(1.0f));
+			fog = Max(fog, Float4(0.0f));
+		}
+
+		c0.x -= *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[0]));
+		c0.y -= *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[1]));
+		c0.z -= *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[2]));
+
+		c0.x *= fog;
+		c0.y *= fog;
+		c0.z *= fog;
+
+		c0.x += *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[0]));
+		c0.y += *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[1]));
+		c0.z += *Pointer<Float4>(data + OFFSET(DrawData,fog.colorF[2]));
+	}
+
+	void PixelRoutine::pixelFog(Float4 &visibility)
+	{
+		Float4 &zw = visibility;
+
+		if(state.pixelFogMode != FOG_NONE)
+		{
+			if(state.wBasedFog)
+			{
+				zw = rhw;
+			}
+			else
+			{
+				if(complementaryDepthBuffer)
+				{
+					zw = Float4(1.0f) - z[0];
+				}
+				else
+				{
+					zw = z[0];
+				}
+			}
+		}
+
+		switch(state.pixelFogMode)
+		{
+		case FOG_NONE:
+			break;
+		case FOG_LINEAR:
+			zw *= *Pointer<Float4>(data + OFFSET(DrawData,fog.scale));
+			zw += *Pointer<Float4>(data + OFFSET(DrawData,fog.offset));
+			break;
+		case FOG_EXP:
+			zw *= *Pointer<Float4>(data + OFFSET(DrawData,fog.densityE));
+			zw = exponential2(zw, true);
+			break;
+		case FOG_EXP2:
+			zw *= zw;
+			zw *= *Pointer<Float4>(data + OFFSET(DrawData,fog.density2E));
+			zw = exponential2(zw, true);
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask)
+	{
+		if(!state.depthWriteEnable)
+		{
+			return;
+		}
+
+		Float4 Z = z;
+
+		if(shader && shader->depthOverride())
+		{
+			if(complementaryDepthBuffer)
+			{
+				Z = Float4(1.0f) - oDepth;
+			}
+			else
+			{
+				Z = oDepth;
+			}
+		}
+
+		Pointer<Byte> buffer;
+		Int pitch;
+
+		if(!state.quadLayoutDepthBuffer)
+		{
+			buffer = zBuffer + 4 * x;
+			pitch = *Pointer<Int>(data + OFFSET(DrawData,depthPitchB));
+		}
+		else
+		{
+			buffer = zBuffer + 8 * x;
+		}
+
+		if(q > 0)
+		{
+			buffer += q * *Pointer<Int>(data + OFFSET(DrawData,depthSliceB));
+		}
+
+		Float4 zValue;
+
+		if(state.depthCompareMode != DEPTH_NEVER || (state.depthCompareMode != DEPTH_ALWAYS && !state.depthWriteEnable))
+		{
+			if(!state.quadLayoutDepthBuffer)
+			{
+				// FIXME: Properly optimizes?
+				zValue.xy = *Pointer<Float4>(buffer);
+				zValue.zw = *Pointer<Float4>(buffer + pitch - 8);
+			}
+			else
+			{
+				zValue = *Pointer<Float4>(buffer, 16);
+			}
+		}
+
+		Z = As<Float4>(As<Int4>(Z) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X) + zMask * 16, 16));
+		zValue = As<Float4>(As<Int4>(zValue) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X) + zMask * 16, 16));
+		Z = As<Float4>(As<Int4>(Z) | As<Int4>(zValue));
+
+		if(!state.quadLayoutDepthBuffer)
+		{
+			// FIXME: Properly optimizes?
+			*Pointer<Float2>(buffer) = Float2(Z.xy);
+			*Pointer<Float2>(buffer + pitch) = Float2(Z.zw);
+		}
+		else
+		{
+			*Pointer<Float4>(buffer, 16) = Z;
+		}
+	}
+
+	void PixelRoutine::writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask)
+	{
+		if(!state.stencilActive)
+		{
+			return;
+		}
+
+		if(state.stencilPassOperation == OPERATION_KEEP && state.stencilZFailOperation == OPERATION_KEEP && state.stencilFailOperation == OPERATION_KEEP)
+		{
+			if(!state.twoSidedStencil || (state.stencilPassOperationCCW == OPERATION_KEEP && state.stencilZFailOperationCCW == OPERATION_KEEP && state.stencilFailOperationCCW == OPERATION_KEEP))
+			{
+				return;
+			}
+		}
+
+		if(state.stencilWriteMasked && (!state.twoSidedStencil || state.stencilWriteMaskedCCW))
+		{
+			return;
+		}
+
+		Pointer<Byte> buffer = sBuffer + 2 * x;
+
+		if(q > 0)
+		{
+			buffer += q * *Pointer<Int>(data + OFFSET(DrawData,stencilSliceB));
+		}
+
+		Byte8 bufferValue = *Pointer<Byte8>(buffer);
+
+		Byte8 newValue;
+		stencilOperation(newValue, bufferValue, state.stencilPassOperation, state.stencilZFailOperation, state.stencilFailOperation, false, zMask, sMask);
+
+		if(!state.noStencilWriteMask)
+		{
+			Byte8 maskedValue = bufferValue;
+			newValue &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[0].writeMaskQ));
+			maskedValue &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[0].invWriteMaskQ));
+			newValue |= maskedValue;
+		}
+
+		if(state.twoSidedStencil)
+		{
+			Byte8 newValueCCW;
+
+			stencilOperation(newValueCCW, bufferValue, state.stencilPassOperationCCW, state.stencilZFailOperationCCW, state.stencilFailOperationCCW, true, zMask, sMask);
+
+			if(!state.noStencilWriteMaskCCW)
+			{
+				Byte8 maskedValue = bufferValue;
+				newValueCCW &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[1].writeMaskQ));
+				maskedValue &= *Pointer<Byte8>(data + OFFSET(DrawData,stencil[1].invWriteMaskQ));
+				newValueCCW |= maskedValue;
+			}
+
+			newValue &= *Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask));
+			newValueCCW &= *Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask));
+			newValue |= newValueCCW;
+		}
+
+		newValue &= *Pointer<Byte8>(constants + OFFSET(Constants,maskB4Q) + 8 * cMask);
+		bufferValue &= *Pointer<Byte8>(constants + OFFSET(Constants,invMaskB4Q) + 8 * cMask);
+		newValue |= bufferValue;
+
+		*Pointer<Byte4>(buffer) = Byte4(newValue);
+	}
+
+	void PixelRoutine::stencilOperation(Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask)
+	{
+		Byte8 &pass = newValue;
+		Byte8 fail;
+		Byte8 zFail;
+
+		stencilOperation(pass, bufferValue, stencilPassOperation, CCW);
+
+		if(stencilZFailOperation != stencilPassOperation)
+		{
+			stencilOperation(zFail, bufferValue, stencilZFailOperation, CCW);
+		}
+
+		if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
+		{
+			stencilOperation(fail, bufferValue, stencilFailOperation, CCW);
+		}
+
+		if(stencilFailOperation != stencilPassOperation || stencilFailOperation != stencilZFailOperation)
+		{
+			if(state.depthTestActive && stencilZFailOperation != stencilPassOperation)   // zMask valid and values not the same
+			{
+				pass &= *Pointer<Byte8>(constants + OFFSET(Constants,maskB4Q) + 8 * zMask);
+				zFail &= *Pointer<Byte8>(constants + OFFSET(Constants,invMaskB4Q) + 8 * zMask);
+				pass |= zFail;
+			}
+
+			pass &= *Pointer<Byte8>(constants + OFFSET(Constants,maskB4Q) + 8 * sMask);
+			fail &= *Pointer<Byte8>(constants + OFFSET(Constants,invMaskB4Q) + 8 * sMask);
+			pass |= fail;
+		}
+	}
+
+	void PixelRoutine::stencilOperation(Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW)
+	{
+		switch(operation)
+		{
+		case OPERATION_KEEP:
+			output = bufferValue;
+			break;
+		case OPERATION_ZERO:
+			output = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+			break;
+		case OPERATION_REPLACE:
+			output = *Pointer<Byte8>(data + OFFSET(DrawData,stencil[CCW].referenceQ));
+			break;
+		case OPERATION_INCRSAT:
+			output = AddSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
+			break;
+		case OPERATION_DECRSAT:
+			output = SubSat(bufferValue, Byte8(1, 1, 1, 1, 1, 1, 1, 1));
+			break;
+		case OPERATION_INVERT:
+			output = bufferValue ^ Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+			break;
+		case OPERATION_INCR:
+			output = bufferValue + Byte8(1, 1, 1, 1, 1, 1, 1, 1);
+			break;
+		case OPERATION_DECR:
+			output = bufferValue - Byte8(1, 1, 1, 1, 1, 1, 1, 1);
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
+	{
+		switch(blendFactorActive)
+		{
+		case BLEND_ZERO:
+			// Optimized
+			break;
+		case BLEND_ONE:
+			// Optimized
+			break;
+		case BLEND_SOURCE:
+			blendFactor.x = current.x;
+			blendFactor.y = current.y;
+			blendFactor.z = current.z;
+			break;
+		case BLEND_INVSOURCE:
+			blendFactor.x = Short4(0xFFFFu) - current.x;
+			blendFactor.y = Short4(0xFFFFu) - current.y;
+			blendFactor.z = Short4(0xFFFFu) - current.z;
+			break;
+		case BLEND_DEST:
+			blendFactor.x = pixel.x;
+			blendFactor.y = pixel.y;
+			blendFactor.z = pixel.z;
+			break;
+		case BLEND_INVDEST:
+			blendFactor.x = Short4(0xFFFFu) - pixel.x;
+			blendFactor.y = Short4(0xFFFFu) - pixel.y;
+			blendFactor.z = Short4(0xFFFFu) - pixel.z;
+			break;
+		case BLEND_SOURCEALPHA:
+			blendFactor.x = current.w;
+			blendFactor.y = current.w;
+			blendFactor.z = current.w;
+			break;
+		case BLEND_INVSOURCEALPHA:
+			blendFactor.x = Short4(0xFFFFu) - current.w;
+			blendFactor.y = Short4(0xFFFFu) - current.w;
+			blendFactor.z = Short4(0xFFFFu) - current.w;
+			break;
+		case BLEND_DESTALPHA:
+			blendFactor.x = pixel.w;
+			blendFactor.y = pixel.w;
+			blendFactor.z = pixel.w;
+			break;
+		case BLEND_INVDESTALPHA:
+			blendFactor.x = Short4(0xFFFFu) - pixel.w;
+			blendFactor.y = Short4(0xFFFFu) - pixel.w;
+			blendFactor.z = Short4(0xFFFFu) - pixel.w;
+			break;
+		case BLEND_SRCALPHASAT:
+			blendFactor.x = Short4(0xFFFFu) - pixel.w;
+			blendFactor.x = Min(As<UShort4>(blendFactor.x), As<UShort4>(current.w));
+			blendFactor.y = blendFactor.x;
+			blendFactor.z = blendFactor.x;
+			break;
+		case BLEND_CONSTANT:
+			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[0]));
+			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[1]));
+			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[2]));
+			break;
+		case BLEND_INVCONSTANT:
+			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[0]));
+			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[1]));
+			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[2]));
+			break;
+		case BLEND_CONSTANTALPHA:
+			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
+			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
+			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
+			break;
+		case BLEND_INVCONSTANTALPHA:
+			blendFactor.x = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+			blendFactor.y = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+			blendFactor.z = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive)
+	{
+		switch(blendFactorAlphaActive)
+		{
+		case BLEND_ZERO:
+			// Optimized
+			break;
+		case BLEND_ONE:
+			// Optimized
+			break;
+		case BLEND_SOURCE:
+			blendFactor.w = current.w;
+			break;
+		case BLEND_INVSOURCE:
+			blendFactor.w = Short4(0xFFFFu) - current.w;
+			break;
+		case BLEND_DEST:
+			blendFactor.w = pixel.w;
+			break;
+		case BLEND_INVDEST:
+			blendFactor.w = Short4(0xFFFFu) - pixel.w;
+			break;
+		case BLEND_SOURCEALPHA:
+			blendFactor.w = current.w;
+			break;
+		case BLEND_INVSOURCEALPHA:
+			blendFactor.w = Short4(0xFFFFu) - current.w;
+			break;
+		case BLEND_DESTALPHA:
+			blendFactor.w = pixel.w;
+			break;
+		case BLEND_INVDESTALPHA:
+			blendFactor.w = Short4(0xFFFFu) - pixel.w;
+			break;
+		case BLEND_SRCALPHASAT:
+			blendFactor.w = Short4(0xFFFFu);
+			break;
+		case BLEND_CONSTANT:
+		case BLEND_CONSTANTALPHA:
+			blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.blendConstant4W[3]));
+			break;
+		case BLEND_INVCONSTANT:
+		case BLEND_INVCONSTANTALPHA:
+			blendFactor.w = *Pointer<Short4>(data + OFFSET(DrawData,factor.invBlendConstant4W[3]));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	bool PixelRoutine::isSRGB(int index) const
+	{
+		return Surface::isSRGBformat(state.targetFormat[index]);
+	}
+
+	void PixelRoutine::readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel)
+	{
+		Short4 c01;
+		Short4 c23;
+		Pointer<Byte> buffer;
+		Pointer<Byte> buffer2;
+
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R5G6B5:
+			buffer = cBuffer + 2 * x;
+			buffer2 = buffer + *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c01 = As<Short4>(Int2(*Pointer<Int>(buffer), *Pointer<Int>(buffer2)));
+
+			pixel.x = c01 & Short4(0xF800u);
+			pixel.y = (c01 & Short4(0x07E0u)) << 5;
+			pixel.z = (c01 & Short4(0x001Fu)) << 11;
+			pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_A8R8G8B8:
+			buffer = cBuffer + 4 * x;
+			c01 = *Pointer<Short4>(buffer);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c23 = *Pointer<Short4>(buffer);
+			pixel.z = c01;
+			pixel.y = c01;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
+			pixel.x = pixel.z;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
+			pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
+			pixel.y = pixel.z;
+			pixel.w = pixel.x;
+			pixel.x = UnpackLow(As<Byte8>(pixel.x), As<Byte8>(pixel.x));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
+			pixel.w = UnpackHigh(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
+			break;
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_A8:
+			buffer = cBuffer + 4 * x;
+			c01 = *Pointer<Short4>(buffer);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c23 = *Pointer<Short4>(buffer);
+			pixel.z = c01;
+			pixel.y = c01;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
+			pixel.x = pixel.z;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
+			pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
+			pixel.y = pixel.z;
+			pixel.w = pixel.x;
+			pixel.x = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
+			pixel.z = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
+			pixel.w = UnpackHigh(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
+			break;
+		case FORMAT_A8:
+			buffer = cBuffer + 1 * x;
+			pixel.w = Insert(pixel.w, *Pointer<Short>(buffer), 0);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			pixel.w = Insert(pixel.w, *Pointer<Short>(buffer), 1);
+			pixel.w = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
+			pixel.x = Short4(0x0000);
+			pixel.y = Short4(0x0000);
+			pixel.z = Short4(0x0000);
+			break;
+		case FORMAT_R8:
+			buffer = cBuffer + 1 * x;
+			pixel.x = Insert(pixel.x, *Pointer<Short>(buffer), 0);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			pixel.x = Insert(pixel.x, *Pointer<Short>(buffer), 1);
+			pixel.x = UnpackLow(As<Byte8>(pixel.x), As<Byte8>(pixel.x));
+			pixel.y = Short4(0x0000);
+			pixel.z = Short4(0x0000);
+			pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_X8R8G8B8:
+			buffer = cBuffer + 4 * x;
+			c01 = *Pointer<Short4>(buffer);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c23 = *Pointer<Short4>(buffer);
+			pixel.z = c01;
+			pixel.y = c01;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
+			pixel.x = pixel.z;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
+			pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
+			pixel.y = pixel.z;
+			pixel.x = UnpackLow(As<Byte8>(pixel.x), As<Byte8>(pixel.x));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
+			pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_G8R8:
+			buffer = cBuffer + 2 * x;
+			c01 = As<Short4>(Insert(As<Int2>(c01), *Pointer<Int>(buffer), 0));
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c01 = As<Short4>(Insert(As<Int2>(c01), *Pointer<Int>(buffer), 1));
+			pixel.x = (c01 & Short4(0x00FFu)) | (c01 << 8);
+			pixel.y = (c01 & Short4(0xFF00u)) | As<Short4>(As<UShort4>(c01) >> 8);
+			pixel.z = Short4(0x0000u);
+			pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_SRGB8_X8:
+			buffer = cBuffer + 4 * x;
+			c01 = *Pointer<Short4>(buffer);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			c23 = *Pointer<Short4>(buffer);
+			pixel.z = c01;
+			pixel.y = c01;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(c23));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(c23));
+			pixel.x = pixel.z;
+			pixel.z = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.y));
+			pixel.x = UnpackHigh(As<Byte8>(pixel.x), As<Byte8>(pixel.y));
+			pixel.y = pixel.z;
+			pixel.w = pixel.x;
+			pixel.x = UnpackLow(As<Byte8>(pixel.z), As<Byte8>(pixel.z));
+			pixel.y = UnpackHigh(As<Byte8>(pixel.y), As<Byte8>(pixel.y));
+			pixel.z = UnpackLow(As<Byte8>(pixel.w), As<Byte8>(pixel.w));
+			pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_A8G8R8B8Q:
+			UNIMPLEMENTED();
+		//	pixel.z = UnpackLow(As<Byte8>(pixel.z), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+		//	pixel.x = UnpackHigh(As<Byte8>(pixel.x), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+		//	pixel.y = UnpackLow(As<Byte8>(pixel.y), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+		//	pixel.w = UnpackHigh(As<Byte8>(pixel.w), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+			break;
+		case FORMAT_X8G8R8B8Q:
+			UNIMPLEMENTED();
+		//	pixel.z = UnpackLow(As<Byte8>(pixel.z), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+		//	pixel.x = UnpackHigh(As<Byte8>(pixel.x), *Pointer<Byte8>(cBuffer + 8 * x + 0));
+		//	pixel.y = UnpackLow(As<Byte8>(pixel.y), *Pointer<Byte8>(cBuffer + 8 * x + 8));
+		//	pixel.w = Short4(0xFFFFu);
+			break;
+		case FORMAT_A16B16G16R16:
+			buffer = cBuffer;
+			pixel.x = *Pointer<Short4>(buffer + 8 * x);
+			pixel.y = *Pointer<Short4>(buffer + 8 * x + 8);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			pixel.z = *Pointer<Short4>(buffer + 8 * x);
+			pixel.w = *Pointer<Short4>(buffer + 8 * x + 8);
+			transpose4x4(pixel.x, pixel.y, pixel.z, pixel.w);
+			break;
+		case FORMAT_G16R16:
+			buffer = cBuffer;
+			pixel.x = *Pointer<Short4>(buffer + 4 * x);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+			pixel.y = *Pointer<Short4>(buffer + 4 * x);
+			pixel.z = pixel.x;
+			pixel.x = As<Short4>(UnpackLow(pixel.x, pixel.y));
+			pixel.z = As<Short4>(UnpackHigh(pixel.z, pixel.y));
+			pixel.y = pixel.z;
+			pixel.x = As<Short4>(UnpackLow(pixel.x, pixel.z));
+			pixel.y = As<Short4>(UnpackHigh(pixel.y, pixel.z));
+			pixel.z = Short4(0xFFFFu);
+			pixel.w = Short4(0xFFFFu);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if((postBlendSRGB && state.writeSRGB) || isSRGB(index))
+		{
+			sRGBtoLinear16_12_16(pixel);
+		}
+	}
+
+	void PixelRoutine::alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x)
+	{
+		if(!state.alphaBlendActive)
+		{
+			return;
+		}
+
+		Vector4s pixel;
+		readPixel(index, cBuffer, x, pixel);
+
+		// Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
+		Vector4s sourceFactor;
+		Vector4s destFactor;
+
+		blendFactor(sourceFactor, current, pixel, state.sourceBlendFactor);
+		blendFactor(destFactor, current, pixel, state.destBlendFactor);
+
+		if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+		{
+			current.x = MulHigh(As<UShort4>(current.x), As<UShort4>(sourceFactor.x));
+			current.y = MulHigh(As<UShort4>(current.y), As<UShort4>(sourceFactor.y));
+			current.z = MulHigh(As<UShort4>(current.z), As<UShort4>(sourceFactor.z));
+		}
+
+		if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+		{
+			pixel.x = MulHigh(As<UShort4>(pixel.x), As<UShort4>(destFactor.x));
+			pixel.y = MulHigh(As<UShort4>(pixel.y), As<UShort4>(destFactor.y));
+			pixel.z = MulHigh(As<UShort4>(pixel.z), As<UShort4>(destFactor.z));
+		}
+
+		switch(state.blendOperation)
+		{
+		case BLENDOP_ADD:
+			current.x = AddSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
+			current.y = AddSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
+			current.z = AddSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
+			break;
+		case BLENDOP_SUB:
+			current.x = SubSat(As<UShort4>(current.x), As<UShort4>(pixel.x));
+			current.y = SubSat(As<UShort4>(current.y), As<UShort4>(pixel.y));
+			current.z = SubSat(As<UShort4>(current.z), As<UShort4>(pixel.z));
+			break;
+		case BLENDOP_INVSUB:
+			current.x = SubSat(As<UShort4>(pixel.x), As<UShort4>(current.x));
+			current.y = SubSat(As<UShort4>(pixel.y), As<UShort4>(current.y));
+			current.z = SubSat(As<UShort4>(pixel.z), As<UShort4>(current.z));
+			break;
+		case BLENDOP_MIN:
+			current.x = Min(As<UShort4>(current.x), As<UShort4>(pixel.x));
+			current.y = Min(As<UShort4>(current.y), As<UShort4>(pixel.y));
+			current.z = Min(As<UShort4>(current.z), As<UShort4>(pixel.z));
+			break;
+		case BLENDOP_MAX:
+			current.x = Max(As<UShort4>(current.x), As<UShort4>(pixel.x));
+			current.y = Max(As<UShort4>(current.y), As<UShort4>(pixel.y));
+			current.z = Max(As<UShort4>(current.z), As<UShort4>(pixel.z));
+			break;
+		case BLENDOP_SOURCE:
+			// No operation
+			break;
+		case BLENDOP_DEST:
+			current.x = pixel.x;
+			current.y = pixel.y;
+			current.z = pixel.z;
+			break;
+		case BLENDOP_NULL:
+			current.x = Short4(0x0000);
+			current.y = Short4(0x0000);
+			current.z = Short4(0x0000);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		blendFactorAlpha(sourceFactor, current, pixel, state.sourceBlendFactorAlpha);
+		blendFactorAlpha(destFactor, current, pixel, state.destBlendFactorAlpha);
+
+		if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+		{
+			current.w = MulHigh(As<UShort4>(current.w), As<UShort4>(sourceFactor.w));
+		}
+
+		if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+		{
+			pixel.w = MulHigh(As<UShort4>(pixel.w), As<UShort4>(destFactor.w));
+		}
+
+		switch(state.blendOperationAlpha)
+		{
+		case BLENDOP_ADD:
+			current.w = AddSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
+			break;
+		case BLENDOP_SUB:
+			current.w = SubSat(As<UShort4>(current.w), As<UShort4>(pixel.w));
+			break;
+		case BLENDOP_INVSUB:
+			current.w = SubSat(As<UShort4>(pixel.w), As<UShort4>(current.w));
+			break;
+		case BLENDOP_MIN:
+			current.w = Min(As<UShort4>(current.w), As<UShort4>(pixel.w));
+			break;
+		case BLENDOP_MAX:
+			current.w = Max(As<UShort4>(current.w), As<UShort4>(pixel.w));
+			break;
+		case BLENDOP_SOURCE:
+			// No operation
+			break;
+		case BLENDOP_DEST:
+			current.w = pixel.w;
+			break;
+		case BLENDOP_NULL:
+			current.w = Short4(0x0000);
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::logicOperation(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x)
+	{
+		if(state.logicalOperation == LOGICALOP_COPY)
+		{
+			return;
+		}
+
+		Vector4s pixel;
+		readPixel(index, cBuffer, x, pixel);
+
+		switch(state.logicalOperation)
+		{
+		case LOGICALOP_CLEAR:
+			current.x = UShort4(0);
+			current.y = UShort4(0);
+			current.z = UShort4(0);
+			break;
+		case LOGICALOP_SET:
+			current.x = UShort4(0xFFFFu);
+			current.y = UShort4(0xFFFFu);
+			current.z = UShort4(0xFFFFu);
+			break;
+		case LOGICALOP_COPY:
+			ASSERT(false);   // Optimized out
+			break;
+		case LOGICALOP_COPY_INVERTED:
+			current.x = ~current.x;
+			current.y = ~current.y;
+			current.z = ~current.z;
+			break;
+		case LOGICALOP_NOOP:
+			current.x = pixel.x;
+			current.y = pixel.y;
+			current.z = pixel.z;
+			break;
+		case LOGICALOP_INVERT:
+			current.x = ~pixel.x;
+			current.y = ~pixel.y;
+			current.z = ~pixel.z;
+			break;
+		case LOGICALOP_AND:
+			current.x = pixel.x & current.x;
+			current.y = pixel.y & current.y;
+			current.z = pixel.z & current.z;
+			break;
+		case LOGICALOP_NAND:
+			current.x = ~(pixel.x & current.x);
+			current.y = ~(pixel.y & current.y);
+			current.z = ~(pixel.z & current.z);
+			break;
+		case LOGICALOP_OR:
+			current.x = pixel.x | current.x;
+			current.y = pixel.y | current.y;
+			current.z = pixel.z | current.z;
+			break;
+		case LOGICALOP_NOR:
+			current.x = ~(pixel.x | current.x);
+			current.y = ~(pixel.y | current.y);
+			current.z = ~(pixel.z | current.z);
+			break;
+		case LOGICALOP_XOR:
+			current.x = pixel.x ^ current.x;
+			current.y = pixel.y ^ current.y;
+			current.z = pixel.z ^ current.z;
+			break;
+		case LOGICALOP_EQUIV:
+			current.x = ~(pixel.x ^ current.x);
+			current.y = ~(pixel.y ^ current.y);
+			current.z = ~(pixel.z ^ current.z);
+			break;
+		case LOGICALOP_AND_REVERSE:
+			current.x = ~pixel.x & current.x;
+			current.y = ~pixel.y & current.y;
+			current.z = ~pixel.z & current.z;
+			break;
+		case LOGICALOP_AND_INVERTED:
+			current.x = pixel.x & ~current.x;
+			current.y = pixel.y & ~current.y;
+			current.z = pixel.z & ~current.z;
+			break;
+		case LOGICALOP_OR_REVERSE:
+			current.x = ~pixel.x | current.x;
+			current.y = ~pixel.y | current.y;
+			current.z = ~pixel.z | current.z;
+			break;
+		case LOGICALOP_OR_INVERTED:
+			current.x = pixel.x | ~current.x;
+			current.y = pixel.y | ~current.y;
+			current.z = pixel.z | ~current.z;
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::writeColor(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &current, Int &sMask, Int &zMask, Int &cMask)
+	{
+		if((postBlendSRGB && state.writeSRGB) || isSRGB(index))
+		{
+			linearToSRGB16_12_16(current);
+		}
+
+		if(exactColorRounding)
+		{
+			switch(state.targetFormat[index])
+			{
+			case FORMAT_R5G6B5:
+				current.x = AddSat(As<UShort4>(current.x), UShort4(0x0400));
+				current.y = AddSat(As<UShort4>(current.y), UShort4(0x0200));
+				current.z = AddSat(As<UShort4>(current.z), UShort4(0x0400));
+				break;
+			case FORMAT_X8G8R8B8Q:
+			case FORMAT_A8G8R8B8Q:
+			case FORMAT_X8R8G8B8:
+			case FORMAT_X8B8G8R8:
+			case FORMAT_A8R8G8B8:
+			case FORMAT_A8B8G8R8:
+			case FORMAT_SRGB8_X8:
+			case FORMAT_SRGB8_A8:
+			case FORMAT_G8R8:
+			case FORMAT_R8:
+				current.x = current.x - As<Short4>(As<UShort4>(current.x) >> 8) + Short4(0x0080);
+				current.y = current.y - As<Short4>(As<UShort4>(current.y) >> 8) + Short4(0x0080);
+				current.z = current.z - As<Short4>(As<UShort4>(current.z) >> 8) + Short4(0x0080);
+				current.w = current.w - As<Short4>(As<UShort4>(current.w) >> 8) + Short4(0x0080);
+				break;
+			default:
+				break;
+			}
+		}
+
+		int rgbaWriteMask = state.colorWriteActive(index);
+		int bgraWriteMask = (rgbaWriteMask & 0x0000000A) | (rgbaWriteMask & 0x00000001) << 2 | (rgbaWriteMask & 0x00000004) >> 2;
+
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R5G6B5:
+			{
+				current.x = current.x & Short4(0xF800u);
+				current.y = As<UShort4>(current.y & Short4(0xFC00u)) >> 5;
+				current.z = As<UShort4>(current.z) >> 11;
+
+				current.x = current.x | current.y | current.z;
+			}
+			break;
+		case FORMAT_X8G8R8B8Q:
+			UNIMPLEMENTED();
+		//	current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+		//	current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+		//	current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+
+		//	current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
+		//	current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.y)));
+			break;
+		case FORMAT_A8G8R8B8Q:
+			UNIMPLEMENTED();
+		//	current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+		//	current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+		//	current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+		//	current.w = As<Short4>(As<UShort4>(current.w) >> 8);
+
+		//	current.z = As<Short4>(Pack(As<UShort4>(current.z), As<UShort4>(current.x)));
+		//	current.y = As<Short4>(Pack(As<UShort4>(current.y), As<UShort4>(current.w)));
+			break;
+		case FORMAT_X8R8G8B8:
+		case FORMAT_A8R8G8B8:
+			if(state.targetFormat[index] == FORMAT_X8R8G8B8 || rgbaWriteMask == 0x7)
+			{
+				current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+				current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+				current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+
+				current.z = As<Short4>(PackUnsigned(current.z, current.x));
+				current.y = As<Short4>(PackUnsigned(current.y, current.y));
+
+				current.x = current.z;
+				current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
+				current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
+				current.y = current.z;
+				current.z = As<Short4>(UnpackLow(current.z, current.x));
+				current.y = As<Short4>(UnpackHigh(current.y, current.x));
+			}
+			else
+			{
+				current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+				current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+				current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+				current.w = As<Short4>(As<UShort4>(current.w) >> 8);
+
+				current.z = As<Short4>(PackUnsigned(current.z, current.x));
+				current.y = As<Short4>(PackUnsigned(current.y, current.w));
+
+				current.x = current.z;
+				current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
+				current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
+				current.y = current.z;
+				current.z = As<Short4>(UnpackLow(current.z, current.x));
+				current.y = As<Short4>(UnpackHigh(current.y, current.x));
+			}
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+			if(state.targetFormat[index] == FORMAT_X8B8G8R8 || state.targetFormat[index] == FORMAT_SRGB8_X8 || rgbaWriteMask == 0x7)
+			{
+				current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+				current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+				current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+
+				current.z = As<Short4>(PackUnsigned(current.x, current.z));
+				current.y = As<Short4>(PackUnsigned(current.y, current.y));
+
+				current.x = current.z;
+				current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
+				current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
+				current.y = current.z;
+				current.z = As<Short4>(UnpackLow(current.z, current.x));
+				current.y = As<Short4>(UnpackHigh(current.y, current.x));
+			}
+			else
+			{
+				current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+				current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+				current.z = As<Short4>(As<UShort4>(current.z) >> 8);
+				current.w = As<Short4>(As<UShort4>(current.w) >> 8);
+
+				current.z = As<Short4>(PackUnsigned(current.x, current.z));
+				current.y = As<Short4>(PackUnsigned(current.y, current.w));
+
+				current.x = current.z;
+				current.z = UnpackLow(As<Byte8>(current.z), As<Byte8>(current.y));
+				current.x = UnpackHigh(As<Byte8>(current.x), As<Byte8>(current.y));
+				current.y = current.z;
+				current.z = As<Short4>(UnpackLow(current.z, current.x));
+				current.y = As<Short4>(UnpackHigh(current.y, current.x));
+			}
+			break;
+		case FORMAT_G8R8:
+			current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+			current.y = As<Short4>(As<UShort4>(current.y) >> 8);
+			current.x = As<Short4>(PackUnsigned(current.x, current.x));
+			current.y = As<Short4>(PackUnsigned(current.y, current.y));
+			current.x = UnpackLow(As<Byte8>(current.x), As<Byte8>(current.y));
+			break;
+		case FORMAT_R8:
+			current.x = As<Short4>(As<UShort4>(current.x) >> 8);
+			current.x = As<Short4>(PackUnsigned(current.x, current.x));
+			break;
+		case FORMAT_A8:
+			current.w = As<Short4>(As<UShort4>(current.w) >> 8);
+			current.w = As<Short4>(PackUnsigned(current.w, current.w));
+			break;
+		case FORMAT_G16R16:
+			current.z = current.x;
+			current.x = As<Short4>(UnpackLow(current.x, current.y));
+			current.z = As<Short4>(UnpackHigh(current.z, current.y));
+			current.y = current.z;
+			break;
+		case FORMAT_A16B16G16R16:
+			transpose4x4(current.x, current.y, current.z, current.w);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		Short4 c01 = current.z;
+		Short4 c23 = current.y;
+
+		Int xMask;   // Combination of all masks
+
+		if(state.depthTestActive)
+		{
+			xMask = zMask;
+		}
+		else
+		{
+			xMask = cMask;
+		}
+
+		if(state.stencilActive)
+		{
+			xMask &= sMask;
+		}
+
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R5G6B5:
+			{
+				Pointer<Byte> buffer = cBuffer + 2 * x;
+				Int value = *Pointer<Int>(buffer);
+
+				Int c01 = Extract(As<Int2>(current.x), 0);
+
+				if((bgraWriteMask & 0x00000007) != 0x00000007)
+				{
+					Int masked = value;
+					c01 &= *Pointer<Int>(constants + OFFSET(Constants,mask565Q[bgraWriteMask & 0x7][0]));
+					masked &= *Pointer<Int>(constants + OFFSET(Constants,mask565Q[~bgraWriteMask & 0x7][0]));
+					c01 |= masked;
+				}
+
+				c01 &= *Pointer<Int>(constants + OFFSET(Constants,maskW4Q[0][0]) + xMask * 8);
+				value &= *Pointer<Int>(constants + OFFSET(Constants,invMaskW4Q[0][0]) + xMask * 8);
+				c01 |= value;
+				*Pointer<Int>(buffer) = c01;
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+				value = *Pointer<Int>(buffer);
+
+				Int c23 = Extract(As<Int2>(current.x), 1);
+
+				if((bgraWriteMask & 0x00000007) != 0x00000007)
+				{
+					Int masked = value;
+					c23 &= *Pointer<Int>(constants + OFFSET(Constants,mask565Q[bgraWriteMask & 0x7][0]));
+					masked &= *Pointer<Int>(constants + OFFSET(Constants,mask565Q[~bgraWriteMask & 0x7][0]));
+					c23 |= masked;
+				}
+
+				c23 &= *Pointer<Int>(constants + OFFSET(Constants,maskW4Q[0][2]) + xMask * 8);
+				value &= *Pointer<Int>(constants + OFFSET(Constants,invMaskW4Q[0][2]) + xMask * 8);
+				c23 |= value;
+				*Pointer<Int>(buffer) = c23;
+			}
+			break;
+		case FORMAT_A8G8R8B8Q:
+		case FORMAT_X8G8R8B8Q:   // FIXME: Don't touch alpha?
+			UNIMPLEMENTED();
+		//	value = *Pointer<Short4>(cBuffer + 8 * x + 0);
+
+		//	if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
+		//	   ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
+		//	    (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
+		//	{
+		//		Short4 masked = value;
+		//		c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+		//		masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+		//		c01 |= masked;
+		//	}
+
+		//	c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+		//	value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+		//	c01 |= value;
+		//	*Pointer<Short4>(cBuffer + 8 * x + 0) = c01;
+
+		//	value = *Pointer<Short4>(cBuffer + 8 * x + 8);
+
+		//	if((state.targetFormat[index] == FORMAT_A8G8R8B8Q && bgraWriteMask != 0x0000000F) ||
+		//	   ((state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x00000007) &&
+		//	    (state.targetFormat[index] == FORMAT_X8G8R8B8Q && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
+		//	{
+		//		Short4 masked = value;
+		//		c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+		//		masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+		//		c23 |= masked;
+		//	}
+
+		//	c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+		//	value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+		//	c23 |= value;
+		//	*Pointer<Short4>(cBuffer + 8 * x + 8) = c23;
+			break;
+		case FORMAT_A8R8G8B8:
+		case FORMAT_X8R8G8B8:   // FIXME: Don't touch alpha?
+			{
+				Pointer<Byte> buffer = cBuffer + x * 4;
+				Short4 value = *Pointer<Short4>(buffer);
+
+				if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
+				   ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
+					(state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
+				{
+					Short4 masked = value;
+					c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+					c01 |= masked;
+				}
+
+				c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+				c01 |= value;
+				*Pointer<Short4>(buffer) = c01;
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+				value = *Pointer<Short4>(buffer);
+
+				if((state.targetFormat[index] == FORMAT_A8R8G8B8 && bgraWriteMask != 0x0000000F) ||
+				   ((state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x00000007) &&
+					(state.targetFormat[index] == FORMAT_X8R8G8B8 && bgraWriteMask != 0x0000000F)))   // FIXME: Need for masking when XRGB && Fh?
+				{
+					Short4 masked = value;
+					c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[bgraWriteMask][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[bgraWriteMask][0]));
+					c23 |= masked;
+				}
+
+				c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+				c23 |= value;
+				*Pointer<Short4>(buffer) = c23;
+			}
+			break;
+		case FORMAT_A8B8G8R8:
+		case FORMAT_X8B8G8R8:   // FIXME: Don't touch alpha?
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+			{
+				Pointer<Byte> buffer = cBuffer + x * 4;
+				Short4 value = *Pointer<Short4>(buffer);
+
+				bool masked = (((state.targetFormat[index] == FORMAT_A8B8G8R8 || state.targetFormat[index] == FORMAT_SRGB8_A8) && rgbaWriteMask != 0x0000000F) ||
+				              (((state.targetFormat[index] == FORMAT_X8B8G8R8 || state.targetFormat[index] == FORMAT_SRGB8_X8) && rgbaWriteMask != 0x00000007) &&
+				               ((state.targetFormat[index] == FORMAT_X8B8G8R8 || state.targetFormat[index] == FORMAT_SRGB8_X8) && rgbaWriteMask != 0x0000000F))); // FIXME: Need for masking when XBGR && Fh?
+
+				if(masked)
+				{
+					Short4 masked = value;
+					c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[rgbaWriteMask][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[rgbaWriteMask][0]));
+					c01 |= masked;
+				}
+
+				c01 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+				c01 |= value;
+				*Pointer<Short4>(buffer) = c01;
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+				value = *Pointer<Short4>(buffer);
+
+				if(masked)
+				{
+					Short4 masked = value;
+					c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q[rgbaWriteMask][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q[rgbaWriteMask][0]));
+					c23 |= masked;
+				}
+
+				c23 &= *Pointer<Short4>(constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+				c23 |= value;
+				*Pointer<Short4>(buffer) = c23;
+			}
+			break;
+		case FORMAT_G8R8:
+			if((rgbaWriteMask & 0x00000003) != 0x0)
+			{
+				Pointer<Byte> buffer = cBuffer + 2 * x;
+				Int2 value;
+				value = Insert(value, *Pointer<Int>(buffer), 0);
+				Int pitch = *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				value = Insert(value, *Pointer<Int>(buffer + pitch), 1);
+
+				Int2 packedCol = As<Int2>(current.x);
+
+				UInt2 mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskW4Q) + xMask * 8);
+				if((rgbaWriteMask & 0x3) != 0x3)
+				{
+					Int tmpMask = *Pointer<Int>(constants + OFFSET(Constants, maskB4Q[5 * (rgbaWriteMask & 0x3)][0]));
+					UInt2 rgbaMask = As<UInt2>(Int2(tmpMask, tmpMask));
+					mergedMask &= rgbaMask;
+				}
+
+				packedCol = As<Int2>((As<UInt2>(packedCol) & mergedMask) | (As<UInt2>(value) & ~mergedMask));
+
+				*Pointer<UInt>(buffer) = As<UInt>(Extract(packedCol, 0));
+				*Pointer<UInt>(buffer + pitch) = As<UInt>(Extract(packedCol, 1));
+			}
+			break;
+		case FORMAT_R8:
+			if(rgbaWriteMask & 0x00000001)
+			{
+				Pointer<Byte> buffer = cBuffer + 1 * x;
+				Short4 value;
+				value = Insert(value, *Pointer<Short>(buffer), 0);
+				Int pitch = *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				value = Insert(value, *Pointer<Short>(buffer + pitch), 1);
+
+				current.x &= *Pointer<Short4>(constants + OFFSET(Constants, maskB4Q) + 8 * xMask);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants, invMaskB4Q) + 8 * xMask);
+				current.x |= value;
+
+				*Pointer<Short>(buffer) = Extract(current.x, 0);
+				*Pointer<Short>(buffer + pitch) = Extract(current.x, 1);
+			}
+			break;
+		case FORMAT_A8:
+			if(rgbaWriteMask & 0x00000008)
+			{
+				Pointer<Byte> buffer = cBuffer + 1 * x;
+				Short4 value;
+				value = Insert(value, *Pointer<Short>(buffer), 0);
+				Int pitch = *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+				value = Insert(value, *Pointer<Short>(buffer + pitch), 1);
+
+				current.w &= *Pointer<Short4>(constants + OFFSET(Constants,maskB4Q) + 8 * xMask);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskB4Q) + 8 * xMask);
+				current.w |= value;
+
+				*Pointer<Short>(buffer) = Extract(current.w, 0);
+				*Pointer<Short>(buffer + pitch) = Extract(current.w, 1);
+			}
+			break;
+		case FORMAT_G16R16:
+			{
+				Pointer<Byte> buffer = cBuffer + 4 * x;
+
+				Short4 value = *Pointer<Short4>(buffer);
+
+				if((rgbaWriteMask & 0x00000003) != 0x00000003)
+				{
+					Short4 masked = value;
+					current.x &= *Pointer<Short4>(constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,maskW01Q[~rgbaWriteMask & 0x3][0]));
+					current.x |= masked;
+				}
+
+				current.x &= *Pointer<Short4>(constants + OFFSET(Constants,maskD01Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD01Q) + xMask * 8);
+				current.x |= value;
+				*Pointer<Short4>(buffer) = current.x;
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+				value = *Pointer<Short4>(buffer);
+
+				if((rgbaWriteMask & 0x00000003) != 0x00000003)
+				{
+					Short4 masked = value;
+					current.y &= *Pointer<Short4>(constants + OFFSET(Constants,maskW01Q[rgbaWriteMask & 0x3][0]));
+					masked &= *Pointer<Short4>(constants + OFFSET(Constants,maskW01Q[~rgbaWriteMask & 0x3][0]));
+					current.y |= masked;
+				}
+
+				current.y &= *Pointer<Short4>(constants + OFFSET(Constants,maskD23Q) + xMask * 8);
+				value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskD23Q) + xMask * 8);
+				current.y |= value;
+				*Pointer<Short4>(buffer) = current.y;
+			}
+			break;
+		case FORMAT_A16B16G16R16:
+			{
+				Pointer<Byte> buffer = cBuffer + 8 * x;
+
+				{
+					Short4 value = *Pointer<Short4>(buffer);
+
+					if(rgbaWriteMask != 0x0000000F)
+					{
+						Short4 masked = value;
+						current.x &= *Pointer<Short4>(constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+						masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+						current.x |= masked;
+					}
+
+					current.x &= *Pointer<Short4>(constants + OFFSET(Constants,maskQ0Q) + xMask * 8);
+					value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskQ0Q) + xMask * 8);
+					current.x |= value;
+					*Pointer<Short4>(buffer) = current.x;
+				}
+
+				{
+					Short4 value = *Pointer<Short4>(buffer + 8);
+
+					if(rgbaWriteMask != 0x0000000F)
+					{
+						Short4 masked = value;
+						current.y &= *Pointer<Short4>(constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+						masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+						current.y |= masked;
+					}
+
+					current.y &= *Pointer<Short4>(constants + OFFSET(Constants,maskQ1Q) + xMask * 8);
+					value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskQ1Q) + xMask * 8);
+					current.y |= value;
+					*Pointer<Short4>(buffer + 8) = current.y;
+				}
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+				{
+					Short4 value = *Pointer<Short4>(buffer);
+
+					if(rgbaWriteMask != 0x0000000F)
+					{
+						Short4 masked = value;
+						current.z &= *Pointer<Short4>(constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+						masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+						current.z |= masked;
+					}
+
+					current.z &= *Pointer<Short4>(constants + OFFSET(Constants,maskQ2Q) + xMask * 8);
+					value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskQ2Q) + xMask * 8);
+					current.z |= value;
+					*Pointer<Short4>(buffer) = current.z;
+				}
+
+				{
+					Short4 value = *Pointer<Short4>(buffer + 8);
+
+					if(rgbaWriteMask != 0x0000000F)
+					{
+						Short4 masked = value;
+						current.w &= *Pointer<Short4>(constants + OFFSET(Constants,maskW4Q[rgbaWriteMask][0]));
+						masked &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskW4Q[rgbaWriteMask][0]));
+						current.w |= masked;
+					}
+
+					current.w &= *Pointer<Short4>(constants + OFFSET(Constants,maskQ3Q) + xMask * 8);
+					value &= *Pointer<Short4>(constants + OFFSET(Constants,invMaskQ3Q) + xMask * 8);
+					current.w |= value;
+					*Pointer<Short4>(buffer + 8) = current.w;
+				}
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive)
+	{
+		switch(blendFactorActive)
+		{
+		case BLEND_ZERO:
+			// Optimized
+			break;
+		case BLEND_ONE:
+			// Optimized
+			break;
+		case BLEND_SOURCE:
+			blendFactor.x = oC.x;
+			blendFactor.y = oC.y;
+			blendFactor.z = oC.z;
+			break;
+		case BLEND_INVSOURCE:
+			blendFactor.x = Float4(1.0f) - oC.x;
+			blendFactor.y = Float4(1.0f) - oC.y;
+			blendFactor.z = Float4(1.0f) - oC.z;
+			break;
+		case BLEND_DEST:
+			blendFactor.x = pixel.x;
+			blendFactor.y = pixel.y;
+			blendFactor.z = pixel.z;
+			break;
+		case BLEND_INVDEST:
+			blendFactor.x = Float4(1.0f) - pixel.x;
+			blendFactor.y = Float4(1.0f) - pixel.y;
+			blendFactor.z = Float4(1.0f) - pixel.z;
+			break;
+		case BLEND_SOURCEALPHA:
+			blendFactor.x = oC.w;
+			blendFactor.y = oC.w;
+			blendFactor.z = oC.w;
+			break;
+		case BLEND_INVSOURCEALPHA:
+			blendFactor.x = Float4(1.0f) - oC.w;
+			blendFactor.y = Float4(1.0f) - oC.w;
+			blendFactor.z = Float4(1.0f) - oC.w;
+			break;
+		case BLEND_DESTALPHA:
+			blendFactor.x = pixel.w;
+			blendFactor.y = pixel.w;
+			blendFactor.z = pixel.w;
+			break;
+		case BLEND_INVDESTALPHA:
+			blendFactor.x = Float4(1.0f) - pixel.w;
+			blendFactor.y = Float4(1.0f) - pixel.w;
+			blendFactor.z = Float4(1.0f) - pixel.w;
+			break;
+		case BLEND_SRCALPHASAT:
+			blendFactor.x = Float4(1.0f) - pixel.w;
+			blendFactor.x = Min(blendFactor.x, oC.w);
+			blendFactor.y = blendFactor.x;
+			blendFactor.z = blendFactor.x;
+			break;
+		case BLEND_CONSTANT:
+			blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[0]));
+			blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[1]));
+			blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[2]));
+			break;
+		case BLEND_INVCONSTANT:
+			blendFactor.x = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[0]));
+			blendFactor.y = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[1]));
+			blendFactor.z = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[2]));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive)
+	{
+		switch(blendFactorAlphaActive)
+		{
+		case BLEND_ZERO:
+			// Optimized
+			break;
+		case BLEND_ONE:
+			// Optimized
+			break;
+		case BLEND_SOURCE:
+			blendFactor.w = oC.w;
+			break;
+		case BLEND_INVSOURCE:
+			blendFactor.w = Float4(1.0f) - oC.w;
+			break;
+		case BLEND_DEST:
+			blendFactor.w = pixel.w;
+			break;
+		case BLEND_INVDEST:
+			blendFactor.w = Float4(1.0f) - pixel.w;
+			break;
+		case BLEND_SOURCEALPHA:
+			blendFactor.w = oC.w;
+			break;
+		case BLEND_INVSOURCEALPHA:
+			blendFactor.w = Float4(1.0f) - oC.w;
+			break;
+		case BLEND_DESTALPHA:
+			blendFactor.w = pixel.w;
+			break;
+		case BLEND_INVDESTALPHA:
+			blendFactor.w = Float4(1.0f) - pixel.w;
+			break;
+		case BLEND_SRCALPHASAT:
+			blendFactor.w = Float4(1.0f);
+			break;
+		case BLEND_CONSTANT:
+			blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.blendConstant4F[3]));
+			break;
+		case BLEND_INVCONSTANT:
+			blendFactor.w = *Pointer<Float4>(data + OFFSET(DrawData,factor.invBlendConstant4F[3]));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4f &oC, Int &x)
+	{
+		if(!state.alphaBlendActive)
+		{
+			return;
+		}
+
+		Pointer<Byte> buffer;
+		Vector4f pixel;
+
+		Vector4s color;
+		Short4 c01;
+		Short4 c23;
+
+		Float4 one;
+		if(Surface::isFloatFormat(state.targetFormat[index]))
+		{
+			one = Float4(1.0f);
+		}
+		else if(Surface::isNonNormalizedInteger(state.targetFormat[index]))
+		{
+			one = As<Float4>(Surface::isUnsignedComponent(state.targetFormat[index], 0) ? Int4(0xFFFFFFFF) : Int4(0x7FFFFFFF));
+		}
+
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_R32F:
+			buffer = cBuffer;
+			// FIXME: movlps
+			pixel.x.x = *Pointer<Float>(buffer + 4 * x + 0);
+			pixel.x.y = *Pointer<Float>(buffer + 4 * x + 4);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+			// FIXME: movhps
+			pixel.x.z = *Pointer<Float>(buffer + 4 * x + 0);
+			pixel.x.w = *Pointer<Float>(buffer + 4 * x + 4);
+			pixel.y = pixel.z = pixel.w = one;
+			break;
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_G32R32F:
+			buffer = cBuffer;
+			pixel.x = *Pointer<Float4>(buffer + 8 * x, 16);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+			pixel.y = *Pointer<Float4>(buffer + 8 * x, 16);
+			pixel.z = pixel.x;
+			pixel.x = ShuffleLowHigh(pixel.x, pixel.y, 0x88);
+			pixel.z = ShuffleLowHigh(pixel.z, pixel.y, 0xDD);
+			pixel.y = pixel.z;
+			pixel.z = pixel.w = one;
+			break;
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			buffer = cBuffer;
+			pixel.x = *Pointer<Float4>(buffer + 16 * x, 16);
+			pixel.y = *Pointer<Float4>(buffer + 16 * x + 16, 16);
+			buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+			pixel.z = *Pointer<Float4>(buffer + 16 * x, 16);
+			pixel.w = *Pointer<Float4>(buffer + 16 * x + 16, 16);
+			transpose4x4(pixel.x, pixel.y, pixel.z, pixel.w);
+			if(state.targetFormat[index] == FORMAT_X32B32G32R32F ||
+			   state.targetFormat[index] == FORMAT_X32B32G32R32F_UNSIGNED)
+			{
+				pixel.w = Float4(1.0f);
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if((postBlendSRGB && state.writeSRGB) || isSRGB(index))
+		{
+			sRGBtoLinear(pixel.x);
+			sRGBtoLinear(pixel.y);
+			sRGBtoLinear(pixel.z);
+		}
+
+		// Final Color = ObjectColor * SourceBlendFactor + PixelColor * DestinationBlendFactor
+		Vector4f sourceFactor;
+		Vector4f destFactor;
+
+		blendFactor(sourceFactor, oC, pixel, state.sourceBlendFactor);
+		blendFactor(destFactor, oC, pixel, state.destBlendFactor);
+
+		if(state.sourceBlendFactor != BLEND_ONE && state.sourceBlendFactor != BLEND_ZERO)
+		{
+			oC.x *= sourceFactor.x;
+			oC.y *= sourceFactor.y;
+			oC.z *= sourceFactor.z;
+		}
+
+		if(state.destBlendFactor != BLEND_ONE && state.destBlendFactor != BLEND_ZERO)
+		{
+			pixel.x *= destFactor.x;
+			pixel.y *= destFactor.y;
+			pixel.z *= destFactor.z;
+		}
+
+		switch(state.blendOperation)
+		{
+		case BLENDOP_ADD:
+			oC.x += pixel.x;
+			oC.y += pixel.y;
+			oC.z += pixel.z;
+			break;
+		case BLENDOP_SUB:
+			oC.x -= pixel.x;
+			oC.y -= pixel.y;
+			oC.z -= pixel.z;
+			break;
+		case BLENDOP_INVSUB:
+			oC.x = pixel.x - oC.x;
+			oC.y = pixel.y - oC.y;
+			oC.z = pixel.z - oC.z;
+			break;
+		case BLENDOP_MIN:
+			oC.x = Min(oC.x, pixel.x);
+			oC.y = Min(oC.y, pixel.y);
+			oC.z = Min(oC.z, pixel.z);
+			break;
+		case BLENDOP_MAX:
+			oC.x = Max(oC.x, pixel.x);
+			oC.y = Max(oC.y, pixel.y);
+			oC.z = Max(oC.z, pixel.z);
+			break;
+		case BLENDOP_SOURCE:
+			// No operation
+			break;
+		case BLENDOP_DEST:
+			oC.x = pixel.x;
+			oC.y = pixel.y;
+			oC.z = pixel.z;
+			break;
+		case BLENDOP_NULL:
+			oC.x = Float4(0.0f);
+			oC.y = Float4(0.0f);
+			oC.z = Float4(0.0f);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		blendFactorAlpha(sourceFactor, oC, pixel, state.sourceBlendFactorAlpha);
+		blendFactorAlpha(destFactor, oC, pixel, state.destBlendFactorAlpha);
+
+		if(state.sourceBlendFactorAlpha != BLEND_ONE && state.sourceBlendFactorAlpha != BLEND_ZERO)
+		{
+			oC.w *= sourceFactor.w;
+		}
+
+		if(state.destBlendFactorAlpha != BLEND_ONE && state.destBlendFactorAlpha != BLEND_ZERO)
+		{
+			pixel.w *= destFactor.w;
+		}
+
+		switch(state.blendOperationAlpha)
+		{
+		case BLENDOP_ADD:
+			oC.w += pixel.w;
+			break;
+		case BLENDOP_SUB:
+			oC.w -= pixel.w;
+			break;
+		case BLENDOP_INVSUB:
+			pixel.w -= oC.w;
+			oC.w = pixel.w;
+			break;
+		case BLENDOP_MIN:
+			oC.w = Min(oC.w, pixel.w);
+			break;
+		case BLENDOP_MAX:
+			oC.w = Max(oC.w, pixel.w);
+			break;
+		case BLENDOP_SOURCE:
+			// No operation
+			break;
+		case BLENDOP_DEST:
+			oC.w = pixel.w;
+			break;
+		case BLENDOP_NULL:
+			oC.w = Float4(0.0f);
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelRoutine::writeColor(int index, Pointer<Byte> &cBuffer, Int &x, Vector4f &oC, Int &sMask, Int &zMask, Int &cMask)
+	{
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R32F:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+			break;
+		case FORMAT_G32R32F:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+			oC.z = oC.x;
+			oC.x = UnpackLow(oC.x, oC.y);
+			oC.z = UnpackHigh(oC.z, oC.y);
+			oC.y = oC.z;
+			break;
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+			transpose4x4(oC.x, oC.y, oC.z, oC.w);
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		int rgbaWriteMask = state.colorWriteActive(index);
+
+		Int xMask;   // Combination of all masks
+
+		if(state.depthTestActive)
+		{
+			xMask = zMask;
+		}
+		else
+		{
+			xMask = cMask;
+		}
+
+		if(state.stencilActive)
+		{
+			xMask &= sMask;
+		}
+
+		Pointer<Byte> buffer;
+		Float4 value;
+
+		switch(state.targetFormat[index])
+		{
+		case FORMAT_R32F:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+			if(rgbaWriteMask & 0x00000001)
+			{
+				buffer = cBuffer + 4 * x;
+
+				// FIXME: movlps
+				value.x = *Pointer<Float>(buffer + 0);
+				value.y = *Pointer<Float>(buffer + 4);
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+				// FIXME: movhps
+				value.z = *Pointer<Float>(buffer + 0);
+				value.w = *Pointer<Float>(buffer + 4);
+
+				oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X) + xMask * 16, 16));
+				oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
+
+				// FIXME: movhps
+				*Pointer<Float>(buffer + 0) = oC.x.z;
+				*Pointer<Float>(buffer + 4) = oC.x.w;
+
+				buffer -= *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+				// FIXME: movlps
+				*Pointer<Float>(buffer + 0) = oC.x.x;
+				*Pointer<Float>(buffer + 4) = oC.x.y;
+			}
+			break;
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+			if(rgbaWriteMask & 0x00000001)
+			{
+				buffer = cBuffer + 2 * x;
+
+				UShort4 xyzw;
+				xyzw = As<UShort4>(Insert(As<Int2>(xyzw), *Pointer<Int>(buffer), 0));
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+				xyzw = As<UShort4>(Insert(As<Int2>(xyzw), *Pointer<Int>(buffer), 1));
+				value = As<Float4>(Int4(xyzw));
+
+				oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants, maskD4X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants, invMaskD4X) + xMask * 16, 16));
+				oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
+
+				if(state.targetFormat[index] == FORMAT_R16I)
+				{
+					Float component = oC.x.z;
+					*Pointer<Short>(buffer + 0) = Short(As<Int>(component));
+					component = oC.x.w;
+					*Pointer<Short>(buffer + 2) = Short(As<Int>(component));
+
+					buffer -= *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+					component = oC.x.x;
+					*Pointer<Short>(buffer + 0) = Short(As<Int>(component));
+					component = oC.x.y;
+					*Pointer<Short>(buffer + 2) = Short(As<Int>(component));
+				}
+				else // FORMAT_R16UI
+				{
+					Float component = oC.x.z;
+					*Pointer<UShort>(buffer + 0) = UShort(As<Int>(component));
+					component = oC.x.w;
+					*Pointer<UShort>(buffer + 2) = UShort(As<Int>(component));
+
+					buffer -= *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+					component = oC.x.x;
+					*Pointer<UShort>(buffer + 0) = UShort(As<Int>(component));
+					component = oC.x.y;
+					*Pointer<UShort>(buffer + 2) = UShort(As<Int>(component));
+				}
+			}
+			break;
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+			if(rgbaWriteMask & 0x00000001)
+			{
+				buffer = cBuffer + x;
+
+				UInt xyzw, packedCol;
+
+				xyzw = UInt(*Pointer<UShort>(buffer)) & 0xFFFF;
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				xyzw |= UInt(*Pointer<UShort>(buffer)) << 16;
+
+				Short4 tmpCol = Short4(As<Int4>(oC.x));
+				if(state.targetFormat[index] == FORMAT_R8I)
+				{
+					tmpCol = As<Short4>(PackSigned(tmpCol, tmpCol));
+				}
+				else
+				{
+					tmpCol = As<Short4>(PackUnsigned(tmpCol, tmpCol));
+				}
+				packedCol = Extract(As<Int2>(tmpCol), 0);
+
+				packedCol = (packedCol & *Pointer<UInt>(constants + OFFSET(Constants, maskB4Q) + 8 * xMask)) |
+				            (xyzw & *Pointer<UInt>(constants + OFFSET(Constants, invMaskB4Q) + 8 * xMask));
+
+				*Pointer<UShort>(buffer) = UShort(packedCol >> 16);
+				buffer -= *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				*Pointer<UShort>(buffer) = UShort(packedCol);
+			}
+			break;
+		case FORMAT_G32R32F:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+			buffer = cBuffer + 8 * x;
+
+			value = *Pointer<Float4>(buffer);
+
+			if((rgbaWriteMask & 0x00000003) != 0x00000003)
+			{
+				Float4 masked = value;
+				oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
+				masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,maskD01X[~rgbaWriteMask & 0x3][0])));
+				oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(masked));
+			}
+
+			oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants,maskQ01X) + xMask * 16, 16));
+			value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskQ01X) + xMask * 16, 16));
+			oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
+			*Pointer<Float4>(buffer) = oC.x;
+
+			buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+			value = *Pointer<Float4>(buffer);
+
+			if((rgbaWriteMask & 0x00000003) != 0x00000003)
+			{
+				Float4 masked;
+
+				masked = value;
+				oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(constants + OFFSET(Constants,maskD01X[rgbaWriteMask & 0x3][0])));
+				masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,maskD01X[~rgbaWriteMask & 0x3][0])));
+				oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(masked));
+			}
+
+			oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(constants + OFFSET(Constants,maskQ23X) + xMask * 16, 16));
+			value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskQ23X) + xMask * 16, 16));
+			oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(value));
+			*Pointer<Float4>(buffer) = oC.y;
+			break;
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+			if((rgbaWriteMask & 0x00000003) != 0x0)
+			{
+				buffer = cBuffer + 4 * x;
+
+				UInt2 rgbaMask;
+				UShort4 packedCol = UShort4(As<Int4>(oC.x));
+				UShort4 value = *Pointer<UShort4>(buffer);
+				UInt2 mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskD01Q) + xMask * 8);
+				if((rgbaWriteMask & 0x3) != 0x3)
+				{
+					Int tmpMask = *Pointer<Int>(constants + OFFSET(Constants, maskW4Q[rgbaWriteMask & 0x3][0]));
+					rgbaMask = As<UInt2>(Int2(tmpMask, tmpMask));
+					mergedMask &= rgbaMask;
+				}
+				*Pointer<UInt2>(buffer) = (As<UInt2>(packedCol) & mergedMask) | (As<UInt2>(value) & ~mergedMask);
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+				packedCol = UShort4(As<Int4>(oC.y));
+				value = *Pointer<UShort4>(buffer);
+				mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskD23Q) + xMask * 8);
+				if((rgbaWriteMask & 0x3) != 0x3)
+				{
+					mergedMask &= rgbaMask;
+				}
+				*Pointer<UInt2>(buffer) = (As<UInt2>(packedCol) & mergedMask) | (As<UInt2>(value) & ~mergedMask);
+			}
+			break;
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+			if((rgbaWriteMask & 0x00000003) != 0x0)
+			{
+				buffer = cBuffer + 2 * x;
+
+				Int2 xyzw, packedCol;
+
+				xyzw = Insert(xyzw, *Pointer<Int>(buffer), 0);
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				xyzw = Insert(xyzw, *Pointer<Int>(buffer), 1);
+
+				if(state.targetFormat[index] == FORMAT_G8R8I)
+				{
+					packedCol = As<Int2>(PackSigned(Short4(As<Int4>(oC.x)), Short4(As<Int4>(oC.y))));
+				}
+				else
+				{
+					packedCol = As<Int2>(PackUnsigned(Short4(As<Int4>(oC.x)), Short4(As<Int4>(oC.y))));
+				}
+
+				UInt2 mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskW4Q) + xMask * 8);
+				if((rgbaWriteMask & 0x3) != 0x3)
+				{
+					Int tmpMask = *Pointer<Int>(constants + OFFSET(Constants, maskB4Q[5 * (rgbaWriteMask & 0x3)][0]));
+					UInt2 rgbaMask = As<UInt2>(Int2(tmpMask, tmpMask));
+					mergedMask &= rgbaMask;
+				}
+
+				packedCol = As<Int2>((As<UInt2>(packedCol) & mergedMask) | (As<UInt2>(xyzw) & ~mergedMask));
+
+				*Pointer<UInt>(buffer) = As<UInt>(Extract(packedCol, 1));
+				buffer -= *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+				*Pointer<UInt>(buffer) = As<UInt>(Extract(packedCol, 0));
+			}
+			break;
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			buffer = cBuffer + 16 * x;
+
+			{
+				value = *Pointer<Float4>(buffer, 16);
+
+				if(rgbaWriteMask != 0x0000000F)
+				{
+					Float4 masked = value;
+					oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+					masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+					oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(masked));
+				}
+
+				oC.x = As<Float4>(As<Int4>(oC.x) & *Pointer<Int4>(constants + OFFSET(Constants,maskX0X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskX0X) + xMask * 16, 16));
+				oC.x = As<Float4>(As<Int4>(oC.x) | As<Int4>(value));
+				*Pointer<Float4>(buffer, 16) = oC.x;
+			}
+
+			{
+				value = *Pointer<Float4>(buffer + 16, 16);
+
+				if(rgbaWriteMask != 0x0000000F)
+				{
+					Float4 masked = value;
+					oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+					masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+					oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(masked));
+				}
+
+				oC.y = As<Float4>(As<Int4>(oC.y) & *Pointer<Int4>(constants + OFFSET(Constants,maskX1X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskX1X) + xMask * 16, 16));
+				oC.y = As<Float4>(As<Int4>(oC.y) | As<Int4>(value));
+				*Pointer<Float4>(buffer + 16, 16) = oC.y;
+			}
+
+			buffer += *Pointer<Int>(data + OFFSET(DrawData,colorPitchB[index]));
+
+			{
+				value = *Pointer<Float4>(buffer, 16);
+
+				if(rgbaWriteMask != 0x0000000F)
+				{
+					Float4 masked = value;
+					oC.z = As<Float4>(As<Int4>(oC.z) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+					masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+					oC.z = As<Float4>(As<Int4>(oC.z) | As<Int4>(masked));
+				}
+
+				oC.z = As<Float4>(As<Int4>(oC.z) & *Pointer<Int4>(constants + OFFSET(Constants,maskX2X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskX2X) + xMask * 16, 16));
+				oC.z = As<Float4>(As<Int4>(oC.z) | As<Int4>(value));
+				*Pointer<Float4>(buffer, 16) = oC.z;
+			}
+
+			{
+				value = *Pointer<Float4>(buffer + 16, 16);
+
+				if(rgbaWriteMask != 0x0000000F)
+				{
+					Float4 masked = value;
+					oC.w = As<Float4>(As<Int4>(oC.w) & *Pointer<Int4>(constants + OFFSET(Constants,maskD4X[rgbaWriteMask][0])));
+					masked = As<Float4>(As<Int4>(masked) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskD4X[rgbaWriteMask][0])));
+					oC.w = As<Float4>(As<Int4>(oC.w) | As<Int4>(masked));
+				}
+
+				oC.w = As<Float4>(As<Int4>(oC.w) & *Pointer<Int4>(constants + OFFSET(Constants,maskX3X) + xMask * 16, 16));
+				value = As<Float4>(As<Int4>(value) & *Pointer<Int4>(constants + OFFSET(Constants,invMaskX3X) + xMask * 16, 16));
+				oC.w = As<Float4>(As<Int4>(oC.w) | As<Int4>(value));
+				*Pointer<Float4>(buffer + 16, 16) = oC.w;
+			}
+			break;
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+			if((rgbaWriteMask & 0x0000000F) != 0x0)
+			{
+				buffer = cBuffer + 8 * x;
+
+				UInt4 rgbaMask;
+				UShort8 value = *Pointer<UShort8>(buffer);
+				UShort8 packedCol = UShort8(UShort4(As<Int4>(oC.x)), UShort4(As<Int4>(oC.y)));
+				UInt4 mergedMask = *Pointer<UInt4>(constants + OFFSET(Constants, maskQ01X) + xMask * 16);
+				if((rgbaWriteMask & 0xF) != 0xF)
+				{
+					UInt2 tmpMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskW4Q[rgbaWriteMask][0]));
+					rgbaMask = UInt4(tmpMask, tmpMask);
+					mergedMask &= rgbaMask;
+				}
+				*Pointer<UInt4>(buffer) = (As<UInt4>(packedCol) & mergedMask) | (As<UInt4>(value) & ~mergedMask);
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+				value = *Pointer<UShort8>(buffer);
+				packedCol = UShort8(UShort4(As<Int4>(oC.z)), UShort4(As<Int4>(oC.w)));
+				mergedMask = *Pointer<UInt4>(constants + OFFSET(Constants, maskQ23X) + xMask * 16);
+				if((rgbaWriteMask & 0xF) != 0xF)
+				{
+					mergedMask &= rgbaMask;
+				}
+				*Pointer<UInt4>(buffer) = (As<UInt4>(packedCol) & mergedMask) | (As<UInt4>(value) & ~mergedMask);
+			}
+			break;
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+			if((rgbaWriteMask & 0x0000000F) != 0x0)
+			{
+				UInt2 value, packedCol, mergedMask;
+
+				buffer = cBuffer + 4 * x;
+
+				if(state.targetFormat[index] == FORMAT_A8B8G8R8I)
+				{
+					packedCol = As<UInt2>(PackSigned(Short4(As<Int4>(oC.x)), Short4(As<Int4>(oC.y))));
+				}
+				else
+				{
+					packedCol = As<UInt2>(PackUnsigned(Short4(As<Int4>(oC.x)), Short4(As<Int4>(oC.y))));
+				}
+				value = *Pointer<UInt2>(buffer, 16);
+				mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskD01Q) + xMask * 8);
+				if(rgbaWriteMask != 0xF)
+				{
+					mergedMask &= *Pointer<UInt2>(constants + OFFSET(Constants, maskB4Q[rgbaWriteMask][0]));
+				}
+				*Pointer<UInt2>(buffer) = (packedCol & mergedMask) | (value & ~mergedMask);
+
+				buffer += *Pointer<Int>(data + OFFSET(DrawData, colorPitchB[index]));
+
+				if(state.targetFormat[index] == FORMAT_A8B8G8R8I)
+				{
+					packedCol = As<UInt2>(PackSigned(Short4(As<Int4>(oC.z)), Short4(As<Int4>(oC.w))));
+				}
+				else
+				{
+					packedCol = As<UInt2>(PackUnsigned(Short4(As<Int4>(oC.z)), Short4(As<Int4>(oC.w))));
+				}
+				value = *Pointer<UInt2>(buffer, 16);
+				mergedMask = *Pointer<UInt2>(constants + OFFSET(Constants, maskD23Q) + xMask * 8);
+				if(rgbaWriteMask != 0xF)
+				{
+					mergedMask &= *Pointer<UInt2>(constants + OFFSET(Constants, maskB4Q[rgbaWriteMask][0]));
+				}
+				*Pointer<UInt2>(buffer) = (packedCol & mergedMask) | (value & ~mergedMask);
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	UShort4 PixelRoutine::convertFixed16(Float4 &cf, bool saturate)
+	{
+		return UShort4(cf * Float4(0xFFFF), saturate);
+	}
+
+	void PixelRoutine::sRGBtoLinear16_12_16(Vector4s &c)
+	{
+		Pointer<Byte> LUT = constants + OFFSET(Constants,sRGBtoLinear12_16);
+
+		c.x = As<UShort4>(c.x) >> 4;
+		c.y = As<UShort4>(c.y) >> 4;
+		c.z = As<UShort4>(c.z) >> 4;
+
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 0))), 0);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 1))), 1);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 2))), 2);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 3))), 3);
+
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 0))), 0);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 1))), 1);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 2))), 2);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 3))), 3);
+
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 0))), 0);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 1))), 1);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 2))), 2);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 3))), 3);
+	}
+
+	void PixelRoutine::linearToSRGB16_12_16(Vector4s &c)
+	{
+		c.x = As<UShort4>(c.x) >> 4;
+		c.y = As<UShort4>(c.y) >> 4;
+		c.z = As<UShort4>(c.z) >> 4;
+
+		linearToSRGB12_16(c);
+	}
+
+	void PixelRoutine::linearToSRGB12_16(Vector4s &c)
+	{
+		Pointer<Byte> LUT = constants + OFFSET(Constants,linearToSRGB12_16);
+
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 0))), 0);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 1))), 1);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 2))), 2);
+		c.x = Insert(c.x, *Pointer<Short>(LUT + 2 * Int(Extract(c.x, 3))), 3);
+
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 0))), 0);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 1))), 1);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 2))), 2);
+		c.y = Insert(c.y, *Pointer<Short>(LUT + 2 * Int(Extract(c.y, 3))), 3);
+
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 0))), 0);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 1))), 1);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 2))), 2);
+		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 3))), 3);
+	}
+
+	Float4 PixelRoutine::sRGBtoLinear(const Float4 &x)   // Approximates x^2.2
+	{
+		Float4 linear = x * x;
+		linear = linear * Float4(0.73f) + linear * x * Float4(0.27f);
+
+		return Min(Max(linear, Float4(0.0f)), Float4(1.0f));
+	}
+
+	bool PixelRoutine::colorUsed()
+	{
+		return state.colorWriteMask || state.alphaTestActive() || state.shaderContainsKill;
+	}
+}
diff --git a/src/Pipeline/PixelRoutine.hpp b/src/Pipeline/PixelRoutine.hpp
new file mode 100644
index 0000000..1cd076e
--- /dev/null
+++ b/src/Pipeline/PixelRoutine.hpp
@@ -0,0 +1,93 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_PixelRoutine_hpp
+#define sw_PixelRoutine_hpp
+
+#include "Renderer/QuadRasterizer.hpp"
+
+namespace sw
+{
+	class PixelShader;
+	class SamplerCore;
+
+	class PixelRoutine : public sw::QuadRasterizer, public ShaderCore
+	{
+	public:
+		PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader);
+
+		virtual ~PixelRoutine();
+
+	protected:
+		Float4 z[4]; // Multisampled z
+		Float4 w;    // Used as is
+		Float4 rhw;  // Reciprocal w
+
+		RegisterArray<MAX_FRAGMENT_INPUTS> v;   // Varying registers
+
+		// Depth output
+		Float4 oDepth;
+
+		typedef Shader::SourceParameter Src;
+		typedef Shader::DestinationParameter Dst;
+
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w) = 0;
+		virtual void applyShader(Int cMask[4]) = 0;
+		virtual Bool alphaTest(Int cMask[4]) = 0;
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]) = 0;
+
+		virtual void quad(Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
+
+		void alphaTest(Int &aMask, Short4 &alpha);
+		void alphaToCoverage(Int cMask[4], Float4 &alpha);
+		void fogBlend(Vector4f &c0, Float4 &fog);
+		void pixelFog(Float4 &visibility);
+
+		// Raster operations
+		void alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
+		void logicOperation(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
+		void writeColor(int index, Pointer<Byte> &cBuffer, Int &i, Vector4s &current, Int &sMask, Int &zMask, Int &cMask);
+		void alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4f &oC, Int &x);
+		void writeColor(int index, Pointer<Byte> &cBuffer, Int &i, Vector4f &oC, Int &sMask, Int &zMask, Int &cMask);
+
+		bool isSRGB(int index) const;
+		UShort4 convertFixed16(Float4 &cf, bool saturate = true);
+		void linearToSRGB12_16(Vector4s &c);
+
+	private:
+		Float4 interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+		void stencilTest(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask);
+		void stencilTest(Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW);
+		void stencilOperation(Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
+		void stencilOperation(Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW);
+		Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
+
+		// Raster operations
+		void blendFactor(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
+		void readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel);
+		void blendFactor(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
+		void writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
+		void writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);
+
+		void sRGBtoLinear16_12_16(Vector4s &c);
+		void linearToSRGB16_12_16(Vector4s &c);
+		Float4 sRGBtoLinear(const Float4 &x);
+
+		bool colorUsed();
+	};
+}
+
+#endif   // sw_PixelRoutine_hpp
diff --git a/src/Pipeline/PixelShader.cpp b/src/Pipeline/PixelShader.cpp
new file mode 100644
index 0000000..d24e7c2
--- /dev/null
+++ b/src/Pipeline/PixelShader.cpp
@@ -0,0 +1,746 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "PixelShader.hpp"
+
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	PixelShader::PixelShader(const PixelShader *ps) : Shader()
+	{
+		shaderModel = 0x0300;
+		vPosDeclared = false;
+		vFaceDeclared = false;
+		centroid = false;
+
+		if(ps)   // Make a copy
+		{
+			for(size_t i = 0; i < ps->getLength(); i++)
+			{
+				append(new sw::Shader::Instruction(*ps->getInstruction(i)));
+			}
+
+			memcpy(input, ps->input, sizeof(input));
+			vPosDeclared = ps->vPosDeclared;
+			vFaceDeclared = ps->vFaceDeclared;
+			usedSamplers = ps->usedSamplers;
+
+			optimize();
+			analyze();
+		}
+	}
+
+	PixelShader::PixelShader(const unsigned long *token) : Shader()
+	{
+		parse(token);
+
+		vPosDeclared = false;
+		vFaceDeclared = false;
+		centroid = false;
+
+		optimize();
+		analyze();
+	}
+
+	PixelShader::~PixelShader()
+	{
+	}
+
+	int PixelShader::validate(const unsigned long *const token)
+	{
+		if(!token)
+		{
+			return 0;
+		}
+
+		unsigned short version = (unsigned short)(token[0] & 0x0000FFFF);
+		// unsigned char minorVersion = (unsigned char)(token[0] & 0x000000FF);
+		unsigned char majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+		ShaderType shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+		if(shaderType != SHADER_PIXEL || majorVersion > 3)
+		{
+			return 0;
+		}
+
+		int instructionCount = 1;
+
+		for(int i = 0; token[i] != 0x0000FFFF; i++)
+		{
+			if((token[i] & 0x0000FFFF) == 0x0000FFFE)   // Comment token
+			{
+				int length = (token[i] & 0x7FFF0000) >> 16;
+
+				i += length;
+			}
+			else
+			{
+				Shader::Opcode opcode = (Shader::Opcode)(token[i] & 0x0000FFFF);
+
+				switch(opcode)
+				{
+				case Shader::OPCODE_RESERVED0:
+				case Shader::OPCODE_MOVA:
+					return 0;   // Unsupported operation
+				default:
+					instructionCount++;
+					break;
+				}
+
+				i += size(token[i], version);
+			}
+		}
+
+		return instructionCount;
+	}
+
+	bool PixelShader::depthOverride() const
+	{
+		return zOverride;
+	}
+
+	bool PixelShader::containsKill() const
+	{
+		return kill;
+	}
+
+	bool PixelShader::containsCentroid() const
+	{
+		return centroid;
+	}
+
+	bool PixelShader::usesDiffuse(int component) const
+	{
+		return input[0][component].active();
+	}
+
+	bool PixelShader::usesSpecular(int component) const
+	{
+		return input[1][component].active();
+	}
+
+	bool PixelShader::usesTexture(int coordinate, int component) const
+	{
+		return input[2 + coordinate][component].active();
+	}
+
+	void PixelShader::setInput(int inputIdx, int nbComponents, const sw::Shader::Semantic& semantic)
+	{
+		for(int i = 0; i < nbComponents; ++i)
+		{
+			input[inputIdx][i] = semantic;
+		}
+	}
+
+	const sw::Shader::Semantic& PixelShader::getInput(int inputIdx, int component) const
+	{
+		return input[inputIdx][component];
+	}
+
+	void PixelShader::analyze()
+	{
+		analyzeZOverride();
+		analyzeKill();
+		analyzeInterpolants();
+		analyzeDirtyConstants();
+		analyzeDynamicBranching();
+		analyzeSamplers();
+		analyzeCallSites();
+		analyzeIndirectAddressing();
+	}
+
+	void PixelShader::analyzeZOverride()
+	{
+		zOverride = false;
+
+		for(const auto &inst : instruction)
+		{
+			if(inst->opcode == Shader::OPCODE_TEXM3X2DEPTH ||
+			   inst->opcode == Shader::OPCODE_TEXDEPTH ||
+			   inst->dst.type == Shader::PARAMETER_DEPTHOUT)
+			{
+				zOverride = true;
+
+				break;
+			}
+		}
+	}
+
+	void PixelShader::analyzeKill()
+	{
+		kill = false;
+
+		for(const auto &inst : instruction)
+		{
+			if(inst->opcode == Shader::OPCODE_TEXKILL ||
+			   inst->opcode == Shader::OPCODE_DISCARD)
+			{
+				kill = true;
+
+				break;
+			}
+		}
+	}
+
+	void PixelShader::analyzeInterpolants()
+	{
+		if(shaderModel < 0x0300)
+		{
+			// Set default mapping; disable unused interpolants below
+			input[0][0] = Semantic(Shader::USAGE_COLOR, 0);
+			input[0][1] = Semantic(Shader::USAGE_COLOR, 0);
+			input[0][2] = Semantic(Shader::USAGE_COLOR, 0);
+			input[0][3] = Semantic(Shader::USAGE_COLOR, 0);
+
+			input[1][0] = Semantic(Shader::USAGE_COLOR, 1);
+			input[1][1] = Semantic(Shader::USAGE_COLOR, 1);
+			input[1][2] = Semantic(Shader::USAGE_COLOR, 1);
+			input[1][3] = Semantic(Shader::USAGE_COLOR, 1);
+
+			for(int i = 0; i < 8; i++)
+			{
+				input[2 + i][0] = Semantic(Shader::USAGE_TEXCOORD, i);
+				input[2 + i][1] = Semantic(Shader::USAGE_TEXCOORD, i);
+				input[2 + i][2] = Semantic(Shader::USAGE_TEXCOORD, i);
+				input[2 + i][3] = Semantic(Shader::USAGE_TEXCOORD, i);
+			}
+
+			Shader::SamplerType samplerType[16];
+
+			for(int i = 0; i < 16; i++)
+			{
+				samplerType[i] = Shader::SAMPLER_UNKNOWN;
+			}
+
+			for(const auto &inst : instruction)
+			{
+				if(inst->dst.type == Shader::PARAMETER_SAMPLER)
+				{
+					int sampler = inst->dst.index;
+
+					samplerType[sampler] = inst->samplerType;
+				}
+			}
+
+			bool interpolant[MAX_FRAGMENT_INPUTS][4] = {{false}};   // Interpolants in use
+
+			for(const auto &inst : instruction)
+			{
+				if(inst->dst.type == Shader::PARAMETER_TEXTURE)
+				{
+					int index = inst->dst.index + 2;
+
+					switch(inst->opcode)
+					{
+					case Shader::OPCODE_TEX:
+					case Shader::OPCODE_TEXBEM:
+					case Shader::OPCODE_TEXBEML:
+					case Shader::OPCODE_TEXCOORD:
+					case Shader::OPCODE_TEXDP3:
+					case Shader::OPCODE_TEXDP3TEX:
+					case Shader::OPCODE_TEXM3X2DEPTH:
+					case Shader::OPCODE_TEXM3X2PAD:
+					case Shader::OPCODE_TEXM3X2TEX:
+					case Shader::OPCODE_TEXM3X3:
+					case Shader::OPCODE_TEXM3X3PAD:
+					case Shader::OPCODE_TEXM3X3TEX:
+						interpolant[index][0] = true;
+						interpolant[index][1] = true;
+						interpolant[index][2] = true;
+						break;
+					case Shader::OPCODE_TEXKILL:
+						if(majorVersion < 2)
+						{
+							interpolant[index][0] = true;
+							interpolant[index][1] = true;
+							interpolant[index][2] = true;
+						}
+						else
+						{
+							interpolant[index][0] = true;
+							interpolant[index][1] = true;
+							interpolant[index][2] = true;
+							interpolant[index][3] = true;
+						}
+						break;
+					case Shader::OPCODE_TEXM3X3VSPEC:
+						interpolant[index][0] = true;
+						interpolant[index][1] = true;
+						interpolant[index][2] = true;
+						interpolant[index - 2][3] = true;
+						interpolant[index - 1][3] = true;
+						interpolant[index - 0][3] = true;
+						break;
+					case Shader::OPCODE_DCL:
+						break;   // Ignore
+					default:   // Arithmetic instruction
+						if(shaderModel >= 0x0104)
+						{
+							ASSERT(false);
+						}
+					}
+				}
+
+				for(int argument = 0; argument < 4; argument++)
+				{
+					if(inst->src[argument].type == Shader::PARAMETER_INPUT ||
+					   inst->src[argument].type == Shader::PARAMETER_TEXTURE)
+					{
+						int index = inst->src[argument].index;
+						int swizzle = inst->src[argument].swizzle;
+						int mask = inst->dst.mask;
+
+						if(inst->src[argument].type == Shader::PARAMETER_TEXTURE)
+						{
+							index += 2;
+						}
+
+						switch(inst->opcode)
+						{
+						case Shader::OPCODE_TEX:
+						case Shader::OPCODE_TEXLDD:
+						case Shader::OPCODE_TEXLDL:
+						case Shader::OPCODE_TEXLOD:
+						case Shader::OPCODE_TEXBIAS:
+						case Shader::OPCODE_TEXOFFSET:
+						case Shader::OPCODE_TEXOFFSETBIAS:
+						case Shader::OPCODE_TEXLODOFFSET:
+						case Shader::OPCODE_TEXELFETCH:
+						case Shader::OPCODE_TEXELFETCHOFFSET:
+						case Shader::OPCODE_TEXGRAD:
+						case Shader::OPCODE_TEXGRADOFFSET:
+							{
+								int sampler = inst->src[1].index;
+
+								switch(samplerType[sampler])
+								{
+								case Shader::SAMPLER_UNKNOWN:
+									if(shaderModel == 0x0104)
+									{
+										if((inst->src[0].swizzle & 0x30) == 0x20)   // .xyz
+										{
+											interpolant[index][0] = true;
+											interpolant[index][1] = true;
+											interpolant[index][2] = true;
+										}
+										else   // .xyw
+										{
+											interpolant[index][0] = true;
+											interpolant[index][1] = true;
+											interpolant[index][3] = true;
+										}
+									}
+									else
+									{
+										ASSERT(false);
+									}
+									break;
+								case Shader::SAMPLER_1D:
+									interpolant[index][0] = true;
+									break;
+								case Shader::SAMPLER_2D:
+									interpolant[index][0] = true;
+									interpolant[index][1] = true;
+									break;
+								case Shader::SAMPLER_CUBE:
+									interpolant[index][0] = true;
+									interpolant[index][1] = true;
+									interpolant[index][2] = true;
+									break;
+								case Shader::SAMPLER_VOLUME:
+									interpolant[index][0] = true;
+									interpolant[index][1] = true;
+									interpolant[index][2] = true;
+									break;
+								default:
+									ASSERT(false);
+								}
+
+								if(inst->bias)
+								{
+									interpolant[index][3] = true;
+								}
+
+								if(inst->project)
+								{
+									interpolant[index][3] = true;
+								}
+
+								if(shaderModel == 0x0104 && inst->opcode == Shader::OPCODE_TEX)
+								{
+									if(inst->src[0].modifier == Shader::MODIFIER_DZ)
+									{
+										interpolant[index][2] = true;
+									}
+
+									if(inst->src[0].modifier == Shader::MODIFIER_DW)
+									{
+										interpolant[index][3] = true;
+									}
+								}
+							}
+							break;
+						case Shader::OPCODE_M3X2:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+							}
+
+							if(argument == 1)
+							{
+								if(mask & 0x2)
+								{
+									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+							}
+							break;
+						case Shader::OPCODE_M3X3:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+							}
+
+							if(argument == 1)
+							{
+								if(mask & 0x2)
+								{
+									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+
+								if(mask & 0x4)
+								{
+									interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+							}
+							break;
+						case Shader::OPCODE_M3X4:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+							}
+
+							if(argument == 1)
+							{
+								if(mask & 0x2)
+								{
+									interpolant[index + 1][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 1][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 1][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 1][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+
+								if(mask & 0x4)
+								{
+									interpolant[index + 2][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 2][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 2][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 2][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+
+								if(mask & 0x8)
+								{
+									interpolant[index + 3][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+									interpolant[index + 3][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+									interpolant[index + 3][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+									interpolant[index + 3][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+								}
+							}
+							break;
+						case Shader::OPCODE_M4X3:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+							}
+
+							if(argument == 1)
+							{
+								if(mask & 0x2)
+								{
+									interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
+									interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
+									interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
+									interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
+								}
+
+								if(mask & 0x4)
+								{
+									interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
+									interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
+									interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
+									interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
+								}
+							}
+							break;
+						case Shader::OPCODE_M4X4:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+							}
+
+							if(argument == 1)
+							{
+								if(mask & 0x2)
+								{
+									interpolant[index + 1][0] |= swizzleContainsComponent(swizzle, 0);
+									interpolant[index + 1][1] |= swizzleContainsComponent(swizzle, 1);
+									interpolant[index + 1][2] |= swizzleContainsComponent(swizzle, 2);
+									interpolant[index + 1][3] |= swizzleContainsComponent(swizzle, 3);
+								}
+
+								if(mask & 0x4)
+								{
+									interpolant[index + 2][0] |= swizzleContainsComponent(swizzle, 0);
+									interpolant[index + 2][1] |= swizzleContainsComponent(swizzle, 1);
+									interpolant[index + 2][2] |= swizzleContainsComponent(swizzle, 2);
+									interpolant[index + 2][3] |= swizzleContainsComponent(swizzle, 3);
+								}
+
+								if(mask & 0x8)
+								{
+									interpolant[index + 3][0] |= swizzleContainsComponent(swizzle, 0);
+									interpolant[index + 3][1] |= swizzleContainsComponent(swizzle, 1);
+									interpolant[index + 3][2] |= swizzleContainsComponent(swizzle, 2);
+									interpolant[index + 3][3] |= swizzleContainsComponent(swizzle, 3);
+								}
+							}
+							break;
+						case Shader::OPCODE_CRS:
+							if(mask & 0x1)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x6);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x6);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x6);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x6);
+							}
+
+							if(mask & 0x2)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x5);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x5);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x5);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x5);
+							}
+
+							if(mask & 0x4)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
+							}
+							break;
+						case Shader::OPCODE_DP2ADD:
+							if(argument == 0 || argument == 1)
+							{
+								interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x3);
+								interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x3);
+								interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x3);
+								interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x3);
+							}
+							else   // argument == 2
+							{
+								interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+								interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+								interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+								interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+							}
+							break;
+						case Shader::OPCODE_DP3:
+							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7);
+							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7);
+							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7);
+							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7);
+							break;
+						case Shader::OPCODE_DP4:
+							interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+							interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+							interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+							interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+							break;
+						case Shader::OPCODE_SINCOS:
+						case Shader::OPCODE_EXP2X:
+						case Shader::OPCODE_LOG2X:
+						case Shader::OPCODE_POWX:
+						case Shader::OPCODE_RCPX:
+						case Shader::OPCODE_RSQX:
+							interpolant[index][0] |= swizzleContainsComponent(swizzle, 0);
+							interpolant[index][1] |= swizzleContainsComponent(swizzle, 1);
+							interpolant[index][2] |= swizzleContainsComponent(swizzle, 2);
+							interpolant[index][3] |= swizzleContainsComponent(swizzle, 3);
+							break;
+						case Shader::OPCODE_NRM3:
+							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, 0x7 | mask);
+							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, 0x7 | mask);
+							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, 0x7 | mask);
+							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, 0x7 | mask);
+							break;
+						case Shader::OPCODE_MOV:
+						case Shader::OPCODE_ADD:
+						case Shader::OPCODE_SUB:
+						case Shader::OPCODE_MUL:
+						case Shader::OPCODE_MAD:
+						case Shader::OPCODE_ABS:
+						case Shader::OPCODE_CMP0:
+						case Shader::OPCODE_CND:
+						case Shader::OPCODE_FRC:
+						case Shader::OPCODE_LRP:
+						case Shader::OPCODE_MAX:
+						case Shader::OPCODE_MIN:
+						case Shader::OPCODE_CMP:
+						case Shader::OPCODE_BREAKC:
+						case Shader::OPCODE_DFDX:
+						case Shader::OPCODE_DFDY:
+							interpolant[index][0] |= swizzleContainsComponentMasked(swizzle, 0, mask);
+							interpolant[index][1] |= swizzleContainsComponentMasked(swizzle, 1, mask);
+							interpolant[index][2] |= swizzleContainsComponentMasked(swizzle, 2, mask);
+							interpolant[index][3] |= swizzleContainsComponentMasked(swizzle, 3, mask);
+							break;
+						case Shader::OPCODE_TEXCOORD:
+							interpolant[index][0] = true;
+							interpolant[index][1] = true;
+							interpolant[index][2] = true;
+							interpolant[index][3] = true;
+							break;
+						case Shader::OPCODE_TEXDP3:
+						case Shader::OPCODE_TEXDP3TEX:
+						case Shader::OPCODE_TEXM3X2PAD:
+						case Shader::OPCODE_TEXM3X3PAD:
+						case Shader::OPCODE_TEXM3X2TEX:
+						case Shader::OPCODE_TEXM3X3SPEC:
+						case Shader::OPCODE_TEXM3X3VSPEC:
+						case Shader::OPCODE_TEXBEM:
+						case Shader::OPCODE_TEXBEML:
+						case Shader::OPCODE_TEXM3X2DEPTH:
+						case Shader::OPCODE_TEXM3X3:
+						case Shader::OPCODE_TEXM3X3TEX:
+							interpolant[index][0] = true;
+							interpolant[index][1] = true;
+							interpolant[index][2] = true;
+							break;
+						case Shader::OPCODE_TEXREG2AR:
+						case Shader::OPCODE_TEXREG2GB:
+						case Shader::OPCODE_TEXREG2RGB:
+							break;
+						default:
+						//	ASSERT(false);   // Refine component usage
+							interpolant[index][0] = true;
+							interpolant[index][1] = true;
+							interpolant[index][2] = true;
+							interpolant[index][3] = true;
+						}
+					}
+				}
+			}
+
+			for(int index = 0; index < MAX_FRAGMENT_INPUTS; index++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					if(!interpolant[index][component])
+					{
+						input[index][component] = Semantic();
+					}
+				}
+			}
+		}
+		else   // Shader Model 3.0 input declaration; v# indexable
+		{
+			for(const auto &inst : instruction)
+			{
+				if(inst->opcode == Shader::OPCODE_DCL)
+				{
+					if(inst->dst.type == Shader::PARAMETER_INPUT)
+					{
+						unsigned char usage = inst->usage;
+						unsigned char index = inst->usageIndex;
+						unsigned char mask = inst->dst.mask;
+						unsigned char reg = inst->dst.index;
+
+						if(mask & 0x01) input[reg][0] = Semantic(usage, index);
+						if(mask & 0x02) input[reg][1] = Semantic(usage, index);
+						if(mask & 0x04) input[reg][2] = Semantic(usage, index);
+						if(mask & 0x08) input[reg][3] = Semantic(usage, index);
+					}
+					else if(inst->dst.type == Shader::PARAMETER_MISCTYPE)
+					{
+						unsigned char index = inst->dst.index;
+
+						if(index == Shader::VPosIndex)
+						{
+							vPosDeclared = true;
+						}
+						else if(index == Shader::VFaceIndex)
+						{
+							vFaceDeclared = true;
+						}
+						else ASSERT(false);
+					}
+				}
+			}
+		}
+
+		if(shaderModel >= 0x0200)
+		{
+			for(const auto &inst : instruction)
+			{
+				if(inst->opcode == Shader::OPCODE_DCL)
+				{
+					bool centroid = inst->dst.centroid;
+					unsigned char reg = inst->dst.index;
+
+					switch(inst->dst.type)
+					{
+					case Shader::PARAMETER_INPUT:
+						input[reg][0].centroid = centroid;
+						break;
+					case Shader::PARAMETER_TEXTURE:
+						input[2 + reg][0].centroid = centroid;
+						break;
+					default:
+						break;
+					}
+
+					this->centroid = this->centroid || centroid;
+				}
+			}
+		}
+	}
+}
diff --git a/src/Pipeline/PixelShader.hpp b/src/Pipeline/PixelShader.hpp
new file mode 100644
index 0000000..a06aaaa
--- /dev/null
+++ b/src/Pipeline/PixelShader.hpp
@@ -0,0 +1,63 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_PixelShader_hpp
+#define sw_PixelShader_hpp
+
+#include "Shader.hpp"
+#include "Main/Config.hpp"
+
+namespace sw
+{
+	class PixelShader : public Shader
+	{
+	public:
+		explicit PixelShader(const PixelShader *ps = 0);
+		explicit PixelShader(const unsigned long *token);
+
+		virtual ~PixelShader();
+
+		static int validate(const unsigned long *const token);   // Returns number of instructions if valid
+		bool depthOverride() const;
+		bool containsKill() const;
+		bool containsCentroid() const;
+		bool usesDiffuse(int component) const;
+		bool usesSpecular(int component) const;
+		bool usesTexture(int coordinate, int component) const;
+
+		void setInput(int inputIdx, int nbComponents, const Semantic& semantic);
+		const Semantic& getInput(int inputIdx, int component) const;
+
+		void declareVPos() { vPosDeclared = true; }
+		void declareVFace() { vFaceDeclared = true; }
+		bool isVPosDeclared() const { return vPosDeclared; }
+		bool isVFaceDeclared() const { return vFaceDeclared; }
+
+	private:
+		void analyze();
+		void analyzeZOverride();
+		void analyzeKill();
+		void analyzeInterpolants();
+
+		Semantic input[MAX_FRAGMENT_INPUTS][4];
+
+		bool vPosDeclared;
+		bool vFaceDeclared;
+		bool zOverride;
+		bool kill;
+		bool centroid;
+	};
+}
+
+#endif   // sw_PixelShader_hpp
diff --git a/src/Pipeline/SamplerCore.cpp b/src/Pipeline/SamplerCore.cpp
new file mode 100644
index 0000000..8a2aa39
--- /dev/null
+++ b/src/Pipeline/SamplerCore.cpp
@@ -0,0 +1,3035 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "SamplerCore.hpp"
+
+#include "Constants.hpp"
+#include "Common/Debug.hpp"
+
+namespace
+{
+	void applySwizzle(sw::SwizzleType swizzle, sw::Short4& s, const sw::Vector4s& c)
+	{
+		switch(swizzle)
+		{
+		case sw::SWIZZLE_RED:	s = c.x; break;
+		case sw::SWIZZLE_GREEN: s = c.y; break;
+		case sw::SWIZZLE_BLUE:  s = c.z; break;
+		case sw::SWIZZLE_ALPHA: s = c.w; break;
+		case sw::SWIZZLE_ZERO:  s = sw::Short4(0x0000); break;
+		case sw::SWIZZLE_ONE:   s = sw::Short4(0x1000); break;
+		default: ASSERT(false);
+		}
+	}
+
+	void applySwizzle(sw::SwizzleType swizzle, sw::Float4& f, const sw::Vector4f& c)
+	{
+		switch(swizzle)
+		{
+		case sw::SWIZZLE_RED:	f = c.x; break;
+		case sw::SWIZZLE_GREEN: f = c.y; break;
+		case sw::SWIZZLE_BLUE:  f = c.z; break;
+		case sw::SWIZZLE_ALPHA: f = c.w; break;
+		case sw::SWIZZLE_ZERO:  f = sw::Float4(0.0f, 0.0f, 0.0f, 0.0f); break;
+		case sw::SWIZZLE_ONE:   f = sw::Float4(1.0f, 1.0f, 1.0f, 1.0f); break;
+		default: ASSERT(false);
+		}
+	}
+}
+
+namespace sw
+{
+	extern bool colorsDefaultToZero;
+
+	SamplerCore::SamplerCore(Pointer<Byte> &constants, const Sampler::State &state) : constants(constants), state(state)
+	{
+	}
+
+	Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy)
+	{
+		return sampleTexture(texture, u, v, w, q, q, dsx, dsy, (dsx), Implicit, true);
+	}
+
+	Vector4s SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12)
+	{
+		Vector4s c;
+
+		#if PERF_PROFILE
+			AddAtomic(Pointer<Long>(&profiler.texOperations), 4);
+
+			if(state.compressedFormat)
+			{
+				AddAtomic(Pointer<Long>(&profiler.compressedTex), 4);
+			}
+		#endif
+
+		if(state.textureType == TEXTURE_NULL)
+		{
+			c.x = Short4(0x0000);
+			c.y = Short4(0x0000);
+			c.z = Short4(0x0000);
+
+			if(fixed12)   // FIXME: Convert to fixed12 at higher level, when required
+			{
+				c.w = Short4(0x1000);
+			}
+			else
+			{
+				c.w = Short4(0xFFFFu);   // FIXME
+			}
+		}
+		else
+		{
+			Float4 uuuu = u;
+			Float4 vvvv = v;
+			Float4 wwww = w;
+			Float4 qqqq = q;
+
+			Int face[4];
+			Float lod;
+			Float anisotropy;
+			Float4 uDelta;
+			Float4 vDelta;
+
+			if(state.textureType != TEXTURE_3D)
+			{
+				if(state.textureType != TEXTURE_CUBE)
+				{
+					computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, bias.x, dsx, dsy, function);
+				}
+				else
+				{
+					Float4 M;
+					cubeFace(face, uuuu, vvvv, u, v, w, M);
+					computeLodCube(texture, lod, u, v, w, bias.x, dsx, dsy, M, function);
+				}
+			}
+			else
+			{
+				computeLod3D(texture, lod, uuuu, vvvv, wwww, bias.x, dsx, dsy, function);
+			}
+
+			if(!hasFloatTexture())
+			{
+				c = sampleFilter(texture, uuuu, vvvv, wwww, offset, lod, anisotropy, uDelta, vDelta, face, function);
+			}
+			else
+			{
+				Vector4f cf = sampleFloatFilter(texture, uuuu, vvvv, wwww, qqqq, offset, lod, anisotropy, uDelta, vDelta, face, function);
+
+				convertFixed12(c, cf);
+			}
+
+			if(fixed12)
+			{
+				if(!hasFloatTexture())
+				{
+					if(state.textureFormat == FORMAT_R5G6B5)
+					{
+						c.x = MulHigh(As<UShort4>(c.x), UShort4(0x10000000 / 0xF800));
+						c.y = MulHigh(As<UShort4>(c.y), UShort4(0x10000000 / 0xFC00));
+						c.z = MulHigh(As<UShort4>(c.z), UShort4(0x10000000 / 0xF800));
+					}
+					else
+					{
+						for(int component = 0; component < textureComponentCount(); component++)
+						{
+							if(hasUnsignedTextureComponent(component))
+							{
+								c[component] = As<UShort4>(c[component]) >> 4;
+							}
+							else
+							{
+								c[component] = c[component] >> 3;
+							}
+						}
+					}
+				}
+
+				if(state.textureFilter != FILTER_GATHER)
+				{
+					int componentCount = textureComponentCount();
+					short defaultColorValue = colorsDefaultToZero ? 0x0000 : 0x1000;
+
+					switch(state.textureFormat)
+					{
+					case FORMAT_R8_SNORM:
+					case FORMAT_G8R8_SNORM:
+					case FORMAT_X8B8G8R8_SNORM:
+					case FORMAT_A8B8G8R8_SNORM:
+					case FORMAT_R8:
+					case FORMAT_R5G6B5:
+					case FORMAT_G8R8:
+					case FORMAT_R8I:
+					case FORMAT_R8UI:
+					case FORMAT_G8R8I:
+					case FORMAT_G8R8UI:
+					case FORMAT_X8B8G8R8I:
+					case FORMAT_X8B8G8R8UI:
+					case FORMAT_A8B8G8R8I:
+					case FORMAT_A8B8G8R8UI:
+					case FORMAT_R16I:
+					case FORMAT_R16UI:
+					case FORMAT_G16R16:
+					case FORMAT_G16R16I:
+					case FORMAT_G16R16UI:
+					case FORMAT_X16B16G16R16I:
+					case FORMAT_X16B16G16R16UI:
+					case FORMAT_A16B16G16R16:
+					case FORMAT_A16B16G16R16I:
+					case FORMAT_A16B16G16R16UI:
+					case FORMAT_R32I:
+					case FORMAT_R32UI:
+					case FORMAT_G32R32I:
+					case FORMAT_G32R32UI:
+					case FORMAT_X32B32G32R32I:
+					case FORMAT_X32B32G32R32UI:
+					case FORMAT_A32B32G32R32I:
+					case FORMAT_A32B32G32R32UI:
+					case FORMAT_X8R8G8B8:
+					case FORMAT_X8B8G8R8:
+					case FORMAT_A8R8G8B8:
+					case FORMAT_A8B8G8R8:
+					case FORMAT_SRGB8_X8:
+					case FORMAT_SRGB8_A8:
+					case FORMAT_V8U8:
+					case FORMAT_Q8W8V8U8:
+					case FORMAT_X8L8V8U8:
+					case FORMAT_V16U16:
+					case FORMAT_A16W16V16U16:
+					case FORMAT_Q16W16V16U16:
+					case FORMAT_YV12_BT601:
+					case FORMAT_YV12_BT709:
+					case FORMAT_YV12_JFIF:
+						if(componentCount < 2) c.y = Short4(defaultColorValue);
+						if(componentCount < 3) c.z = Short4(defaultColorValue);
+						if(componentCount < 4) c.w = Short4(0x1000);
+						break;
+					case FORMAT_A8:
+						c.w = c.x;
+						c.x = Short4(0x0000);
+						c.y = Short4(0x0000);
+						c.z = Short4(0x0000);
+						break;
+					case FORMAT_L8:
+					case FORMAT_L16:
+						c.y = c.x;
+						c.z = c.x;
+						c.w = Short4(0x1000);
+						break;
+					case FORMAT_A8L8:
+						c.w = c.y;
+						c.y = c.x;
+						c.z = c.x;
+						break;
+					case FORMAT_R32F:
+						c.y = Short4(defaultColorValue);
+					case FORMAT_G32R32F:
+						c.z = Short4(defaultColorValue);
+					case FORMAT_X32B32G32R32F:
+					case FORMAT_X32B32G32R32F_UNSIGNED:
+						c.w = Short4(0x1000);
+					case FORMAT_A32B32G32R32F:
+						break;
+					case FORMAT_D32F_LOCKABLE:
+					case FORMAT_D32FS8_TEXTURE:
+					case FORMAT_D32F_SHADOW:
+					case FORMAT_D32FS8_SHADOW:
+						c.y = c.x;
+						c.z = c.x;
+						c.w = c.x;
+						break;
+					default:
+						ASSERT(false);
+					}
+				}
+
+				if((state.swizzleR != SWIZZLE_RED) ||
+				   (state.swizzleG != SWIZZLE_GREEN) ||
+				   (state.swizzleB != SWIZZLE_BLUE) ||
+				   (state.swizzleA != SWIZZLE_ALPHA))
+				{
+					const Vector4s col(c);
+					applySwizzle(state.swizzleR, c.x, col);
+					applySwizzle(state.swizzleG, c.y, col);
+					applySwizzle(state.swizzleB, c.z, col);
+					applySwizzle(state.swizzleA, c.w, col);
+				}
+			}
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+	{
+		Vector4f c;
+
+		#if PERF_PROFILE
+			AddAtomic(Pointer<Long>(&profiler.texOperations), 4);
+
+			if(state.compressedFormat)
+			{
+				AddAtomic(Pointer<Long>(&profiler.compressedTex), 4);
+			}
+		#endif
+
+		if(state.textureType == TEXTURE_NULL)
+		{
+			c.x = Float4(0.0f);
+			c.y = Float4(0.0f);
+			c.z = Float4(0.0f);
+			c.w = Float4(1.0f);
+		}
+		else
+		{
+			// FIXME: YUV is not supported by the floating point path
+			bool forceFloatFiltering = state.highPrecisionFiltering && !hasYuvFormat() && (state.textureFilter != FILTER_POINT);
+			bool seamlessCube = (state.addressingModeU == ADDRESSING_SEAMLESS);
+			bool rectangleTexture = (state.textureType == TEXTURE_RECTANGLE);
+			if(hasFloatTexture() || hasUnnormalizedIntegerTexture() || forceFloatFiltering || seamlessCube || rectangleTexture)   // FIXME: Mostly identical to integer sampling
+			{
+				Float4 uuuu = u;
+				Float4 vvvv = v;
+				Float4 wwww = w;
+				Float4 qqqq = q;
+
+				Int face[4];
+				Float lod;
+				Float anisotropy;
+				Float4 uDelta;
+				Float4 vDelta;
+
+				if(state.textureType != TEXTURE_3D)
+				{
+					if(state.textureType != TEXTURE_CUBE)
+					{
+						computeLod(texture, lod, anisotropy, uDelta, vDelta, uuuu, vvvv, bias.x, dsx, dsy, function);
+					}
+					else
+					{
+						Float4 M;
+						cubeFace(face, uuuu, vvvv, u, v, w, M);
+						computeLodCube(texture, lod, u, v, w, bias.x, dsx, dsy, M, function);
+					}
+				}
+				else
+				{
+					computeLod3D(texture, lod, uuuu, vvvv, wwww, bias.x, dsx, dsy, function);
+				}
+
+				c = sampleFloatFilter(texture, uuuu, vvvv, wwww, qqqq, offset, lod, anisotropy, uDelta, vDelta, face, function);
+
+				if(!hasFloatTexture() && !hasUnnormalizedIntegerTexture())
+				{
+					if(has16bitTextureFormat())
+					{
+						switch(state.textureFormat)
+						{
+						case FORMAT_R5G6B5:
+							c.x *= Float4(1.0f / 0xF800);
+							c.y *= Float4(1.0f / 0xFC00);
+							c.z *= Float4(1.0f / 0xF800);
+							break;
+						default:
+							ASSERT(false);
+						}
+					}
+					else
+					{
+						for(int component = 0; component < textureComponentCount(); component++)
+						{
+							c[component] *= Float4(hasUnsignedTextureComponent(component) ? 1.0f / 0xFFFF : 1.0f / 0x7FFF);
+						}
+					}
+				}
+			}
+			else
+			{
+				Vector4s cs = sampleTexture(texture, u, v, w, q, bias, dsx, dsy, offset, function, false);
+
+				if(state.textureFormat ==  FORMAT_R5G6B5)
+				{
+					c.x = Float4(As<UShort4>(cs.x)) * Float4(1.0f / 0xF800);
+					c.y = Float4(As<UShort4>(cs.y)) * Float4(1.0f / 0xFC00);
+					c.z = Float4(As<UShort4>(cs.z)) * Float4(1.0f / 0xF800);
+				}
+				else
+				{
+					for(int component = 0; component < textureComponentCount(); component++)
+					{
+						if(hasUnsignedTextureComponent(component))
+						{
+							convertUnsigned16(c[component], cs[component]);
+						}
+						else
+						{
+							convertSigned15(c[component], cs[component]);
+						}
+					}
+				}
+			}
+
+			int componentCount = textureComponentCount();
+			float defaultColorValue = colorsDefaultToZero ? 0.0f : 1.0f;
+
+			if(state.textureFilter != FILTER_GATHER)
+			{
+				switch(state.textureFormat)
+				{
+				case FORMAT_R8I:
+				case FORMAT_R8UI:
+				case FORMAT_R16I:
+				case FORMAT_R16UI:
+				case FORMAT_R32I:
+				case FORMAT_R32UI:
+					c.y = As<Float4>(UInt4(0));
+				case FORMAT_G8R8I:
+				case FORMAT_G8R8UI:
+				case FORMAT_G16R16I:
+				case FORMAT_G16R16UI:
+				case FORMAT_G32R32I:
+				case FORMAT_G32R32UI:
+					c.z = As<Float4>(UInt4(0));
+				case FORMAT_X8B8G8R8I:
+				case FORMAT_X8B8G8R8UI:
+				case FORMAT_X16B16G16R16I:
+				case FORMAT_X16B16G16R16UI:
+				case FORMAT_X32B32G32R32I:
+				case FORMAT_X32B32G32R32UI:
+					c.w = As<Float4>(UInt4(1));
+				case FORMAT_A8B8G8R8I:
+				case FORMAT_A8B8G8R8UI:
+				case FORMAT_A16B16G16R16I:
+				case FORMAT_A16B16G16R16UI:
+				case FORMAT_A32B32G32R32I:
+				case FORMAT_A32B32G32R32UI:
+					break;
+				case FORMAT_R8_SNORM:
+				case FORMAT_G8R8_SNORM:
+				case FORMAT_X8B8G8R8_SNORM:
+				case FORMAT_A8B8G8R8_SNORM:
+				case FORMAT_R8:
+				case FORMAT_R5G6B5:
+				case FORMAT_G8R8:
+				case FORMAT_G16R16:
+				case FORMAT_A16B16G16R16:
+				case FORMAT_X8R8G8B8:
+				case FORMAT_X8B8G8R8:
+				case FORMAT_A8R8G8B8:
+				case FORMAT_A8B8G8R8:
+				case FORMAT_SRGB8_X8:
+				case FORMAT_SRGB8_A8:
+				case FORMAT_V8U8:
+				case FORMAT_Q8W8V8U8:
+				case FORMAT_X8L8V8U8:
+				case FORMAT_V16U16:
+				case FORMAT_A16W16V16U16:
+				case FORMAT_Q16W16V16U16:
+				case FORMAT_YV12_BT601:
+				case FORMAT_YV12_BT709:
+				case FORMAT_YV12_JFIF:
+					if(componentCount < 2) c.y = Float4(defaultColorValue);
+					if(componentCount < 3) c.z = Float4(defaultColorValue);
+					if(componentCount < 4) c.w = Float4(1.0f);
+					break;
+				case FORMAT_A8:
+					c.w = c.x;
+					c.x = Float4(0.0f);
+					c.y = Float4(0.0f);
+					c.z = Float4(0.0f);
+					break;
+				case FORMAT_L8:
+				case FORMAT_L16:
+					c.y = c.x;
+					c.z = c.x;
+					c.w = Float4(1.0f);
+					break;
+				case FORMAT_A8L8:
+					c.w = c.y;
+					c.y = c.x;
+					c.z = c.x;
+					break;
+				case FORMAT_R32F:
+					c.y = Float4(defaultColorValue);
+				case FORMAT_G32R32F:
+					c.z = Float4(defaultColorValue);
+				case FORMAT_X32B32G32R32F:
+				case FORMAT_X32B32G32R32F_UNSIGNED:
+					c.w = Float4(1.0f);
+				case FORMAT_A32B32G32R32F:
+					break;
+				case FORMAT_D32F_LOCKABLE:
+				case FORMAT_D32FS8_TEXTURE:
+				case FORMAT_D32F_SHADOW:
+				case FORMAT_D32FS8_SHADOW:
+					c.y = Float4(0.0f);
+					c.z = Float4(0.0f);
+					c.w = Float4(1.0f);
+					break;
+				default:
+					ASSERT(false);
+				}
+			}
+
+			if((state.swizzleR != SWIZZLE_RED) ||
+			   (state.swizzleG != SWIZZLE_GREEN) ||
+			   (state.swizzleB != SWIZZLE_BLUE) ||
+			   (state.swizzleA != SWIZZLE_ALPHA))
+			{
+				const Vector4f col(c);
+				applySwizzle(state.swizzleR, c.x, col);
+				applySwizzle(state.swizzleG, c.y, col);
+				applySwizzle(state.swizzleB, c.z, col);
+				applySwizzle(state.swizzleA, c.w, col);
+			}
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::textureSize(Pointer<Byte> &texture, Float4 &lod)
+	{
+		Vector4f size;
+
+		for(int i = 0; i < 4; ++i)
+		{
+			Int baseLevel = *Pointer<Int>(texture + OFFSET(Texture, baseLevel));
+			Pointer<Byte> mipmap = texture + OFFSET(Texture, mipmap) + (As<Int>(Extract(lod, i)) + baseLevel) * sizeof(Mipmap);
+			size.x = Insert(size.x, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, width)))), i);
+			size.y = Insert(size.y, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, height)))), i);
+			size.z = Insert(size.z, As<Float>(Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, depth)))), i);
+		}
+
+		return size;
+	}
+
+	void SamplerCore::border(Short4 &mask, Float4 &coordinates)
+	{
+		Int4 border = As<Int4>(CmpLT(Abs(coordinates - Float4(0.5f)), Float4(0.5f)));
+		mask = As<Short4>(Int2(As<Int4>(PackSigned(border, border))));
+	}
+
+	void SamplerCore::border(Int4 &mask, Float4 &coordinates)
+	{
+		mask = As<Int4>(CmpLT(Abs(coordinates - Float4(0.5f)), Float4(0.5f)));
+	}
+
+	Short4 SamplerCore::offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count, Float &lod)
+	{
+		Short4 offset = *Pointer<Short4>(mipmap + halfOffset);
+
+		if(state.textureFilter == FILTER_MIN_LINEAR_MAG_POINT)
+		{
+			offset &= Short4(CmpNLE(Float4(lod), Float4(0.0f)));
+		}
+		else if(state.textureFilter == FILTER_MIN_POINT_MAG_LINEAR)
+		{
+			offset &= Short4(CmpLE(Float4(lod), Float4(0.0f)));
+		}
+
+		if(wrap)
+		{
+			switch(count)
+			{
+			case -1: return uvw - offset;
+			case  0: return uvw;
+			case +1: return uvw + offset;
+			case  2: return uvw + offset + offset;
+			}
+		}
+		else   // Clamp or mirror
+		{
+			switch(count)
+			{
+			case -1: return SubSat(As<UShort4>(uvw), As<UShort4>(offset));
+			case  0: return uvw;
+			case +1: return AddSat(As<UShort4>(uvw), As<UShort4>(offset));
+			case  2: return AddSat(AddSat(As<UShort4>(uvw), As<UShort4>(offset)), As<UShort4>(offset));
+			}
+		}
+
+		return uvw;
+	}
+
+	Vector4s SamplerCore::sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function)
+	{
+		Vector4s c = sampleAniso(texture, u, v, w, offset, lod, anisotropy, uDelta, vDelta, face, false, function);
+
+		if(function == Fetch)
+		{
+			return c;
+		}
+
+		if(state.mipmapFilter == MIPMAP_LINEAR)
+		{
+			Vector4s cc = sampleAniso(texture, u, v, w, offset, lod, anisotropy, uDelta, vDelta, face, true, function);
+
+			lod *= Float(1 << 16);
+
+			UShort4 utri = UShort4(Float4(lod));   // FIXME: Optimize
+			Short4 stri = utri >> 1;   // FIXME: Optimize
+
+			if(hasUnsignedTextureComponent(0)) cc.x = MulHigh(As<UShort4>(cc.x), utri); else cc.x = MulHigh(cc.x, stri);
+			if(hasUnsignedTextureComponent(1)) cc.y = MulHigh(As<UShort4>(cc.y), utri); else cc.y = MulHigh(cc.y, stri);
+			if(hasUnsignedTextureComponent(2)) cc.z = MulHigh(As<UShort4>(cc.z), utri); else cc.z = MulHigh(cc.z, stri);
+			if(hasUnsignedTextureComponent(3)) cc.w = MulHigh(As<UShort4>(cc.w), utri); else cc.w = MulHigh(cc.w, stri);
+
+			utri = ~utri;
+			stri = Short4(0x7FFF) - stri;
+
+			if(hasUnsignedTextureComponent(0)) c.x = MulHigh(As<UShort4>(c.x), utri); else c.x = MulHigh(c.x, stri);
+			if(hasUnsignedTextureComponent(1)) c.y = MulHigh(As<UShort4>(c.y), utri); else c.y = MulHigh(c.y, stri);
+			if(hasUnsignedTextureComponent(2)) c.z = MulHigh(As<UShort4>(c.z), utri); else c.z = MulHigh(c.z, stri);
+			if(hasUnsignedTextureComponent(3)) c.w = MulHigh(As<UShort4>(c.w), utri); else c.w = MulHigh(c.w, stri);
+
+			c.x += cc.x;
+			c.y += cc.y;
+			c.z += cc.z;
+			c.w += cc.w;
+
+			if(!hasUnsignedTextureComponent(0)) c.x += c.x;
+			if(!hasUnsignedTextureComponent(1)) c.y += c.y;
+			if(!hasUnsignedTextureComponent(2)) c.z += c.z;
+			if(!hasUnsignedTextureComponent(3)) c.w += c.w;
+		}
+
+		Short4 borderMask;
+
+		if(state.addressingModeU == ADDRESSING_BORDER)
+		{
+			Short4 u0;
+
+			border(u0, u);
+
+			borderMask = u0;
+		}
+
+		if(state.addressingModeV == ADDRESSING_BORDER)
+		{
+			Short4 v0;
+
+			border(v0, v);
+
+			if(state.addressingModeU == ADDRESSING_BORDER)
+			{
+				borderMask &= v0;
+			}
+			else
+			{
+				borderMask = v0;
+			}
+		}
+
+		if(state.addressingModeW == ADDRESSING_BORDER && state.textureType == TEXTURE_3D)
+		{
+			Short4 s0;
+
+			border(s0, w);
+
+			if(state.addressingModeU == ADDRESSING_BORDER ||
+			   state.addressingModeV == ADDRESSING_BORDER)
+			{
+				borderMask &= s0;
+			}
+			else
+			{
+				borderMask = s0;
+			}
+		}
+
+		if(state.addressingModeU == ADDRESSING_BORDER ||
+		   state.addressingModeV == ADDRESSING_BORDER ||
+		   (state.addressingModeW == ADDRESSING_BORDER && state.textureType == TEXTURE_3D))
+		{
+			Short4 b;
+
+			c.x = (borderMask & c.x) | (~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[0])) >> (hasUnsignedTextureComponent(0) ? 0 : 1)));
+			c.y = (borderMask & c.y) | (~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[1])) >> (hasUnsignedTextureComponent(1) ? 0 : 1)));
+			c.z = (borderMask & c.z) | (~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[2])) >> (hasUnsignedTextureComponent(2) ? 0 : 1)));
+			c.w = (borderMask & c.w) | (~borderMask & (*Pointer<Short4>(texture + OFFSET(Texture,borderColor4[3])) >> (hasUnsignedTextureComponent(3) ? 0 : 1)));
+		}
+
+		return c;
+	}
+
+	Vector4s SamplerCore::sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		Vector4s c;
+
+		if(state.textureFilter != FILTER_ANISOTROPIC || function == Lod || function == Fetch)
+		{
+			c = sampleQuad(texture, u, v, w, offset, lod, face, secondLOD, function);
+		}
+		else
+		{
+			Int a = RoundInt(anisotropy);
+
+			Vector4s cSum;
+
+			cSum.x = Short4(0);
+			cSum.y = Short4(0);
+			cSum.z = Short4(0);
+			cSum.w = Short4(0);
+
+			Float4 A = *Pointer<Float4>(constants + OFFSET(Constants,uvWeight) + 16 * a);
+			Float4 B = *Pointer<Float4>(constants + OFFSET(Constants,uvStart) + 16 * a);
+			UShort4 cw = *Pointer<UShort4>(constants + OFFSET(Constants,cWeight) + 8 * a);
+			Short4 sw = Short4(cw >> 1);
+
+			Float4 du = uDelta;
+			Float4 dv = vDelta;
+
+			Float4 u0 = u + B * du;
+			Float4 v0 = v + B * dv;
+
+			du *= A;
+			dv *= A;
+
+			Int i = 0;
+
+			Do
+			{
+				c = sampleQuad(texture, u0, v0, w, offset, lod, face, secondLOD, function);
+
+				u0 += du;
+				v0 += dv;
+
+				if(hasUnsignedTextureComponent(0)) cSum.x += As<Short4>(MulHigh(As<UShort4>(c.x), cw)); else cSum.x += MulHigh(c.x, sw);
+				if(hasUnsignedTextureComponent(1)) cSum.y += As<Short4>(MulHigh(As<UShort4>(c.y), cw)); else cSum.y += MulHigh(c.y, sw);
+				if(hasUnsignedTextureComponent(2)) cSum.z += As<Short4>(MulHigh(As<UShort4>(c.z), cw)); else cSum.z += MulHigh(c.z, sw);
+				if(hasUnsignedTextureComponent(3)) cSum.w += As<Short4>(MulHigh(As<UShort4>(c.w), cw)); else cSum.w += MulHigh(c.w, sw);
+
+				i++;
+			}
+			Until(i >= a)
+
+			if(hasUnsignedTextureComponent(0)) c.x = cSum.x; else c.x = AddSat(cSum.x, cSum.x);
+			if(hasUnsignedTextureComponent(1)) c.y = cSum.y; else c.y = AddSat(cSum.y, cSum.y);
+			if(hasUnsignedTextureComponent(2)) c.z = cSum.z; else c.z = AddSat(cSum.z, cSum.z);
+			if(hasUnsignedTextureComponent(3)) c.w = cSum.w; else c.w = AddSat(cSum.w, cSum.w);
+		}
+
+		return c;
+	}
+
+	Vector4s SamplerCore::sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		if(state.textureType != TEXTURE_3D)
+		{
+			return sampleQuad2D(texture, u, v, w, offset, lod, face, secondLOD, function);
+		}
+		else
+		{
+			return sample3D(texture, u, v, w, offset, lod, secondLOD, function);
+		}
+	}
+
+	Vector4s SamplerCore::sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		Vector4s c;
+
+		int componentCount = textureComponentCount();
+		bool gather = state.textureFilter == FILTER_GATHER;
+
+		Pointer<Byte> mipmap;
+		Pointer<Byte> buffer[4];
+
+		selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+		bool texelFetch = (function == Fetch);
+
+		Short4 uuuu = texelFetch ? Short4(As<Int4>(u)) : address(u, state.addressingModeU, mipmap);
+		Short4 vvvv = texelFetch ? Short4(As<Int4>(v)) : address(v, state.addressingModeV, mipmap);
+		Short4 wwww = texelFetch ? Short4(As<Int4>(w)) : address(w, state.addressingModeW, mipmap);
+
+		if(state.textureFilter == FILTER_POINT || texelFetch)
+		{
+			c = sampleTexel(uuuu, vvvv, wwww, offset, mipmap, buffer, function);
+		}
+		else
+		{
+			Short4 uuuu0 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), state.addressingModeU == ADDRESSING_WRAP, gather ? 0 : -1, lod);
+			Short4 vvvv0 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), state.addressingModeV == ADDRESSING_WRAP, gather ? 0 : -1, lod);
+			Short4 uuuu1 = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), state.addressingModeU == ADDRESSING_WRAP, gather ? 2 : +1, lod);
+			Short4 vvvv1 = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), state.addressingModeV == ADDRESSING_WRAP, gather ? 2 : +1, lod);
+
+			Vector4s c0 = sampleTexel(uuuu0, vvvv0, wwww, offset, mipmap, buffer, function);
+			Vector4s c1 = sampleTexel(uuuu1, vvvv0, wwww, offset, mipmap, buffer, function);
+			Vector4s c2 = sampleTexel(uuuu0, vvvv1, wwww, offset, mipmap, buffer, function);
+			Vector4s c3 = sampleTexel(uuuu1, vvvv1, wwww, offset, mipmap, buffer, function);
+
+			if(!gather)   // Blend
+			{
+				// Fractions
+				UShort4 f0u = As<UShort4>(uuuu0) * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,width));
+				UShort4 f0v = As<UShort4>(vvvv0) * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,height));
+
+				UShort4 f1u = ~f0u;
+				UShort4 f1v = ~f0v;
+
+				UShort4 f0u0v = MulHigh(f0u, f0v);
+				UShort4 f1u0v = MulHigh(f1u, f0v);
+				UShort4 f0u1v = MulHigh(f0u, f1v);
+				UShort4 f1u1v = MulHigh(f1u, f1v);
+
+				// Signed fractions
+				Short4 f1u1vs;
+				Short4 f0u1vs;
+				Short4 f1u0vs;
+				Short4 f0u0vs;
+
+				if(!hasUnsignedTextureComponent(0) || !hasUnsignedTextureComponent(1) || !hasUnsignedTextureComponent(2) || !hasUnsignedTextureComponent(3))
+				{
+					f1u1vs = f1u1v >> 1;
+					f0u1vs = f0u1v >> 1;
+					f1u0vs = f1u0v >> 1;
+					f0u0vs = f0u0v >> 1;
+				}
+
+				// Bilinear interpolation
+				if(componentCount >= 1)
+				{
+					if(has16bitTextureComponents() && hasUnsignedTextureComponent(0))
+					{
+						c0.x = As<UShort4>(c0.x) - MulHigh(As<UShort4>(c0.x), f0u) + MulHigh(As<UShort4>(c1.x), f0u);
+						c2.x = As<UShort4>(c2.x) - MulHigh(As<UShort4>(c2.x), f0u) + MulHigh(As<UShort4>(c3.x), f0u);
+						c.x  = As<UShort4>(c0.x) - MulHigh(As<UShort4>(c0.x), f0v) + MulHigh(As<UShort4>(c2.x), f0v);
+					}
+					else
+					{
+						if(hasUnsignedTextureComponent(0))
+						{
+							c0.x = MulHigh(As<UShort4>(c0.x), f1u1v);
+							c1.x = MulHigh(As<UShort4>(c1.x), f0u1v);
+							c2.x = MulHigh(As<UShort4>(c2.x), f1u0v);
+							c3.x = MulHigh(As<UShort4>(c3.x), f0u0v);
+						}
+						else
+						{
+							c0.x = MulHigh(c0.x, f1u1vs);
+							c1.x = MulHigh(c1.x, f0u1vs);
+							c2.x = MulHigh(c2.x, f1u0vs);
+							c3.x = MulHigh(c3.x, f0u0vs);
+						}
+
+						c.x = (c0.x + c1.x) + (c2.x + c3.x);
+						if(!hasUnsignedTextureComponent(0)) c.x = AddSat(c.x, c.x);   // Correct for signed fractions
+					}
+				}
+
+				if(componentCount >= 2)
+				{
+					if(has16bitTextureComponents() && hasUnsignedTextureComponent(1))
+					{
+						c0.y = As<UShort4>(c0.y) - MulHigh(As<UShort4>(c0.y), f0u) + MulHigh(As<UShort4>(c1.y), f0u);
+						c2.y = As<UShort4>(c2.y) - MulHigh(As<UShort4>(c2.y), f0u) + MulHigh(As<UShort4>(c3.y), f0u);
+						c.y  = As<UShort4>(c0.y) - MulHigh(As<UShort4>(c0.y), f0v) + MulHigh(As<UShort4>(c2.y), f0v);
+					}
+					else
+					{
+						if(hasUnsignedTextureComponent(1))
+						{
+							c0.y = MulHigh(As<UShort4>(c0.y), f1u1v);
+							c1.y = MulHigh(As<UShort4>(c1.y), f0u1v);
+							c2.y = MulHigh(As<UShort4>(c2.y), f1u0v);
+							c3.y = MulHigh(As<UShort4>(c3.y), f0u0v);
+						}
+						else
+						{
+							c0.y = MulHigh(c0.y, f1u1vs);
+							c1.y = MulHigh(c1.y, f0u1vs);
+							c2.y = MulHigh(c2.y, f1u0vs);
+							c3.y = MulHigh(c3.y, f0u0vs);
+						}
+
+						c.y = (c0.y + c1.y) + (c2.y + c3.y);
+						if(!hasUnsignedTextureComponent(1)) c.y = AddSat(c.y, c.y);   // Correct for signed fractions
+					}
+				}
+
+				if(componentCount >= 3)
+				{
+					if(has16bitTextureComponents() && hasUnsignedTextureComponent(2))
+					{
+						c0.z = As<UShort4>(c0.z) - MulHigh(As<UShort4>(c0.z), f0u) + MulHigh(As<UShort4>(c1.z), f0u);
+						c2.z = As<UShort4>(c2.z) - MulHigh(As<UShort4>(c2.z), f0u) + MulHigh(As<UShort4>(c3.z), f0u);
+						c.z  = As<UShort4>(c0.z) - MulHigh(As<UShort4>(c0.z), f0v) + MulHigh(As<UShort4>(c2.z), f0v);
+					}
+					else
+					{
+						if(hasUnsignedTextureComponent(2))
+						{
+							c0.z = MulHigh(As<UShort4>(c0.z), f1u1v);
+							c1.z = MulHigh(As<UShort4>(c1.z), f0u1v);
+							c2.z = MulHigh(As<UShort4>(c2.z), f1u0v);
+							c3.z = MulHigh(As<UShort4>(c3.z), f0u0v);
+						}
+						else
+						{
+							c0.z = MulHigh(c0.z, f1u1vs);
+							c1.z = MulHigh(c1.z, f0u1vs);
+							c2.z = MulHigh(c2.z, f1u0vs);
+							c3.z = MulHigh(c3.z, f0u0vs);
+						}
+
+						c.z = (c0.z + c1.z) + (c2.z + c3.z);
+						if(!hasUnsignedTextureComponent(2)) c.z = AddSat(c.z, c.z);   // Correct for signed fractions
+					}
+				}
+
+				if(componentCount >= 4)
+				{
+					if(has16bitTextureComponents() && hasUnsignedTextureComponent(3))
+					{
+						c0.w = As<UShort4>(c0.w) - MulHigh(As<UShort4>(c0.w), f0u) + MulHigh(As<UShort4>(c1.w), f0u);
+						c2.w = As<UShort4>(c2.w) - MulHigh(As<UShort4>(c2.w), f0u) + MulHigh(As<UShort4>(c3.w), f0u);
+						c.w  = As<UShort4>(c0.w) - MulHigh(As<UShort4>(c0.w), f0v) + MulHigh(As<UShort4>(c2.w), f0v);
+					}
+					else
+					{
+						if(hasUnsignedTextureComponent(3))
+						{
+							c0.w = MulHigh(As<UShort4>(c0.w), f1u1v);
+							c1.w = MulHigh(As<UShort4>(c1.w), f0u1v);
+							c2.w = MulHigh(As<UShort4>(c2.w), f1u0v);
+							c3.w = MulHigh(As<UShort4>(c3.w), f0u0v);
+						}
+						else
+						{
+							c0.w = MulHigh(c0.w, f1u1vs);
+							c1.w = MulHigh(c1.w, f0u1vs);
+							c2.w = MulHigh(c2.w, f1u0vs);
+							c3.w = MulHigh(c3.w, f0u0vs);
+						}
+
+						c.w = (c0.w + c1.w) + (c2.w + c3.w);
+						if(!hasUnsignedTextureComponent(3)) c.w = AddSat(c.w, c.w);   // Correct for signed fractions
+					}
+				}
+			}
+			else
+			{
+				c.x = c1.x;
+				c.y = c2.x;
+				c.z = c3.x;
+				c.w = c0.x;
+			}
+		}
+
+		return c;
+	}
+
+	Vector4s SamplerCore::sample3D(Pointer<Byte> &texture, Float4 &u_, Float4 &v_, Float4 &w_, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function)
+	{
+		Vector4s c_;
+
+		int componentCount = textureComponentCount();
+
+		Pointer<Byte> mipmap;
+		Pointer<Byte> buffer[4];
+		Int face[4];
+
+		selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+		bool texelFetch = (function == Fetch);
+
+		Short4 uuuu = texelFetch ? Short4(As<Int4>(u_)) : address(u_, state.addressingModeU, mipmap);
+		Short4 vvvv = texelFetch ? Short4(As<Int4>(v_)) : address(v_, state.addressingModeV, mipmap);
+		Short4 wwww = texelFetch ? Short4(As<Int4>(w_)) : address(w_, state.addressingModeW, mipmap);
+
+		if(state.textureFilter == FILTER_POINT || texelFetch)
+		{
+			c_ = sampleTexel(uuuu, vvvv, wwww, offset, mipmap, buffer, function);
+		}
+		else
+		{
+			Vector4s c[2][2][2];
+
+			Short4 u[2][2][2];
+			Short4 v[2][2][2];
+			Short4 s[2][2][2];
+
+			for(int i = 0; i < 2; i++)
+			{
+				for(int j = 0; j < 2; j++)
+				{
+					for(int k = 0; k < 2; k++)
+					{
+						u[i][j][k] = offsetSample(uuuu, mipmap, OFFSET(Mipmap,uHalf), state.addressingModeU == ADDRESSING_WRAP, i * 2 - 1, lod);
+						v[i][j][k] = offsetSample(vvvv, mipmap, OFFSET(Mipmap,vHalf), state.addressingModeV == ADDRESSING_WRAP, j * 2 - 1, lod);
+						s[i][j][k] = offsetSample(wwww, mipmap, OFFSET(Mipmap,wHalf), state.addressingModeW == ADDRESSING_WRAP, k * 2 - 1, lod);
+					}
+				}
+			}
+
+			// Fractions
+			UShort4 f0u = As<UShort4>(u[0][0][0]) * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,width));
+			UShort4 f0v = As<UShort4>(v[0][0][0]) * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,height));
+			UShort4 f0s = As<UShort4>(s[0][0][0]) * *Pointer<UShort4>(mipmap + OFFSET(Mipmap,depth));
+
+			UShort4 f1u = ~f0u;
+			UShort4 f1v = ~f0v;
+			UShort4 f1s = ~f0s;
+
+			UShort4 f[2][2][2];
+			Short4 fs[2][2][2];
+
+			f[1][1][1] = MulHigh(f1u, f1v);
+			f[0][1][1] = MulHigh(f0u, f1v);
+			f[1][0][1] = MulHigh(f1u, f0v);
+			f[0][0][1] = MulHigh(f0u, f0v);
+			f[1][1][0] = MulHigh(f1u, f1v);
+			f[0][1][0] = MulHigh(f0u, f1v);
+			f[1][0][0] = MulHigh(f1u, f0v);
+			f[0][0][0] = MulHigh(f0u, f0v);
+
+			f[1][1][1] = MulHigh(f[1][1][1], f1s);
+			f[0][1][1] = MulHigh(f[0][1][1], f1s);
+			f[1][0][1] = MulHigh(f[1][0][1], f1s);
+			f[0][0][1] = MulHigh(f[0][0][1], f1s);
+			f[1][1][0] = MulHigh(f[1][1][0], f0s);
+			f[0][1][0] = MulHigh(f[0][1][0], f0s);
+			f[1][0][0] = MulHigh(f[1][0][0], f0s);
+			f[0][0][0] = MulHigh(f[0][0][0], f0s);
+
+			// Signed fractions
+			if(!hasUnsignedTextureComponent(0) || !hasUnsignedTextureComponent(1) || !hasUnsignedTextureComponent(2) || !hasUnsignedTextureComponent(3))
+			{
+				fs[0][0][0] = f[0][0][0] >> 1;
+				fs[0][0][1] = f[0][0][1] >> 1;
+				fs[0][1][0] = f[0][1][0] >> 1;
+				fs[0][1][1] = f[0][1][1] >> 1;
+				fs[1][0][0] = f[1][0][0] >> 1;
+				fs[1][0][1] = f[1][0][1] >> 1;
+				fs[1][1][0] = f[1][1][0] >> 1;
+				fs[1][1][1] = f[1][1][1] >> 1;
+			}
+
+			for(int i = 0; i < 2; i++)
+			{
+				for(int j = 0; j < 2; j++)
+				{
+					for(int k = 0; k < 2; k++)
+					{
+						c[i][j][k] = sampleTexel(u[i][j][k], v[i][j][k], s[i][j][k], offset, mipmap, buffer, function);
+
+						if(componentCount >= 1) { if(hasUnsignedTextureComponent(0)) c[i][j][k].x = MulHigh(As<UShort4>(c[i][j][k].x), f[1 - i][1 - j][1 - k]); else c[i][j][k].x = MulHigh(c[i][j][k].x, fs[1 - i][1 - j][1 - k]); }
+						if(componentCount >= 2) { if(hasUnsignedTextureComponent(1)) c[i][j][k].y = MulHigh(As<UShort4>(c[i][j][k].y), f[1 - i][1 - j][1 - k]); else c[i][j][k].y = MulHigh(c[i][j][k].y, fs[1 - i][1 - j][1 - k]); }
+						if(componentCount >= 3) { if(hasUnsignedTextureComponent(2)) c[i][j][k].z = MulHigh(As<UShort4>(c[i][j][k].z), f[1 - i][1 - j][1 - k]); else c[i][j][k].z = MulHigh(c[i][j][k].z, fs[1 - i][1 - j][1 - k]); }
+						if(componentCount >= 4) { if(hasUnsignedTextureComponent(3)) c[i][j][k].w = MulHigh(As<UShort4>(c[i][j][k].w), f[1 - i][1 - j][1 - k]); else c[i][j][k].w = MulHigh(c[i][j][k].w, fs[1 - i][1 - j][1 - k]); }
+
+						if(i != 0 || j != 0 || k != 0)
+						{
+							if(componentCount >= 1) c[0][0][0].x += c[i][j][k].x;
+							if(componentCount >= 2) c[0][0][0].y += c[i][j][k].y;
+							if(componentCount >= 3) c[0][0][0].z += c[i][j][k].z;
+							if(componentCount >= 4) c[0][0][0].w += c[i][j][k].w;
+						}
+					}
+				}
+			}
+
+			if(componentCount >= 1) c_.x = c[0][0][0].x;
+			if(componentCount >= 2) c_.y = c[0][0][0].y;
+			if(componentCount >= 3) c_.z = c[0][0][0].z;
+			if(componentCount >= 4) c_.w = c[0][0][0].w;
+
+			// Correct for signed fractions
+			if(componentCount >= 1) if(!hasUnsignedTextureComponent(0)) c_.x = AddSat(c_.x, c_.x);
+			if(componentCount >= 2) if(!hasUnsignedTextureComponent(1)) c_.y = AddSat(c_.y, c_.y);
+			if(componentCount >= 3) if(!hasUnsignedTextureComponent(2)) c_.z = AddSat(c_.z, c_.z);
+			if(componentCount >= 4) if(!hasUnsignedTextureComponent(3)) c_.w = AddSat(c_.w, c_.w);
+		}
+
+		return c_;
+	}
+
+	Vector4f SamplerCore::sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function)
+	{
+		Vector4f c = sampleFloatAniso(texture, u, v, w, q, offset, lod, anisotropy, uDelta, vDelta, face, false, function);
+
+		if(function == Fetch)
+		{
+			return c;
+		}
+
+		if(state.mipmapFilter == MIPMAP_LINEAR)
+		{
+			Vector4f cc = sampleFloatAniso(texture, u, v, w, q, offset, lod, anisotropy, uDelta, vDelta, face, true, function);
+
+			Float4 lod4 = Float4(Frac(lod));
+
+			c.x = (cc.x - c.x) * lod4 + c.x;
+			c.y = (cc.y - c.y) * lod4 + c.y;
+			c.z = (cc.z - c.z) * lod4 + c.z;
+			c.w = (cc.w - c.w) * lod4 + c.w;
+		}
+
+		Int4 borderMask;
+
+		if(state.addressingModeU == ADDRESSING_BORDER)
+		{
+			Int4 u0;
+
+			border(u0, u);
+
+			borderMask = u0;
+		}
+
+		if(state.addressingModeV == ADDRESSING_BORDER)
+		{
+			Int4 v0;
+
+			border(v0, v);
+
+			if(state.addressingModeU == ADDRESSING_BORDER)
+			{
+				borderMask &= v0;
+			}
+			else
+			{
+				borderMask = v0;
+			}
+		}
+
+		if(state.addressingModeW == ADDRESSING_BORDER && state.textureType == TEXTURE_3D)
+		{
+			Int4 s0;
+
+			border(s0, w);
+
+			if(state.addressingModeU == ADDRESSING_BORDER ||
+			   state.addressingModeV == ADDRESSING_BORDER)
+			{
+				borderMask &= s0;
+			}
+			else
+			{
+				borderMask = s0;
+			}
+		}
+
+		if(state.addressingModeU == ADDRESSING_BORDER ||
+		   state.addressingModeV == ADDRESSING_BORDER ||
+		   (state.addressingModeW == ADDRESSING_BORDER && state.textureType == TEXTURE_3D))
+		{
+			Int4 b;
+
+			c.x = As<Float4>((borderMask & As<Int4>(c.x)) | (~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[0]))));
+			c.y = As<Float4>((borderMask & As<Int4>(c.y)) | (~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[1]))));
+			c.z = As<Float4>((borderMask & As<Int4>(c.z)) | (~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[2]))));
+			c.w = As<Float4>((borderMask & As<Int4>(c.w)) | (~borderMask & *Pointer<Int4>(texture + OFFSET(Texture,borderColorF[3]))));
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		Vector4f c;
+
+		if(state.textureFilter != FILTER_ANISOTROPIC || function == Lod || function == Fetch)
+		{
+			c = sampleFloat(texture, u, v, w, q, offset, lod, face, secondLOD, function);
+		}
+		else
+		{
+			Int a = RoundInt(anisotropy);
+
+			Vector4f cSum;
+
+			cSum.x = Float4(0.0f);
+			cSum.y = Float4(0.0f);
+			cSum.z = Float4(0.0f);
+			cSum.w = Float4(0.0f);
+
+			Float4 A = *Pointer<Float4>(constants + OFFSET(Constants,uvWeight) + 16 * a);
+			Float4 B = *Pointer<Float4>(constants + OFFSET(Constants,uvStart) + 16 * a);
+
+			Float4 du = uDelta;
+			Float4 dv = vDelta;
+
+			Float4 u0 = u + B * du;
+			Float4 v0 = v + B * dv;
+
+			du *= A;
+			dv *= A;
+
+			Int i = 0;
+
+			Do
+			{
+				c = sampleFloat(texture, u0, v0, w, q, offset, lod, face, secondLOD, function);
+
+				u0 += du;
+				v0 += dv;
+
+				cSum.x += c.x * A;
+				cSum.y += c.y * A;
+				cSum.z += c.z * A;
+				cSum.w += c.w * A;
+
+				i++;
+			}
+			Until(i >= a)
+
+			c.x = cSum.x;
+			c.y = cSum.y;
+			c.z = cSum.z;
+			c.w = cSum.w;
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		if(state.textureType != TEXTURE_3D)
+		{
+			return sampleFloat2D(texture, u, v, w, q, offset, lod, face, secondLOD, function);
+		}
+		else
+		{
+			return sampleFloat3D(texture, u, v, w, offset, lod, secondLOD, function);
+		}
+	}
+
+	Vector4f SamplerCore::sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function)
+	{
+		Vector4f c;
+
+		int componentCount = textureComponentCount();
+		bool gather = state.textureFilter == FILTER_GATHER;
+
+		Pointer<Byte> mipmap;
+		Pointer<Byte> buffer[4];
+
+		selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+		Int4 x0, x1, y0, y1, z0;
+		Float4 fu, fv;
+		Int4 filter = computeFilterOffset(lod);
+		address(u, x0, x1, fu, mipmap, offset.x, filter, OFFSET(Mipmap, width), state.addressingModeU, function);
+		address(v, y0, y1, fv, mipmap, offset.y, filter, OFFSET(Mipmap, height), state.addressingModeV, function);
+		address(w, z0, z0, fv, mipmap, offset.z, filter, OFFSET(Mipmap, depth), state.addressingModeW, function);
+
+		Int4 pitchP = *Pointer<Int4>(mipmap + OFFSET(Mipmap, pitchP), 16);
+		y0 *= pitchP;
+		if(hasThirdCoordinate())
+		{
+			Int4 sliceP = *Pointer<Int4>(mipmap + OFFSET(Mipmap, sliceP), 16);
+			z0 *= sliceP;
+		}
+
+		if(state.textureFilter == FILTER_POINT || (function == Fetch))
+		{
+			c = sampleTexel(x0, y0, z0, q, mipmap, buffer, function);
+		}
+		else
+		{
+			y1 *= pitchP;
+
+			Vector4f c0 = sampleTexel(x0, y0, z0, q, mipmap, buffer, function);
+			Vector4f c1 = sampleTexel(x1, y0, z0, q, mipmap, buffer, function);
+			Vector4f c2 = sampleTexel(x0, y1, z0, q, mipmap, buffer, function);
+			Vector4f c3 = sampleTexel(x1, y1, z0, q, mipmap, buffer, function);
+
+			if(!gather)   // Blend
+			{
+				if(componentCount >= 1) c0.x = c0.x + fu * (c1.x - c0.x);
+				if(componentCount >= 2) c0.y = c0.y + fu * (c1.y - c0.y);
+				if(componentCount >= 3) c0.z = c0.z + fu * (c1.z - c0.z);
+				if(componentCount >= 4) c0.w = c0.w + fu * (c1.w - c0.w);
+
+				if(componentCount >= 1) c2.x = c2.x + fu * (c3.x - c2.x);
+				if(componentCount >= 2) c2.y = c2.y + fu * (c3.y - c2.y);
+				if(componentCount >= 3) c2.z = c2.z + fu * (c3.z - c2.z);
+				if(componentCount >= 4) c2.w = c2.w + fu * (c3.w - c2.w);
+
+				if(componentCount >= 1) c.x = c0.x + fv * (c2.x - c0.x);
+				if(componentCount >= 2) c.y = c0.y + fv * (c2.y - c0.y);
+				if(componentCount >= 3) c.z = c0.z + fv * (c2.z - c0.z);
+				if(componentCount >= 4) c.w = c0.w + fv * (c2.w - c0.w);
+			}
+			else
+			{
+				c.x = c1.x;
+				c.y = c2.x;
+				c.z = c3.x;
+				c.w = c0.x;
+			}
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function)
+	{
+		Vector4f c;
+
+		int componentCount = textureComponentCount();
+
+		Pointer<Byte> mipmap;
+		Pointer<Byte> buffer[4];
+		Int face[4];
+
+		selectMipmap(texture, buffer, mipmap, lod, face, secondLOD);
+
+		Int4 x0, x1, y0, y1, z0, z1;
+		Float4 fu, fv, fw;
+		Int4 filter = computeFilterOffset(lod);
+		address(u, x0, x1, fu, mipmap, offset.x, filter, OFFSET(Mipmap, width), state.addressingModeU, function);
+		address(v, y0, y1, fv, mipmap, offset.y, filter, OFFSET(Mipmap, height), state.addressingModeV, function);
+		address(w, z0, z1, fw, mipmap, offset.z, filter, OFFSET(Mipmap, depth), state.addressingModeW, function);
+
+		Int4 pitchP = *Pointer<Int4>(mipmap + OFFSET(Mipmap, pitchP), 16);
+		Int4 sliceP = *Pointer<Int4>(mipmap + OFFSET(Mipmap, sliceP), 16);
+		y0 *= pitchP;
+		z0 *= sliceP;
+
+		if(state.textureFilter == FILTER_POINT || (function == Fetch))
+		{
+			c = sampleTexel(x0, y0, z0, w, mipmap, buffer, function);
+		}
+		else
+		{
+			y1 *= pitchP;
+			z1 *= sliceP;
+
+			Vector4f c0 = sampleTexel(x0, y0, z0, w, mipmap, buffer, function);
+			Vector4f c1 = sampleTexel(x1, y0, z0, w, mipmap, buffer, function);
+			Vector4f c2 = sampleTexel(x0, y1, z0, w, mipmap, buffer, function);
+			Vector4f c3 = sampleTexel(x1, y1, z0, w, mipmap, buffer, function);
+			Vector4f c4 = sampleTexel(x0, y0, z1, w, mipmap, buffer, function);
+			Vector4f c5 = sampleTexel(x1, y0, z1, w, mipmap, buffer, function);
+			Vector4f c6 = sampleTexel(x0, y1, z1, w, mipmap, buffer, function);
+			Vector4f c7 = sampleTexel(x1, y1, z1, w, mipmap, buffer, function);
+
+			// Blend first slice
+			if(componentCount >= 1) c0.x = c0.x + fu * (c1.x - c0.x);
+			if(componentCount >= 2) c0.y = c0.y + fu * (c1.y - c0.y);
+			if(componentCount >= 3) c0.z = c0.z + fu * (c1.z - c0.z);
+			if(componentCount >= 4) c0.w = c0.w + fu * (c1.w - c0.w);
+
+			if(componentCount >= 1) c2.x = c2.x + fu * (c3.x - c2.x);
+			if(componentCount >= 2) c2.y = c2.y + fu * (c3.y - c2.y);
+			if(componentCount >= 3) c2.z = c2.z + fu * (c3.z - c2.z);
+			if(componentCount >= 4) c2.w = c2.w + fu * (c3.w - c2.w);
+
+			if(componentCount >= 1) c0.x = c0.x + fv * (c2.x - c0.x);
+			if(componentCount >= 2) c0.y = c0.y + fv * (c2.y - c0.y);
+			if(componentCount >= 3) c0.z = c0.z + fv * (c2.z - c0.z);
+			if(componentCount >= 4) c0.w = c0.w + fv * (c2.w - c0.w);
+
+			// Blend second slice
+			if(componentCount >= 1) c4.x = c4.x + fu * (c5.x - c4.x);
+			if(componentCount >= 2) c4.y = c4.y + fu * (c5.y - c4.y);
+			if(componentCount >= 3) c4.z = c4.z + fu * (c5.z - c4.z);
+			if(componentCount >= 4) c4.w = c4.w + fu * (c5.w - c4.w);
+
+			if(componentCount >= 1) c6.x = c6.x + fu * (c7.x - c6.x);
+			if(componentCount >= 2) c6.y = c6.y + fu * (c7.y - c6.y);
+			if(componentCount >= 3) c6.z = c6.z + fu * (c7.z - c6.z);
+			if(componentCount >= 4) c6.w = c6.w + fu * (c7.w - c6.w);
+
+			if(componentCount >= 1) c4.x = c4.x + fv * (c6.x - c4.x);
+			if(componentCount >= 2) c4.y = c4.y + fv * (c6.y - c4.y);
+			if(componentCount >= 3) c4.z = c4.z + fv * (c6.z - c4.z);
+			if(componentCount >= 4) c4.w = c4.w + fv * (c6.w - c4.w);
+
+			// Blend slices
+			if(componentCount >= 1) c.x = c0.x + fw * (c4.x - c0.x);
+			if(componentCount >= 2) c.y = c0.y + fw * (c4.y - c0.y);
+			if(componentCount >= 3) c.z = c0.z + fw * (c4.z - c0.z);
+			if(componentCount >= 4) c.w = c0.w + fw * (c4.w - c0.w);
+		}
+
+		return c;
+	}
+
+	Float SamplerCore::log2sqrt(Float lod)
+	{
+		// log2(sqrt(lod))                               // Equals 0.25 * log2(lod^2).
+		lod *= lod;                                      // Squaring doubles the exponent and produces an extra bit of precision.
+		lod = Float(As<Int>(lod)) - Float(0x3F800000);   // Interpret as integer and subtract the exponent bias.
+		lod *= As<Float>(Int(0x33000000));               // Scale by 0.25 * 2^-23 (mantissa length).
+
+		return lod;
+	}
+
+	Float SamplerCore::log2(Float lod)
+	{
+		lod *= lod;                                      // Squaring doubles the exponent and produces an extra bit of precision.
+		lod = Float(As<Int>(lod)) - Float(0x3F800000);   // Interpret as integer and subtract the exponent bias.
+		lod *= As<Float>(Int(0x33800000));               // Scale by 0.5 * 2^-23 (mantissa length).
+
+		return lod;
+	}
+
+	void SamplerCore::computeLod(Pointer<Byte> &texture, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &uuuu, Float4 &vvvv, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerFunction function)
+	{
+		if(function != Lod && function != Fetch)
+		{
+			Float4 duvdxy;
+
+			if(function != Grad)   // Implicit
+			{
+				duvdxy = Float4(uuuu.yz, vvvv.yz) - Float4(uuuu.xx, vvvv.xx);
+			}
+			else
+			{
+				Float4 dudxy = Float4(dsx.x.xx, dsy.x.xx);
+				Float4 dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+
+				duvdxy = Float4(dudxy.xz, dvdxy.xz);
+			}
+
+			// Scale by texture dimensions and global LOD.
+			Float4 dUVdxy = duvdxy * *Pointer<Float4>(texture + OFFSET(Texture,widthHeightLOD));
+
+			Float4 dUV2dxy = dUVdxy * dUVdxy;
+			Float4 dUV2 = dUV2dxy.xy + dUV2dxy.zw;
+
+			lod = Max(Float(dUV2.x), Float(dUV2.y));   // Square length of major axis
+
+			if(state.textureFilter == FILTER_ANISOTROPIC)
+			{
+				Float det = Abs(Float(dUVdxy.x) * Float(dUVdxy.w) - Float(dUVdxy.y) * Float(dUVdxy.z));
+
+				Float4 dudx = duvdxy.xxxx;
+				Float4 dudy = duvdxy.yyyy;
+				Float4 dvdx = duvdxy.zzzz;
+				Float4 dvdy = duvdxy.wwww;
+
+				Int4 mask = As<Int4>(CmpNLT(dUV2.x, dUV2.y));
+				uDelta = As<Float4>((As<Int4>(dudx) & mask) | ((As<Int4>(dudy) & ~mask)));
+				vDelta = As<Float4>((As<Int4>(dvdx) & mask) | ((As<Int4>(dvdy) & ~mask)));
+
+				anisotropy = lod * Rcp_pp(det);
+				anisotropy = Min(anisotropy, *Pointer<Float>(texture + OFFSET(Texture,maxAnisotropy)));
+
+				lod *= Rcp_pp(anisotropy * anisotropy);
+			}
+
+			lod = log2sqrt(lod);   // log2(sqrt(lod))
+
+			if(function == Bias)
+			{
+				lod += lodBias;
+			}
+		}
+		else if(function == Lod)
+		{
+			lod = lodBias;
+		}
+		else if(function == Fetch)
+		{
+			// TODO: Eliminate int-float-int conversion.
+			lod = Float(As<Int>(lodBias));
+		}
+		else if(function == Base)
+		{
+			lod = Float(0);
+		}
+		else assert(false);
+
+		lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
+		lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
+	}
+
+	void SamplerCore::computeLodCube(Pointer<Byte> &texture, Float &lod, Float4 &u, Float4 &v, Float4 &w, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, Float4 &M, SamplerFunction function)
+	{
+		if(function != Lod && function != Fetch)
+		{
+			Float4 dudxy, dvdxy, dsdxy;
+
+			if(function != Grad)  // Implicit
+			{
+				Float4 U = u * M;
+				Float4 V = v * M;
+				Float4 W = w * M;
+
+				dudxy = Abs(U - U.xxxx);
+				dvdxy = Abs(V - V.xxxx);
+				dsdxy = Abs(W - W.xxxx);
+			}
+			else
+			{
+				dudxy = Float4(dsx.x.xx, dsy.x.xx);
+				dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+				dsdxy = Float4(dsx.z.xx, dsy.z.xx);
+
+				dudxy = Abs(dudxy * Float4(M.x));
+				dvdxy = Abs(dvdxy * Float4(M.x));
+				dsdxy = Abs(dsdxy * Float4(M.x));
+			}
+
+			// Compute the largest Manhattan distance in two dimensions.
+			// This takes the footprint across adjacent faces into account.
+			Float4 duvdxy = dudxy + dvdxy;
+			Float4 dusdxy = dudxy + dsdxy;
+			Float4 dvsdxy = dvdxy + dsdxy;
+
+			dudxy = Max(Max(duvdxy, dusdxy), dvsdxy);
+
+			lod = Max(Float(dudxy.y), Float(dudxy.z));   // FIXME: Max(dudxy.y, dudxy.z);
+
+			// Scale by texture dimension and global LOD.
+			lod *= *Pointer<Float>(texture + OFFSET(Texture,widthLOD));
+
+			lod = log2(lod);
+
+			if(function == Bias)
+			{
+				lod += lodBias;
+			}
+		}
+		else if(function == Lod)
+		{
+			lod = lodBias;
+		}
+		else if(function == Fetch)
+		{
+			// TODO: Eliminate int-float-int conversion.
+			lod = Float(As<Int>(lodBias));
+		}
+		else if(function == Base)
+		{
+			lod = Float(0);
+		}
+		else assert(false);
+
+		lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
+		lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
+	}
+
+	void SamplerCore::computeLod3D(Pointer<Byte> &texture, Float &lod, Float4 &uuuu, Float4 &vvvv, Float4 &wwww, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerFunction function)
+	{
+		if(function != Lod && function != Fetch)
+		{
+			Float4 dudxy, dvdxy, dsdxy;
+
+			if(function != Grad)   // Implicit
+			{
+				dudxy = uuuu - uuuu.xxxx;
+				dvdxy = vvvv - vvvv.xxxx;
+				dsdxy = wwww - wwww.xxxx;
+			}
+			else
+			{
+				dudxy = Float4(dsx.x.xx, dsy.x.xx);
+				dvdxy = Float4(dsx.y.xx, dsy.y.xx);
+				dsdxy = Float4(dsx.z.xx, dsy.z.xx);
+			}
+
+			// Scale by texture dimensions and global LOD.
+			dudxy *= *Pointer<Float4>(texture + OFFSET(Texture,widthLOD));
+			dvdxy *= *Pointer<Float4>(texture + OFFSET(Texture,heightLOD));
+			dsdxy *= *Pointer<Float4>(texture + OFFSET(Texture,depthLOD));
+
+			dudxy *= dudxy;
+			dvdxy *= dvdxy;
+			dsdxy *= dsdxy;
+
+			dudxy += dvdxy;
+			dudxy += dsdxy;
+
+			lod = Max(Float(dudxy.y), Float(dudxy.z));   // FIXME: Max(dudxy.y, dudxy.z);
+
+			lod = log2sqrt(lod);   // log2(sqrt(lod))
+
+			if(function == Bias)
+			{
+				lod += lodBias;
+			}
+		}
+		else if(function == Lod)
+		{
+			lod = lodBias;
+		}
+		else if(function == Fetch)
+		{
+			// TODO: Eliminate int-float-int conversion.
+			lod = Float(As<Int>(lodBias));
+		}
+		else if(function == Base)
+		{
+			lod = Float(0);
+		}
+		else assert(false);
+
+		lod = Max(lod, *Pointer<Float>(texture + OFFSET(Texture, minLod)));
+		lod = Min(lod, *Pointer<Float>(texture + OFFSET(Texture, maxLod)));
+	}
+
+	void SamplerCore::cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &x, Float4 &y, Float4 &z, Float4 &M)
+	{
+		Int4 xn = CmpLT(x, Float4(0.0f));   // x < 0
+		Int4 yn = CmpLT(y, Float4(0.0f));   // y < 0
+		Int4 zn = CmpLT(z, Float4(0.0f));   // z < 0
+
+		Float4 absX = Abs(x);
+		Float4 absY = Abs(y);
+		Float4 absZ = Abs(z);
+
+		Int4 xy = CmpNLE(absX, absY);   // abs(x) > abs(y)
+		Int4 yz = CmpNLE(absY, absZ);   // abs(y) > abs(z)
+		Int4 zx = CmpNLE(absZ, absX);   // abs(z) > abs(x)
+		Int4 xMajor = xy & ~zx;   // abs(x) > abs(y) && abs(x) > abs(z)
+		Int4 yMajor = yz & ~xy;   // abs(y) > abs(z) && abs(y) > abs(x)
+		Int4 zMajor = zx & ~yz;   // abs(z) > abs(x) && abs(z) > abs(y)
+
+		// FACE_POSITIVE_X = 000b
+		// FACE_NEGATIVE_X = 001b
+		// FACE_POSITIVE_Y = 010b
+		// FACE_NEGATIVE_Y = 011b
+		// FACE_POSITIVE_Z = 100b
+		// FACE_NEGATIVE_Z = 101b
+
+		Int yAxis = SignMask(yMajor);
+		Int zAxis = SignMask(zMajor);
+
+		Int4 n = ((xn & xMajor) | (yn & yMajor) | (zn & zMajor)) & Int4(0x80000000);
+		Int negative = SignMask(n);
+
+		face[0] = *Pointer<Int>(constants + OFFSET(Constants,transposeBit0) + negative * 4);
+		face[0] |= *Pointer<Int>(constants + OFFSET(Constants,transposeBit1) + yAxis * 4);
+		face[0] |= *Pointer<Int>(constants + OFFSET(Constants,transposeBit2) + zAxis * 4);
+		face[1] = (face[0] >> 4)  & 0x7;
+		face[2] = (face[0] >> 8)  & 0x7;
+		face[3] = (face[0] >> 12) & 0x7;
+		face[0] &= 0x7;
+
+		M = Max(Max(absX, absY), absZ);
+
+		// U = xMajor ? (neg ^ -z) : ((zMajor & neg) ^ x)
+		U = As<Float4>((xMajor & (n ^ As<Int4>(-z))) | (~xMajor & ((zMajor & n) ^ As<Int4>(x))));
+
+		// V = !yMajor ? -y : (n ^ z)
+		V = As<Float4>((~yMajor & As<Int4>(-y)) | (yMajor & (n ^ As<Int4>(z))));
+
+		M = reciprocal(M) * Float4(0.5f);
+		U = U * M + Float4(0.5f);
+		V = V * M + Float4(0.5f);
+	}
+
+	Short4 SamplerCore::applyOffset(Short4 &uvw, Float4 &offset, const Int4 &whd, AddressingMode mode)
+	{
+		Int4 tmp = Int4(As<UShort4>(uvw));
+		tmp = tmp + As<Int4>(offset);
+
+		switch(mode)
+		{
+		case AddressingMode::ADDRESSING_WRAP:
+			tmp = (tmp + whd * Int4(-MIN_PROGRAM_TEXEL_OFFSET)) % whd;
+			break;
+		case AddressingMode::ADDRESSING_CLAMP:
+		case AddressingMode::ADDRESSING_MIRROR:
+		case AddressingMode::ADDRESSING_MIRRORONCE:
+		case AddressingMode::ADDRESSING_BORDER: // FIXME: Implement and test ADDRESSING_MIRROR, ADDRESSING_MIRRORONCE, ADDRESSING_BORDER
+			tmp = Min(Max(tmp, Int4(0)), whd - Int4(1));
+			break;
+		case ADDRESSING_TEXELFETCH:
+			break;
+		case AddressingMode::ADDRESSING_SEAMLESS:
+			ASSERT(false);   // Cube sampling doesn't support offset.
+		default:
+			ASSERT(false);
+		}
+
+		return As<Short4>(UShort4(tmp));
+	}
+
+	void SamplerCore::computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, SamplerFunction function)
+	{
+		bool texelFetch = (function == Fetch);
+		bool hasOffset = (function.option == Offset);
+
+		if(!texelFetch)
+		{
+			uuuu = MulHigh(As<UShort4>(uuuu), *Pointer<UShort4>(mipmap + OFFSET(Mipmap, width)));
+			vvvv = MulHigh(As<UShort4>(vvvv), *Pointer<UShort4>(mipmap + OFFSET(Mipmap, height)));
+		}
+
+		if(hasOffset)
+		{
+			UShort4 w = *Pointer<UShort4>(mipmap + OFFSET(Mipmap, width));
+			uuuu = applyOffset(uuuu, offset.x, Int4(w), texelFetch ? ADDRESSING_TEXELFETCH : state.addressingModeU);
+			UShort4 h = *Pointer<UShort4>(mipmap + OFFSET(Mipmap, height));
+			vvvv = applyOffset(vvvv, offset.y, Int4(h), texelFetch ? ADDRESSING_TEXELFETCH : state.addressingModeV);
+		}
+
+		Short4 uuu2 = uuuu;
+		uuuu = As<Short4>(UnpackLow(uuuu, vvvv));
+		uuu2 = As<Short4>(UnpackHigh(uuu2, vvvv));
+		uuuu = As<Short4>(MulAdd(uuuu, *Pointer<Short4>(mipmap + OFFSET(Mipmap,onePitchP))));
+		uuu2 = As<Short4>(MulAdd(uuu2, *Pointer<Short4>(mipmap + OFFSET(Mipmap,onePitchP))));
+
+		if(hasThirdCoordinate())
+		{
+			if(state.textureType != TEXTURE_2D_ARRAY)
+			{
+				if(!texelFetch)
+				{
+					wwww = MulHigh(As<UShort4>(wwww), *Pointer<UShort4>(mipmap + OFFSET(Mipmap, depth)));
+				}
+
+				if(hasOffset)
+				{
+					UShort4 d = *Pointer<UShort4>(mipmap + OFFSET(Mipmap, depth));
+					wwww = applyOffset(wwww, offset.z, Int4(d), texelFetch ? ADDRESSING_TEXELFETCH : state.addressingModeW);
+				}
+			}
+
+			UInt4 uv(As<UInt2>(uuuu), As<UInt2>(uuu2));
+			uv += As<UInt4>(Int4(As<UShort4>(wwww))) * *Pointer<UInt4>(mipmap + OFFSET(Mipmap, sliceP));
+
+			index[0] = Extract(As<Int4>(uv), 0);
+			index[1] = Extract(As<Int4>(uv), 1);
+			index[2] = Extract(As<Int4>(uv), 2);
+			index[3] = Extract(As<Int4>(uv), 3);
+		}
+		else
+		{
+			index[0] = Extract(As<Int2>(uuuu), 0);
+			index[1] = Extract(As<Int2>(uuuu), 1);
+			index[2] = Extract(As<Int2>(uuu2), 0);
+			index[3] = Extract(As<Int2>(uuu2), 1);
+		}
+
+		if(texelFetch)
+		{
+			Int size = Int(*Pointer<Int>(mipmap + OFFSET(Mipmap, sliceP)));
+			if(hasThirdCoordinate())
+			{
+				size *= Int(*Pointer<Short>(mipmap + OFFSET(Mipmap, depth)));
+			}
+			UInt min = 0;
+			UInt max = size - 1;
+
+			for(int i = 0; i < 4; i++)
+			{
+				index[i] = Min(Max(index[i], min), max);
+			}
+		}
+	}
+
+	void SamplerCore::computeIndices(UInt index[4], Int4& uuuu, Int4& vvvv, Int4& wwww, const Pointer<Byte> &mipmap, SamplerFunction function)
+	{
+		UInt4 indices = uuuu + vvvv;
+
+		if(hasThirdCoordinate())
+		{
+			indices += As<UInt4>(wwww);
+		}
+
+		for(int i = 0; i < 4; i++)
+		{
+			index[i] = Extract(As<Int4>(indices), i);
+		}
+	}
+
+	Vector4s SamplerCore::sampleTexel(UInt index[4], Pointer<Byte> buffer[4])
+	{
+		Vector4s c;
+
+		int f0 = state.textureType == TEXTURE_CUBE ? 0 : 0;
+		int f1 = state.textureType == TEXTURE_CUBE ? 1 : 0;
+		int f2 = state.textureType == TEXTURE_CUBE ? 2 : 0;
+		int f3 = state.textureType == TEXTURE_CUBE ? 3 : 0;
+
+		if(has16bitTextureFormat())
+		{
+			c.x = Insert(c.x, Pointer<Short>(buffer[f0])[index[0]], 0);
+			c.x = Insert(c.x, Pointer<Short>(buffer[f1])[index[1]], 1);
+			c.x = Insert(c.x, Pointer<Short>(buffer[f2])[index[2]], 2);
+			c.x = Insert(c.x, Pointer<Short>(buffer[f3])[index[3]], 3);
+
+			switch(state.textureFormat)
+			{
+			case FORMAT_R5G6B5:
+				c.z = (c.x & Short4(0x001Fu)) << 11;
+				c.y = (c.x & Short4(0x07E0u)) << 5;
+				c.x = (c.x & Short4(0xF800u));
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+		else if(has8bitTextureComponents())
+		{
+			switch(textureComponentCount())
+			{
+			case 4:
+				{
+					Byte4 c0 = Pointer<Byte4>(buffer[f0])[index[0]];
+					Byte4 c1 = Pointer<Byte4>(buffer[f1])[index[1]];
+					Byte4 c2 = Pointer<Byte4>(buffer[f2])[index[2]];
+					Byte4 c3 = Pointer<Byte4>(buffer[f3])[index[3]];
+					c.x = Unpack(c0, c1);
+					c.y = Unpack(c2, c3);
+
+					switch(state.textureFormat)
+					{
+					case FORMAT_A8R8G8B8:
+						c.z = As<Short4>(UnpackLow(c.x, c.y));
+						c.x = As<Short4>(UnpackHigh(c.x, c.y));
+						c.y = c.z;
+						c.w = c.x;
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(c.z));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(c.y));
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(c.x));
+						c.w = UnpackHigh(As<Byte8>(c.w), As<Byte8>(c.w));
+						break;
+					case FORMAT_A8B8G8R8:
+					case FORMAT_A8B8G8R8I:
+					case FORMAT_A8B8G8R8_SNORM:
+					case FORMAT_Q8W8V8U8:
+					case FORMAT_SRGB8_A8:
+						c.z = As<Short4>(UnpackHigh(c.x, c.y));
+						c.x = As<Short4>(UnpackLow(c.x, c.y));
+						c.y = c.x;
+						c.w = c.z;
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(c.x));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(c.y));
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(c.z));
+						c.w = UnpackHigh(As<Byte8>(c.w), As<Byte8>(c.w));
+						// Propagate sign bit
+						if(state.textureFormat == FORMAT_A8B8G8R8I)
+						{
+							c.x >>= 8;
+							c.y >>= 8;
+							c.z >>= 8;
+							c.w >>= 8;
+						}
+						break;
+					case FORMAT_A8B8G8R8UI:
+						c.z = As<Short4>(UnpackHigh(c.x, c.y));
+						c.x = As<Short4>(UnpackLow(c.x, c.y));
+						c.y = c.x;
+						c.w = c.z;
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(Short4(0)));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(Short4(0)));
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(Short4(0)));
+						c.w = UnpackHigh(As<Byte8>(c.w), As<Byte8>(Short4(0)));
+						break;
+					default:
+						ASSERT(false);
+					}
+				}
+				break;
+			case 3:
+				{
+					Byte4 c0 = Pointer<Byte4>(buffer[f0])[index[0]];
+					Byte4 c1 = Pointer<Byte4>(buffer[f1])[index[1]];
+					Byte4 c2 = Pointer<Byte4>(buffer[f2])[index[2]];
+					Byte4 c3 = Pointer<Byte4>(buffer[f3])[index[3]];
+					c.x = Unpack(c0, c1);
+					c.y = Unpack(c2, c3);
+
+					switch(state.textureFormat)
+					{
+					case FORMAT_X8R8G8B8:
+						c.z = As<Short4>(UnpackLow(c.x, c.y));
+						c.x = As<Short4>(UnpackHigh(c.x, c.y));
+						c.y = c.z;
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(c.z));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(c.y));
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(c.x));
+						break;
+					case FORMAT_X8B8G8R8_SNORM:
+					case FORMAT_X8B8G8R8I:
+					case FORMAT_X8B8G8R8:
+					case FORMAT_X8L8V8U8:
+					case FORMAT_SRGB8_X8:
+						c.z = As<Short4>(UnpackHigh(c.x, c.y));
+						c.x = As<Short4>(UnpackLow(c.x, c.y));
+						c.y = c.x;
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(c.x));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(c.y));
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(c.z));
+						// Propagate sign bit
+						if(state.textureFormat == FORMAT_X8B8G8R8I)
+						{
+							c.x >>= 8;
+							c.y >>= 8;
+							c.z >>= 8;
+						}
+						break;
+					case FORMAT_X8B8G8R8UI:
+						c.z = As<Short4>(UnpackHigh(c.x, c.y));
+						c.x = As<Short4>(UnpackLow(c.x, c.y));
+						c.y = c.x;
+						c.x = UnpackLow(As<Byte8>(c.x), As<Byte8>(Short4(0)));
+						c.y = UnpackHigh(As<Byte8>(c.y), As<Byte8>(Short4(0)));
+						c.z = UnpackLow(As<Byte8>(c.z), As<Byte8>(Short4(0)));
+						break;
+					default:
+						ASSERT(false);
+					}
+				}
+				break;
+			case 2:
+				c.x = Insert(c.x, Pointer<Short>(buffer[f0])[index[0]], 0);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f1])[index[1]], 1);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f2])[index[2]], 2);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f3])[index[3]], 3);
+
+				switch(state.textureFormat)
+				{
+				case FORMAT_G8R8:
+				case FORMAT_G8R8_SNORM:
+				case FORMAT_V8U8:
+				case FORMAT_A8L8:
+					c.y = (c.x & Short4(0xFF00u)) | As<Short4>(As<UShort4>(c.x) >> 8);
+					c.x = (c.x & Short4(0x00FFu)) | (c.x << 8);
+					break;
+				case FORMAT_G8R8I:
+					c.y = c.x >> 8;
+					c.x = (c.x << 8) >> 8; // Propagate sign bit
+					break;
+				case FORMAT_G8R8UI:
+					c.y = As<Short4>(As<UShort4>(c.x) >> 8);
+					c.x &= Short4(0x00FFu);
+					break;
+				default:
+					ASSERT(false);
+				}
+				break;
+			case 1:
+				{
+					Int c0 = Int(*Pointer<Byte>(buffer[f0] + index[0]));
+					Int c1 = Int(*Pointer<Byte>(buffer[f1] + index[1]));
+					Int c2 = Int(*Pointer<Byte>(buffer[f2] + index[2]));
+					Int c3 = Int(*Pointer<Byte>(buffer[f3] + index[3]));
+					c0 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+
+					switch(state.textureFormat)
+					{
+					case FORMAT_R8I:
+					case FORMAT_R8UI:
+						{
+							Int zero(0);
+							c.x = Unpack(As<Byte4>(c0), As<Byte4>(zero));
+							// Propagate sign bit
+							if(state.textureFormat == FORMAT_R8I)
+							{
+								c.x = (c.x << 8) >> 8;
+							}
+						}
+						break;
+					default:
+						c.x = Unpack(As<Byte4>(c0));
+						break;
+					}
+				}
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+		else if(has16bitTextureComponents())
+		{
+			switch(textureComponentCount())
+			{
+			case 4:
+				c.x = Pointer<Short4>(buffer[f0])[index[0]];
+				c.y = Pointer<Short4>(buffer[f1])[index[1]];
+				c.z = Pointer<Short4>(buffer[f2])[index[2]];
+				c.w = Pointer<Short4>(buffer[f3])[index[3]];
+				transpose4x4(c.x, c.y, c.z, c.w);
+				break;
+			case 3:
+				c.x = Pointer<Short4>(buffer[f0])[index[0]];
+				c.y = Pointer<Short4>(buffer[f1])[index[1]];
+				c.z = Pointer<Short4>(buffer[f2])[index[2]];
+				c.w = Pointer<Short4>(buffer[f3])[index[3]];
+				transpose4x3(c.x, c.y, c.z, c.w);
+				break;
+			case 2:
+				c.x = *Pointer<Short4>(buffer[f0] + 4 * index[0]);
+				c.x = As<Short4>(UnpackLow(c.x, *Pointer<Short4>(buffer[f1] + 4 * index[1])));
+				c.z = *Pointer<Short4>(buffer[f2] + 4 * index[2]);
+				c.z = As<Short4>(UnpackLow(c.z, *Pointer<Short4>(buffer[f3] + 4 * index[3])));
+				c.y = c.x;
+				c.x = UnpackLow(As<Int2>(c.x), As<Int2>(c.z));
+				c.y = UnpackHigh(As<Int2>(c.y), As<Int2>(c.z));
+				break;
+			case 1:
+				c.x = Insert(c.x, Pointer<Short>(buffer[f0])[index[0]], 0);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f1])[index[1]], 1);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f2])[index[2]], 2);
+				c.x = Insert(c.x, Pointer<Short>(buffer[f3])[index[3]], 3);
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+		else ASSERT(false);
+
+		if(state.sRGB)
+		{
+			if(state.textureFormat == FORMAT_R5G6B5)
+			{
+				sRGBtoLinear16_5_16(c.x);
+				sRGBtoLinear16_6_16(c.y);
+				sRGBtoLinear16_5_16(c.z);
+			}
+			else
+			{
+				for(int i = 0; i < textureComponentCount(); i++)
+				{
+					if(isRGBComponent(i))
+					{
+						sRGBtoLinear16_8_16(c[i]);
+					}
+				}
+			}
+		}
+
+		return c;
+	}
+
+	Vector4s SamplerCore::sampleTexel(Short4 &uuuu, Short4 &vvvv, Short4 &wwww, Vector4f &offset, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4], SamplerFunction function)
+	{
+		Vector4s c;
+
+		UInt index[4];
+		computeIndices(index, uuuu, vvvv, wwww, offset, mipmap, function);
+
+		if(hasYuvFormat())
+		{
+			// Generic YPbPr to RGB transformation
+			// R = Y                               +           2 * (1 - Kr) * Pr
+			// G = Y - 2 * Kb * (1 - Kb) / Kg * Pb - 2 * Kr * (1 - Kr) / Kg * Pr
+			// B = Y +           2 * (1 - Kb) * Pb
+
+			float Kb = 0.114f;
+			float Kr = 0.299f;
+			int studioSwing = 1;
+
+			switch(state.textureFormat)
+			{
+			case FORMAT_YV12_BT601:
+				Kb = 0.114f;
+				Kr = 0.299f;
+				studioSwing = 1;
+				break;
+			case FORMAT_YV12_BT709:
+				Kb = 0.0722f;
+				Kr = 0.2126f;
+				studioSwing = 1;
+				break;
+			case FORMAT_YV12_JFIF:
+				Kb = 0.114f;
+				Kr = 0.299f;
+				studioSwing = 0;
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			const float Kg = 1.0f - Kr - Kb;
+
+			const float Rr = 2 * (1 - Kr);
+			const float Gb = -2 * Kb * (1 - Kb) / Kg;
+			const float Gr = -2 * Kr * (1 - Kr) / Kg;
+			const float Bb = 2 * (1 - Kb);
+
+			// Scaling and bias for studio-swing range: Y = [16 .. 235], U/V = [16 .. 240]
+			const float Yy = studioSwing ? 255.0f / (235 - 16) : 1.0f;
+			const float Uu = studioSwing ? 255.0f / (240 - 16) : 1.0f;
+			const float Vv = studioSwing ? 255.0f / (240 - 16) : 1.0f;
+
+			const float Rv = Vv *  Rr;
+			const float Gu = Uu *  Gb;
+			const float Gv = Vv *  Gr;
+			const float Bu = Uu *  Bb;
+
+			const float R0 = (studioSwing * -16 * Yy - 128 * Rv) / 255;
+			const float G0 = (studioSwing * -16 * Yy - 128 * Gu - 128 * Gv) / 255;
+			const float B0 = (studioSwing * -16 * Yy - 128 * Bu) / 255;
+
+			Int c0 = Int(buffer[0][index[0]]);
+			Int c1 = Int(buffer[0][index[1]]);
+			Int c2 = Int(buffer[0][index[2]]);
+			Int c3 = Int(buffer[0][index[3]]);
+			c0 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+			UShort4 Y = As<UShort4>(Unpack(As<Byte4>(c0)));
+
+			computeIndices(index, uuuu, vvvv, wwww, offset, mipmap + sizeof(Mipmap), function);
+			c0 = Int(buffer[1][index[0]]);
+			c1 = Int(buffer[1][index[1]]);
+			c2 = Int(buffer[1][index[2]]);
+			c3 = Int(buffer[1][index[3]]);
+			c0 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+			UShort4 V = As<UShort4>(Unpack(As<Byte4>(c0)));
+
+			c0 = Int(buffer[2][index[0]]);
+			c1 = Int(buffer[2][index[1]]);
+			c2 = Int(buffer[2][index[2]]);
+			c3 = Int(buffer[2][index[3]]);
+			c0 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
+			UShort4 U = As<UShort4>(Unpack(As<Byte4>(c0)));
+
+			const UShort4 yY = UShort4(iround(Yy * 0x4000));
+			const UShort4 rV = UShort4(iround(Rv * 0x4000));
+			const UShort4 gU = UShort4(iround(-Gu * 0x4000));
+			const UShort4 gV = UShort4(iround(-Gv * 0x4000));
+			const UShort4 bU = UShort4(iround(Bu * 0x4000));
+
+			const UShort4 r0 = UShort4(iround(-R0 * 0x4000));
+			const UShort4 g0 = UShort4(iround(G0 * 0x4000));
+			const UShort4 b0 = UShort4(iround(-B0 * 0x4000));
+
+			UShort4 y = MulHigh(Y, yY);
+			UShort4 r = SubSat(y + MulHigh(V, rV), r0);
+			UShort4 g = SubSat(y + g0, MulHigh(U, gU) + MulHigh(V, gV));
+			UShort4 b = SubSat(y + MulHigh(U, bU), b0);
+
+			c.x = Min(r, UShort4(0x3FFF)) << 2;
+			c.y = Min(g, UShort4(0x3FFF)) << 2;
+			c.z = Min(b, UShort4(0x3FFF)) << 2;
+		}
+		else
+		{
+			return sampleTexel(index, buffer);
+		}
+
+		return c;
+	}
+
+	Vector4f SamplerCore::sampleTexel(Int4 &uuuu, Int4 &vvvv, Int4 &wwww, Float4 &z, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4], SamplerFunction function)
+	{
+		Vector4f c;
+
+		UInt index[4];
+		computeIndices(index, uuuu, vvvv, wwww, mipmap, function);
+
+		if(hasFloatTexture() || has32bitIntegerTextureComponents())
+		{
+			int f0 = state.textureType == TEXTURE_CUBE ? 0 : 0;
+			int f1 = state.textureType == TEXTURE_CUBE ? 1 : 0;
+			int f2 = state.textureType == TEXTURE_CUBE ? 2 : 0;
+			int f3 = state.textureType == TEXTURE_CUBE ? 3 : 0;
+
+			// Read texels
+			switch(textureComponentCount())
+			{
+			case 4:
+				c.x = *Pointer<Float4>(buffer[f0] + index[0] * 16, 16);
+				c.y = *Pointer<Float4>(buffer[f1] + index[1] * 16, 16);
+				c.z = *Pointer<Float4>(buffer[f2] + index[2] * 16, 16);
+				c.w = *Pointer<Float4>(buffer[f3] + index[3] * 16, 16);
+				transpose4x4(c.x, c.y, c.z, c.w);
+				break;
+			case 3:
+				c.x = *Pointer<Float4>(buffer[f0] + index[0] * 16, 16);
+				c.y = *Pointer<Float4>(buffer[f1] + index[1] * 16, 16);
+				c.z = *Pointer<Float4>(buffer[f2] + index[2] * 16, 16);
+				c.w = *Pointer<Float4>(buffer[f3] + index[3] * 16, 16);
+				transpose4x3(c.x, c.y, c.z, c.w);
+				break;
+			case 2:
+				// FIXME: Optimal shuffling?
+				c.x.xy = *Pointer<Float4>(buffer[f0] + index[0] * 8);
+				c.x.zw = *Pointer<Float4>(buffer[f1] + index[1] * 8 - 8);
+				c.z.xy = *Pointer<Float4>(buffer[f2] + index[2] * 8);
+				c.z.zw = *Pointer<Float4>(buffer[f3] + index[3] * 8 - 8);
+				c.y = c.x;
+				c.x = Float4(c.x.xz, c.z.xz);
+				c.y = Float4(c.y.yw, c.z.yw);
+				break;
+			case 1:
+				// FIXME: Optimal shuffling?
+				c.x.x = *Pointer<Float>(buffer[f0] + index[0] * 4);
+				c.x.y = *Pointer<Float>(buffer[f1] + index[1] * 4);
+				c.x.z = *Pointer<Float>(buffer[f2] + index[2] * 4);
+				c.x.w = *Pointer<Float>(buffer[f3] + index[3] * 4);
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			if(state.compare != COMPARE_BYPASS)
+			{
+				Float4 ref = z;
+
+				if(!hasFloatTexture())
+				{
+					ref = Min(Max(ref, Float4(0.0f)), Float4(1.0f));
+				}
+
+				Int4 boolean;
+
+				switch(state.compare)
+				{
+				case COMPARE_LESSEQUAL:    boolean = CmpLE(ref, c.x);  break;
+				case COMPARE_GREATEREQUAL: boolean = CmpNLT(ref, c.x); break;
+				case COMPARE_LESS:         boolean = CmpLT(ref, c.x);  break;
+				case COMPARE_GREATER:      boolean = CmpNLE(ref, c.x); break;
+				case COMPARE_EQUAL:        boolean = CmpEQ(ref, c.x);  break;
+				case COMPARE_NOTEQUAL:     boolean = CmpNEQ(ref, c.x); break;
+				case COMPARE_ALWAYS:       boolean = Int4(-1);         break;
+				case COMPARE_NEVER:        boolean = Int4(0);          break;
+				default:                   ASSERT(false);
+				}
+
+				c.x = As<Float4>(boolean & As<Int4>(Float4(1.0f)));
+				c.y = Float4(0.0f);
+				c.z = Float4(0.0f);
+				c.w = Float4(1.0f);
+			}
+		}
+		else
+		{
+			ASSERT(!hasYuvFormat());
+
+			Vector4s cs = sampleTexel(index, buffer);
+
+			bool isInteger = Surface::isNonNormalizedInteger(state.textureFormat);
+			int componentCount = textureComponentCount();
+			for(int n = 0; n < componentCount; n++)
+			{
+				if(hasUnsignedTextureComponent(n))
+				{
+					if(isInteger)
+					{
+						c[n] = As<Float4>(Int4(As<UShort4>(cs[n])));
+					}
+					else
+					{
+						c[n] = Float4(As<UShort4>(cs[n]));
+					}
+				}
+				else
+				{
+					if(isInteger)
+					{
+						c[n] = As<Float4>(Int4(cs[n]));
+					}
+					else
+					{
+						c[n] = Float4(cs[n]);
+					}
+				}
+			}
+		}
+
+		return c;
+	}
+
+	void SamplerCore::selectMipmap(Pointer<Byte> &texture, Pointer<Byte> buffer[4], Pointer<Byte> &mipmap, Float &lod, Int face[4], bool secondLOD)
+	{
+		if(state.mipmapFilter == MIPMAP_NONE)
+		{
+			mipmap = texture + OFFSET(Texture,mipmap[0]);
+		}
+		else
+		{
+			Int ilod;
+
+			if(state.mipmapFilter == MIPMAP_POINT)
+			{
+				ilod = RoundInt(lod);
+			}
+			else   // MIPMAP_LINEAR
+			{
+				ilod = Int(lod);
+			}
+
+			mipmap = texture + OFFSET(Texture,mipmap) + ilod * sizeof(Mipmap) + secondLOD * sizeof(Mipmap);
+		}
+
+		if(state.textureType != TEXTURE_CUBE)
+		{
+			buffer[0] = *Pointer<Pointer<Byte> >(mipmap + OFFSET(Mipmap,buffer[0]));
+
+			if(hasYuvFormat())
+			{
+				buffer[1] = *Pointer<Pointer<Byte> >(mipmap + OFFSET(Mipmap,buffer[1]));
+				buffer[2] = *Pointer<Pointer<Byte> >(mipmap + OFFSET(Mipmap,buffer[2]));
+			}
+		}
+		else
+		{
+			for(int i = 0; i < 4; i++)
+			{
+				buffer[i] = *Pointer<Pointer<Byte> >(mipmap + OFFSET(Mipmap,buffer) + face[i] * sizeof(void*));
+			}
+		}
+	}
+
+	Int4 SamplerCore::computeFilterOffset(Float &lod)
+	{
+		Int4 filter = -1;
+
+		if(state.textureFilter == FILTER_POINT)
+		{
+			filter = 0;
+		}
+		else if(state.textureFilter == FILTER_MIN_LINEAR_MAG_POINT)
+		{
+			filter = CmpNLE(Float4(lod), Float4(0.0f));
+		}
+		else if(state.textureFilter == FILTER_MIN_POINT_MAG_LINEAR)
+		{
+			filter = CmpLE(Float4(lod), Float4(0.0f));
+		}
+
+		return filter;
+	}
+
+	Short4 SamplerCore::address(Float4 &uw, AddressingMode addressingMode, Pointer<Byte> &mipmap)
+	{
+		if(addressingMode == ADDRESSING_LAYER && state.textureType != TEXTURE_2D_ARRAY)
+		{
+			return Short4();   // Unused
+		}
+		else if(addressingMode == ADDRESSING_LAYER && state.textureType == TEXTURE_2D_ARRAY)
+		{
+			return Min(Max(Short4(RoundInt(uw)), Short4(0)), *Pointer<Short4>(mipmap + OFFSET(Mipmap, depth)) - Short4(1));
+		}
+		else if(addressingMode == ADDRESSING_CLAMP || addressingMode == ADDRESSING_BORDER)
+		{
+			Float4 clamp = Min(Max(uw, Float4(0.0f)), Float4(65535.0f / 65536.0f));
+
+			return Short4(Int4(clamp * Float4(1 << 16)));
+		}
+		else if(addressingMode == ADDRESSING_MIRROR)
+		{
+			Int4 convert = Int4(uw * Float4(1 << 16));
+			Int4 mirror = (convert << 15) >> 31;
+
+			convert ^= mirror;
+
+			return Short4(convert);
+		}
+		else if(addressingMode == ADDRESSING_MIRRORONCE)
+		{
+			// Absolute value
+			Int4 convert = Int4(Abs(uw * Float4(1 << 16)));
+
+			// Clamp
+			convert -= Int4(0x00008000, 0x00008000, 0x00008000, 0x00008000);
+			convert = As<Int4>(PackSigned(convert, convert));
+
+			return As<Short4>(Int2(convert)) + Short4(0x8000u);
+		}
+		else   // Wrap
+		{
+			return Short4(Int4(uw * Float4(1 << 16)));
+		}
+	}
+
+	void SamplerCore::address(Float4 &uvw, Int4 &xyz0, Int4 &xyz1, Float4 &f, Pointer<Byte> &mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function)
+	{
+		if(addressingMode == ADDRESSING_LAYER && state.textureType != TEXTURE_2D_ARRAY)
+		{
+			return;   // Unused
+		}
+
+		Int4 dim = Int4(*Pointer<Short4>(mipmap + whd, 16));
+		Int4 maxXYZ = dim - Int4(1);
+
+		if(function == Fetch)
+		{
+			xyz0 = Min(Max(((function.option == Offset) && (addressingMode != ADDRESSING_LAYER)) ? As<Int4>(uvw) + As<Int4>(texOffset) : As<Int4>(uvw), Int4(0)), maxXYZ);
+		}
+		else if(addressingMode == ADDRESSING_LAYER && state.textureType == TEXTURE_2D_ARRAY)   // Note: Offset does not apply to array layers
+		{
+			xyz0 = Min(Max(RoundInt(uvw), Int4(0)), maxXYZ);
+		}
+		else
+		{
+			const int halfBits = 0x3EFFFFFF;   // Value just under 0.5f
+			const int oneBits  = 0x3F7FFFFF;   // Value just under 1.0f
+			const int twoBits  = 0x3FFFFFFF;   // Value just under 2.0f
+
+			bool pointFilter = state.textureFilter == FILTER_POINT ||
+			                   state.textureFilter == FILTER_MIN_POINT_MAG_LINEAR ||
+			                   state.textureFilter == FILTER_MIN_LINEAR_MAG_POINT;
+
+			Float4 coord = uvw;
+
+			if(state.textureType == TEXTURE_RECTANGLE)
+			{
+				// According to https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_rectangle.txt
+				// "CLAMP_TO_EDGE causes the s coordinate to be clamped to the range[0.5, wt - 0.5].
+				//  CLAMP_TO_EDGE causes the t coordinate to be clamped to the range[0.5, ht - 0.5]."
+				// Unless SwiftShader implements support for ADDRESSING_BORDER, other modes should be equivalent
+				// to CLAMP_TO_EDGE. Rectangle textures have no support for any MIRROR or REPEAT modes.
+				coord = Min(Max(coord, Float4(0.5f)), Float4(dim) - Float4(0.5f));
+			}
+			else
+			{
+				switch(addressingMode)
+				{
+				case ADDRESSING_CLAMP:
+				case ADDRESSING_BORDER:
+				case ADDRESSING_SEAMLESS:
+					// Linear filtering of cube doesn't require clamping because the coordinates
+					// are already in [0, 1] range and numerical imprecision is tolerated.
+					if(addressingMode != ADDRESSING_SEAMLESS || pointFilter)
+					{
+						Float4 one = As<Float4>(Int4(oneBits));
+						coord = Min(Max(coord, Float4(0.0f)), one);
+					}
+					break;
+				case ADDRESSING_MIRROR:
+				{
+					Float4 half = As<Float4>(Int4(halfBits));
+					Float4 one = As<Float4>(Int4(oneBits));
+					Float4 two = As<Float4>(Int4(twoBits));
+					coord = one - Abs(two * Frac(coord * half) - one);
+				}
+				break;
+				case ADDRESSING_MIRRORONCE:
+				{
+					Float4 half = As<Float4>(Int4(halfBits));
+					Float4 one = As<Float4>(Int4(oneBits));
+					Float4 two = As<Float4>(Int4(twoBits));
+					coord = one - Abs(two * Frac(Min(Max(coord, -one), two) * half) - one);
+				}
+				break;
+				default:   // Wrap
+					coord = Frac(coord);
+					break;
+				}
+
+				coord = coord * Float4(dim);
+			}
+
+			if(state.textureFilter == FILTER_POINT ||
+			   state.textureFilter == FILTER_GATHER)
+			{
+				xyz0 = Int4(coord);
+			}
+			else
+			{
+				if(state.textureFilter == FILTER_MIN_POINT_MAG_LINEAR ||
+				   state.textureFilter == FILTER_MIN_LINEAR_MAG_POINT)
+				{
+					coord -= As<Float4>(As<Int4>(Float4(0.5f)) & filter);
+				}
+				else
+				{
+					coord -= Float4(0.5f);
+				}
+
+				Float4 floor = Floor(coord);
+				xyz0 = Int4(floor);
+				f = coord - floor;
+			}
+
+			if(function.option == Offset)
+			{
+				xyz0 += As<Int4>(texOffset);
+			}
+
+			if(addressingMode == ADDRESSING_SEAMLESS)
+			{
+				xyz0 += Int4(1);
+			}
+
+			xyz1 = xyz0 - filter;   // Increment
+
+			if(function.option == Offset)
+			{
+				switch(addressingMode)
+				{
+				case ADDRESSING_SEAMLESS:
+					ASSERT(false);   // Cube sampling doesn't support offset.
+				case ADDRESSING_MIRROR:
+				case ADDRESSING_MIRRORONCE:
+				case ADDRESSING_BORDER:
+					// FIXME: Implement ADDRESSING_MIRROR, ADDRESSING_MIRRORONCE, and ADDRESSING_BORDER.
+					// Fall through to Clamp.
+				case ADDRESSING_CLAMP:
+					xyz0 = Min(Max(xyz0, Int4(0)), maxXYZ);
+					xyz1 = Min(Max(xyz1, Int4(0)), maxXYZ);
+					break;
+				default:   // Wrap
+					xyz0 = (xyz0 + dim * Int4(-MIN_PROGRAM_TEXEL_OFFSET)) % dim;
+					xyz1 = (xyz1 + dim * Int4(-MIN_PROGRAM_TEXEL_OFFSET)) % dim;
+					break;
+				}
+			}
+			else if(state.textureFilter != FILTER_POINT)
+			{
+				switch(addressingMode)
+				{
+				case ADDRESSING_SEAMLESS:
+					break;
+				case ADDRESSING_MIRROR:
+				case ADDRESSING_MIRRORONCE:
+				case ADDRESSING_BORDER:
+				case ADDRESSING_CLAMP:
+					xyz0 = Max(xyz0, Int4(0));
+					xyz1 = Min(xyz1, maxXYZ);
+					break;
+				default:   // Wrap
+					{
+						Int4 under = CmpLT(xyz0, Int4(0));
+						xyz0 = (under & maxXYZ) | (~under & xyz0);   // xyz < 0 ? dim - 1 : xyz   // FIXME: IfThenElse()
+
+						Int4 nover = CmpLT(xyz1, dim);
+						xyz1 = nover & xyz1;   // xyz >= dim ? 0 : xyz
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	void SamplerCore::convertFixed12(Short4 &cs, Float4 &cf)
+	{
+		cs = RoundShort4(cf * Float4(0x1000));
+	}
+
+	void SamplerCore::convertFixed12(Vector4s &cs, Vector4f &cf)
+	{
+		convertFixed12(cs.x, cf.x);
+		convertFixed12(cs.y, cf.y);
+		convertFixed12(cs.z, cf.z);
+		convertFixed12(cs.w, cf.w);
+	}
+
+	void SamplerCore::convertSigned12(Float4 &cf, Short4 &cs)
+	{
+		cf = Float4(cs) * Float4(1.0f / 0x0FFE);
+	}
+
+//	void SamplerCore::convertSigned12(Vector4f &cf, Vector4s &cs)
+//	{
+//		convertSigned12(cf.x, cs.x);
+//		convertSigned12(cf.y, cs.y);
+//		convertSigned12(cf.z, cs.z);
+//		convertSigned12(cf.w, cs.w);
+//	}
+
+	void SamplerCore::convertSigned15(Float4 &cf, Short4 &cs)
+	{
+		cf = Float4(cs) * Float4(1.0f / 0x7FFF);
+	}
+
+	void SamplerCore::convertUnsigned16(Float4 &cf, Short4 &cs)
+	{
+		cf = Float4(As<UShort4>(cs)) * Float4(1.0f / 0xFFFF);
+	}
+
+	void SamplerCore::sRGBtoLinear16_8_16(Short4 &c)
+	{
+		c = As<UShort4>(c) >> 8;
+
+		Pointer<Byte> LUT = Pointer<Byte>(constants + OFFSET(Constants,sRGBtoLinear8_16));
+
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 0))), 0);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 1))), 1);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 2))), 2);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 3))), 3);
+	}
+
+	void SamplerCore::sRGBtoLinear16_6_16(Short4 &c)
+	{
+		c = As<UShort4>(c) >> 10;
+
+		Pointer<Byte> LUT = Pointer<Byte>(constants + OFFSET(Constants,sRGBtoLinear6_16));
+
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 0))), 0);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 1))), 1);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 2))), 2);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 3))), 3);
+	}
+
+	void SamplerCore::sRGBtoLinear16_5_16(Short4 &c)
+	{
+		c = As<UShort4>(c) >> 11;
+
+		Pointer<Byte> LUT = Pointer<Byte>(constants + OFFSET(Constants,sRGBtoLinear5_16));
+
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 0))), 0);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 1))), 1);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 2))), 2);
+		c = Insert(c, *Pointer<Short>(LUT + 2 * Int(Extract(c, 3))), 3);
+	}
+
+	bool SamplerCore::hasFloatTexture() const
+	{
+		return Surface::isFloatFormat(state.textureFormat);
+	}
+
+	bool SamplerCore::hasUnnormalizedIntegerTexture() const
+	{
+		return Surface::isNonNormalizedInteger(state.textureFormat);
+	}
+
+	bool SamplerCore::hasUnsignedTextureComponent(int component) const
+	{
+		return Surface::isUnsignedComponent(state.textureFormat, component);
+	}
+
+	int SamplerCore::textureComponentCount() const
+	{
+		return Surface::componentCount(state.textureFormat);
+	}
+
+	bool SamplerCore::hasThirdCoordinate() const
+	{
+		return (state.textureType == TEXTURE_3D) || (state.textureType == TEXTURE_2D_ARRAY);
+	}
+
+	bool SamplerCore::has16bitTextureFormat() const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_R5G6B5:
+			return true;
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_L16:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return false;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool SamplerCore::has8bitTextureComponents() const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+			return true;
+		case FORMAT_R5G6B5:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_L16:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return false;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool SamplerCore::has16bitTextureComponents() const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_R5G6B5:
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return false;
+		case FORMAT_L16:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+			return true;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool SamplerCore::has32bitIntegerTextureComponents() const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_R5G6B5:
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_L16:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return false;
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+			return true;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool SamplerCore::hasYuvFormat() const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_YV12_BT601:
+		case FORMAT_YV12_BT709:
+		case FORMAT_YV12_JFIF:
+			return true;
+		case FORMAT_R5G6B5:
+		case FORMAT_R8_SNORM:
+		case FORMAT_G8R8_SNORM:
+		case FORMAT_X8B8G8R8_SNORM:
+		case FORMAT_A8B8G8R8_SNORM:
+		case FORMAT_R8I:
+		case FORMAT_R8UI:
+		case FORMAT_G8R8I:
+		case FORMAT_G8R8UI:
+		case FORMAT_X8B8G8R8I:
+		case FORMAT_X8B8G8R8UI:
+		case FORMAT_A8B8G8R8I:
+		case FORMAT_A8B8G8R8UI:
+		case FORMAT_R32I:
+		case FORMAT_R32UI:
+		case FORMAT_G32R32I:
+		case FORMAT_G32R32UI:
+		case FORMAT_X32B32G32R32I:
+		case FORMAT_X32B32G32R32UI:
+		case FORMAT_A32B32G32R32I:
+		case FORMAT_A32B32G32R32UI:
+		case FORMAT_G8R8:
+		case FORMAT_X8R8G8B8:
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8R8G8B8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+		case FORMAT_V8U8:
+		case FORMAT_Q8W8V8U8:
+		case FORMAT_X8L8V8U8:
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_X32B32G32R32F:
+		case FORMAT_A32B32G32R32F:
+		case FORMAT_X32B32G32R32F_UNSIGNED:
+		case FORMAT_A8:
+		case FORMAT_R8:
+		case FORMAT_L8:
+		case FORMAT_A8L8:
+		case FORMAT_D32F_LOCKABLE:
+		case FORMAT_D32FS8_TEXTURE:
+		case FORMAT_D32F_SHADOW:
+		case FORMAT_D32FS8_SHADOW:
+		case FORMAT_L16:
+		case FORMAT_G16R16:
+		case FORMAT_A16B16G16R16:
+		case FORMAT_R16I:
+		case FORMAT_R16UI:
+		case FORMAT_G16R16I:
+		case FORMAT_G16R16UI:
+		case FORMAT_X16B16G16R16I:
+		case FORMAT_X16B16G16R16UI:
+		case FORMAT_A16B16G16R16I:
+		case FORMAT_A16B16G16R16UI:
+		case FORMAT_V16U16:
+		case FORMAT_A16W16V16U16:
+		case FORMAT_Q16W16V16U16:
+			return false;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+
+	bool SamplerCore::isRGBComponent(int component) const
+	{
+		switch(state.textureFormat)
+		{
+		case FORMAT_R5G6B5:         return component < 3;
+		case FORMAT_R8_SNORM:      return component < 1;
+		case FORMAT_G8R8_SNORM:    return component < 2;
+		case FORMAT_X8B8G8R8_SNORM: return component < 3;
+		case FORMAT_A8B8G8R8_SNORM: return component < 3;
+		case FORMAT_R8I:            return component < 1;
+		case FORMAT_R8UI:           return component < 1;
+		case FORMAT_G8R8I:          return component < 2;
+		case FORMAT_G8R8UI:         return component < 2;
+		case FORMAT_X8B8G8R8I:      return component < 3;
+		case FORMAT_X8B8G8R8UI:     return component < 3;
+		case FORMAT_A8B8G8R8I:      return component < 3;
+		case FORMAT_A8B8G8R8UI:     return component < 3;
+		case FORMAT_R32I:           return component < 1;
+		case FORMAT_R32UI:          return component < 1;
+		case FORMAT_G32R32I:        return component < 2;
+		case FORMAT_G32R32UI:       return component < 2;
+		case FORMAT_X32B32G32R32I:  return component < 3;
+		case FORMAT_X32B32G32R32UI: return component < 3;
+		case FORMAT_A32B32G32R32I:  return component < 3;
+		case FORMAT_A32B32G32R32UI: return component < 3;
+		case FORMAT_G8R8:           return component < 2;
+		case FORMAT_X8R8G8B8:       return component < 3;
+		case FORMAT_X8B8G8R8:       return component < 3;
+		case FORMAT_A8R8G8B8:       return component < 3;
+		case FORMAT_A8B8G8R8:       return component < 3;
+		case FORMAT_SRGB8_X8:       return component < 3;
+		case FORMAT_SRGB8_A8:       return component < 3;
+		case FORMAT_V8U8:           return false;
+		case FORMAT_Q8W8V8U8:       return false;
+		case FORMAT_X8L8V8U8:       return false;
+		case FORMAT_R32F:           return component < 1;
+		case FORMAT_G32R32F:        return component < 2;
+		case FORMAT_X32B32G32R32F:  return component < 3;
+		case FORMAT_A32B32G32R32F:  return component < 3;
+		case FORMAT_X32B32G32R32F_UNSIGNED: return component < 3;
+		case FORMAT_A8:             return false;
+		case FORMAT_R8:             return component < 1;
+		case FORMAT_L8:             return component < 1;
+		case FORMAT_A8L8:           return component < 1;
+		case FORMAT_D32F_LOCKABLE:  return false;
+		case FORMAT_D32FS8_TEXTURE: return false;
+		case FORMAT_D32F_SHADOW:    return false;
+		case FORMAT_D32FS8_SHADOW:  return false;
+		case FORMAT_L16:            return component < 1;
+		case FORMAT_G16R16:         return component < 2;
+		case FORMAT_A16B16G16R16:   return component < 3;
+		case FORMAT_R16I:           return component < 1;
+		case FORMAT_R16UI:          return component < 1;
+		case FORMAT_G16R16I:        return component < 2;
+		case FORMAT_G16R16UI:       return component < 2;
+		case FORMAT_X16B16G16R16I:  return component < 3;
+		case FORMAT_X16B16G16R16UI: return component < 3;
+		case FORMAT_A16B16G16R16I:  return component < 3;
+		case FORMAT_A16B16G16R16UI: return component < 3;
+		case FORMAT_V16U16:         return false;
+		case FORMAT_A16W16V16U16:   return false;
+		case FORMAT_Q16W16V16U16:   return false;
+		case FORMAT_YV12_BT601:     return component < 3;
+		case FORMAT_YV12_BT709:     return component < 3;
+		case FORMAT_YV12_JFIF:      return component < 3;
+		default:
+			ASSERT(false);
+		}
+
+		return false;
+	}
+}
diff --git a/src/Pipeline/SamplerCore.hpp b/src/Pipeline/SamplerCore.hpp
new file mode 100644
index 0000000..684c1a7
--- /dev/null
+++ b/src/Pipeline/SamplerCore.hpp
@@ -0,0 +1,116 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_SamplerCore_hpp
+#define sw_SamplerCore_hpp
+
+#include "PixelRoutine.hpp"
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+	enum SamplerMethod
+	{
+		Implicit,  // Compute gradients (pixel shader only).
+		Bias,      // Compute gradients and add provided bias.
+		Lod,       // Use provided LOD.
+		Grad,      // Use provided gradients.
+		Fetch,     // Use provided integer coordinates.
+		Base       // Sample base level.
+	};
+
+	enum SamplerOption
+	{
+		None,
+		Offset   // Offset sample location by provided integer coordinates.
+	};
+
+	struct SamplerFunction
+	{
+		SamplerFunction(SamplerMethod method, SamplerOption option = None) : method(method), option(option) {}
+		operator SamplerMethod() { return method; }
+
+		const SamplerMethod method;
+		const SamplerOption option;
+ 	};
+
+	class SamplerCore
+	{
+	public:
+		SamplerCore(Pointer<Byte> &constants, const Sampler::State &state);
+
+		Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy);
+		Vector4f sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+		static Vector4f textureSize(Pointer<Byte> &mipmap, Float4 &lod);
+
+	private:
+		Vector4s sampleTexture(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Float4 &bias, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function, bool fixed12);
+
+		void border(Short4 &mask, Float4 &coordinates);
+		void border(Int4 &mask, Float4 &coordinates);
+		Short4 offsetSample(Short4 &uvw, Pointer<Byte> &mipmap, int halfOffset, bool wrap, int count, Float &lod);
+		Vector4s sampleFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function);
+		Vector4s sampleAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4s sampleQuad(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4s sampleQuad2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4s sample3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function);
+		Vector4f sampleFloatFilter(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], SamplerFunction function);
+		Vector4f sampleFloatAniso(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4f sampleFloat(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4f sampleFloat2D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &offset, Float &lod, Int face[4], bool secondLOD, SamplerFunction function);
+		Vector4f sampleFloat3D(Pointer<Byte> &texture, Float4 &u, Float4 &v, Float4 &w, Vector4f &offset, Float &lod, bool secondLOD, SamplerFunction function);
+		Float log2sqrt(Float lod);
+		Float log2(Float lod);
+		void computeLod(Pointer<Byte> &texture, Float &lod, Float &anisotropy, Float4 &uDelta, Float4 &vDelta, Float4 &u, Float4 &v, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerFunction function);
+		void computeLodCube(Pointer<Byte> &texture, Float &lod, Float4 &u, Float4 &v, Float4 &w, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, Float4 &M, SamplerFunction function);
+		void computeLod3D(Pointer<Byte> &texture, Float &lod, Float4 &u, Float4 &v, Float4 &w, const Float &lodBias, Vector4f &dsx, Vector4f &dsy, SamplerFunction function);
+		void cubeFace(Int face[4], Float4 &U, Float4 &V, Float4 &x, Float4 &y, Float4 &z, Float4 &M);
+		Short4 applyOffset(Short4 &uvw, Float4 &offset, const Int4 &whd, AddressingMode mode);
+		void computeIndices(UInt index[4], Short4 uuuu, Short4 vvvv, Short4 wwww, Vector4f &offset, const Pointer<Byte> &mipmap, SamplerFunction function);
+		void computeIndices(UInt index[4], Int4& uuuu, Int4& vvvv, Int4& wwww, const Pointer<Byte> &mipmap, SamplerFunction function);
+		Vector4s sampleTexel(Short4 &u, Short4 &v, Short4 &s, Vector4f &offset, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4], SamplerFunction function);
+		Vector4s sampleTexel(UInt index[4], Pointer<Byte> buffer[4]);
+		Vector4f sampleTexel(Int4 &u, Int4 &v, Int4 &s, Float4 &z, Pointer<Byte> &mipmap, Pointer<Byte> buffer[4], SamplerFunction function);
+		void selectMipmap(Pointer<Byte> &texture, Pointer<Byte> buffer[4], Pointer<Byte> &mipmap, Float &lod, Int face[4], bool secondLOD);
+		Short4 address(Float4 &uw, AddressingMode addressingMode, Pointer<Byte>& mipmap);
+		void address(Float4 &uw, Int4& xyz0, Int4& xyz1, Float4& f, Pointer<Byte>& mipmap, Float4 &texOffset, Int4 &filter, int whd, AddressingMode addressingMode, SamplerFunction function);
+		Int4 computeFilterOffset(Float &lod);
+
+		void convertFixed12(Short4 &ci, Float4 &cf);
+		void convertFixed12(Vector4s &cs, Vector4f &cf);
+		void convertSigned12(Float4 &cf, Short4 &ci);
+		void convertSigned15(Float4 &cf, Short4 &ci);
+		void convertUnsigned16(Float4 &cf, Short4 &ci);
+		void sRGBtoLinear16_8_16(Short4 &c);
+		void sRGBtoLinear16_6_16(Short4 &c);
+		void sRGBtoLinear16_5_16(Short4 &c);
+
+		bool hasFloatTexture() const;
+		bool hasUnnormalizedIntegerTexture() const;
+		bool hasUnsignedTextureComponent(int component) const;
+		int textureComponentCount() const;
+		bool hasThirdCoordinate() const;
+		bool has16bitTextureFormat() const;
+		bool has8bitTextureComponents() const;
+		bool has16bitTextureComponents() const;
+		bool has32bitIntegerTextureComponents() const;
+		bool hasYuvFormat() const;
+		bool isRGBComponent(int component) const;
+
+		Pointer<Byte> &constants;
+		const Sampler::State &state;
+	};
+}
+
+#endif   // sw_SamplerCore_hpp
diff --git a/src/Pipeline/SetupRoutine.cpp b/src/Pipeline/SetupRoutine.cpp
new file mode 100644
index 0000000..d733c2d
--- /dev/null
+++ b/src/Pipeline/SetupRoutine.cpp
@@ -0,0 +1,669 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "SetupRoutine.hpp"
+
+#include "Constants.hpp"
+#include "Renderer/Primitive.hpp"
+#include "Renderer/Polygon.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+	extern bool complementaryDepthBuffer;
+	extern TranscendentalPrecision logPrecision;
+	extern bool leadingVertexFirst;
+
+	SetupRoutine::SetupRoutine(const SetupProcessor::State &state) : state(state)
+	{
+		routine = 0;
+	}
+
+	SetupRoutine::~SetupRoutine()
+	{
+	}
+
+	void SetupRoutine::generate()
+	{
+		Function<Bool(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)> function;
+		{
+			Pointer<Byte> primitive(function.Arg<0>());
+			Pointer<Byte> tri(function.Arg<1>());
+			Pointer<Byte> polygon(function.Arg<2>());
+			Pointer<Byte> data(function.Arg<3>());
+
+			Pointer<Byte> constants = *Pointer<Pointer<Byte> >(data + OFFSET(DrawData,constants));
+
+			const bool point = state.isDrawPoint;
+			const bool sprite = state.pointSprite;
+			const bool line = state.isDrawLine;
+			const bool triangle = state.isDrawSolidTriangle || sprite;
+			const bool solidTriangle = state.isDrawSolidTriangle;
+
+			const int V0 = OFFSET(Triangle,v0);
+			const int V1 = (triangle || line) ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0);
+			const int V2 = triangle ? OFFSET(Triangle,v2) : (line ? OFFSET(Triangle,v1) : OFFSET(Triangle,v0));
+
+			int pos = state.positionRegister;
+
+			Pointer<Byte> v0 = tri + V0;
+			Pointer<Byte> v1 = tri + V1;
+			Pointer<Byte> v2 = tri + V2;
+
+			Array<Int> X(16);
+			Array<Int> Y(16);
+
+			X[0] = *Pointer<Int>(v0 + OFFSET(Vertex,X));
+			X[1] = *Pointer<Int>(v1 + OFFSET(Vertex,X));
+			X[2] = *Pointer<Int>(v2 + OFFSET(Vertex,X));
+
+			Y[0] = *Pointer<Int>(v0 + OFFSET(Vertex,Y));
+			Y[1] = *Pointer<Int>(v1 + OFFSET(Vertex,Y));
+			Y[2] = *Pointer<Int>(v2 + OFFSET(Vertex,Y));
+
+			Int d = 1;     // Winding direction
+
+			// Culling
+			if(solidTriangle)
+			{
+				Float x0 = Float(X[0]);
+				Float x1 = Float(X[1]);
+				Float x2 = Float(X[2]);
+
+				Float y0 = Float(Y[0]);
+				Float y1 = Float(Y[1]);
+				Float y2 = Float(Y[2]);
+
+				Float A = (y2 - y0) * x1 + (y1 - y2) * x0 + (y0 - y1) * x2;   // Area
+
+				If(A == 0.0f)
+				{
+					Return(false);
+				}
+
+				Int w0w1w2 = *Pointer<Int>(v0 + pos * 16 + 12) ^
+							 *Pointer<Int>(v1 + pos * 16 + 12) ^
+							 *Pointer<Int>(v2 + pos * 16 + 12);
+
+				A = IfThenElse(w0w1w2 < 0, -A, A);
+
+				if(state.cullMode == CULL_CLOCKWISE)
+				{
+					If(A >= 0.0f) Return(false);
+				}
+				else if(state.cullMode == CULL_COUNTERCLOCKWISE)
+				{
+					If(A <= 0.0f) Return(false);
+				}
+
+				d = IfThenElse(A < 0.0f, d, Int(0));
+
+				if(state.twoSidedStencil)
+				{
+					If(A > 0.0f)
+					{
+						*Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+						*Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+					}
+					Else
+					{
+						*Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+						*Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+					}
+				}
+
+				if(state.vFace)
+				{
+					*Pointer<Float>(primitive + OFFSET(Primitive,area)) = 0.5f * A;
+				}
+			}
+			else
+			{
+				if(state.twoSidedStencil)
+				{
+					*Pointer<Byte8>(primitive + OFFSET(Primitive,clockwiseMask)) = Byte8(0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF);
+					*Pointer<Byte8>(primitive + OFFSET(Primitive,invClockwiseMask)) = Byte8(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+				}
+			}
+
+			Int n = *Pointer<Int>(polygon + OFFSET(Polygon,n));
+			Int m = *Pointer<Int>(polygon + OFFSET(Polygon,i));
+
+			If(m != 0 || Bool(!solidTriangle))   // Clipped triangle; reproject
+			{
+				Pointer<Byte> V = polygon + OFFSET(Polygon,P) + m * sizeof(void*) * 16;
+
+				Int i = 0;
+
+				Do
+				{
+					Pointer<Float4> p = *Pointer<Pointer<Float4> >(V + i * sizeof(void*));
+					Float4 v = *Pointer<Float4>(p, 16);
+
+					Float w = v.w;
+					Float rhw = IfThenElse(w != 0.0f, 1.0f / w, Float(1.0f));
+
+					X[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float>(data + OFFSET(DrawData,Wx16)));
+					Y[i] = RoundInt(*Pointer<Float>(data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float>(data + OFFSET(DrawData,Hx16)));
+
+					i++;
+				}
+				Until(i >= n)
+			}
+
+			// Vertical range
+			Int yMin = Y[0];
+			Int yMax = Y[0];
+
+			Int i = 1;
+
+			Do
+			{
+				yMin = Min(Y[i], yMin);
+				yMax = Max(Y[i], yMax);
+
+				i++;
+			}
+			Until(i >= n)
+
+			if(state.multiSample > 1)
+			{
+				yMin = (yMin + 0x0A) >> 4;
+				yMax = (yMax + 0x14) >> 4;
+			}
+			else
+			{
+				yMin = (yMin + 0x0F) >> 4;
+				yMax = (yMax + 0x0F) >> 4;
+			}
+
+			If(yMin == yMax)
+			{
+				Return(false);
+			}
+
+			yMin = Max(yMin, *Pointer<Int>(data + OFFSET(DrawData,scissorY0)));
+			yMax = Min(yMax, *Pointer<Int>(data + OFFSET(DrawData,scissorY1)));
+
+			For(Int q = 0, q < state.multiSample, q++)
+			{
+				Array<Int> Xq(16);
+				Array<Int> Yq(16);
+
+				Int i = 0;
+
+				Do
+				{
+					Xq[i] = X[i];
+					Yq[i] = Y[i];
+
+					if(state.multiSample > 1)
+					{
+						Xq[i] = Xq[i] + *Pointer<Int>(constants + OFFSET(Constants,Xf) + q * sizeof(int));
+						Yq[i] = Yq[i] + *Pointer<Int>(constants + OFFSET(Constants,Yf) + q * sizeof(int));
+					}
+
+					i++;
+				}
+				Until(i >= n)
+
+				Pointer<Byte> leftEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->left)) + q * sizeof(Primitive);
+				Pointer<Byte> rightEdge = Pointer<Byte>(primitive + OFFSET(Primitive,outline->right)) + q * sizeof(Primitive);
+
+				if(state.multiSample > 1)
+				{
+					Int xMin = *Pointer<Int>(data + OFFSET(DrawData, scissorX0));
+					Int xMax = *Pointer<Int>(data + OFFSET(DrawData, scissorX1));
+					Short x = Short(Clamp((X[0] + 0xF) >> 4, xMin, xMax));
+
+					For(Int y = yMin - 1, y < yMax + 1, y++)
+					{
+						*Pointer<Short>(leftEdge + y * sizeof(Primitive::Span)) = x;
+						*Pointer<Short>(rightEdge + y * sizeof(Primitive::Span)) = x;
+					}
+				}
+
+				Xq[n] = Xq[0];
+				Yq[n] = Yq[0];
+
+				// Rasterize
+				{
+					Int i = 0;
+
+					Do
+					{
+						edge(primitive, data, Xq[i + 1 - d], Yq[i + 1 - d], Xq[i + d], Yq[i + d], q);
+
+						i++;
+					}
+					Until(i >= n)
+				}
+
+				if(state.multiSample == 1)
+				{
+					For(, yMin < yMax && *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + yMin * sizeof(Primitive::Span)), yMin++)
+					{
+						// Increments yMin
+					}
+
+					For(, yMax > yMin && *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span)) == *Pointer<Short>(rightEdge + (yMax - 1) * sizeof(Primitive::Span)), yMax--)
+					{
+						// Decrements yMax
+					}
+
+					If(yMin == yMax)
+					{
+						Return(false);
+					}
+
+					*Pointer<Short>(leftEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span));
+					*Pointer<Short>(rightEdge + (yMin - 1) * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + yMin * sizeof(Primitive::Span));
+					*Pointer<Short>(leftEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span));
+					*Pointer<Short>(rightEdge + yMax * sizeof(Primitive::Span)) = *Pointer<Short>(leftEdge + (yMax - 1) * sizeof(Primitive::Span));
+				}
+			}
+
+			*Pointer<Int>(primitive + OFFSET(Primitive,yMin)) = yMin;
+			*Pointer<Int>(primitive + OFFSET(Primitive,yMax)) = yMax;
+
+			// Sort by minimum y
+			if(solidTriangle && logPrecision >= WHQL)
+			{
+				Float y0 = *Pointer<Float>(v0 + pos * 16 + 4);
+				Float y1 = *Pointer<Float>(v1 + pos * 16 + 4);
+				Float y2 = *Pointer<Float>(v2 + pos * 16 + 4);
+
+				Float yMin = Min(Min(y0, y1), y2);
+
+				conditionalRotate1(yMin == y1, v0, v1, v2);
+				conditionalRotate2(yMin == y2, v0, v1, v2);
+			}
+
+			// Sort by maximum w
+			if(solidTriangle)
+			{
+				Float w0 = *Pointer<Float>(v0 + pos * 16 + 12);
+				Float w1 = *Pointer<Float>(v1 + pos * 16 + 12);
+				Float w2 = *Pointer<Float>(v2 + pos * 16 + 12);
+
+				Float wMax = Max(Max(w0, w1), w2);
+
+				conditionalRotate1(wMax == w1, v0, v1, v2);
+				conditionalRotate2(wMax == w2, v0, v1, v2);
+			}
+
+			Float w0 = *Pointer<Float>(v0 + pos * 16 + 12);
+			Float w1 = *Pointer<Float>(v1 + pos * 16 + 12);
+			Float w2 = *Pointer<Float>(v2 + pos * 16 + 12);
+
+			Float4 w012;
+
+			w012.x = w0;
+			w012.y = w1;
+			w012.z = w2;
+			w012.w = 1;
+
+			Float rhw0 = *Pointer<Float>(v0 + OFFSET(Vertex,W));
+
+			Int X0 = *Pointer<Int>(v0 + OFFSET(Vertex,X));
+			Int X1 = *Pointer<Int>(v1 + OFFSET(Vertex,X));
+			Int X2 = *Pointer<Int>(v2 + OFFSET(Vertex,X));
+
+			Int Y0 = *Pointer<Int>(v0 + OFFSET(Vertex,Y));
+			Int Y1 = *Pointer<Int>(v1 + OFFSET(Vertex,Y));
+			Int Y2 = *Pointer<Int>(v2 + OFFSET(Vertex,Y));
+
+			if(line)
+			{
+				X2 = X1 + Y1 - Y0;
+				Y2 = Y1 + X0 - X1;
+			}
+
+			Float dx = Float(X0) * (1.0f / 16.0f);
+			Float dy = Float(Y0) * (1.0f / 16.0f);
+
+			X1 -= X0;
+			Y1 -= Y0;
+
+			X2 -= X0;
+			Y2 -= Y0;
+
+			Float x1 = w1 * (1.0f / 16.0f) * Float(X1);
+			Float y1 = w1 * (1.0f / 16.0f) * Float(Y1);
+
+			Float x2 = w2 * (1.0f / 16.0f) * Float(X2);
+			Float y2 = w2 * (1.0f / 16.0f) * Float(Y2);
+
+			Float a = x1 * y2 - x2 * y1;
+
+			Float4 xQuad = Float4(0, 1, 0, 1) - Float4(dx);
+			Float4 yQuad = Float4(0, 0, 1, 1) - Float4(dy);
+
+			*Pointer<Float4>(primitive + OFFSET(Primitive,xQuad), 16) = xQuad;
+			*Pointer<Float4>(primitive + OFFSET(Primitive,yQuad), 16) = yQuad;
+
+			Float4 M[3];
+
+			M[0] = Float4(0, 0, 0, 0);
+			M[1] = Float4(0, 0, 0, 0);
+			M[2] = Float4(0, 0, 0, 0);
+
+			M[0].z = rhw0;
+
+			If(a != 0.0f)
+			{
+				Float A = 1.0f / a;
+				Float D = A * rhw0;
+
+				M[0].x = (y1 * w2 - y2 * w1) * D;
+				M[0].y = (x2 * w1 - x1 * w2) * D;
+			//	M[0].z = rhw0;
+			//	M[0].w = 0;
+
+				M[1].x = y2 * A;
+				M[1].y = -x2 * A;
+			//	M[1].z = 0;
+			//	M[1].w = 0;
+
+				M[2].x = -y1 * A;
+				M[2].y = x1 * A;
+			//	M[2].z = 0;
+			//	M[2].w = 0;
+			}
+
+			if(state.interpolateW)
+			{
+				Float4 ABC = M[0] + M[1] + M[2];
+
+				Float4 A = ABC.x;
+				Float4 B = ABC.y;
+				Float4 C = ABC.z;
+
+				*Pointer<Float4>(primitive + OFFSET(Primitive,w.A), 16) = A;
+				*Pointer<Float4>(primitive + OFFSET(Primitive,w.B), 16) = B;
+				*Pointer<Float4>(primitive + OFFSET(Primitive,w.C), 16) = C;
+			}
+
+			if(state.interpolateZ)
+			{
+				Float z0 = *Pointer<Float>(v0 + OFFSET(Vertex,Z));
+				Float z1 = *Pointer<Float>(v1 + OFFSET(Vertex,Z));
+				Float z2 = *Pointer<Float>(v2 + OFFSET(Vertex,Z));
+
+				z1 -= z0;
+				z2 -= z0;
+
+				Float4 A;
+				Float4 B;
+				Float4 C;
+
+				if(!point)
+				{
+					Float x1 = Float(X1) * (1.0f / 16.0f);
+					Float y1 = Float(Y1) * (1.0f / 16.0f);
+					Float x2 = Float(X2) * (1.0f / 16.0f);
+					Float y2 = Float(Y2) * (1.0f / 16.0f);
+
+					Float D = *Pointer<Float>(data + OFFSET(DrawData,depthRange)) / (x1 * y2 - x2 * y1);
+
+					Float a = (y2 * z1 - y1 * z2) * D;
+					Float b = (x1 * z2 - x2 * z1) * D;
+
+					A = Float4(a);
+					B = Float4(b);
+				}
+				else
+				{
+					A = Float4(0, 0, 0, 0);
+					B = Float4(0, 0, 0, 0);
+				}
+
+				*Pointer<Float4>(primitive + OFFSET(Primitive,z.A), 16) = A;
+				*Pointer<Float4>(primitive + OFFSET(Primitive,z.B), 16) = B;
+
+				Float c = z0;
+
+				if(state.isDrawTriangle && state.slopeDepthBias)
+				{
+					Float bias = Max(Abs(Float(A.x)), Abs(Float(B.x)));
+					bias *= *Pointer<Float>(data + OFFSET(DrawData,slopeDepthBias));
+
+					if(complementaryDepthBuffer)
+					{
+						bias = -bias;
+					}
+
+					c += bias;
+				}
+
+				C = Float4(c * *Pointer<Float>(data + OFFSET(DrawData,depthRange)) + *Pointer<Float>(data + OFFSET(DrawData,depthNear)));
+
+				*Pointer<Float4>(primitive + OFFSET(Primitive,z.C), 16) = C;
+			}
+
+			for(int interpolant = 0; interpolant < MAX_FRAGMENT_INPUTS; interpolant++)
+			{
+				for(int component = 0; component < 4; component++)
+				{
+					int attribute = state.gradient[interpolant][component].attribute;
+					bool flat = state.gradient[interpolant][component].flat;
+					bool wrap = state.gradient[interpolant][component].wrap;
+
+					if(attribute != Unused)
+					{
+						setupGradient(primitive, tri, w012, M, v0, v1, v2, OFFSET(Vertex,v[attribute][component]), OFFSET(Primitive,V[interpolant][component]), flat, sprite, state.perspective, wrap, component);
+					}
+				}
+			}
+
+			if(state.fog.attribute == Fog)
+			{
+				setupGradient(primitive, tri, w012, M, v0, v1, v2, OFFSET(Vertex,f), OFFSET(Primitive,f), state.fog.flat, false, state.perspective, false, 0);
+			}
+
+			Return(true);
+		}
+
+		routine = function(L"SetupRoutine");
+	}
+
+	void SetupRoutine::setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flat, bool sprite, bool perspective, bool wrap, int component)
+	{
+		Float4 i;
+
+		if(!flat)
+		{
+			if(!sprite)
+			{
+				i.x = *Pointer<Float>(v0 + attribute);
+				i.y = *Pointer<Float>(v1 + attribute);
+				i.z = *Pointer<Float>(v2 + attribute);
+				i.w = 0;
+			}
+			else
+			{
+				if(component == 0) i.x = 0.5f;
+				if(component == 1) i.x = 0.5f;
+				if(component == 2) i.x = 0.0f;
+				if(component == 3) i.x = 1.0f;
+
+				if(component == 0) i.y = 1.0f;
+				if(component == 1) i.y = 0.5f;
+				if(component == 2) i.y = 0.0f;
+				if(component == 3) i.y = 1.0f;
+
+				if(component == 0) i.z = 0.5f;
+				if(component == 1) i.z = 1.0f;
+				if(component == 2) i.z = 0.0f;
+				if(component == 3) i.z = 1.0f;
+
+				i.w = 0;
+			}
+
+			if(wrap)
+			{
+				Float m;
+
+				m = *Pointer<Float>(v0 + attribute);
+				m = Max(m, *Pointer<Float>(v1 + attribute));
+				m = Max(m, *Pointer<Float>(v2 + attribute));
+				m -= 0.5f;
+
+				// FIXME: Vectorize
+				If(Float(i.x) < m) i.x = i.x + 1.0f;
+				If(Float(i.y) < m) i.y = i.y + 1.0f;
+				If(Float(i.z) < m) i.z = i.z + 1.0f;
+			}
+
+			if(!perspective)
+			{
+				i *= w012;
+			}
+
+			Float4 A = i.xxxx * m[0];
+			Float4 B = i.yyyy * m[1];
+			Float4 C = i.zzzz * m[2];
+
+			C = A + B + C;
+
+			A = C.xxxx;
+			B = C.yyyy;
+			C = C.zzzz;
+
+			*Pointer<Float4>(primitive + planeEquation + 0, 16) = A;
+			*Pointer<Float4>(primitive + planeEquation + 16, 16) = B;
+			*Pointer<Float4>(primitive + planeEquation + 32, 16) = C;
+		}
+		else
+		{
+			int leadingVertex = leadingVertexFirst ? OFFSET(Triangle,v0) : OFFSET(Triangle,v2);
+			Float C = *Pointer<Float>(triangle + leadingVertex + attribute);
+
+			*Pointer<Float4>(primitive + planeEquation + 0, 16) = Float4(0, 0, 0, 0);
+			*Pointer<Float4>(primitive + planeEquation + 16, 16) = Float4(0, 0, 0, 0);
+			*Pointer<Float4>(primitive + planeEquation + 32, 16) = Float4(C);
+		}
+	}
+
+	void SetupRoutine::edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &Xa, const Int &Ya, const Int &Xb, const Int &Yb, Int &q)
+	{
+		If(Ya != Yb)
+		{
+			Bool swap = Yb < Ya;
+
+			Int X1 = IfThenElse(swap, Xb, Xa);
+			Int X2 = IfThenElse(swap, Xa, Xb);
+			Int Y1 = IfThenElse(swap, Yb, Ya);
+			Int Y2 = IfThenElse(swap, Ya, Yb);
+
+			Int y1 = Max((Y1 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY0)));
+			Int y2 = Min((Y2 + 0x0000000F) >> 4, *Pointer<Int>(data + OFFSET(DrawData,scissorY1)));
+
+			If(y1 < y2)
+			{
+				Int xMin = *Pointer<Int>(data + OFFSET(DrawData,scissorX0));
+				Int xMax = *Pointer<Int>(data + OFFSET(DrawData,scissorX1));
+
+				Pointer<Byte> leftEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->left);
+				Pointer<Byte> rightEdge = primitive + q * sizeof(Primitive) + OFFSET(Primitive,outline->right);
+				Pointer<Byte> edge = IfThenElse(swap, rightEdge, leftEdge);
+
+				// Deltas
+				Int DX12 = X2 - X1;
+				Int DY12 = Y2 - Y1;
+
+				Int FDX12 = DX12 << 4;
+				Int FDY12 = DY12 << 4;
+
+				Int X = DX12 * ((y1 << 4) - Y1) + (X1 & 0x0000000F) * DY12;
+				Int x = (X1 >> 4) + X / FDY12;   // Edge
+				Int d = X % FDY12;               // Error-term
+				Int ceil = -d >> 31;             // Ceiling division: remainder <= 0
+				x -= ceil;
+				d -= ceil & FDY12;
+
+				Int Q = FDX12 / FDY12;   // Edge-step
+				Int R = FDX12 % FDY12;   // Error-step
+				Int floor = R >> 31;     // Flooring division: remainder >= 0
+				Q += floor;
+				R += floor & FDY12;
+
+				Int D = FDY12;   // Error-overflow
+				Int y = y1;
+
+				Do
+				{
+					*Pointer<Short>(edge + y * sizeof(Primitive::Span)) = Short(Clamp(x, xMin, xMax));
+
+					x += Q;
+					d += R;
+
+					Int overflow = -d >> 31;
+
+					d -= D & overflow;
+					x -= overflow;
+
+					y++;
+				}
+				Until(y >= y2)
+			}
+		}
+	}
+
+	void SetupRoutine::conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2)
+	{
+		#if 0   // Rely on LLVM optimization
+			If(condition)
+			{
+				Pointer<Byte> vX;
+
+				vX = v0;
+				v0 = v1;
+				v1 = v2;
+				v2 = vX;
+			}
+		#else
+			Pointer<Byte> vX = v0;
+			v0 = IfThenElse(condition, v1, v0);
+			v1 = IfThenElse(condition, v2, v1);
+			v2 = IfThenElse(condition, vX, v2);
+		#endif
+	}
+
+	void SetupRoutine::conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2)
+	{
+		#if 0   // Rely on LLVM optimization
+			If(condition)
+			{
+				Pointer<Byte> vX;
+
+				vX = v2;
+				v2 = v1;
+				v1 = v0;
+				v0 = vX;
+			}
+		#else
+			Pointer<Byte> vX = v2;
+			v2 = IfThenElse(condition, v1, v2);
+			v1 = IfThenElse(condition, v0, v1);
+			v0 = IfThenElse(condition, vX, v0);
+		#endif
+	}
+
+	Routine *SetupRoutine::getRoutine()
+	{
+		return routine;
+	}
+}
diff --git a/src/Pipeline/SetupRoutine.hpp b/src/Pipeline/SetupRoutine.hpp
new file mode 100644
index 0000000..c1c3205
--- /dev/null
+++ b/src/Pipeline/SetupRoutine.hpp
@@ -0,0 +1,47 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_SetupRoutine_hpp
+#define sw_SetupRoutine_hpp
+
+#include "Renderer/SetupProcessor.hpp"
+#include "Reactor/Reactor.hpp"
+
+namespace sw
+{
+	class Context;
+
+	class SetupRoutine
+	{
+	public:
+		SetupRoutine(const SetupProcessor::State &state);
+
+		virtual ~SetupRoutine();
+
+		void generate();
+		Routine *getRoutine();
+
+	private:
+		void setupGradient(Pointer<Byte> &primitive, Pointer<Byte> &triangle, Float4 &w012, Float4 (&m)[3], Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2, int attribute, int planeEquation, bool flatShading, bool sprite, bool perspective, bool wrap, int component);
+		void edge(Pointer<Byte> &primitive, Pointer<Byte> &data, const Int &Xa, const Int &Ya, const Int &Xb, const Int &Yb, Int &q);
+		void conditionalRotate1(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
+		void conditionalRotate2(Bool condition, Pointer<Byte> &v0, Pointer<Byte> &v1, Pointer<Byte> &v2);
+
+		const SetupProcessor::State &state;
+
+		Routine *routine;
+	};
+}
+
+#endif   // sw_SetupRoutine_hpp
diff --git a/src/Pipeline/Shader.cpp b/src/Pipeline/Shader.cpp
new file mode 100644
index 0000000..36192c9
--- /dev/null
+++ b/src/Pipeline/Shader.cpp
@@ -0,0 +1,1927 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Shader.hpp"
+
+#include "VertexShader.hpp"
+#include "PixelShader.hpp"
+#include "Common/Math.hpp"
+#include "Common/Debug.hpp"
+
+#include <set>
+#include <fstream>
+#include <sstream>
+#include <stdarg.h>
+
+namespace sw
+{
+	volatile int Shader::serialCounter = 1;
+
+	Shader::Opcode Shader::OPCODE_DP(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_DP1;
+		case 2: return OPCODE_DP2;
+		case 3: return OPCODE_DP3;
+		case 4: return OPCODE_DP4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_LEN(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_ABS;
+		case 2: return OPCODE_LEN2;
+		case 3: return OPCODE_LEN3;
+		case 4: return OPCODE_LEN4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_DIST(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_DIST1;
+		case 2: return OPCODE_DIST2;
+		case 3: return OPCODE_DIST3;
+		case 4: return OPCODE_DIST4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_NRM(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_SGN;
+		case 2: return OPCODE_NRM2;
+		case 3: return OPCODE_NRM3;
+		case 4: return OPCODE_NRM4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_FORWARD(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_FORWARD1;
+		case 2: return OPCODE_FORWARD2;
+		case 3: return OPCODE_FORWARD3;
+		case 4: return OPCODE_FORWARD4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_REFLECT(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_REFLECT1;
+		case 2: return OPCODE_REFLECT2;
+		case 3: return OPCODE_REFLECT3;
+		case 4: return OPCODE_REFLECT4;
+		}
+	}
+
+	Shader::Opcode Shader::OPCODE_REFRACT(int i)
+	{
+		switch(i)
+		{
+		default: ASSERT(false);
+		case 1: return OPCODE_REFRACT1;
+		case 2: return OPCODE_REFRACT2;
+		case 3: return OPCODE_REFRACT3;
+		case 4: return OPCODE_REFRACT4;
+		}
+	}
+
+	Shader::Instruction::Instruction(Opcode opcode) : opcode(opcode), analysis(0)
+	{
+		control = CONTROL_RESERVED0;
+
+		predicate = false;
+		predicateNot = false;
+		predicateSwizzle = 0xE4;
+
+		coissue = false;
+		samplerType = SAMPLER_UNKNOWN;
+		usage = USAGE_POSITION;
+		usageIndex = 0;
+	}
+
+	Shader::Instruction::Instruction(const unsigned long *token, int size, unsigned char majorVersion) : analysis(0)
+	{
+		parseOperationToken(*token++, majorVersion);
+
+		samplerType = SAMPLER_UNKNOWN;
+		usage = USAGE_POSITION;
+		usageIndex = 0;
+
+		if(opcode == OPCODE_IF ||
+		   opcode == OPCODE_IFC ||
+		   opcode == OPCODE_LOOP ||
+		   opcode == OPCODE_REP ||
+		   opcode == OPCODE_BREAKC ||
+		   opcode == OPCODE_BREAKP)   // No destination operand
+		{
+			if(size > 0) parseSourceToken(0, token++, majorVersion);
+			if(size > 1) parseSourceToken(1, token++, majorVersion);
+			if(size > 2) parseSourceToken(2, token++, majorVersion);
+			if(size > 3) ASSERT(false);
+		}
+		else if(opcode == OPCODE_DCL)
+		{
+			parseDeclarationToken(*token++);
+			parseDestinationToken(token++, majorVersion);
+		}
+		else
+		{
+			if(size > 0)
+			{
+				parseDestinationToken(token, majorVersion);
+
+				if(dst.rel.type != PARAMETER_VOID && majorVersion >= 3)
+				{
+					token++;
+					size--;
+				}
+
+				token++;
+				size--;
+			}
+
+			if(predicate)
+			{
+				ASSERT(size != 0);
+
+				predicateNot = (Modifier)((*token & 0x0F000000) >> 24) == MODIFIER_NOT;
+				predicateSwizzle = (unsigned char)((*token & 0x00FF0000) >> 16);
+
+				token++;
+				size--;
+			}
+
+			for(int i = 0; size > 0; i++)
+			{
+				parseSourceToken(i, token, majorVersion);
+
+				token++;
+				size--;
+
+				if(src[i].rel.type != PARAMETER_VOID && majorVersion >= 2)
+				{
+					token++;
+					size--;
+				}
+			}
+		}
+	}
+
+	Shader::Instruction::~Instruction()
+	{
+	}
+
+	std::string Shader::Instruction::string(ShaderType shaderType, unsigned short version) const
+	{
+		std::string instructionString;
+
+		if(opcode != OPCODE_DCL)
+		{
+			instructionString += coissue ? "+ " : "";
+
+			if(predicate)
+			{
+				instructionString += predicateNot ? "(!p0" : "(p0";
+				instructionString += swizzleString(PARAMETER_PREDICATE, predicateSwizzle);
+				instructionString += ") ";
+			}
+
+			instructionString += operationString(version) + controlString() + dst.shiftString() + dst.modifierString();
+
+			if(dst.type != PARAMETER_VOID)
+			{
+				instructionString += " " + dst.string(shaderType, version) +
+				                           dst.relativeString() +
+				                           dst.maskString();
+			}
+
+			for(int i = 0; i < 4; i++)
+			{
+				if(src[i].type != PARAMETER_VOID)
+				{
+					instructionString += (dst.type != PARAMETER_VOID || i > 0) ? ", " : " ";
+					instructionString += src[i].preModifierString() +
+										 src[i].string(shaderType, version) +
+										 src[i].relativeString() +
+										 src[i].postModifierString() +
+										 src[i].swizzleString();
+				}
+			}
+		}
+		else   // DCL
+		{
+			instructionString += "dcl";
+
+			if(dst.type == PARAMETER_SAMPLER)
+			{
+				switch(samplerType)
+				{
+				case SAMPLER_UNKNOWN: instructionString += " ";        break;
+				case SAMPLER_1D:      instructionString += "_1d ";     break;
+				case SAMPLER_2D:      instructionString += "_2d ";     break;
+				case SAMPLER_CUBE:    instructionString += "_cube ";   break;
+				case SAMPLER_VOLUME:  instructionString += "_volume "; break;
+				default:
+					ASSERT(false);
+				}
+
+				instructionString += dst.string(shaderType, version);
+			}
+			else if(dst.type == PARAMETER_INPUT ||
+				    dst.type == PARAMETER_OUTPUT ||
+				    dst.type == PARAMETER_TEXTURE)
+			{
+				if(version >= 0x0300)
+				{
+					switch(usage)
+					{
+					case USAGE_POSITION:     instructionString += "_position";     break;
+					case USAGE_BLENDWEIGHT:  instructionString += "_blendweight";  break;
+					case USAGE_BLENDINDICES: instructionString += "_blendindices"; break;
+					case USAGE_NORMAL:       instructionString += "_normal";       break;
+					case USAGE_PSIZE:        instructionString += "_psize";        break;
+					case USAGE_TEXCOORD:     instructionString += "_texcoord";     break;
+					case USAGE_TANGENT:      instructionString += "_tangent";      break;
+					case USAGE_BINORMAL:     instructionString += "_binormal";     break;
+					case USAGE_TESSFACTOR:   instructionString += "_tessfactor";   break;
+					case USAGE_POSITIONT:    instructionString += "_positiont";    break;
+					case USAGE_COLOR:        instructionString += "_color";        break;
+					case USAGE_FOG:          instructionString += "_fog";          break;
+					case USAGE_DEPTH:        instructionString += "_depth";        break;
+					case USAGE_SAMPLE:       instructionString += "_sample";       break;
+					default:
+						ASSERT(false);
+					}
+
+					if(usageIndex > 0)
+					{
+						std::ostringstream buffer;
+
+						buffer << (int)usageIndex;
+
+						instructionString += buffer.str();
+					}
+				}
+				else ASSERT(dst.type != PARAMETER_OUTPUT);
+
+				instructionString += " ";
+
+				instructionString += dst.string(shaderType, version);
+				instructionString += dst.maskString();
+			}
+			else if(dst.type == PARAMETER_MISCTYPE)   // vPos and vFace
+			{
+				instructionString += " ";
+
+				instructionString += dst.string(shaderType, version);
+			}
+			else ASSERT(false);
+		}
+
+		return instructionString;
+	}
+
+	std::string Shader::DestinationParameter::modifierString() const
+	{
+		if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+		{
+			return "";
+		}
+
+		std::string modifierString;
+
+		if(saturate)
+		{
+			modifierString += "_sat";
+		}
+
+		if(partialPrecision)
+		{
+			modifierString += "_pp";
+		}
+
+		if(centroid)
+		{
+			modifierString += "_centroid";
+		}
+
+		return modifierString;
+	}
+
+	std::string Shader::DestinationParameter::shiftString() const
+	{
+		if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+		{
+			return "";
+		}
+
+		switch(shift)
+		{
+		case 0:		return "";
+		case 1:		return "_x2";
+		case 2:		return "_x4";
+		case 3:		return "_x8";
+		case -1:	return "_d2";
+		case -2:	return "_d4";
+		case -3:	return "_d8";
+		default:
+			return "";
+		//	ASSERT(false);   // FIXME
+		}
+	}
+
+	std::string Shader::DestinationParameter::maskString() const
+	{
+		if(type == PARAMETER_VOID || type == PARAMETER_LABEL)
+		{
+			return "";
+		}
+
+		switch(mask)
+		{
+		case 0x0:	return "";
+		case 0x1:	return ".x";
+		case 0x2:	return ".y";
+		case 0x3:	return ".xy";
+		case 0x4:	return ".z";
+		case 0x5:	return ".xz";
+		case 0x6:	return ".yz";
+		case 0x7:	return ".xyz";
+		case 0x8:	return ".w";
+		case 0x9:	return ".xw";
+		case 0xA:	return ".yw";
+		case 0xB:	return ".xyw";
+		case 0xC:	return ".zw";
+		case 0xD:	return ".xzw";
+		case 0xE:	return ".yzw";
+		case 0xF:	return "";
+		default:
+			ASSERT(false);
+		}
+
+		return "";
+	}
+
+	std::string Shader::SourceParameter::preModifierString() const
+	{
+		if(type == PARAMETER_VOID)
+		{
+			return "";
+		}
+
+		switch(modifier)
+		{
+		case MODIFIER_NONE:			return "";
+		case MODIFIER_NEGATE:		return "-";
+		case MODIFIER_BIAS:			return "";
+		case MODIFIER_BIAS_NEGATE:	return "-";
+		case MODIFIER_SIGN:			return "";
+		case MODIFIER_SIGN_NEGATE:	return "-";
+		case MODIFIER_COMPLEMENT:	return "1-";
+		case MODIFIER_X2:			return "";
+		case MODIFIER_X2_NEGATE:	return "-";
+		case MODIFIER_DZ:			return "";
+		case MODIFIER_DW:			return "";
+		case MODIFIER_ABS:			return "";
+		case MODIFIER_ABS_NEGATE:	return "-";
+		case MODIFIER_NOT:			return "!";
+		default:
+			ASSERT(false);
+		}
+
+		return "";
+	}
+
+	std::string Shader::Parameter::relativeString() const
+	{
+		if(type == PARAMETER_CONST || type == PARAMETER_INPUT || type == PARAMETER_OUTPUT || type == PARAMETER_TEMP)
+		{
+			if(rel.type == PARAMETER_VOID)
+			{
+				return "";
+			}
+			else if(rel.type == PARAMETER_ADDR)
+			{
+				switch(rel.swizzle & 0x03)
+				{
+				case 0: return "[a0.x]";
+				case 1: return "[a0.y]";
+				case 2: return "[a0.z]";
+				case 3: return "[a0.w]";
+				}
+			}
+			else if(rel.type == PARAMETER_TEMP)
+			{
+				std::ostringstream buffer;
+				buffer << rel.index;
+
+				switch(rel.swizzle & 0x03)
+				{
+				case 0: return "[r" + buffer.str() + ".x]";
+				case 1: return "[r" + buffer.str() + ".y]";
+				case 2: return "[r" + buffer.str() + ".z]";
+				case 3: return "[r" + buffer.str() + ".w]";
+				}
+			}
+			else if(rel.type == PARAMETER_LOOP)
+			{
+				return "[aL]";
+			}
+			else if(rel.type == PARAMETER_CONST)
+			{
+				std::ostringstream buffer;
+				buffer << rel.index;
+
+				switch(rel.swizzle & 0x03)
+				{
+				case 0: return "[c" + buffer.str() + ".x]";
+				case 1: return "[c" + buffer.str() + ".y]";
+				case 2: return "[c" + buffer.str() + ".z]";
+				case 3: return "[c" + buffer.str() + ".w]";
+				}
+			}
+			else ASSERT(false);
+		}
+
+		return "";
+	}
+
+	std::string Shader::SourceParameter::postModifierString() const
+	{
+		if(type == PARAMETER_VOID)
+		{
+			return "";
+		}
+
+		switch(modifier)
+		{
+		case MODIFIER_NONE:			return "";
+		case MODIFIER_NEGATE:		return "";
+		case MODIFIER_BIAS:			return "_bias";
+		case MODIFIER_BIAS_NEGATE:	return "_bias";
+		case MODIFIER_SIGN:			return "_bx2";
+		case MODIFIER_SIGN_NEGATE:	return "_bx2";
+		case MODIFIER_COMPLEMENT:	return "";
+		case MODIFIER_X2:			return "_x2";
+		case MODIFIER_X2_NEGATE:	return "_x2";
+		case MODIFIER_DZ:			return "_dz";
+		case MODIFIER_DW:			return "_dw";
+		case MODIFIER_ABS:			return "_abs";
+		case MODIFIER_ABS_NEGATE:	return "_abs";
+		case MODIFIER_NOT:			return "";
+		default:
+			ASSERT(false);
+		}
+
+		return "";
+	}
+
+	std::string Shader::SourceParameter::string(ShaderType shaderType, unsigned short version) const
+	{
+		if(type == PARAMETER_CONST && bufferIndex >= 0)
+		{
+			std::ostringstream buffer;
+			buffer << bufferIndex;
+
+			std::ostringstream offset;
+			offset << index;
+
+			return "cb" + buffer.str() + "[" + offset.str() + "]";
+		}
+		else
+		{
+			return Parameter::string(shaderType, version);
+		}
+	}
+
+	std::string Shader::SourceParameter::swizzleString() const
+	{
+		return Instruction::swizzleString(type, swizzle);
+	}
+
+	void Shader::Instruction::parseOperationToken(unsigned long token, unsigned char majorVersion)
+	{
+		if((token & 0xFFFF0000) == 0xFFFF0000 || (token & 0xFFFF0000) == 0xFFFE0000)   // Version token
+		{
+			opcode = (Opcode)token;
+
+			control = CONTROL_RESERVED0;
+			predicate = false;
+			coissue = false;
+		}
+		else
+		{
+			opcode = (Opcode)(token & 0x0000FFFF);
+			control = (Control)((token & 0x00FF0000) >> 16);
+
+			int size = (token & 0x0F000000) >> 24;
+
+			predicate = (token & 0x10000000) != 0x00000000;
+			coissue = (token & 0x40000000) != 0x00000000;
+
+			if(majorVersion < 2)
+			{
+				if(size != 0)
+				{
+					ASSERT(false);   // Reserved
+				}
+			}
+
+			if(majorVersion < 2)
+			{
+				if(predicate)
+				{
+					ASSERT(false);
+				}
+			}
+
+			if((token & 0x20000000) != 0x00000000)
+			{
+				ASSERT(false);   // Reserved
+			}
+
+			if(majorVersion >= 2)
+			{
+				if(coissue)
+				{
+					ASSERT(false);   // Reserved
+				}
+			}
+
+			if((token & 0x80000000) != 0x00000000)
+			{
+				ASSERT(false);
+			}
+		}
+	}
+
+	void Shader::Instruction::parseDeclarationToken(unsigned long token)
+	{
+		samplerType = (SamplerType)((token & 0x78000000) >> 27);
+		usage = (Usage)(token & 0x0000001F);
+		usageIndex = (unsigned char)((token & 0x000F0000) >> 16);
+	}
+
+	void Shader::Instruction::parseDestinationToken(const unsigned long *token, unsigned char majorVersion)
+	{
+		dst.index = (unsigned short)(token[0] & 0x000007FF);
+		dst.type = (ParameterType)(((token[0] & 0x00001800) >> 8) | ((token[0] & 0x70000000) >> 28));
+
+		// TODO: Check type and index range
+
+		bool relative = (token[0] & 0x00002000) != 0x00000000;
+		dst.rel.type = relative ? PARAMETER_ADDR : PARAMETER_VOID;
+		dst.rel.swizzle = 0x00;
+		dst.rel.scale = 1;
+
+		if(relative && majorVersion >= 3)
+		{
+			dst.rel.type = (ParameterType)(((token[1] & 0x00001800) >> 8) | ((token[1] & 0x70000000) >> 28));
+			dst.rel.swizzle = (unsigned char)((token[1] & 0x00FF0000) >> 16);
+		}
+		else if(relative) ASSERT(false);   // Reserved
+
+		if((token[0] & 0x0000C000) != 0x00000000)
+		{
+			ASSERT(false);   // Reserved
+		}
+
+		dst.mask = (unsigned char)((token[0] & 0x000F0000) >> 16);
+		dst.saturate = (token[0] & 0x00100000) != 0;
+		dst.partialPrecision = (token[0] & 0x00200000) != 0;
+		dst.centroid = (token[0] & 0x00400000) != 0;
+		dst.shift = (signed char)((token[0] & 0x0F000000) >> 20) >> 4;
+
+		if(majorVersion >= 2)
+		{
+			if(dst.shift)
+			{
+				ASSERT(false);   // Reserved
+			}
+		}
+
+		if((token[0] & 0x80000000) != 0x80000000)
+		{
+			ASSERT(false);
+		}
+	}
+
+	void Shader::Instruction::parseSourceToken(int i, const unsigned long *token, unsigned char majorVersion)
+	{
+		// Defaults
+		src[i].index = 0;
+		src[i].type = PARAMETER_VOID;
+		src[i].modifier = MODIFIER_NONE;
+		src[i].swizzle = 0xE4;
+		src[i].rel.type = PARAMETER_VOID;
+		src[i].rel.swizzle = 0x00;
+		src[i].rel.scale = 1;
+
+		switch(opcode)
+		{
+		case OPCODE_DEF:
+			src[0].type = PARAMETER_FLOAT4LITERAL;
+			src[0].value[i] = *(float*)token;
+			break;
+		case OPCODE_DEFB:
+			src[0].type = PARAMETER_BOOL1LITERAL;
+			src[0].boolean[0] = *(int*)token;
+			break;
+		case OPCODE_DEFI:
+			src[0].type = PARAMETER_INT4LITERAL;
+			src[0].integer[i] = *(int*)token;
+			break;
+		default:
+			src[i].index = (unsigned short)(token[0] & 0x000007FF);
+			src[i].type = (ParameterType)(((token[0] & 0x00001800) >> 8) | ((token[0] & 0x70000000) >> 28));
+
+			// FIXME: Check type and index range
+
+			bool relative = (token[0] & 0x00002000) != 0x00000000;
+			src[i].rel.type = relative ? PARAMETER_ADDR : PARAMETER_VOID;
+
+			if((token[0] & 0x0000C000) != 0x00000000)
+			{
+				if(opcode != OPCODE_DEF &&
+				   opcode != OPCODE_DEFI &&
+				   opcode != OPCODE_DEFB)
+				{
+					ASSERT(false);
+				}
+			}
+
+			src[i].swizzle = (unsigned char)((token[0] & 0x00FF0000) >> 16);
+			src[i].modifier = (Modifier)((token[0] & 0x0F000000) >> 24);
+
+			if((token[0] & 0x80000000) != 0x80000000)
+			{
+				if(opcode != OPCODE_DEF &&
+				   opcode != OPCODE_DEFI &&
+				   opcode != OPCODE_DEFB)
+				{
+					ASSERT(false);
+				}
+			}
+
+			if(relative && majorVersion >= 2)
+			{
+				src[i].rel.type = (ParameterType)(((token[1] & 0x00001800) >> 8) | ((token[1] & 0x70000000) >> 28));
+				src[i].rel.swizzle = (unsigned char)((token[1] & 0x00FF0000) >> 16);
+			}
+		}
+	}
+
+	std::string Shader::Instruction::swizzleString(ParameterType type, unsigned char swizzle)
+	{
+		if(type == PARAMETER_VOID || type == PARAMETER_LABEL || swizzle == 0xE4)
+		{
+			return "";
+		}
+
+		int x = (swizzle & 0x03) >> 0;
+		int y = (swizzle & 0x0C) >> 2;
+		int z = (swizzle & 0x30) >> 4;
+		int w = (swizzle & 0xC0) >> 6;
+
+		std::string swizzleString = ".";
+
+		switch(x)
+		{
+		case 0: swizzleString += "x"; break;
+		case 1: swizzleString += "y"; break;
+		case 2: swizzleString += "z"; break;
+		case 3: swizzleString += "w"; break;
+		}
+
+		if(!(x == y && y == z && z == w))
+		{
+			switch(y)
+			{
+			case 0: swizzleString += "x"; break;
+			case 1: swizzleString += "y"; break;
+			case 2: swizzleString += "z"; break;
+			case 3: swizzleString += "w"; break;
+			}
+
+			if(!(y == z && z == w))
+			{
+				switch(z)
+				{
+				case 0: swizzleString += "x"; break;
+				case 1: swizzleString += "y"; break;
+				case 2: swizzleString += "z"; break;
+				case 3: swizzleString += "w"; break;
+				}
+
+				if(!(z == w))
+				{
+					switch(w)
+					{
+					case 0: swizzleString += "x"; break;
+					case 1: swizzleString += "y"; break;
+					case 2: swizzleString += "z"; break;
+					case 3: swizzleString += "w"; break;
+					}
+				}
+			}
+		}
+
+		return swizzleString;
+	}
+
+	std::string Shader::Instruction::operationString(unsigned short version) const
+	{
+		switch(opcode)
+		{
+		case OPCODE_NULL:            return "null";
+		case OPCODE_NOP:             return "nop";
+		case OPCODE_MOV:             return "mov";
+		case OPCODE_ADD:             return "add";
+		case OPCODE_IADD:            return "iadd";
+		case OPCODE_SUB:             return "sub";
+		case OPCODE_ISUB:            return "isub";
+		case OPCODE_MAD:             return "mad";
+		case OPCODE_IMAD:            return "imad";
+		case OPCODE_MUL:             return "mul";
+		case OPCODE_IMUL:            return "imul";
+		case OPCODE_RCPX:            return "rcpx";
+		case OPCODE_DIV:             return "div";
+		case OPCODE_IDIV:            return "idiv";
+		case OPCODE_UDIV:            return "udiv";
+		case OPCODE_MOD:             return "mod";
+		case OPCODE_IMOD:            return "imod";
+		case OPCODE_UMOD:            return "umod";
+		case OPCODE_SHL:             return "shl";
+		case OPCODE_ISHR:            return "ishr";
+		case OPCODE_USHR:            return "ushr";
+		case OPCODE_RSQX:            return "rsqx";
+		case OPCODE_SQRT:            return "sqrt";
+		case OPCODE_RSQ:             return "rsq";
+		case OPCODE_LEN2:            return "len2";
+		case OPCODE_LEN3:            return "len3";
+		case OPCODE_LEN4:            return "len4";
+		case OPCODE_DIST1:           return "dist1";
+		case OPCODE_DIST2:           return "dist2";
+		case OPCODE_DIST3:           return "dist3";
+		case OPCODE_DIST4:           return "dist4";
+		case OPCODE_DP3:             return "dp3";
+		case OPCODE_DP4:             return "dp4";
+		case OPCODE_DET2:            return "det2";
+		case OPCODE_DET3:            return "det3";
+		case OPCODE_DET4:            return "det4";
+		case OPCODE_MIN:             return "min";
+		case OPCODE_IMIN:            return "imin";
+		case OPCODE_UMIN:            return "umin";
+		case OPCODE_MAX:             return "max";
+		case OPCODE_IMAX:            return "imax";
+		case OPCODE_UMAX:            return "umax";
+		case OPCODE_SLT:             return "slt";
+		case OPCODE_SGE:             return "sge";
+		case OPCODE_EXP2X:           return "exp2x";
+		case OPCODE_LOG2X:           return "log2x";
+		case OPCODE_LIT:             return "lit";
+		case OPCODE_ATT:             return "att";
+		case OPCODE_LRP:             return "lrp";
+		case OPCODE_STEP:            return "step";
+		case OPCODE_SMOOTH:          return "smooth";
+		case OPCODE_FLOATBITSTOINT:  return "floatBitsToInt";
+		case OPCODE_FLOATBITSTOUINT: return "floatBitsToUInt";
+		case OPCODE_INTBITSTOFLOAT:  return "intBitsToFloat";
+		case OPCODE_UINTBITSTOFLOAT: return "uintBitsToFloat";
+		case OPCODE_PACKSNORM2x16:   return "packSnorm2x16";
+		case OPCODE_PACKUNORM2x16:   return "packUnorm2x16";
+		case OPCODE_PACKHALF2x16:    return "packHalf2x16";
+		case OPCODE_UNPACKSNORM2x16: return "unpackSnorm2x16";
+		case OPCODE_UNPACKUNORM2x16: return "unpackUnorm2x16";
+		case OPCODE_UNPACKHALF2x16:  return "unpackHalf2x16";
+		case OPCODE_FRC:             return "frc";
+		case OPCODE_M4X4:            return "m4x4";
+		case OPCODE_M4X3:            return "m4x3";
+		case OPCODE_M3X4:            return "m3x4";
+		case OPCODE_M3X3:            return "m3x3";
+		case OPCODE_M3X2:            return "m3x2";
+		case OPCODE_CALL:            return "call";
+		case OPCODE_CALLNZ:          return "callnz";
+		case OPCODE_LOOP:            return "loop";
+		case OPCODE_RET:             return "ret";
+		case OPCODE_ENDLOOP:         return "endloop";
+		case OPCODE_LABEL:           return "label";
+		case OPCODE_DCL:             return "dcl";
+		case OPCODE_POWX:            return "powx";
+		case OPCODE_CRS:             return "crs";
+		case OPCODE_SGN:             return "sgn";
+		case OPCODE_ISGN:            return "isgn";
+		case OPCODE_ABS:             return "abs";
+		case OPCODE_IABS:            return "iabs";
+		case OPCODE_NRM2:            return "nrm2";
+		case OPCODE_NRM3:            return "nrm3";
+		case OPCODE_NRM4:            return "nrm4";
+		case OPCODE_SINCOS:          return "sincos";
+		case OPCODE_REP:             return "rep";
+		case OPCODE_ENDREP:          return "endrep";
+		case OPCODE_IF:              return "if";
+		case OPCODE_IFC:             return "ifc";
+		case OPCODE_ELSE:            return "else";
+		case OPCODE_ENDIF:           return "endif";
+		case OPCODE_BREAK:           return "break";
+		case OPCODE_BREAKC:          return "breakc";
+		case OPCODE_MOVA:            return "mova";
+		case OPCODE_DEFB:            return "defb";
+		case OPCODE_DEFI:            return "defi";
+		case OPCODE_TEXCOORD:        return "texcoord";
+		case OPCODE_TEXKILL:         return "texkill";
+		case OPCODE_DISCARD:         return "discard";
+		case OPCODE_TEX:
+			if(version < 0x0104)     return "tex";
+			else                     return "texld";
+		case OPCODE_TEXBEM:          return "texbem";
+		case OPCODE_TEXBEML:         return "texbeml";
+		case OPCODE_TEXREG2AR:       return "texreg2ar";
+		case OPCODE_TEXREG2GB:       return "texreg2gb";
+		case OPCODE_TEXM3X2PAD:      return "texm3x2pad";
+		case OPCODE_TEXM3X2TEX:      return "texm3x2tex";
+		case OPCODE_TEXM3X3PAD:      return "texm3x3pad";
+		case OPCODE_TEXM3X3TEX:      return "texm3x3tex";
+		case OPCODE_RESERVED0:       return "reserved0";
+		case OPCODE_TEXM3X3SPEC:     return "texm3x3spec";
+		case OPCODE_TEXM3X3VSPEC:    return "texm3x3vspec";
+		case OPCODE_EXPP:            return "expp";
+		case OPCODE_LOGP:            return "logp";
+		case OPCODE_CND:             return "cnd";
+		case OPCODE_DEF:             return "def";
+		case OPCODE_TEXREG2RGB:      return "texreg2rgb";
+		case OPCODE_TEXDP3TEX:       return "texdp3tex";
+		case OPCODE_TEXM3X2DEPTH:    return "texm3x2depth";
+		case OPCODE_TEXDP3:          return "texdp3";
+		case OPCODE_TEXM3X3:         return "texm3x3";
+		case OPCODE_TEXDEPTH:        return "texdepth";
+		case OPCODE_CMP0:            return "cmp0";
+		case OPCODE_ICMP:            return "icmp";
+		case OPCODE_UCMP:            return "ucmp";
+		case OPCODE_SELECT:          return "select";
+		case OPCODE_EXTRACT:         return "extract";
+		case OPCODE_INSERT:          return "insert";
+		case OPCODE_BEM:             return "bem";
+		case OPCODE_DP2ADD:          return "dp2add";
+		case OPCODE_DFDX:            return "dFdx";
+		case OPCODE_DFDY:            return "dFdy";
+		case OPCODE_FWIDTH:          return "fwidth";
+		case OPCODE_TEXLDD:          return "texldd";
+		case OPCODE_CMP:             return "cmp";
+		case OPCODE_TEXLDL:          return "texldl";
+		case OPCODE_TEXBIAS:         return "texbias";
+		case OPCODE_TEXOFFSET:       return "texoffset";
+		case OPCODE_TEXOFFSETBIAS:   return "texoffsetbias";
+		case OPCODE_TEXLODOFFSET:    return "texlodoffset";
+		case OPCODE_TEXELFETCH:      return "texelfetch";
+		case OPCODE_TEXELFETCHOFFSET: return "texelfetchoffset";
+		case OPCODE_TEXGRAD:         return "texgrad";
+		case OPCODE_TEXGRADOFFSET:   return "texgradoffset";
+		case OPCODE_BREAKP:          return "breakp";
+		case OPCODE_TEXSIZE:         return "texsize";
+		case OPCODE_PHASE:           return "phase";
+		case OPCODE_COMMENT:         return "comment";
+		case OPCODE_END:             return "end";
+		case OPCODE_PS_1_0:          return "ps_1_0";
+		case OPCODE_PS_1_1:          return "ps_1_1";
+		case OPCODE_PS_1_2:          return "ps_1_2";
+		case OPCODE_PS_1_3:          return "ps_1_3";
+		case OPCODE_PS_1_4:          return "ps_1_4";
+		case OPCODE_PS_2_0:          return "ps_2_0";
+		case OPCODE_PS_2_x:          return "ps_2_x";
+		case OPCODE_PS_3_0:          return "ps_3_0";
+		case OPCODE_VS_1_0:          return "vs_1_0";
+		case OPCODE_VS_1_1:          return "vs_1_1";
+		case OPCODE_VS_2_0:          return "vs_2_0";
+		case OPCODE_VS_2_x:          return "vs_2_x";
+		case OPCODE_VS_2_sw:         return "vs_2_sw";
+		case OPCODE_VS_3_0:          return "vs_3_0";
+		case OPCODE_VS_3_sw:         return "vs_3_sw";
+		case OPCODE_WHILE:           return "while";
+		case OPCODE_ENDWHILE:        return "endwhile";
+		case OPCODE_COS:             return "cos";
+		case OPCODE_SIN:             return "sin";
+		case OPCODE_TAN:             return "tan";
+		case OPCODE_ACOS:            return "acos";
+		case OPCODE_ASIN:            return "asin";
+		case OPCODE_ATAN:            return "atan";
+		case OPCODE_ATAN2:           return "atan2";
+		case OPCODE_COSH:            return "cosh";
+		case OPCODE_SINH:            return "sinh";
+		case OPCODE_TANH:            return "tanh";
+		case OPCODE_ACOSH:           return "acosh";
+		case OPCODE_ASINH:           return "asinh";
+		case OPCODE_ATANH:           return "atanh";
+		case OPCODE_DP1:             return "dp1";
+		case OPCODE_DP2:             return "dp2";
+		case OPCODE_TRUNC:           return "trunc";
+		case OPCODE_FLOOR:           return "floor";
+		case OPCODE_ROUND:           return "round";
+		case OPCODE_ROUNDEVEN:       return "roundEven";
+		case OPCODE_CEIL:            return "ceil";
+		case OPCODE_EXP2:            return "exp2";
+		case OPCODE_LOG2:            return "log2";
+		case OPCODE_EXP:             return "exp";
+		case OPCODE_LOG:             return "log";
+		case OPCODE_POW:             return "pow";
+		case OPCODE_F2B:             return "f2b";
+		case OPCODE_B2F:             return "b2f";
+		case OPCODE_F2I:             return "f2i";
+		case OPCODE_I2F:             return "i2f";
+		case OPCODE_F2U:             return "f2u";
+		case OPCODE_U2F:             return "u2f";
+		case OPCODE_B2I:             return "b2i";
+		case OPCODE_I2B:             return "i2b";
+		case OPCODE_ALL:             return "all";
+		case OPCODE_ANY:             return "any";
+		case OPCODE_NEG:             return "neg";
+		case OPCODE_INEG:            return "ineg";
+		case OPCODE_ISNAN:           return "isnan";
+		case OPCODE_ISINF:           return "isinf";
+		case OPCODE_NOT:             return "not";
+		case OPCODE_OR:              return "or";
+		case OPCODE_XOR:             return "xor";
+		case OPCODE_AND:             return "and";
+		case OPCODE_EQ:              return "eq";
+		case OPCODE_NE:              return "neq";
+		case OPCODE_FORWARD1:        return "forward1";
+		case OPCODE_FORWARD2:        return "forward2";
+		case OPCODE_FORWARD3:        return "forward3";
+		case OPCODE_FORWARD4:        return "forward4";
+		case OPCODE_REFLECT1:        return "reflect1";
+		case OPCODE_REFLECT2:        return "reflect2";
+		case OPCODE_REFLECT3:        return "reflect3";
+		case OPCODE_REFLECT4:        return "reflect4";
+		case OPCODE_REFRACT1:        return "refract1";
+		case OPCODE_REFRACT2:        return "refract2";
+		case OPCODE_REFRACT3:        return "refract3";
+		case OPCODE_REFRACT4:        return "refract4";
+		case OPCODE_LEAVE:           return "leave";
+		case OPCODE_CONTINUE:        return "continue";
+		case OPCODE_TEST:            return "test";
+		case OPCODE_SWITCH:          return "switch";
+		case OPCODE_ENDSWITCH:       return "endswitch";
+		default:
+			ASSERT(false);
+		}
+
+		return "<unknown>";
+	}
+
+	std::string Shader::Instruction::controlString() const
+	{
+		if(opcode != OPCODE_LOOP && opcode != OPCODE_BREAKC && opcode != OPCODE_IFC && opcode != OPCODE_CMP)
+		{
+			if(project) return "p";
+
+			if(bias) return "b";
+
+			// FIXME: LOD
+		}
+
+		switch(control)
+		{
+		case 1: return "_gt";
+		case 2: return "_eq";
+		case 3: return "_ge";
+		case 4: return "_lt";
+		case 5: return "_ne";
+		case 6: return "_le";
+		default:
+			return "";
+		//	ASSERT(false);   // FIXME
+		}
+	}
+
+	std::string Shader::Parameter::string(ShaderType shaderType, unsigned short version) const
+	{
+		std::ostringstream buffer;
+
+		if(type == PARAMETER_FLOAT4LITERAL)
+		{
+			buffer << '{' << value[0] << ", " << value[1] << ", " << value[2] << ", " << value[3] << '}';
+
+			return buffer.str();
+		}
+		else if(type != PARAMETER_RASTOUT && !(type == PARAMETER_ADDR && shaderType == SHADER_VERTEX) && type != PARAMETER_LOOP && type != PARAMETER_PREDICATE && type != PARAMETER_MISCTYPE)
+		{
+			buffer << index;
+
+			return typeString(shaderType, version) + buffer.str();
+		}
+		else
+		{
+			return typeString(shaderType, version);
+		}
+	}
+
+	std::string Shader::Parameter::typeString(ShaderType shaderType, unsigned short version) const
+	{
+		switch(type)
+		{
+		case PARAMETER_TEMP:			return "r";
+		case PARAMETER_INPUT:			return "v";
+		case PARAMETER_CONST:			return "c";
+		case PARAMETER_TEXTURE:
+	//	case PARAMETER_ADDR:
+			if(shaderType == SHADER_PIXEL)	return "t";
+			else							return "a0";
+		case PARAMETER_RASTOUT:
+			if(index == 0)              return "oPos";
+			else if(index == 1)         return "oFog";
+			else if(index == 2)         return "oPts";
+			else                        ASSERT(false);
+		case PARAMETER_ATTROUT:			return "oD";
+		case PARAMETER_TEXCRDOUT:
+	//	case PARAMETER_OUTPUT:			return "";
+			if(version < 0x0300)		return "oT";
+			else						return "o";
+		case PARAMETER_CONSTINT:		return "i";
+		case PARAMETER_COLOROUT:		return "oC";
+		case PARAMETER_DEPTHOUT:		return "oDepth";
+		case PARAMETER_SAMPLER:			return "s";
+	//	case PARAMETER_CONST2:			return "";
+	//	case PARAMETER_CONST3:			return "";
+	//	case PARAMETER_CONST4:			return "";
+		case PARAMETER_CONSTBOOL:		return "b";
+		case PARAMETER_LOOP:			return "aL";
+	//	case PARAMETER_TEMPFLOAT16:		return "";
+		case PARAMETER_MISCTYPE:
+			switch(index)
+			{
+			case VPosIndex:				return "vPos";
+			case VFaceIndex:			return "vFace";
+			case InstanceIDIndex:		return "iID";
+			case VertexIDIndex:			return "vID";
+			default: ASSERT(false);
+			}
+		case PARAMETER_LABEL:			return "l";
+		case PARAMETER_PREDICATE:		return "p0";
+		case PARAMETER_FLOAT4LITERAL:	return "";
+		case PARAMETER_BOOL1LITERAL:	return "";
+		case PARAMETER_INT4LITERAL:		return "";
+	//	case PARAMETER_VOID:			return "";
+		default:
+			ASSERT(false);
+		}
+
+		return "";
+	}
+
+	bool Shader::Instruction::isBranch() const
+	{
+		return opcode == OPCODE_IF || opcode == OPCODE_IFC;
+	}
+
+	bool Shader::Instruction::isCall() const
+	{
+		return opcode == OPCODE_CALL || opcode == OPCODE_CALLNZ;
+	}
+
+	bool Shader::Instruction::isBreak() const
+	{
+		return opcode == OPCODE_BREAK || opcode == OPCODE_BREAKC || opcode == OPCODE_BREAKP;
+	}
+
+	bool Shader::Instruction::isLoop() const
+	{
+		return opcode == OPCODE_LOOP || opcode == OPCODE_REP || opcode == OPCODE_WHILE;
+	}
+
+	bool Shader::Instruction::isEndLoop() const
+	{
+		return opcode == OPCODE_ENDLOOP || opcode == OPCODE_ENDREP || opcode == OPCODE_ENDWHILE;
+	}
+
+	bool Shader::Instruction::isPredicated() const
+	{
+		return predicate ||
+		       analysisBranch ||
+		       analysisBreak ||
+		       analysisContinue ||
+		       analysisLeave;
+	}
+
+	Shader::Shader() : serialID(serialCounter++)
+	{
+		usedSamplers = 0;
+	}
+
+	Shader::~Shader()
+	{
+		for(auto &inst : instruction)
+		{
+			delete inst;
+			inst = 0;
+		}
+	}
+
+	void Shader::parse(const unsigned long *token)
+	{
+		minorVersion = (unsigned char)(token[0] & 0x000000FF);
+		majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+		shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+		int length = 0;
+
+		if(shaderType == SHADER_VERTEX)
+		{
+			length = VertexShader::validate(token);
+		}
+		else if(shaderType == SHADER_PIXEL)
+		{
+			length = PixelShader::validate(token);
+		}
+		else ASSERT(false);
+
+		ASSERT(length != 0);
+		instruction.resize(length);
+
+		for(int i = 0; i < length; i++)
+		{
+			while((*token & 0x0000FFFF) == 0x0000FFFE)   // Comment token
+			{
+				int length = (*token & 0x7FFF0000) >> 16;
+
+				token += length + 1;
+			}
+
+			int tokenCount = size(*token);
+
+			instruction[i] = new Instruction(token, tokenCount, majorVersion);
+
+			token += 1 + tokenCount;
+		}
+	}
+
+	int Shader::size(unsigned long opcode) const
+	{
+		return size(opcode, shaderModel);
+	}
+
+	int Shader::size(unsigned long opcode, unsigned short shaderModel)
+	{
+		if(shaderModel > 0x0300)
+		{
+			ASSERT(false);
+		}
+
+		static const signed char size[] =
+		{
+			0,   // NOP = 0
+			2,   // MOV
+			3,   // ADD
+			3,   // SUB
+			4,   // MAD
+			3,   // MUL
+			2,   // RCP
+			2,   // RSQ
+			3,   // DP3
+			3,   // DP4
+			3,   // MIN
+			3,   // MAX
+			3,   // SLT
+			3,   // SGE
+			2,   // EXP
+			2,   // LOG
+			2,   // LIT
+			3,   // DST
+			4,   // LRP
+			2,   // FRC
+			3,   // M4x4
+			3,   // M4x3
+			3,   // M3x4
+			3,   // M3x3
+			3,   // M3x2
+			1,   // CALL
+			2,   // CALLNZ
+			2,   // LOOP
+			0,   // RET
+			0,   // ENDLOOP
+			1,   // LABEL
+			2,   // DCL
+			3,   // POW
+			3,   // CRS
+			4,   // SGN
+			2,   // ABS
+			2,   // NRM
+			4,   // SINCOS
+			1,   // REP
+			0,   // ENDREP
+			1,   // IF
+			2,   // IFC
+			0,   // ELSE
+			0,   // ENDIF
+			0,   // BREAK
+			2,   // BREAKC
+			2,   // MOVA
+			2,   // DEFB
+			5,   // DEFI
+			-1,  // 49
+			-1,  // 50
+			-1,  // 51
+			-1,  // 52
+			-1,  // 53
+			-1,  // 54
+			-1,  // 55
+			-1,  // 56
+			-1,  // 57
+			-1,  // 58
+			-1,  // 59
+			-1,  // 60
+			-1,  // 61
+			-1,  // 62
+			-1,  // 63
+			1,   // TEXCOORD = 64
+			1,   // TEXKILL
+			1,   // TEX
+			2,   // TEXBEM
+			2,   // TEXBEML
+			2,   // TEXREG2AR
+			2,   // TEXREG2GB
+			2,   // TEXM3x2PAD
+			2,   // TEXM3x2TEX
+			2,   // TEXM3x3PAD
+			2,   // TEXM3x3TEX
+			-1,  // RESERVED0
+			3,   // TEXM3x3SPEC
+			2,   // TEXM3x3VSPEC
+			2,   // EXPP
+			2,   // LOGP
+			4,   // CND
+			5,   // DEF
+			2,   // TEXREG2RGB
+			2,   // TEXDP3TEX
+			2,   // TEXM3x2DEPTH
+			2,   // TEXDP3
+			2,   // TEXM3x3
+			1,   // TEXDEPTH
+			4,   // CMP
+			3,   // BEM
+			4,   // DP2ADD
+			2,   // DSX
+			2,   // DSY
+			5,   // TEXLDD
+			3,   // SETP
+			3,   // TEXLDL
+			2,   // BREAKP
+			-1,  // 97
+			-1,  // 98
+			-1,  // 99
+			-1,  // 100
+			-1,  // 101
+			-1,  // 102
+			-1,  // 103
+			-1,  // 104
+			-1,  // 105
+			-1,  // 106
+			-1,  // 107
+			-1,  // 108
+			-1,  // 109
+			-1,  // 110
+			-1,  // 111
+			-1,  // 112
+		};
+
+		int length = 0;
+
+		if((opcode & 0x0000FFFF) == OPCODE_COMMENT)
+		{
+			return (opcode & 0x7FFF0000) >> 16;
+		}
+
+		if(opcode != OPCODE_PS_1_0 &&
+		   opcode != OPCODE_PS_1_1 &&
+		   opcode != OPCODE_PS_1_2 &&
+		   opcode != OPCODE_PS_1_3 &&
+		   opcode != OPCODE_PS_1_4 &&
+		   opcode != OPCODE_PS_2_0 &&
+		   opcode != OPCODE_PS_2_x &&
+		   opcode != OPCODE_PS_3_0 &&
+		   opcode != OPCODE_VS_1_0 &&
+		   opcode != OPCODE_VS_1_1 &&
+		   opcode != OPCODE_VS_2_0 &&
+		   opcode != OPCODE_VS_2_x &&
+		   opcode != OPCODE_VS_2_sw &&
+		   opcode != OPCODE_VS_3_0 &&
+		   opcode != OPCODE_VS_3_sw &&
+		   opcode != OPCODE_PHASE &&
+		   opcode != OPCODE_END)
+		{
+			if(shaderModel >= 0x0200)
+			{
+				length = (opcode & 0x0F000000) >> 24;
+			}
+			else
+			{
+				length = size[opcode & 0x0000FFFF];
+			}
+		}
+
+		if(length < 0)
+		{
+			ASSERT(false);
+		}
+
+		if(shaderModel == 0x0104)
+		{
+			switch(opcode & 0x0000FFFF)
+			{
+			case OPCODE_TEX:
+				length += 1;
+				break;
+			case OPCODE_TEXCOORD:
+				length += 1;
+				break;
+			default:
+				break;
+			}
+		}
+
+		return length;
+	}
+
+	bool Shader::maskContainsComponent(int mask, int component)
+	{
+		return (mask & (1 << component)) != 0;
+	}
+
+	bool Shader::swizzleContainsComponent(int swizzle, int component)
+	{
+		if((swizzle & 0x03) >> 0 == component) return true;
+		if((swizzle & 0x0C) >> 2 == component) return true;
+		if((swizzle & 0x30) >> 4 == component) return true;
+		if((swizzle & 0xC0) >> 6 == component) return true;
+
+		return false;
+	}
+
+	bool Shader::swizzleContainsComponentMasked(int swizzle, int component, int mask)
+	{
+		if(mask & 0x1) if((swizzle & 0x03) >> 0 == component) return true;
+		if(mask & 0x2) if((swizzle & 0x0C) >> 2 == component) return true;
+		if(mask & 0x4) if((swizzle & 0x30) >> 4 == component) return true;
+		if(mask & 0x8) if((swizzle & 0xC0) >> 6 == component) return true;
+
+		return false;
+	}
+
+	bool Shader::containsDynamicBranching() const
+	{
+		return dynamicBranching;
+	}
+
+	bool Shader::containsBreakInstruction() const
+	{
+		return containsBreak;
+	}
+
+	bool Shader::containsContinueInstruction() const
+	{
+		return containsContinue;
+	}
+
+	bool Shader::containsLeaveInstruction() const
+	{
+		return containsLeave;
+	}
+
+	bool Shader::containsDefineInstruction() const
+	{
+		return containsDefine;
+	}
+
+	bool Shader::usesSampler(int index) const
+	{
+		return (usedSamplers & (1 << index)) != 0;
+	}
+
+	int Shader::getSerialID() const
+	{
+		return serialID;
+	}
+
+	size_t Shader::getLength() const
+	{
+		return instruction.size();
+	}
+
+	Shader::ShaderType Shader::getShaderType() const
+	{
+		return shaderType;
+	}
+
+	unsigned short Shader::getShaderModel() const
+	{
+		return shaderModel;
+	}
+
+	void Shader::print(const char *fileName, ...) const
+	{
+		char fullName[1024 + 1];
+
+		va_list vararg;
+		va_start(vararg, fileName);
+		vsnprintf(fullName, 1024, fileName, vararg);
+		va_end(vararg);
+
+		std::ofstream file(fullName, std::ofstream::out);
+
+		for(const auto &inst : instruction)
+		{
+			file << inst->string(shaderType, shaderModel) << std::endl;
+		}
+	}
+
+	void Shader::printInstruction(int index, const char *fileName) const
+	{
+		std::ofstream file(fileName, std::ofstream::out | std::ofstream::app);
+
+		file << instruction[index]->string(shaderType, shaderModel) << std::endl;
+	}
+
+	void Shader::append(Instruction *instruction)
+	{
+		this->instruction.push_back(instruction);
+	}
+
+	void Shader::declareSampler(int i)
+	{
+		if(i >= 0 && i < 16)
+		{
+			usedSamplers |= 1 << i;
+		}
+	}
+
+	const Shader::Instruction *Shader::getInstruction(size_t i) const
+	{
+		ASSERT(i < instruction.size());
+
+		return instruction[i];
+	}
+
+	void Shader::optimize()
+	{
+		optimizeLeave();
+		optimizeCall();
+		removeNull();
+	}
+
+	void Shader::optimizeLeave()
+	{
+		// A return (leave) right before the end of a function or the shader can be removed
+		for(unsigned int i = 0; i < instruction.size(); i++)
+		{
+			if(instruction[i]->opcode == OPCODE_LEAVE)
+			{
+				if(i == instruction.size() - 1 || instruction[i + 1]->opcode == OPCODE_RET)
+				{
+					instruction[i]->opcode = OPCODE_NULL;
+				}
+			}
+		}
+	}
+
+	void Shader::optimizeCall()
+	{
+		// Eliminate uncalled functions
+		std::set<int> calledFunctions;
+		bool rescan = true;
+
+		while(rescan)
+		{
+			calledFunctions.clear();
+			rescan = false;
+
+			for(const auto &inst : instruction)
+			{
+				if(inst->isCall())
+				{
+					calledFunctions.insert(inst->dst.label);
+				}
+			}
+
+			if(!calledFunctions.empty())
+			{
+				for(unsigned int i = 0; i < instruction.size(); i++)
+				{
+					if(instruction[i]->opcode == OPCODE_LABEL)
+					{
+						if(calledFunctions.find(instruction[i]->dst.label) == calledFunctions.end())
+						{
+							for( ; i < instruction.size(); i++)
+							{
+								Opcode oldOpcode = instruction[i]->opcode;
+								instruction[i]->opcode = OPCODE_NULL;
+
+								if(oldOpcode == OPCODE_RET)
+								{
+									rescan = true;
+									break;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		// Optimize the entry call
+		if(instruction.size() >= 2 && instruction[0]->opcode == OPCODE_CALL && instruction[1]->opcode == OPCODE_RET)
+		{
+			if(calledFunctions.size() == 1)
+			{
+				instruction[0]->opcode = OPCODE_NULL;
+				instruction[1]->opcode = OPCODE_NULL;
+
+				for(size_t i = 2; i < instruction.size(); i++)
+				{
+					if(instruction[i]->opcode == OPCODE_LABEL || instruction[i]->opcode == OPCODE_RET)
+					{
+						instruction[i]->opcode = OPCODE_NULL;
+					}
+				}
+			}
+		}
+	}
+
+	void Shader::removeNull()
+	{
+		size_t size = 0;
+		for(size_t i = 0; i < instruction.size(); i++)
+		{
+			if(instruction[i]->opcode != OPCODE_NULL)
+			{
+				instruction[size] = instruction[i];
+				size++;
+			}
+			else
+			{
+				delete instruction[i];
+			}
+		}
+
+		instruction.resize(size);
+	}
+
+	void Shader::analyzeDirtyConstants()
+	{
+		dirtyConstantsF = 0;
+		dirtyConstantsI = 0;
+		dirtyConstantsB = 0;
+
+		for(const auto &inst : instruction)
+		{
+			switch(inst->opcode)
+			{
+			case OPCODE_DEF:
+				if(inst->dst.index + 1 > dirtyConstantsF)
+				{
+					dirtyConstantsF = inst->dst.index + 1;
+				}
+				break;
+			case OPCODE_DEFI:
+				if(inst->dst.index + 1 > dirtyConstantsI)
+				{
+					dirtyConstantsI = inst->dst.index + 1;
+				}
+				break;
+			case OPCODE_DEFB:
+				if(inst->dst.index + 1 > dirtyConstantsB)
+				{
+					dirtyConstantsB = inst->dst.index + 1;
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	void Shader::analyzeDynamicBranching()
+	{
+		dynamicBranching = false;
+		containsLeave = false;
+		containsBreak = false;
+		containsContinue = false;
+		containsDefine = false;
+
+		// Determine global presence of branching instructions
+		for(const auto &inst : instruction)
+		{
+			switch(inst->opcode)
+			{
+			case OPCODE_CALLNZ:
+			case OPCODE_IF:
+			case OPCODE_IFC:
+			case OPCODE_BREAK:
+			case OPCODE_BREAKC:
+			case OPCODE_CMP:
+			case OPCODE_BREAKP:
+			case OPCODE_LEAVE:
+			case OPCODE_CONTINUE:
+				if(inst->src[0].type != PARAMETER_CONSTBOOL)
+				{
+					dynamicBranching = true;
+				}
+
+				if(inst->opcode == OPCODE_LEAVE)
+				{
+					containsLeave = true;
+				}
+
+				if(inst->isBreak())
+				{
+					containsBreak = true;
+				}
+
+				if(inst->opcode == OPCODE_CONTINUE)
+				{
+					containsContinue = true;
+				}
+			case OPCODE_DEF:
+			case OPCODE_DEFB:
+			case OPCODE_DEFI:
+				containsDefine = true;
+			default:
+				break;
+			}
+		}
+
+		// Conservatively determine which instructions are affected by dynamic branching
+		int branchDepth = 0;
+		int breakDepth = 0;
+		int continueDepth = 0;
+		bool leaveReturn = false;
+		unsigned int functionBegin = 0;
+
+		for(unsigned int i = 0; i < instruction.size(); i++)
+		{
+			// If statements and loops
+			if(instruction[i]->isBranch() || instruction[i]->isLoop())
+			{
+				branchDepth++;
+			}
+			else if(instruction[i]->opcode == OPCODE_ENDIF || instruction[i]->isEndLoop())
+			{
+				branchDepth--;
+			}
+
+			if(branchDepth > 0)
+			{
+				instruction[i]->analysisBranch = true;
+
+				if(instruction[i]->isCall())
+				{
+					markFunctionAnalysis(instruction[i]->dst.label, ANALYSIS_BRANCH);
+				}
+			}
+
+			// Break statemement
+			if(instruction[i]->isBreak())
+			{
+				breakDepth++;
+			}
+
+			if(breakDepth > 0)
+			{
+				if(instruction[i]->isLoop() || instruction[i]->opcode == OPCODE_SWITCH)   // Nested loop or switch, don't make the end of it disable the break execution mask
+				{
+					breakDepth++;
+				}
+				else if(instruction[i]->isEndLoop() || instruction[i]->opcode == OPCODE_ENDSWITCH)
+				{
+					breakDepth--;
+				}
+
+				instruction[i]->analysisBreak = true;
+
+				if(instruction[i]->isCall())
+				{
+					markFunctionAnalysis(instruction[i]->dst.label, ANALYSIS_BRANCH);
+				}
+			}
+
+			// Continue statement
+			if(instruction[i]->opcode == OPCODE_CONTINUE)
+			{
+				continueDepth++;
+			}
+
+			if(continueDepth > 0)
+			{
+				if(instruction[i]->isLoop() || instruction[i]->opcode == OPCODE_SWITCH)   // Nested loop or switch, don't make the end of it disable the break execution mask
+				{
+					continueDepth++;
+				}
+				else if(instruction[i]->isEndLoop() || instruction[i]->opcode == OPCODE_ENDSWITCH)
+				{
+					continueDepth--;
+				}
+
+				instruction[i]->analysisContinue = true;
+
+				if(instruction[i]->isCall())
+				{
+					markFunctionAnalysis(instruction[i]->dst.label, ANALYSIS_CONTINUE);
+				}
+			}
+
+			// Return (leave) statement
+			if(instruction[i]->opcode == OPCODE_LEAVE)
+			{
+				leaveReturn = true;
+
+				// Mark loop body instructions prior to the return statement
+				for(unsigned int l = functionBegin; l < i; l++)
+				{
+					if(instruction[l]->isLoop())
+					{
+						for(unsigned int r = l + 1; r < i; r++)
+						{
+							instruction[r]->analysisLeave = true;
+						}
+
+						break;
+					}
+				}
+			}
+			else if(instruction[i]->opcode == OPCODE_RET)   // End of the function
+			{
+				leaveReturn = false;
+			}
+			else if(instruction[i]->opcode == OPCODE_LABEL)
+			{
+				functionBegin = i;
+			}
+
+			if(leaveReturn)
+			{
+				instruction[i]->analysisLeave = true;
+
+				if(instruction[i]->isCall())
+				{
+					markFunctionAnalysis(instruction[i]->dst.label, ANALYSIS_LEAVE);
+				}
+			}
+		}
+	}
+
+	void Shader::markFunctionAnalysis(unsigned int functionLabel, Analysis flag)
+	{
+		bool marker = false;
+		for(auto &inst : instruction)
+		{
+			if(!marker)
+			{
+				if(inst->opcode == OPCODE_LABEL && inst->dst.label == functionLabel)
+				{
+					marker = true;
+				}
+			}
+			else
+			{
+				if(inst->opcode == OPCODE_RET)
+				{
+					break;
+				}
+				else if(inst->isCall())
+				{
+					markFunctionAnalysis(inst->dst.label, flag);
+				}
+
+				inst->analysis |= flag;
+			}
+		}
+	}
+
+	void Shader::analyzeSamplers()
+	{
+		for(const auto &inst : instruction)
+		{
+			switch(inst->opcode)
+			{
+			case OPCODE_TEX:
+			case OPCODE_TEXBEM:
+			case OPCODE_TEXBEML:
+			case OPCODE_TEXREG2AR:
+			case OPCODE_TEXREG2GB:
+			case OPCODE_TEXM3X2TEX:
+			case OPCODE_TEXM3X3TEX:
+			case OPCODE_TEXM3X3SPEC:
+			case OPCODE_TEXM3X3VSPEC:
+			case OPCODE_TEXREG2RGB:
+			case OPCODE_TEXDP3TEX:
+			case OPCODE_TEXM3X2DEPTH:
+			case OPCODE_TEXLDD:
+			case OPCODE_TEXLDL:
+			case OPCODE_TEXLOD:
+			case OPCODE_TEXOFFSET:
+			case OPCODE_TEXOFFSETBIAS:
+			case OPCODE_TEXLODOFFSET:
+			case OPCODE_TEXELFETCH:
+			case OPCODE_TEXELFETCHOFFSET:
+			case OPCODE_TEXGRAD:
+			case OPCODE_TEXGRADOFFSET:
+				{
+					Parameter &dst = inst->dst;
+					Parameter &src1 = inst->src[1];
+
+					if(majorVersion >= 2)
+					{
+						if(src1.type == PARAMETER_SAMPLER)
+						{
+							usedSamplers |= 1 << src1.index;
+						}
+					}
+					else
+					{
+						usedSamplers |= 1 << dst.index;
+					}
+				}
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
+	// Assigns a unique index to each call instruction, on a per label basis.
+	// This is used to know what basic block to return to.
+	void Shader::analyzeCallSites()
+	{
+		int callSiteIndex[2048] = {0};
+
+		for(auto &inst : instruction)
+		{
+			if(inst->opcode == OPCODE_CALL || inst->opcode == OPCODE_CALLNZ)
+			{
+				int label = inst->dst.label;
+
+				inst->dst.callSite = callSiteIndex[label]++;
+			}
+		}
+	}
+
+	void Shader::analyzeIndirectAddressing()
+	{
+		indirectAddressableTemporaries = false;
+		indirectAddressableInput = false;
+		indirectAddressableOutput = false;
+
+		for(const auto &inst : instruction)
+		{
+			if(inst->dst.rel.type != PARAMETER_VOID)
+			{
+				switch(inst->dst.type)
+				{
+				case PARAMETER_TEMP:   indirectAddressableTemporaries = true; break;
+				case PARAMETER_INPUT:  indirectAddressableInput = true;       break;
+				case PARAMETER_OUTPUT: indirectAddressableOutput = true;      break;
+				default: break;
+				}
+			}
+
+			for(int j = 0; j < 3; j++)
+			{
+				if(inst->src[j].rel.type != PARAMETER_VOID)
+				{
+					switch(inst->src[j].type)
+					{
+					case PARAMETER_TEMP:   indirectAddressableTemporaries = true; break;
+					case PARAMETER_INPUT:  indirectAddressableInput = true;       break;
+					case PARAMETER_OUTPUT: indirectAddressableOutput = true;      break;
+					default: break;
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/Pipeline/Shader.hpp b/src/Pipeline/Shader.hpp
new file mode 100644
index 0000000..9e4a810
--- /dev/null
+++ b/src/Pipeline/Shader.hpp
@@ -0,0 +1,662 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Shader_hpp
+#define sw_Shader_hpp
+
+#include "Common/Types.hpp"
+
+#include <string>
+#include <vector>
+
+namespace sw
+{
+	class Shader
+	{
+	public:
+		enum ShaderType
+		{
+			SHADER_PIXEL = 0xFFFF,
+			SHADER_VERTEX = 0xFFFE,
+			SHADER_GEOMETRY = 0xFFFD
+		};
+
+		enum Opcode
+		{
+			// Matches order in d3d9types.h
+			OPCODE_NOP = 0,
+			OPCODE_MOV,
+			OPCODE_ADD,
+			OPCODE_SUB,
+			OPCODE_MAD,
+			OPCODE_MUL,
+			OPCODE_RCPX,
+			OPCODE_RSQX,
+			OPCODE_DP3,
+			OPCODE_DP4,
+			OPCODE_MIN,
+			OPCODE_MAX,
+			OPCODE_SLT,
+			OPCODE_SGE,
+			OPCODE_EXP2X,   // D3DSIO_EXP
+			OPCODE_LOG2X,   // D3DSIO_LOG
+			OPCODE_LIT,
+			OPCODE_ATT,   // D3DSIO_DST
+			OPCODE_LRP,
+			OPCODE_FRC,
+			OPCODE_M4X4,
+			OPCODE_M4X3,
+			OPCODE_M3X4,
+			OPCODE_M3X3,
+			OPCODE_M3X2,
+			OPCODE_CALL,
+			OPCODE_CALLNZ,
+			OPCODE_LOOP,
+			OPCODE_RET,
+			OPCODE_ENDLOOP,
+			OPCODE_LABEL,
+			OPCODE_DCL,
+			OPCODE_POWX,
+			OPCODE_CRS,
+			OPCODE_SGN,
+			OPCODE_ABS,
+			OPCODE_NRM3,   // D3DSIO_NRM
+			OPCODE_SINCOS,
+			OPCODE_REP,
+			OPCODE_ENDREP,
+			OPCODE_IF,
+			OPCODE_IFC,
+			OPCODE_ELSE,
+			OPCODE_ENDIF,
+			OPCODE_BREAK,
+			OPCODE_BREAKC,
+			OPCODE_MOVA,
+			OPCODE_DEFB,
+			OPCODE_DEFI,
+
+			OPCODE_TEXCOORD = 64,
+			OPCODE_TEXKILL,
+			OPCODE_TEX,
+			OPCODE_TEXBEM,
+			OPCODE_TEXBEML,
+			OPCODE_TEXREG2AR,
+			OPCODE_TEXREG2GB,
+			OPCODE_TEXM3X2PAD,
+			OPCODE_TEXM3X2TEX,
+			OPCODE_TEXM3X3PAD,
+			OPCODE_TEXM3X3TEX,
+			OPCODE_RESERVED0,
+			OPCODE_TEXM3X3SPEC,
+			OPCODE_TEXM3X3VSPEC,
+			OPCODE_EXPP,
+			OPCODE_LOGP,
+			OPCODE_CND,
+			OPCODE_DEF,
+			OPCODE_TEXREG2RGB,
+			OPCODE_TEXDP3TEX,
+			OPCODE_TEXM3X2DEPTH,
+			OPCODE_TEXDP3,
+			OPCODE_TEXM3X3,
+			OPCODE_TEXDEPTH,
+			OPCODE_CMP0,   // D3DSIO_CMP
+			OPCODE_BEM,
+			OPCODE_DP2ADD,
+			OPCODE_DFDX,   // D3DSIO_DSX
+			OPCODE_DFDY,   // D3DSIO_DSY
+			OPCODE_TEXLDD,
+			OPCODE_CMP,   // D3DSIO_SETP
+			OPCODE_TEXLDL,
+			OPCODE_BREAKP,
+
+			OPCODE_PHASE = 0xFFFD,
+			OPCODE_COMMENT = 0xFFFE,
+			OPCODE_END = 0xFFFF,
+
+			OPCODE_PS_1_0 = 0xFFFF0100,
+			OPCODE_PS_1_1 = 0xFFFF0101,
+			OPCODE_PS_1_2 = 0xFFFF0102,
+			OPCODE_PS_1_3 = 0xFFFF0103,
+			OPCODE_PS_1_4 = 0xFFFF0104,
+			OPCODE_PS_2_0 = 0xFFFF0200,
+			OPCODE_PS_2_x = 0xFFFF0201,
+			OPCODE_PS_3_0 = 0xFFFF0300,
+
+			OPCODE_VS_1_0 = 0xFFFE0100,
+			OPCODE_VS_1_1 = 0xFFFE0101,
+			OPCODE_VS_2_0 = 0xFFFE0200,
+			OPCODE_VS_2_x = 0xFFFE0201,
+			OPCODE_VS_2_sw = 0xFFFE02FF,
+			OPCODE_VS_3_0 = 0xFFFE0300,
+			OPCODE_VS_3_sw = 0xFFFE03FF,
+
+			OPCODE_NULL = 0x10000000,   // Dead instruction, to be eliminated
+			OPCODE_WHILE,
+			OPCODE_ENDWHILE,
+			OPCODE_COS,
+			OPCODE_SIN,
+			OPCODE_TAN,
+			OPCODE_ACOS,
+			OPCODE_ASIN,
+			OPCODE_ATAN,
+			OPCODE_ATAN2,
+			OPCODE_COSH,
+			OPCODE_SINH,
+			OPCODE_TANH,
+			OPCODE_ACOSH,
+			OPCODE_ASINH,
+			OPCODE_ATANH,
+			OPCODE_DP1,
+			OPCODE_DP2,
+			OPCODE_TRUNC,
+			OPCODE_FLOOR,
+			OPCODE_ROUND,
+			OPCODE_ROUNDEVEN,
+			OPCODE_CEIL,
+			OPCODE_SQRT,
+			OPCODE_RSQ,
+			OPCODE_LEN2,
+			OPCODE_LEN3,
+			OPCODE_LEN4,
+			OPCODE_DIST1,
+			OPCODE_DIST2,
+			OPCODE_DIST3,
+			OPCODE_DIST4,
+			OPCODE_NRM2,
+			OPCODE_NRM4,
+			OPCODE_DIV,
+			OPCODE_MOD,
+			OPCODE_EXP2,
+			OPCODE_LOG2,
+			OPCODE_EXP,
+			OPCODE_LOG,
+			OPCODE_POW,
+			OPCODE_F2B,   // Float to bool
+			OPCODE_B2F,   // Bool to float
+			OPCODE_F2I,   // Float to int
+			OPCODE_I2F,   // Int to float
+			OPCODE_F2U,   // Float to uint
+			OPCODE_U2F,   // Uint to float
+			OPCODE_I2B,   // Int to bool
+			OPCODE_B2I,   // Bool to int
+			OPCODE_DET2,
+			OPCODE_DET3,
+			OPCODE_DET4,
+			OPCODE_ALL,
+			OPCODE_ANY,
+			OPCODE_NEG,
+			OPCODE_NOT,
+			OPCODE_OR,
+			OPCODE_XOR,
+			OPCODE_AND,
+			OPCODE_EQ,
+			OPCODE_NE,
+			OPCODE_STEP,
+			OPCODE_SMOOTH,
+			OPCODE_ISNAN,
+			OPCODE_ISINF,
+			OPCODE_TEXOFFSET,
+			OPCODE_TEXLODOFFSET,
+			OPCODE_TEXELFETCH,
+			OPCODE_TEXELFETCHOFFSET,
+			OPCODE_TEXGRAD,
+			OPCODE_TEXGRADOFFSET,
+			OPCODE_TEXBIAS,
+			OPCODE_TEXLOD,
+			OPCODE_TEXOFFSETBIAS,
+			OPCODE_TEXSIZE,
+			OPCODE_FLOATBITSTOINT,
+			OPCODE_FLOATBITSTOUINT,
+			OPCODE_INTBITSTOFLOAT,
+			OPCODE_UINTBITSTOFLOAT,
+			OPCODE_PACKSNORM2x16,
+			OPCODE_PACKUNORM2x16,
+			OPCODE_PACKHALF2x16,
+			OPCODE_UNPACKSNORM2x16,
+			OPCODE_UNPACKUNORM2x16,
+			OPCODE_UNPACKHALF2x16,
+			OPCODE_FORWARD1,
+			OPCODE_FORWARD2,
+			OPCODE_FORWARD3,
+			OPCODE_FORWARD4,
+			OPCODE_REFLECT1,
+			OPCODE_REFLECT2,
+			OPCODE_REFLECT3,
+			OPCODE_REFLECT4,
+			OPCODE_REFRACT1,
+			OPCODE_REFRACT2,
+			OPCODE_REFRACT3,
+			OPCODE_REFRACT4,
+			OPCODE_ICMP,
+			OPCODE_UCMP,
+			OPCODE_SELECT,
+			OPCODE_EXTRACT,
+			OPCODE_INSERT,
+			OPCODE_DISCARD,
+			OPCODE_FWIDTH,
+			OPCODE_LEAVE,   // Return before the end of the function
+			OPCODE_CONTINUE,
+			OPCODE_TEST,   // Marks the end of the code that can be skipped by 'continue'
+			OPCODE_SWITCH,
+			OPCODE_ENDSWITCH,
+
+			// Integer opcodes
+			OPCODE_INEG,
+			OPCODE_IABS,
+			OPCODE_ISGN,
+			OPCODE_IADD,
+			OPCODE_ISUB,
+			OPCODE_IMUL,
+			OPCODE_IDIV,
+			OPCODE_IMAD,
+			OPCODE_IMOD,
+			OPCODE_SHL,
+			OPCODE_ISHR,
+			OPCODE_IMIN,
+			OPCODE_IMAX,
+
+			// Unsigned integer opcodes
+			OPCODE_UDIV,
+			OPCODE_UMOD,
+			OPCODE_USHR,
+			OPCODE_UMIN,
+			OPCODE_UMAX,
+		};
+
+		static Opcode OPCODE_DP(int);
+		static Opcode OPCODE_LEN(int);
+		static Opcode OPCODE_DIST(int);
+		static Opcode OPCODE_NRM(int);
+		static Opcode OPCODE_FORWARD(int);
+		static Opcode OPCODE_REFLECT(int);
+		static Opcode OPCODE_REFRACT(int);
+
+		enum Control
+		{
+			CONTROL_RESERVED0,
+			CONTROL_GT,
+			CONTROL_EQ,
+			CONTROL_GE,
+			CONTROL_LT,
+			CONTROL_NE,
+			CONTROL_LE,
+			CONTROL_RESERVED1
+		};
+
+		enum SamplerType
+		{
+			SAMPLER_UNKNOWN,
+			SAMPLER_1D,
+			SAMPLER_2D,
+			SAMPLER_CUBE,
+			SAMPLER_VOLUME
+		};
+
+		enum Usage   // For vertex input/output declarations
+		{
+			USAGE_POSITION = 0,
+			USAGE_BLENDWEIGHT = 1,
+			USAGE_BLENDINDICES = 2,
+			USAGE_NORMAL = 3,
+			USAGE_PSIZE = 4,
+			USAGE_TEXCOORD = 5,
+			USAGE_TANGENT = 6,
+			USAGE_BINORMAL = 7,
+			USAGE_TESSFACTOR = 8,
+			USAGE_POSITIONT = 9,
+			USAGE_COLOR = 10,
+			USAGE_FOG = 11,
+			USAGE_DEPTH = 12,
+			USAGE_SAMPLE = 13
+		};
+
+		enum ParameterType
+		{
+			PARAMETER_TEMP = 0,
+			PARAMETER_INPUT = 1,
+			PARAMETER_CONST = 2,
+			PARAMETER_TEXTURE = 3,
+			PARAMETER_ADDR = 3,
+			PARAMETER_RASTOUT = 4,
+			PARAMETER_ATTROUT = 5,
+			PARAMETER_TEXCRDOUT = 6,
+			PARAMETER_OUTPUT = 6,
+			PARAMETER_CONSTINT = 7,
+			PARAMETER_COLOROUT = 8,
+			PARAMETER_DEPTHOUT = 9,
+			PARAMETER_SAMPLER = 10,
+			PARAMETER_CONST2 = 11,
+			PARAMETER_CONST3 = 12,
+			PARAMETER_CONST4 = 13,
+			PARAMETER_CONSTBOOL = 14,
+			PARAMETER_LOOP = 15,
+			PARAMETER_TEMPFLOAT16 = 16,
+			PARAMETER_MISCTYPE = 17,
+			PARAMETER_LABEL = 18,
+			PARAMETER_PREDICATE = 19,
+
+		//	PARAMETER_FLOAT1LITERAL,
+		//	PARAMETER_FLOAT2LITERAL,
+		//	PARAMETER_FLOAT3LITERAL,
+			PARAMETER_FLOAT4LITERAL,
+			PARAMETER_BOOL1LITERAL,
+		//	PARAMETER_BOOL2LITERAL,
+		//	PARAMETER_BOOL3LITERAL,
+		//	PARAMETER_BOOL4LITERAL,
+		//	PARAMETER_INT1LITERAL,
+		//	PARAMETER_INT2LITERAL,
+		//	PARAMETER_INT3LITERAL,
+			PARAMETER_INT4LITERAL,
+
+			PARAMETER_VOID
+		};
+
+		enum MiscParameterIndex
+		{
+			VPosIndex = 0,
+			VFaceIndex = 1,
+			InstanceIDIndex = 2,
+			VertexIDIndex = 3,
+		};
+
+		enum Modifier
+		{
+			MODIFIER_NONE,
+			MODIFIER_NEGATE,
+			MODIFIER_BIAS,
+			MODIFIER_BIAS_NEGATE,
+			MODIFIER_SIGN,
+			MODIFIER_SIGN_NEGATE,
+			MODIFIER_COMPLEMENT,
+			MODIFIER_X2,
+			MODIFIER_X2_NEGATE,
+			MODIFIER_DZ,
+			MODIFIER_DW,
+			MODIFIER_ABS,
+			MODIFIER_ABS_NEGATE,
+			MODIFIER_NOT
+		};
+
+		enum Analysis
+		{
+			// Flags indicating whether an instruction is affected by an execution enable mask
+			ANALYSIS_BRANCH   = 0x00000001,
+			ANALYSIS_BREAK    = 0x00000002,
+			ANALYSIS_CONTINUE = 0x00000004,
+			ANALYSIS_LEAVE    = 0x00000008,
+		};
+
+		struct Relative
+		{
+			ParameterType type : 8;
+			unsigned int index;
+			unsigned int swizzle : 8;
+			unsigned int scale;
+			bool dynamic;   // Varies between concurrent shader instances
+		};
+
+		struct Parameter
+		{
+			union
+			{
+				struct
+				{
+					unsigned int index;   // For registers types
+
+					Relative rel;
+				};
+
+				float value[4];       // For float constants
+				int integer[4];       // For integer constants
+				int boolean[4];       // For boolean constants
+
+				struct
+				{
+					unsigned int label;      // Label index
+					unsigned int callSite;   // Call index (per label)
+				};
+			};
+
+			Parameter() : index(0), type(PARAMETER_VOID)
+			{
+				rel.type = PARAMETER_VOID;
+				rel.index = 0;
+				rel.swizzle = 0;
+				rel.scale = 1;
+				rel.dynamic = true;
+			}
+
+			std::string string(ShaderType shaderType, unsigned short version) const;
+			std::string typeString(ShaderType shaderType, unsigned short version) const;
+			std::string relativeString() const;
+
+			ParameterType type : 8;
+		};
+
+		struct DestinationParameter : Parameter
+		{
+			union
+			{
+				unsigned char mask;
+
+				struct
+				{
+					bool x : 1;
+					bool y : 1;
+					bool z : 1;
+					bool w : 1;
+				};
+			};
+
+			DestinationParameter() : mask(0xF), saturate(false), partialPrecision(false), centroid(false), shift(0)
+			{
+			}
+
+			std::string modifierString() const;
+			std::string shiftString() const;
+			std::string maskString() const;
+
+			bool saturate         : 1;
+			bool partialPrecision : 1;
+			bool centroid         : 1;
+			signed char shift     : 4;
+		};
+
+		struct SourceParameter : Parameter
+		{
+			SourceParameter() : swizzle(0xE4), modifier(MODIFIER_NONE), bufferIndex(-1)
+			{
+			}
+
+			std::string string(ShaderType shaderType, unsigned short version) const;
+			std::string swizzleString() const;
+			std::string preModifierString() const;
+			std::string postModifierString() const;
+
+			unsigned int swizzle : 8;
+			Modifier modifier : 8;
+			int bufferIndex : 8;
+		};
+
+		struct Instruction
+		{
+			explicit Instruction(Opcode opcode);
+			Instruction(const unsigned long *token, int size, unsigned char majorVersion);
+
+			virtual ~Instruction();
+
+			void parseOperationToken(unsigned long token, unsigned char majorVersion);
+			void parseDeclarationToken(unsigned long token);
+			void parseDestinationToken(const unsigned long *token, unsigned char majorVersion);
+			void parseSourceToken(int i, const unsigned long *token, unsigned char majorVersion);
+
+			std::string string(ShaderType shaderType, unsigned short version) const;
+			static std::string swizzleString(ParameterType type, unsigned char swizzle);
+			std::string operationString(unsigned short version) const;
+			std::string controlString() const;
+
+			bool isBranch() const;
+			bool isCall() const;
+			bool isBreak() const;
+			bool isLoop() const;
+			bool isEndLoop() const;
+
+			bool isPredicated() const;
+
+			Opcode opcode;
+
+			union
+			{
+				Control control;
+
+				struct
+				{
+					unsigned char project : 1;   // D3DSI_TEXLD_PROJECT
+					unsigned char bias : 1;      // D3DSI_TEXLD_BIAS
+				};
+			};
+
+			bool predicate;
+			bool predicateNot;   // Negative predicate
+			unsigned char predicateSwizzle;
+
+			bool coissue;
+			SamplerType samplerType;
+			Usage usage;
+			unsigned char usageIndex;
+
+			DestinationParameter dst;
+			SourceParameter src[5];
+
+			union
+			{
+				unsigned int analysis;
+
+				struct
+				{
+					// Keep in sync with Shader::Analysis flags
+					unsigned int analysisBranch : 1;
+					unsigned int analysisBreak : 1;
+					unsigned int analysisContinue : 1;
+					unsigned int analysisLeave : 1;
+				};
+			};
+		};
+
+		Shader();
+
+		virtual ~Shader();
+
+		int getSerialID() const;
+		size_t getLength() const;
+		ShaderType getShaderType() const;
+		unsigned short getShaderModel() const;
+
+		void append(Instruction *instruction);
+		void declareSampler(int i);
+
+		const Instruction *getInstruction(size_t i) const;
+		int size(unsigned long opcode) const;
+		static int size(unsigned long opcode, unsigned short shaderModel);
+
+		void print(const char *fileName, ...) const;
+		void printInstruction(int index, const char *fileName) const;
+
+		static bool maskContainsComponent(int mask, int component);
+		static bool swizzleContainsComponent(int swizzle, int component);
+		static bool swizzleContainsComponentMasked(int swizzle, int component, int mask);
+
+		bool containsDynamicBranching() const;
+		bool containsBreakInstruction() const;
+		bool containsContinueInstruction() const;
+		bool containsLeaveInstruction() const;
+		bool containsDefineInstruction() const;
+		bool usesSampler(int i) const;
+
+		struct Semantic
+		{
+			Semantic(unsigned char usage = 0xFF, unsigned char index = 0xFF, bool flat = false) : usage(usage), index(index), centroid(false), flat(flat)
+			{
+			}
+
+			bool operator==(const Semantic &semantic) const
+			{
+				return usage == semantic.usage && index == semantic.index;
+			}
+
+			bool active() const
+			{
+				return usage != 0xFF;
+			}
+
+			unsigned char usage;
+			unsigned char index;
+			bool centroid;
+			bool flat;
+		};
+
+		void optimize();
+
+		// FIXME: Private
+		unsigned int dirtyConstantsF;
+		unsigned int dirtyConstantsI;
+		unsigned int dirtyConstantsB;
+
+		bool indirectAddressableTemporaries;
+		bool indirectAddressableInput;
+		bool indirectAddressableOutput;
+
+	protected:
+		void parse(const unsigned long *token);
+
+		void optimizeLeave();
+		void optimizeCall();
+		void removeNull();
+
+		void analyzeDirtyConstants();
+		void analyzeDynamicBranching();
+		void analyzeSamplers();
+		void analyzeCallSites();
+		void analyzeIndirectAddressing();
+		void markFunctionAnalysis(unsigned int functionLabel, Analysis flag);
+
+		ShaderType shaderType;
+
+		union
+		{
+			unsigned short shaderModel;
+
+			struct
+			{
+				unsigned char minorVersion;
+				unsigned char majorVersion;
+			};
+		};
+
+		std::vector<Instruction*> instruction;
+
+		unsigned short usedSamplers;   // Bit flags
+
+	private:
+		const int serialID;
+		static volatile int serialCounter;
+
+		bool dynamicBranching;
+		bool containsBreak;
+		bool containsContinue;
+		bool containsLeave;
+		bool containsDefine;
+	};
+}
+
+#endif   // sw_Shader_hpp
diff --git a/src/Pipeline/ShaderCore.cpp b/src/Pipeline/ShaderCore.cpp
new file mode 100644
index 0000000..4ea3260
--- /dev/null
+++ b/src/Pipeline/ShaderCore.cpp
@@ -0,0 +1,2006 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ShaderCore.hpp"
+
+#include "Renderer/Renderer.hpp"
+#include "Common/Debug.hpp"
+
+#include <limits.h>
+
+namespace sw
+{
+	extern TranscendentalPrecision logPrecision;
+	extern TranscendentalPrecision expPrecision;
+	extern TranscendentalPrecision rcpPrecision;
+	extern TranscendentalPrecision rsqPrecision;
+
+	Vector4s::Vector4s()
+	{
+	}
+
+	Vector4s::Vector4s(unsigned short x, unsigned short y, unsigned short z, unsigned short w)
+	{
+		this->x = Short4(x);
+		this->y = Short4(y);
+		this->z = Short4(z);
+		this->w = Short4(w);
+	}
+
+	Vector4s::Vector4s(const Vector4s &rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = rhs.z;
+		w = rhs.w;
+	}
+
+	Vector4s &Vector4s::operator=(const Vector4s &rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = rhs.z;
+		w = rhs.w;
+
+		return *this;
+	}
+
+	Short4 &Vector4s::operator[](int i)
+	{
+		switch(i)
+		{
+		case 0: return x;
+		case 1: return y;
+		case 2: return z;
+		case 3: return w;
+		}
+
+		return x;
+	}
+
+	Vector4f::Vector4f()
+	{
+	}
+
+	Vector4f::Vector4f(float x, float y, float z, float w)
+	{
+		this->x = Float4(x);
+		this->y = Float4(y);
+		this->z = Float4(z);
+		this->w = Float4(w);
+	}
+
+	Vector4f::Vector4f(const Vector4f &rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = rhs.z;
+		w = rhs.w;
+	}
+
+	Vector4f &Vector4f::operator=(const Vector4f &rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = rhs.z;
+		w = rhs.w;
+
+		return *this;
+	}
+
+	Float4 &Vector4f::operator[](int i)
+	{
+		switch(i)
+		{
+		case 0: return x;
+		case 1: return y;
+		case 2: return z;
+		case 3: return w;
+		}
+
+		return x;
+	}
+
+	Float4 exponential2(RValue<Float4> x, bool pp)
+	{
+		// This implementation is based on 2^(i + f) = 2^i * 2^f,
+		// where i is the integer part of x and f is the fraction.
+
+		// For 2^i we can put the integer part directly in the exponent of
+		// the IEEE-754 floating-point number. Clamp to prevent overflow
+		// past the representation of infinity.
+		Float4 x0 = x;
+		x0 = Min(x0, As<Float4>(Int4(0x43010000)));   // 129.00000e+0f
+		x0 = Max(x0, As<Float4>(Int4(0xC2FDFFFF)));   // -126.99999e+0f
+
+		Int4 i = RoundInt(x0 - Float4(0.5f));
+		Float4 ii = As<Float4>((i + Int4(127)) << 23);   // Add single-precision bias, and shift into exponent.
+
+		// For the fractional part use a polynomial
+		// which approximates 2^f in the 0 to 1 range.
+		Float4 f = x0 - Float4(i);
+		Float4 ff = As<Float4>(Int4(0x3AF61905));     // 1.8775767e-3f
+		ff = ff * f + As<Float4>(Int4(0x3C134806));   // 8.9893397e-3f
+		ff = ff * f + As<Float4>(Int4(0x3D64AA23));   // 5.5826318e-2f
+		ff = ff * f + As<Float4>(Int4(0x3E75EAD4));   // 2.4015361e-1f
+		ff = ff * f + As<Float4>(Int4(0x3F31727B));   // 6.9315308e-1f
+		ff = ff * f + Float4(1.0f);
+
+		return ii * ff;
+	}
+
+	Float4 logarithm2(RValue<Float4> x, bool absolute, bool pp)
+	{
+		Float4 x0;
+		Float4 x1;
+		Float4 x2;
+		Float4 x3;
+
+		x0 = x;
+
+		x1 = As<Float4>(As<Int4>(x0) & Int4(0x7F800000));
+		x1 = As<Float4>(As<UInt4>(x1) >> 8);
+		x1 = As<Float4>(As<Int4>(x1) | As<Int4>(Float4(1.0f)));
+		x1 = (x1 - Float4(1.4960938f)) * Float4(256.0f);   // FIXME: (x1 - 1.4960938f) * 256.0f;
+		x0 = As<Float4>((As<Int4>(x0) & Int4(0x007FFFFF)) | As<Int4>(Float4(1.0f)));
+
+		x2 = (Float4(9.5428179e-2f) * x0 + Float4(4.7779095e-1f)) * x0 + Float4(1.9782813e-1f);
+		x3 = ((Float4(1.6618466e-2f) * x0 + Float4(2.0350508e-1f)) * x0 + Float4(2.7382900e-1f)) * x0 + Float4(4.0496687e-2f);
+		x2 /= x3;
+
+		x1 += (x0 - Float4(1.0f)) * x2;
+
+		Int4 pos_inf_x = CmpEQ(As<Int4>(x), Int4(0x7F800000));
+		return As<Float4>((pos_inf_x & As<Int4>(x)) | (~pos_inf_x & As<Int4>(x1)));
+	}
+
+	Float4 exponential(RValue<Float4> x, bool pp)
+	{
+		// FIXME: Propagate the constant
+		return exponential2(Float4(1.44269504f) * x, pp);   // 1/ln(2)
+	}
+
+	Float4 logarithm(RValue<Float4> x, bool absolute, bool pp)
+	{
+		// FIXME: Propagate the constant
+		return Float4(6.93147181e-1f) * logarithm2(x, absolute, pp);   // ln(2)
+	}
+
+	Float4 power(RValue<Float4> x, RValue<Float4> y, bool pp)
+	{
+		Float4 log = logarithm2(x, true, pp);
+		log *= y;
+		return exponential2(log, pp);
+	}
+
+	Float4 reciprocal(RValue<Float4> x, bool pp, bool finite, bool exactAtPow2)
+	{
+		Float4 rcp;
+
+		if(!pp && rcpPrecision >= WHQL)
+		{
+			rcp = Float4(1.0f) / x;
+		}
+		else
+		{
+			rcp = Rcp_pp(x, exactAtPow2);
+
+			if(!pp)
+			{
+				rcp = (rcp + rcp) - (x * rcp * rcp);
+			}
+		}
+
+		if(finite)
+		{
+			int big = 0x7F7FFFFF;
+			rcp = Min(rcp, Float4((float&)big));
+		}
+
+		return rcp;
+	}
+
+	Float4 reciprocalSquareRoot(RValue<Float4> x, bool absolute, bool pp)
+	{
+		Float4 abs = x;
+
+		if(absolute)
+		{
+			abs = Abs(abs);
+		}
+
+		Float4 rsq;
+
+		if(!pp)
+		{
+			rsq = Float4(1.0f) / Sqrt(abs);
+		}
+		else
+		{
+			rsq = RcpSqrt_pp(abs);
+
+			if(!pp)
+			{
+				rsq = rsq * (Float4(3.0f) - rsq * rsq * abs) * Float4(0.5f);
+			}
+
+			rsq = As<Float4>(CmpNEQ(As<Int4>(abs), Int4(0x7F800000)) & As<Int4>(rsq));
+		}
+
+		return rsq;
+	}
+
+	Float4 modulo(RValue<Float4> x, RValue<Float4> y)
+	{
+		return x - y * Floor(x / y);
+	}
+
+	Float4 sine_pi(RValue<Float4> x, bool pp)
+	{
+		const Float4 A = Float4(-4.05284734e-1f);   // -4/pi^2
+		const Float4 B = Float4(1.27323954e+0f);    // 4/pi
+		const Float4 C = Float4(7.75160950e-1f);
+		const Float4 D = Float4(2.24839049e-1f);
+
+		// Parabola approximating sine
+		Float4 sin = x * (Abs(x) * A + B);
+
+		// Improve precision from 0.06 to 0.001
+		if(true)
+		{
+			sin = sin * (Abs(sin) * D + C);
+		}
+
+		return sin;
+	}
+
+	Float4 cosine_pi(RValue<Float4> x, bool pp)
+	{
+		// cos(x) = sin(x + pi/2)
+		Float4 y = x + Float4(1.57079632e+0f);
+
+		// Wrap around
+		y -= As<Float4>(CmpNLT(y, Float4(3.14159265e+0f)) & As<Int4>(Float4(6.28318530e+0f)));
+
+		return sine_pi(y, pp);
+	}
+
+	Float4 sine(RValue<Float4> x, bool pp)
+	{
+		// Reduce to [-0.5, 0.5] range
+		Float4 y = x * Float4(1.59154943e-1f);   // 1/2pi
+		y = y - Round(y);
+
+		if(!pp)
+		{
+			// From the paper: "A Fast, Vectorizable Algorithm for Producing Single-Precision Sine-Cosine Pairs"
+			// This implementation passes OpenGL ES 3.0 precision requirements, at the cost of more operations:
+			// !pp : 17 mul, 7 add, 1 sub, 1 reciprocal
+			//  pp : 4 mul, 2 add, 2 abs
+
+			Float4 y2 = y * y;
+			Float4 c1 = y2 * (y2 * (y2 * Float4(-0.0204391631f) + Float4(0.2536086171f)) + Float4(-1.2336977925f)) + Float4(1.0f);
+			Float4 s1 = y * (y2 * (y2 * (y2 * Float4(-0.0046075748f) + Float4(0.0796819754f)) + Float4(-0.645963615f)) + Float4(1.5707963235f));
+			Float4 c2 = (c1 * c1) - (s1 * s1);
+			Float4 s2 = Float4(2.0f) * s1 * c1;
+			return Float4(2.0f) * s2 * c2 * reciprocal(s2 * s2 + c2 * c2, pp, true);
+		}
+
+		const Float4 A = Float4(-16.0f);
+		const Float4 B = Float4(8.0f);
+		const Float4 C = Float4(7.75160950e-1f);
+		const Float4 D = Float4(2.24839049e-1f);
+
+		// Parabola approximating sine
+		Float4 sin = y * (Abs(y) * A + B);
+
+		// Improve precision from 0.06 to 0.001
+		if(true)
+		{
+			sin = sin * (Abs(sin) * D + C);
+		}
+
+		return sin;
+	}
+
+	Float4 cosine(RValue<Float4> x, bool pp)
+	{
+		// cos(x) = sin(x + pi/2)
+		Float4 y = x + Float4(1.57079632e+0f);
+		return sine(y, pp);
+	}
+
+	Float4 tangent(RValue<Float4> x, bool pp)
+	{
+		return sine(x, pp) / cosine(x, pp);
+	}
+
+	Float4 arccos(RValue<Float4> x, bool pp)
+	{
+		// pi/2 - arcsin(x)
+		return Float4(1.57079632e+0f) - arcsin(x);
+	}
+
+	Float4 arcsin(RValue<Float4> x, bool pp)
+	{
+		if(false) // Simpler implementation fails even lowp precision tests
+		{
+			// x*(pi/2-sqrt(1-x*x)*pi/5)
+			return x * (Float4(1.57079632e+0f) - Sqrt(Float4(1.0f) - x*x) * Float4(6.28318531e-1f));
+		}
+		else
+		{
+			// From 4.4.45, page 81 of the Handbook of Mathematical Functions, by Milton Abramowitz and Irene Stegun
+			const Float4 half_pi(1.57079632f);
+			const Float4 a0(1.5707288f);
+			const Float4 a1(-0.2121144f);
+			const Float4 a2(0.0742610f);
+			const Float4 a3(-0.0187293f);
+			Float4 absx = Abs(x);
+			return As<Float4>(As<Int4>(half_pi - Sqrt(Float4(1.0f) - absx) * (a0 + absx * (a1 + absx * (a2 + absx * a3)))) ^
+			       (As<Int4>(x) & Int4(0x80000000)));
+		}
+	}
+
+	// Approximation of atan in [0..1]
+	Float4 arctan_01(Float4 x, bool pp)
+	{
+		if(pp)
+		{
+			return x * (Float4(-0.27f) * x + Float4(1.05539816f));
+		}
+		else
+		{
+			// From 4.4.49, page 81 of the Handbook of Mathematical Functions, by Milton Abramowitz and Irene Stegun
+			const Float4 a2(-0.3333314528f);
+			const Float4 a4(0.1999355085f);
+			const Float4 a6(-0.1420889944f);
+			const Float4 a8(0.1065626393f);
+			const Float4 a10(-0.0752896400f);
+			const Float4 a12(0.0429096138f);
+			const Float4 a14(-0.0161657367f);
+			const Float4 a16(0.0028662257f);
+			Float4 x2 = x * x;
+			return (x + x * (x2 * (a2 + x2 * (a4 + x2 * (a6 + x2 * (a8 + x2 * (a10 + x2 * (a12 + x2 * (a14 + x2 * a16)))))))));
+		}
+	}
+
+	Float4 arctan(RValue<Float4> x, bool pp)
+	{
+		Float4 absx = Abs(x);
+		Int4 O = CmpNLT(absx, Float4(1.0f));
+		Float4 y = As<Float4>((O & As<Int4>(Float4(1.0f) / absx)) | (~O & As<Int4>(absx))); // FIXME: Vector select
+
+		const Float4 half_pi(1.57079632f);
+		Float4 theta = arctan_01(y, pp);
+		return As<Float4>(((O & As<Int4>(half_pi - theta)) | (~O & As<Int4>(theta))) ^ // FIXME: Vector select
+		       (As<Int4>(x) & Int4(0x80000000)));
+	}
+
+	Float4 arctan(RValue<Float4> y, RValue<Float4> x, bool pp)
+	{
+		const Float4 pi(3.14159265f);            // pi
+		const Float4 minus_pi(-3.14159265f);     // -pi
+		const Float4 half_pi(1.57079632f);       // pi/2
+		const Float4 quarter_pi(7.85398163e-1f); // pi/4
+
+		// Rotate to upper semicircle when in lower semicircle
+		Int4 S = CmpLT(y, Float4(0.0f));
+		Float4 theta = As<Float4>(S & As<Int4>(minus_pi));
+		Float4 x0 = As<Float4>((As<Int4>(y) & Int4(0x80000000)) ^ As<Int4>(x));
+		Float4 y0 = Abs(y);
+
+		// Rotate to right quadrant when in left quadrant
+		Int4 Q = CmpLT(x0, Float4(0.0f));
+		theta += As<Float4>(Q & As<Int4>(half_pi));
+		Float4 x1 = As<Float4>((Q & As<Int4>(y0)) | (~Q & As<Int4>(x0)));  // FIXME: Vector select
+		Float4 y1 = As<Float4>((Q & As<Int4>(-x0)) | (~Q & As<Int4>(y0))); // FIXME: Vector select
+
+		// Mirror to first octant when in second octant
+		Int4 O = CmpNLT(y1, x1);
+		Float4 x2 = As<Float4>((O & As<Int4>(y1)) | (~O & As<Int4>(x1))); // FIXME: Vector select
+		Float4 y2 = As<Float4>((O & As<Int4>(x1)) | (~O & As<Int4>(y1))); // FIXME: Vector select
+
+		// Approximation of atan in [0..1]
+		Int4 zero_x = CmpEQ(x2, Float4(0.0f));
+		Int4 inf_y = IsInf(y2); // Since x2 >= y2, this means x2 == y2 == inf, so we use 45 degrees or pi/4
+		Float4 atan2_theta = arctan_01(y2 / x2, pp);
+		theta += As<Float4>((~zero_x & ~inf_y & ((O & As<Int4>(half_pi - atan2_theta)) | (~O & (As<Int4>(atan2_theta))))) | // FIXME: Vector select
+		                    (inf_y & As<Int4>(quarter_pi)));
+
+		// Recover loss of precision for tiny theta angles
+		Int4 precision_loss = S & Q & O & ~inf_y; // This combination results in (-pi + half_pi + half_pi - atan2_theta) which is equivalent to -atan2_theta
+		return As<Float4>((precision_loss & As<Int4>(-atan2_theta)) | (~precision_loss & As<Int4>(theta))); // FIXME: Vector select
+	}
+
+	Float4 sineh(RValue<Float4> x, bool pp)
+	{
+		return (exponential(x, pp) - exponential(-x, pp)) * Float4(0.5f);
+	}
+
+	Float4 cosineh(RValue<Float4> x, bool pp)
+	{
+		return (exponential(x, pp) + exponential(-x, pp)) * Float4(0.5f);
+	}
+
+	Float4 tangenth(RValue<Float4> x, bool pp)
+	{
+		Float4 e_x = exponential(x, pp);
+		Float4 e_minus_x = exponential(-x, pp);
+		return (e_x - e_minus_x) / (e_x + e_minus_x);
+	}
+
+	Float4 arccosh(RValue<Float4> x, bool pp)
+	{
+		return logarithm(x + Sqrt(x + Float4(1.0f)) * Sqrt(x - Float4(1.0f)), pp);
+	}
+
+	Float4 arcsinh(RValue<Float4> x, bool pp)
+	{
+		return logarithm(x + Sqrt(x * x + Float4(1.0f)), pp);
+	}
+
+	Float4 arctanh(RValue<Float4> x, bool pp)
+	{
+		return logarithm((Float4(1.0f) + x) / (Float4(1.0f) - x), pp) * Float4(0.5f);
+	}
+
+	Float4 dot2(const Vector4f &v0, const Vector4f &v1)
+	{
+		return v0.x * v1.x + v0.y * v1.y;
+	}
+
+	Float4 dot3(const Vector4f &v0, const Vector4f &v1)
+	{
+		return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z;
+	}
+
+	Float4 dot4(const Vector4f &v0, const Vector4f &v1)
+	{
+		return v0.x * v1.x + v0.y * v1.y + v0.z * v1.z + v0.w * v1.w;
+	}
+
+	void transpose4x4(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3)
+	{
+		Int2 tmp0 = UnpackHigh(row0, row1);
+		Int2 tmp1 = UnpackHigh(row2, row3);
+		Int2 tmp2 = UnpackLow(row0, row1);
+		Int2 tmp3 = UnpackLow(row2, row3);
+
+		row0 = UnpackLow(tmp2, tmp3);
+		row1 = UnpackHigh(tmp2, tmp3);
+		row2 = UnpackLow(tmp0, tmp1);
+		row3 = UnpackHigh(tmp0, tmp1);
+	}
+
+	void transpose4x3(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3)
+	{
+		Int2 tmp0 = UnpackHigh(row0, row1);
+		Int2 tmp1 = UnpackHigh(row2, row3);
+		Int2 tmp2 = UnpackLow(row0, row1);
+		Int2 tmp3 = UnpackLow(row2, row3);
+
+		row0 = UnpackLow(tmp2, tmp3);
+		row1 = UnpackHigh(tmp2, tmp3);
+		row2 = UnpackLow(tmp0, tmp1);
+	}
+
+	void transpose4x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
+	{
+		Float4 tmp0 = UnpackLow(row0, row1);
+		Float4 tmp1 = UnpackLow(row2, row3);
+		Float4 tmp2 = UnpackHigh(row0, row1);
+		Float4 tmp3 = UnpackHigh(row2, row3);
+
+		row0 = Float4(tmp0.xy, tmp1.xy);
+		row1 = Float4(tmp0.zw, tmp1.zw);
+		row2 = Float4(tmp2.xy, tmp3.xy);
+		row3 = Float4(tmp2.zw, tmp3.zw);
+	}
+
+	void transpose4x3(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
+	{
+		Float4 tmp0 = UnpackLow(row0, row1);
+		Float4 tmp1 = UnpackLow(row2, row3);
+		Float4 tmp2 = UnpackHigh(row0, row1);
+		Float4 tmp3 = UnpackHigh(row2, row3);
+
+		row0 = Float4(tmp0.xy, tmp1.xy);
+		row1 = Float4(tmp0.zw, tmp1.zw);
+		row2 = Float4(tmp2.xy, tmp3.xy);
+	}
+
+	void transpose4x2(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
+	{
+		Float4 tmp0 = UnpackLow(row0, row1);
+		Float4 tmp1 = UnpackLow(row2, row3);
+
+		row0 = Float4(tmp0.xy, tmp1.xy);
+		row1 = Float4(tmp0.zw, tmp1.zw);
+	}
+
+	void transpose4x1(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
+	{
+		Float4 tmp0 = UnpackLow(row0, row1);
+		Float4 tmp1 = UnpackLow(row2, row3);
+
+		row0 = Float4(tmp0.xy, tmp1.xy);
+	}
+
+	void transpose2x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3)
+	{
+		Float4 tmp01 = UnpackLow(row0, row1);
+		Float4 tmp23 = UnpackHigh(row0, row1);
+
+		row0 = tmp01;
+		row1 = Float4(tmp01.zw, row1.zw);
+		row2 = tmp23;
+		row3 = Float4(tmp23.zw, row3.zw);
+	}
+
+	void transpose4xN(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3, int N)
+	{
+		switch(N)
+		{
+		case 1: transpose4x1(row0, row1, row2, row3); break;
+		case 2: transpose4x2(row0, row1, row2, row3); break;
+		case 3: transpose4x3(row0, row1, row2, row3); break;
+		case 4: transpose4x4(row0, row1, row2, row3); break;
+		}
+	}
+
+	const Vector4f RegisterFile::operator[](RValue<Int4> index)
+	{
+		ASSERT(indirectAddressable);
+
+		Int index0 = Extract(index, 0);
+		Int index1 = Extract(index, 1);
+		Int index2 = Extract(index, 2);
+		Int index3 = Extract(index, 3);
+
+		Vector4f r;
+
+		r.x.x = Extract(x[0][index0], 0);
+		r.x.y = Extract(x[0][index1], 1);
+		r.x.z = Extract(x[0][index2], 2);
+		r.x.w = Extract(x[0][index3], 3);
+
+		r.y.x = Extract(y[0][index0], 0);
+		r.y.y = Extract(y[0][index1], 1);
+		r.y.z = Extract(y[0][index2], 2);
+		r.y.w = Extract(y[0][index3], 3);
+
+		r.z.x = Extract(z[0][index0], 0);
+		r.z.y = Extract(z[0][index1], 1);
+		r.z.z = Extract(z[0][index2], 2);
+		r.z.w = Extract(z[0][index3], 3);
+
+		r.w.x = Extract(w[0][index0], 0);
+		r.w.y = Extract(w[0][index1], 1);
+		r.w.z = Extract(w[0][index2], 2);
+		r.w.w = Extract(w[0][index3], 3);
+
+		return r;
+	}
+
+	void RegisterFile::scatter_x(Int4 index, RValue<Float4> r)
+	{
+		ASSERT(indirectAddressable);
+
+		Int index0 = Extract(index, 0);
+		Int index1 = Extract(index, 1);
+		Int index2 = Extract(index, 2);
+		Int index3 = Extract(index, 3);
+
+		x[0][index0] = Insert(x[0][index0], Extract(r, 0), 0);
+		x[0][index1] = Insert(x[0][index1], Extract(r, 1), 1);
+		x[0][index2] = Insert(x[0][index2], Extract(r, 2), 2);
+		x[0][index3] = Insert(x[0][index3], Extract(r, 3), 3);
+	}
+
+	void RegisterFile::scatter_y(Int4 index, RValue<Float4> r)
+	{
+		ASSERT(indirectAddressable);
+
+		Int index0 = Extract(index, 0);
+		Int index1 = Extract(index, 1);
+		Int index2 = Extract(index, 2);
+		Int index3 = Extract(index, 3);
+
+		y[0][index0] = Insert(y[0][index0], Extract(r, 0), 0);
+		y[0][index1] = Insert(y[0][index1], Extract(r, 1), 1);
+		y[0][index2] = Insert(y[0][index2], Extract(r, 2), 2);
+		y[0][index3] = Insert(y[0][index3], Extract(r, 3), 3);
+	}
+
+	void RegisterFile::scatter_z(Int4 index, RValue<Float4> r)
+	{
+		ASSERT(indirectAddressable);
+
+		Int index0 = Extract(index, 0);
+		Int index1 = Extract(index, 1);
+		Int index2 = Extract(index, 2);
+		Int index3 = Extract(index, 3);
+
+		z[0][index0] = Insert(z[0][index0], Extract(r, 0), 0);
+		z[0][index1] = Insert(z[0][index1], Extract(r, 1), 1);
+		z[0][index2] = Insert(z[0][index2], Extract(r, 2), 2);
+		z[0][index3] = Insert(z[0][index3], Extract(r, 3), 3);
+	}
+
+	void RegisterFile::scatter_w(Int4 index, RValue<Float4> r)
+	{
+		ASSERT(indirectAddressable);
+
+		Int index0 = Extract(index, 0);
+		Int index1 = Extract(index, 1);
+		Int index2 = Extract(index, 2);
+		Int index3 = Extract(index, 3);
+
+		w[0][index0] = Insert(w[0][index0], Extract(r, 0), 0);
+		w[0][index1] = Insert(w[0][index1], Extract(r, 1), 1);
+		w[0][index2] = Insert(w[0][index2], Extract(r, 2), 2);
+		w[0][index3] = Insert(w[0][index3], Extract(r, 3), 3);
+	}
+
+	void ShaderCore::mov(Vector4f &dst, const Vector4f &src, bool integerDestination)
+	{
+		if(integerDestination)
+		{
+			dst.x = As<Float4>(RoundInt(src.x));
+			dst.y = As<Float4>(RoundInt(src.y));
+			dst.z = As<Float4>(RoundInt(src.z));
+			dst.w = As<Float4>(RoundInt(src.w));
+		}
+		else
+		{
+			dst = src;
+		}
+	}
+
+	void ShaderCore::neg(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = -src.x;
+		dst.y = -src.y;
+		dst.z = -src.z;
+		dst.w = -src.w;
+	}
+
+	void ShaderCore::ineg(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(-As<Int4>(src.x));
+		dst.y = As<Float4>(-As<Int4>(src.y));
+		dst.z = As<Float4>(-As<Int4>(src.z));
+		dst.w = As<Float4>(-As<Int4>(src.w));
+	}
+
+	void ShaderCore::f2b(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(CmpNEQ(src.x, Float4(0.0f)));
+		dst.y = As<Float4>(CmpNEQ(src.y, Float4(0.0f)));
+		dst.z = As<Float4>(CmpNEQ(src.z, Float4(0.0f)));
+		dst.w = As<Float4>(CmpNEQ(src.w, Float4(0.0f)));
+	}
+
+	void ShaderCore::b2f(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(As<Int4>(src.x) & As<Int4>(Float4(1.0f)));
+		dst.y = As<Float4>(As<Int4>(src.y) & As<Int4>(Float4(1.0f)));
+		dst.z = As<Float4>(As<Int4>(src.z) & As<Int4>(Float4(1.0f)));
+		dst.w = As<Float4>(As<Int4>(src.w) & As<Int4>(Float4(1.0f)));
+	}
+
+	void ShaderCore::f2i(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(Int4(src.x));
+		dst.y = As<Float4>(Int4(src.y));
+		dst.z = As<Float4>(Int4(src.z));
+		dst.w = As<Float4>(Int4(src.w));
+	}
+
+	void ShaderCore::i2f(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Float4(As<Int4>(src.x));
+		dst.y = Float4(As<Int4>(src.y));
+		dst.z = Float4(As<Int4>(src.z));
+		dst.w = Float4(As<Int4>(src.w));
+	}
+
+	void ShaderCore::f2u(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(UInt4(src.x));
+		dst.y = As<Float4>(UInt4(src.y));
+		dst.z = As<Float4>(UInt4(src.z));
+		dst.w = As<Float4>(UInt4(src.w));
+	}
+
+	void ShaderCore::u2f(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Float4(As<UInt4>(src.x));
+		dst.y = Float4(As<UInt4>(src.y));
+		dst.z = Float4(As<UInt4>(src.z));
+		dst.w = Float4(As<UInt4>(src.w));
+	}
+
+	void ShaderCore::i2b(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(CmpNEQ(As<Int4>(src.x), Int4(0)));
+		dst.y = As<Float4>(CmpNEQ(As<Int4>(src.y), Int4(0)));
+		dst.z = As<Float4>(CmpNEQ(As<Int4>(src.z), Int4(0)));
+		dst.w = As<Float4>(CmpNEQ(As<Int4>(src.w), Int4(0)));
+	}
+
+	void ShaderCore::b2i(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(As<Int4>(src.x) & Int4(1));
+		dst.y = As<Float4>(As<Int4>(src.y) & Int4(1));
+		dst.z = As<Float4>(As<Int4>(src.z) & Int4(1));
+		dst.w = As<Float4>(As<Int4>(src.w) & Int4(1));
+	}
+
+	void ShaderCore::add(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.x + src1.x;
+		dst.y = src0.y + src1.y;
+		dst.z = src0.z + src1.z;
+		dst.w = src0.w + src1.w;
+	}
+
+	void ShaderCore::iadd(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) + As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) + As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) + As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) + As<Int4>(src1.w));
+	}
+
+	void ShaderCore::sub(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.x - src1.x;
+		dst.y = src0.y - src1.y;
+		dst.z = src0.z - src1.z;
+		dst.w = src0.w - src1.w;
+	}
+
+	void ShaderCore::isub(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) - As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) - As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) - As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) - As<Int4>(src1.w));
+	}
+
+	void ShaderCore::mad(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		dst.x = src0.x * src1.x + src2.x;
+		dst.y = src0.y * src1.y + src2.y;
+		dst.z = src0.z * src1.z + src2.z;
+		dst.w = src0.w * src1.w + src2.w;
+	}
+
+	void ShaderCore::imad(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) * As<Int4>(src1.x) + As<Int4>(src2.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) * As<Int4>(src1.y) + As<Int4>(src2.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) * As<Int4>(src1.z) + As<Int4>(src2.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) * As<Int4>(src1.w) + As<Int4>(src2.w));
+	}
+
+	void ShaderCore::mul(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.x * src1.x;
+		dst.y = src0.y * src1.y;
+		dst.z = src0.z * src1.z;
+		dst.w = src0.w * src1.w;
+	}
+
+	void ShaderCore::imul(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) * As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) * As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) * As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) * As<Int4>(src1.w));
+	}
+
+	void ShaderCore::rcpx(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 rcp = reciprocal(src.x, pp, true, true);
+
+		dst.x = rcp;
+		dst.y = rcp;
+		dst.z = rcp;
+		dst.w = rcp;
+	}
+
+	void ShaderCore::div(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.x / src1.x;
+		dst.y = src0.y / src1.y;
+		dst.z = src0.z / src1.z;
+		dst.w = src0.w / src1.w;
+	}
+
+	void ShaderCore::idiv(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 intMax(As<Float4>(Int4(INT_MAX)));
+		cmp0i(dst.x, src1.x, intMax, src1.x);
+		dst.x = As<Float4>(As<Int4>(src0.x) / As<Int4>(dst.x));
+		cmp0i(dst.y, src1.y, intMax, src1.y);
+		dst.y = As<Float4>(As<Int4>(src0.y) / As<Int4>(dst.y));
+		cmp0i(dst.z, src1.z, intMax, src1.z);
+		dst.z = As<Float4>(As<Int4>(src0.z) / As<Int4>(dst.z));
+		cmp0i(dst.w, src1.w, intMax, src1.w);
+		dst.w = As<Float4>(As<Int4>(src0.w) / As<Int4>(dst.w));
+	}
+
+	void ShaderCore::udiv(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 uintMax(As<Float4>(UInt4(UINT_MAX)));
+		cmp0i(dst.x, src1.x, uintMax, src1.x);
+		dst.x = As<Float4>(As<UInt4>(src0.x) / As<UInt4>(dst.x));
+		cmp0i(dst.y, src1.y, uintMax, src1.y);
+		dst.y = As<Float4>(As<UInt4>(src0.y) / As<UInt4>(dst.y));
+		cmp0i(dst.z, src1.z, uintMax, src1.z);
+		dst.z = As<Float4>(As<UInt4>(src0.z) / As<UInt4>(dst.z));
+		cmp0i(dst.w, src1.w, uintMax, src1.w);
+		dst.w = As<Float4>(As<UInt4>(src0.w) / As<UInt4>(dst.w));
+	}
+
+	void ShaderCore::mod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = modulo(src0.x, src1.x);
+		dst.y = modulo(src0.y, src1.y);
+		dst.z = modulo(src0.z, src1.z);
+		dst.w = modulo(src0.w, src1.w);
+	}
+
+	void ShaderCore::imod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 intMax(As<Float4>(Int4(INT_MAX)));
+		cmp0i(dst.x, src1.x, intMax, src1.x);
+		dst.x = As<Float4>(As<Int4>(src0.x) % As<Int4>(dst.x));
+		cmp0i(dst.y, src1.y, intMax, src1.y);
+		dst.y = As<Float4>(As<Int4>(src0.y) % As<Int4>(dst.y));
+		cmp0i(dst.z, src1.z, intMax, src1.z);
+		dst.z = As<Float4>(As<Int4>(src0.z) % As<Int4>(dst.z));
+		cmp0i(dst.w, src1.w, intMax, src1.w);
+		dst.w = As<Float4>(As<Int4>(src0.w) % As<Int4>(dst.w));
+	}
+
+	void ShaderCore::umod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 uintMax(As<Float4>(UInt4(UINT_MAX)));
+		cmp0i(dst.x, src1.x, uintMax, src1.x);
+		dst.x = As<Float4>(As<UInt4>(src0.x) % As<UInt4>(dst.x));
+		cmp0i(dst.y, src1.y, uintMax, src1.y);
+		dst.y = As<Float4>(As<UInt4>(src0.y) % As<UInt4>(dst.y));
+		cmp0i(dst.z, src1.z, uintMax, src1.z);
+		dst.z = As<Float4>(As<UInt4>(src0.z) % As<UInt4>(dst.z));
+		cmp0i(dst.w, src1.w, uintMax, src1.w);
+		dst.w = As<Float4>(As<UInt4>(src0.w) % As<UInt4>(dst.w));
+	}
+
+	void ShaderCore::shl(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) << As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) << As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) << As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) << As<Int4>(src1.w));
+	}
+
+	void ShaderCore::ishr(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) >> As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) >> As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) >> As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) >> As<Int4>(src1.w));
+	}
+
+	void ShaderCore::ushr(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<UInt4>(src0.x) >> As<UInt4>(src1.x));
+		dst.y = As<Float4>(As<UInt4>(src0.y) >> As<UInt4>(src1.y));
+		dst.z = As<Float4>(As<UInt4>(src0.z) >> As<UInt4>(src1.z));
+		dst.w = As<Float4>(As<UInt4>(src0.w) >> As<UInt4>(src1.w));
+	}
+
+	void ShaderCore::rsqx(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 rsq = reciprocalSquareRoot(src.x, true, pp);
+
+		dst.x = rsq;
+		dst.y = rsq;
+		dst.z = rsq;
+		dst.w = rsq;
+	}
+
+	void ShaderCore::sqrt(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = Sqrt(src.x);
+		dst.y = Sqrt(src.y);
+		dst.z = Sqrt(src.z);
+		dst.w = Sqrt(src.w);
+	}
+
+	void ShaderCore::rsq(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = reciprocalSquareRoot(src.x, false, pp);
+		dst.y = reciprocalSquareRoot(src.y, false, pp);
+		dst.z = reciprocalSquareRoot(src.z, false, pp);
+		dst.w = reciprocalSquareRoot(src.w, false, pp);
+	}
+
+	void ShaderCore::len2(Float4 &dst, const Vector4f &src, bool pp)
+	{
+		dst = Sqrt(dot2(src, src));
+	}
+
+	void ShaderCore::len3(Float4 &dst, const Vector4f &src, bool pp)
+	{
+		dst = Sqrt(dot3(src, src));
+	}
+
+	void ShaderCore::len4(Float4 &dst, const Vector4f &src, bool pp)
+	{
+		dst = Sqrt(dot4(src, src));
+	}
+
+	void ShaderCore::dist1(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		dst = Abs(src0.x - src1.x);
+	}
+
+	void ShaderCore::dist2(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		Float4 dx = src0.x - src1.x;
+		Float4 dy = src0.y - src1.y;
+		Float4 dot2 = dx * dx + dy * dy;
+		dst = Sqrt(dot2);
+	}
+
+	void ShaderCore::dist3(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		Float4 dx = src0.x - src1.x;
+		Float4 dy = src0.y - src1.y;
+		Float4 dz = src0.z - src1.z;
+		Float4 dot3 = dx * dx + dy * dy + dz * dz;
+		dst = Sqrt(dot3);
+	}
+
+	void ShaderCore::dist4(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		Float4 dx = src0.x - src1.x;
+		Float4 dy = src0.y - src1.y;
+		Float4 dz = src0.z - src1.z;
+		Float4 dw = src0.w - src1.w;
+		Float4 dot4 = dx * dx + dy * dy + dz * dz + dw * dw;
+		dst = Sqrt(dot4);
+	}
+
+	void ShaderCore::dp1(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 t = src0.x * src1.x;
+
+		dst.x = t;
+		dst.y = t;
+		dst.z = t;
+		dst.w = t;
+	}
+
+	void ShaderCore::dp2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 t = dot2(src0, src1);
+
+		dst.x = t;
+		dst.y = t;
+		dst.z = t;
+		dst.w = t;
+	}
+
+	void ShaderCore::dp2add(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		Float4 t = dot2(src0, src1) + src2.x;
+
+		dst.x = t;
+		dst.y = t;
+		dst.z = t;
+		dst.w = t;
+	}
+
+	void ShaderCore::dp3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 dot = dot3(src0, src1);
+
+		dst.x = dot;
+		dst.y = dot;
+		dst.z = dot;
+		dst.w = dot;
+	}
+
+	void ShaderCore::dp4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		Float4 dot = dot4(src0, src1);
+
+		dst.x = dot;
+		dst.y = dot;
+		dst.z = dot;
+		dst.w = dot;
+	}
+
+	void ShaderCore::min(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = Min(src0.x, src1.x);
+		dst.y = Min(src0.y, src1.y);
+		dst.z = Min(src0.z, src1.z);
+		dst.w = Min(src0.w, src1.w);
+	}
+
+	void ShaderCore::imin(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(Min(As<Int4>(src0.x), As<Int4>(src1.x)));
+		dst.y = As<Float4>(Min(As<Int4>(src0.y), As<Int4>(src1.y)));
+		dst.z = As<Float4>(Min(As<Int4>(src0.z), As<Int4>(src1.z)));
+		dst.w = As<Float4>(Min(As<Int4>(src0.w), As<Int4>(src1.w)));
+	}
+
+	void ShaderCore::umin(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(Min(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+		dst.y = As<Float4>(Min(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+		dst.z = As<Float4>(Min(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+		dst.w = As<Float4>(Min(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+	}
+
+	void ShaderCore::max(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = Max(src0.x, src1.x);
+		dst.y = Max(src0.y, src1.y);
+		dst.z = Max(src0.z, src1.z);
+		dst.w = Max(src0.w, src1.w);
+	}
+
+	void ShaderCore::imax(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(Max(As<Int4>(src0.x), As<Int4>(src1.x)));
+		dst.y = As<Float4>(Max(As<Int4>(src0.y), As<Int4>(src1.y)));
+		dst.z = As<Float4>(Max(As<Int4>(src0.z), As<Int4>(src1.z)));
+		dst.w = As<Float4>(Max(As<Int4>(src0.w), As<Int4>(src1.w)));
+	}
+
+	void ShaderCore::umax(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(Max(As<Int4>(src0.x), As<Int4>(src1.x)));
+		dst.y = As<Float4>(Max(As<Int4>(src0.y), As<Int4>(src1.y)));
+		dst.z = As<Float4>(Max(As<Int4>(src0.z), As<Int4>(src1.z)));
+		dst.w = As<Float4>(Max(As<Int4>(src0.w), As<Int4>(src1.w)));
+	}
+
+	void ShaderCore::slt(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(CmpLT(src0.x, src1.x)) & As<Int4>(Float4(1.0f)));
+		dst.y = As<Float4>(As<Int4>(CmpLT(src0.y, src1.y)) & As<Int4>(Float4(1.0f)));
+		dst.z = As<Float4>(As<Int4>(CmpLT(src0.z, src1.z)) & As<Int4>(Float4(1.0f)));
+		dst.w = As<Float4>(As<Int4>(CmpLT(src0.w, src1.w)) & As<Int4>(Float4(1.0f)));
+	}
+
+	void ShaderCore::step(Vector4f &dst, const Vector4f &edge, const Vector4f &x)
+	{
+		dst.x = As<Float4>(CmpNLT(x.x, edge.x) & As<Int4>(Float4(1.0f)));
+		dst.y = As<Float4>(CmpNLT(x.y, edge.y) & As<Int4>(Float4(1.0f)));
+		dst.z = As<Float4>(CmpNLT(x.z, edge.z) & As<Int4>(Float4(1.0f)));
+		dst.w = As<Float4>(CmpNLT(x.w, edge.w) & As<Int4>(Float4(1.0f)));
+	}
+
+	void ShaderCore::exp2x(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 exp = exponential2(src.x, pp);
+
+		dst.x = exp;
+		dst.y = exp;
+		dst.z = exp;
+		dst.w = exp;
+	}
+
+	void ShaderCore::exp2(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = exponential2(src.x, pp);
+		dst.y = exponential2(src.y, pp);
+		dst.z = exponential2(src.z, pp);
+		dst.w = exponential2(src.w, pp);
+	}
+
+	void ShaderCore::exp(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = exponential(src.x, pp);
+		dst.y = exponential(src.y, pp);
+		dst.z = exponential(src.z, pp);
+		dst.w = exponential(src.w, pp);
+	}
+
+	void ShaderCore::log2x(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 log = logarithm2(src.x, true, pp);
+
+		dst.x = log;
+		dst.y = log;
+		dst.z = log;
+		dst.w = log;
+	}
+
+	void ShaderCore::log2(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = logarithm2(src.x, false, pp);
+		dst.y = logarithm2(src.y, false, pp);
+		dst.z = logarithm2(src.z, false, pp);
+		dst.w = logarithm2(src.w, false, pp);
+	}
+
+	void ShaderCore::log(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = logarithm(src.x, false, pp);
+		dst.y = logarithm(src.y, false, pp);
+		dst.z = logarithm(src.z, false, pp);
+		dst.w = logarithm(src.w, false, pp);
+	}
+
+	void ShaderCore::lit(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Float4(1.0f);
+		dst.y = Max(src.x, Float4(0.0f));
+
+		Float4 pow;
+
+		pow = src.w;
+		pow = Min(pow, Float4(127.9961f));
+		pow = Max(pow, Float4(-127.9961f));
+
+		dst.z = power(src.y, pow);
+		dst.z = As<Float4>(As<Int4>(dst.z) & CmpNLT(src.x, Float4(0.0f)));
+		dst.z = As<Float4>(As<Int4>(dst.z) & CmpNLT(src.y, Float4(0.0f)));
+
+		dst.w = Float4(1.0f);
+	}
+
+	void ShaderCore::att(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		// Computes attenuation factors (1, d, d^2, 1/d) assuming src0 = d^2, src1 = 1/d
+		dst.x = 1;
+		dst.y = src0.y * src1.y;
+		dst.z = src0.z;
+		dst.w = src1.w;
+	}
+
+	void ShaderCore::lrp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		dst.x = src0.x * (src1.x - src2.x) + src2.x;
+		dst.y = src0.y * (src1.y - src2.y) + src2.y;
+		dst.z = src0.z * (src1.z - src2.z) + src2.z;
+		dst.w = src0.w * (src1.w - src2.w) + src2.w;
+	}
+
+	void ShaderCore::isinf(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(IsInf(src.x));
+		dst.y = As<Float4>(IsInf(src.y));
+		dst.z = As<Float4>(IsInf(src.z));
+		dst.w = As<Float4>(IsInf(src.w));
+	}
+
+	void ShaderCore::isnan(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(IsNan(src.x));
+		dst.y = As<Float4>(IsNan(src.y));
+		dst.z = As<Float4>(IsNan(src.z));
+		dst.w = As<Float4>(IsNan(src.w));
+	}
+
+	void ShaderCore::smooth(Vector4f &dst, const Vector4f &edge0, const Vector4f &edge1, const Vector4f &x)
+	{
+		Float4 tx = Min(Max((x.x - edge0.x) / (edge1.x - edge0.x), Float4(0.0f)), Float4(1.0f)); dst.x = tx * tx * (Float4(3.0f) - Float4(2.0f) * tx);
+		Float4 ty = Min(Max((x.y - edge0.y) / (edge1.y - edge0.y), Float4(0.0f)), Float4(1.0f)); dst.y = ty * ty * (Float4(3.0f) - Float4(2.0f) * ty);
+		Float4 tz = Min(Max((x.z - edge0.z) / (edge1.z - edge0.z), Float4(0.0f)), Float4(1.0f)); dst.z = tz * tz * (Float4(3.0f) - Float4(2.0f) * tz);
+		Float4 tw = Min(Max((x.w - edge0.w) / (edge1.w - edge0.w), Float4(0.0f)), Float4(1.0f)); dst.w = tw * tw * (Float4(3.0f) - Float4(2.0f) * tw);
+	}
+
+	void ShaderCore::floatToHalfBits(Float4& dst, const Float4& floatBits, bool storeInUpperBits)
+	{
+		static const uint32_t mask_sign = 0x80000000u;
+		static const uint32_t mask_round = ~0xfffu;
+		static const uint32_t c_f32infty = 255 << 23;
+		static const uint32_t c_magic = 15 << 23;
+		static const uint32_t c_nanbit = 0x200;
+		static const uint32_t c_infty_as_fp16 = 0x7c00;
+		static const uint32_t c_clamp = (31 << 23) - 0x1000;
+
+		UInt4 justsign = UInt4(mask_sign) & As<UInt4>(floatBits);
+		UInt4 absf = As<UInt4>(floatBits) ^ justsign;
+		UInt4 b_isnormal = CmpNLE(UInt4(c_f32infty), absf);
+
+		// Note: this version doesn't round to the nearest even in case of a tie as defined by IEEE 754-2008, it rounds to +inf
+		//       instead of nearest even, since that's fine for GLSL ES 3.0's needs (see section 2.1.1 Floating-Point Computation)
+		UInt4 joined = ((((As<UInt4>(Min(As<Float4>(absf & UInt4(mask_round)) * As<Float4>(UInt4(c_magic)),
+		                                 As<Float4>(UInt4(c_clamp))))) - UInt4(mask_round)) >> 13) & b_isnormal) |
+		               ((b_isnormal ^ UInt4(0xFFFFFFFF)) & ((CmpNLE(absf, UInt4(c_f32infty)) & UInt4(c_nanbit)) |
+		               UInt4(c_infty_as_fp16)));
+
+		dst = As<Float4>(storeInUpperBits ? As<UInt4>(dst) | ((joined << 16) | justsign) : joined | (justsign >> 16));
+	}
+
+	void ShaderCore::halfToFloatBits(Float4& dst, const Float4& halfBits)
+	{
+		static const uint32_t mask_nosign = 0x7FFF;
+		static const uint32_t magic = (254 - 15) << 23;
+		static const uint32_t was_infnan = 0x7BFF;
+		static const uint32_t exp_infnan = 255 << 23;
+
+		UInt4 expmant = As<UInt4>(halfBits) & UInt4(mask_nosign);
+		dst = As<Float4>(As<UInt4>(As<Float4>(expmant << 13) * As<Float4>(UInt4(magic))) |
+		                 ((As<UInt4>(halfBits) ^ UInt4(expmant)) << 16) |
+		                 (CmpNLE(As<UInt4>(expmant), UInt4(was_infnan)) & UInt4(exp_infnan)));
+	}
+
+	void ShaderCore::packHalf2x16(Vector4f &d, const Vector4f &s0)
+	{
+		// half2 | half1
+		floatToHalfBits(d.x, s0.x, false);
+		floatToHalfBits(d.x, s0.y, true);
+	}
+
+	void ShaderCore::unpackHalf2x16(Vector4f &dst, const Vector4f &s0)
+	{
+		// half2 | half1
+		halfToFloatBits(dst.x, As<Float4>(As<UInt4>(s0.x) & UInt4(0x0000FFFF)));
+		halfToFloatBits(dst.y, As<Float4>((As<UInt4>(s0.x) & UInt4(0xFFFF0000)) >> 16));
+	}
+
+	void ShaderCore::packSnorm2x16(Vector4f &d, const Vector4f &s0)
+	{
+		// round(clamp(c, -1.0, 1.0) * 32767.0)
+		d.x = As<Float4>((Int4(Round(Min(Max(s0.x, Float4(-1.0f)), Float4(1.0f)) * Float4(32767.0f))) & Int4(0xFFFF)) |
+		                ((Int4(Round(Min(Max(s0.y, Float4(-1.0f)), Float4(1.0f)) * Float4(32767.0f))) & Int4(0xFFFF)) << 16));
+	}
+
+	void ShaderCore::packUnorm2x16(Vector4f &d, const Vector4f &s0)
+	{
+		// round(clamp(c, 0.0, 1.0) * 65535.0)
+		d.x = As<Float4>((Int4(Round(Min(Max(s0.x, Float4(0.0f)), Float4(1.0f)) * Float4(65535.0f))) & Int4(0xFFFF)) |
+		                ((Int4(Round(Min(Max(s0.y, Float4(0.0f)), Float4(1.0f)) * Float4(65535.0f))) & Int4(0xFFFF)) << 16));
+	}
+
+	void ShaderCore::unpackSnorm2x16(Vector4f &dst, const Vector4f &s0)
+	{
+		// clamp(f / 32727.0, -1.0, 1.0)
+		dst.x = Min(Max(Float4(As<Int4>((As<UInt4>(s0.x) & UInt4(0x0000FFFF)) << 16)) * Float4(1.0f / float(0x7FFF0000)), Float4(-1.0f)), Float4(1.0f));
+		dst.y = Min(Max(Float4(As<Int4>(As<UInt4>(s0.x) & UInt4(0xFFFF0000))) * Float4(1.0f / float(0x7FFF0000)), Float4(-1.0f)), Float4(1.0f));
+	}
+
+	void ShaderCore::unpackUnorm2x16(Vector4f &dst, const Vector4f &s0)
+	{
+		// f / 65535.0
+		dst.x = Float4((As<UInt4>(s0.x) & UInt4(0x0000FFFF)) << 16) * Float4(1.0f / float(0xFFFF0000));
+		dst.y = Float4(As<UInt4>(s0.x) & UInt4(0xFFFF0000)) * Float4(1.0f / float(0xFFFF0000));
+	}
+
+	void ShaderCore::det2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.x * src1.y - src0.y * src1.x;
+		dst.y = dst.z = dst.w = dst.x;
+	}
+
+	void ShaderCore::det3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		crs(dst, src1, src2);
+		dp3(dst, dst, src0);
+	}
+
+	void ShaderCore::det4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2, const Vector4f &src3)
+	{
+		dst.x = src2.z * src3.w - src2.w * src3.z;
+		dst.y = src1.w * src3.z - src1.z * src3.w;
+		dst.z = src1.z * src2.w - src1.w * src2.z;
+		dst.x = src0.x * (src1.y * dst.x + src2.y * dst.y + src3.y * dst.z) -
+		        src0.y * (src1.x * dst.x + src2.x * dst.y + src3.x * dst.z) +
+		        src0.z * (src1.x * (src2.y * src3.w - src2.w * src3.y) +
+		                  src2.x * (src1.w * src3.y - src1.y * src3.w) +
+		                  src3.x * (src1.y * src2.w - src1.w * src2.y)) +
+		        src0.w * (src1.x * (src2.z * src3.y - src2.y * src3.z) +
+		                  src2.x * (src1.y * src3.z - src1.z * src3.y) +
+		                  src3.x * (src1.z * src2.y - src1.y * src2.z));
+		dst.y = dst.z = dst.w = dst.x;
+	}
+
+	void ShaderCore::frc(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Frac(src.x);
+		dst.y = Frac(src.y);
+		dst.z = Frac(src.z);
+		dst.w = Frac(src.w);
+	}
+
+	void ShaderCore::trunc(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Trunc(src.x);
+		dst.y = Trunc(src.y);
+		dst.z = Trunc(src.z);
+		dst.w = Trunc(src.w);
+	}
+
+	void ShaderCore::floor(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Floor(src.x);
+		dst.y = Floor(src.y);
+		dst.z = Floor(src.z);
+		dst.w = Floor(src.w);
+	}
+
+	void ShaderCore::round(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Round(src.x);
+		dst.y = Round(src.y);
+		dst.z = Round(src.z);
+		dst.w = Round(src.w);
+	}
+
+	void ShaderCore::roundEven(Vector4f &dst, const Vector4f &src)
+	{
+		// dst = round(src) + ((round(src) < src) * 2 - 1) * (fract(src) == 0.5) * isOdd(round(src));
+		// ex.: 1.5:  2 + (0 * 2 - 1) * 1 * 0 = 2
+		//      2.5:  3 + (0 * 2 - 1) * 1 * 1 = 2
+		//     -1.5: -2 + (1 * 2 - 1) * 1 * 0 = -2
+		//     -2.5: -3 + (1 * 2 - 1) * 1 * 1 = -2
+		// Even if the round implementation rounds the other way:
+		//      1.5:  1 + (1 * 2 - 1) * 1 * 1 = 2
+		//      2.5:  2 + (1 * 2 - 1) * 1 * 0 = 2
+		//     -1.5: -1 + (0 * 2 - 1) * 1 * 1 = -2
+		//     -2.5: -2 + (0 * 2 - 1) * 1 * 0 = -2
+		round(dst, src);
+		dst.x += ((Float4(CmpLT(dst.x, src.x) & Int4(1)) * Float4(2.0f)) - Float4(1.0f)) * Float4(CmpEQ(Frac(src.x), Float4(0.5f)) & Int4(1)) * Float4(Int4(dst.x) & Int4(1));
+		dst.y += ((Float4(CmpLT(dst.y, src.y) & Int4(1)) * Float4(2.0f)) - Float4(1.0f)) * Float4(CmpEQ(Frac(src.y), Float4(0.5f)) & Int4(1)) * Float4(Int4(dst.y) & Int4(1));
+		dst.z += ((Float4(CmpLT(dst.z, src.z) & Int4(1)) * Float4(2.0f)) - Float4(1.0f)) * Float4(CmpEQ(Frac(src.z), Float4(0.5f)) & Int4(1)) * Float4(Int4(dst.z) & Int4(1));
+		dst.w += ((Float4(CmpLT(dst.w, src.w) & Int4(1)) * Float4(2.0f)) - Float4(1.0f)) * Float4(CmpEQ(Frac(src.w), Float4(0.5f)) & Int4(1)) * Float4(Int4(dst.w) & Int4(1));
+	}
+
+	void ShaderCore::ceil(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Ceil(src.x);
+		dst.y = Ceil(src.y);
+		dst.z = Ceil(src.z);
+		dst.w = Ceil(src.w);
+	}
+
+	void ShaderCore::powx(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		Float4 pow = power(src0.x, src1.x, pp);
+
+		dst.x = pow;
+		dst.y = pow;
+		dst.z = pow;
+		dst.w = pow;
+	}
+
+	void ShaderCore::pow(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		dst.x = power(src0.x, src1.x, pp);
+		dst.y = power(src0.y, src1.y, pp);
+		dst.z = power(src0.z, src1.z, pp);
+		dst.w = power(src0.w, src1.w, pp);
+	}
+
+	void ShaderCore::crs(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = src0.y * src1.z - src0.z * src1.y;
+		dst.y = src0.z * src1.x - src0.x * src1.z;
+		dst.z = src0.x * src1.y - src0.y * src1.x;
+	}
+
+	void ShaderCore::forward1(Vector4f &dst, const Vector4f &N, const Vector4f &I, const Vector4f &Nref)
+	{
+		Int4 flip = CmpNLT(Nref.x * I.x, Float4(0.0f)) & Int4(0x80000000);
+
+		dst.x =  As<Float4>(flip ^ As<Int4>(N.x));
+	}
+
+	void ShaderCore::forward2(Vector4f &dst, const Vector4f &N, const Vector4f &I, const Vector4f &Nref)
+	{
+		Int4 flip = CmpNLT(dot2(Nref, I), Float4(0.0f)) & Int4(0x80000000);
+
+		dst.x =  As<Float4>(flip ^ As<Int4>(N.x));
+		dst.y =  As<Float4>(flip ^ As<Int4>(N.y));
+	}
+
+	void ShaderCore::forward3(Vector4f &dst, const Vector4f &N, const Vector4f &I, const Vector4f &Nref)
+	{
+		Int4 flip = CmpNLT(dot3(Nref, I), Float4(0.0f)) & Int4(0x80000000);
+
+		dst.x =  As<Float4>(flip ^ As<Int4>(N.x));
+		dst.y =  As<Float4>(flip ^ As<Int4>(N.y));
+		dst.z =  As<Float4>(flip ^ As<Int4>(N.z));
+	}
+
+	void ShaderCore::forward4(Vector4f &dst, const Vector4f &N, const Vector4f &I, const Vector4f &Nref)
+	{
+		Int4 flip = CmpNLT(dot4(Nref, I), Float4(0.0f)) & Int4(0x80000000);
+
+		dst.x =  As<Float4>(flip ^ As<Int4>(N.x));
+		dst.y =  As<Float4>(flip ^ As<Int4>(N.y));
+		dst.z =  As<Float4>(flip ^ As<Int4>(N.z));
+		dst.w =  As<Float4>(flip ^ As<Int4>(N.w));
+	}
+
+	void ShaderCore::reflect1(Vector4f &dst, const Vector4f &I, const Vector4f &N)
+	{
+		Float4 d = N.x * I.x;
+
+		dst.x = I.x - Float4(2.0f) * d * N.x;
+	}
+
+	void ShaderCore::reflect2(Vector4f &dst, const Vector4f &I, const Vector4f &N)
+	{
+		Float4 d = dot2(N, I);
+
+		dst.x = I.x - Float4(2.0f) * d * N.x;
+		dst.y = I.y - Float4(2.0f) * d * N.y;
+	}
+
+	void ShaderCore::reflect3(Vector4f &dst, const Vector4f &I, const Vector4f &N)
+	{
+		Float4 d = dot3(N, I);
+
+		dst.x = I.x - Float4(2.0f) * d * N.x;
+		dst.y = I.y - Float4(2.0f) * d * N.y;
+		dst.z = I.z - Float4(2.0f) * d * N.z;
+	}
+
+	void ShaderCore::reflect4(Vector4f &dst, const Vector4f &I, const Vector4f &N)
+	{
+		Float4 d = dot4(N, I);
+
+		dst.x = I.x - Float4(2.0f) * d * N.x;
+		dst.y = I.y - Float4(2.0f) * d * N.y;
+		dst.z = I.z - Float4(2.0f) * d * N.z;
+		dst.w = I.w - Float4(2.0f) * d * N.w;
+	}
+
+	void ShaderCore::refract1(Vector4f &dst, const Vector4f &I, const Vector4f &N, const Float4 &eta)
+	{
+		Float4 d = N.x * I.x;
+		Float4 k = Float4(1.0f) - eta * eta * (Float4(1.0f) - d * d);
+		Int4 pos = CmpNLT(k, Float4(0.0f));
+		Float4 t = (eta * d + Sqrt(k));
+
+		dst.x = As<Float4>(pos & As<Int4>(eta * I.x - t * N.x));
+	}
+
+	void ShaderCore::refract2(Vector4f &dst, const Vector4f &I, const Vector4f &N, const Float4 &eta)
+	{
+		Float4 d = dot2(N, I);
+		Float4 k = Float4(1.0f) - eta * eta * (Float4(1.0f) - d * d);
+		Int4 pos = CmpNLT(k, Float4(0.0f));
+		Float4 t = (eta * d + Sqrt(k));
+
+		dst.x = As<Float4>(pos & As<Int4>(eta * I.x - t * N.x));
+		dst.y = As<Float4>(pos & As<Int4>(eta * I.y - t * N.y));
+	}
+
+	void ShaderCore::refract3(Vector4f &dst, const Vector4f &I, const Vector4f &N, const Float4 &eta)
+	{
+		Float4 d = dot3(N, I);
+		Float4 k = Float4(1.0f) - eta * eta * (Float4(1.0f) - d * d);
+		Int4 pos = CmpNLT(k, Float4(0.0f));
+		Float4 t = (eta * d + Sqrt(k));
+
+		dst.x = As<Float4>(pos & As<Int4>(eta * I.x - t * N.x));
+		dst.y = As<Float4>(pos & As<Int4>(eta * I.y - t * N.y));
+		dst.z = As<Float4>(pos & As<Int4>(eta * I.z - t * N.z));
+	}
+
+	void ShaderCore::refract4(Vector4f &dst, const Vector4f &I, const Vector4f &N, const Float4 &eta)
+	{
+		Float4 d = dot4(N, I);
+		Float4 k = Float4(1.0f) - eta * eta * (Float4(1.0f) - d * d);
+		Int4 pos = CmpNLT(k, Float4(0.0f));
+		Float4 t = (eta * d + Sqrt(k));
+
+		dst.x = As<Float4>(pos & As<Int4>(eta * I.x - t * N.x));
+		dst.y = As<Float4>(pos & As<Int4>(eta * I.y - t * N.y));
+		dst.z = As<Float4>(pos & As<Int4>(eta * I.z - t * N.z));
+		dst.w = As<Float4>(pos & As<Int4>(eta * I.w - t * N.w));
+	}
+
+	void ShaderCore::sgn(Vector4f &dst, const Vector4f &src)
+	{
+		sgn(dst.x, src.x);
+		sgn(dst.y, src.y);
+		sgn(dst.z, src.z);
+		sgn(dst.w, src.w);
+	}
+
+	void ShaderCore::isgn(Vector4f &dst, const Vector4f &src)
+	{
+		isgn(dst.x, src.x);
+		isgn(dst.y, src.y);
+		isgn(dst.z, src.z);
+		isgn(dst.w, src.w);
+	}
+
+	void ShaderCore::abs(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = Abs(src.x);
+		dst.y = Abs(src.y);
+		dst.z = Abs(src.z);
+		dst.w = Abs(src.w);
+	}
+
+	void ShaderCore::iabs(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(Abs(As<Int4>(src.x)));
+		dst.y = As<Float4>(Abs(As<Int4>(src.y)));
+		dst.z = As<Float4>(Abs(As<Int4>(src.z)));
+		dst.w = As<Float4>(Abs(As<Int4>(src.w)));
+	}
+
+	void ShaderCore::nrm2(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 dot = dot2(src, src);
+		Float4 rsq = reciprocalSquareRoot(dot, false, pp);
+
+		dst.x = src.x * rsq;
+		dst.y = src.y * rsq;
+		dst.z = src.z * rsq;
+		dst.w = src.w * rsq;
+	}
+
+	void ShaderCore::nrm3(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 dot = dot3(src, src);
+		Float4 rsq = reciprocalSquareRoot(dot, false, pp);
+
+		dst.x = src.x * rsq;
+		dst.y = src.y * rsq;
+		dst.z = src.z * rsq;
+		dst.w = src.w * rsq;
+	}
+
+	void ShaderCore::nrm4(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		Float4 dot = dot4(src, src);
+		Float4 rsq = reciprocalSquareRoot(dot, false, pp);
+
+		dst.x = src.x * rsq;
+		dst.y = src.y * rsq;
+		dst.z = src.z * rsq;
+		dst.w = src.w * rsq;
+	}
+
+	void ShaderCore::sincos(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = cosine_pi(src.x, pp);
+		dst.y = sine_pi(src.x, pp);
+	}
+
+	void ShaderCore::cos(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = cosine(src.x, pp);
+		dst.y = cosine(src.y, pp);
+		dst.z = cosine(src.z, pp);
+		dst.w = cosine(src.w, pp);
+	}
+
+	void ShaderCore::sin(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = sine(src.x, pp);
+		dst.y = sine(src.y, pp);
+		dst.z = sine(src.z, pp);
+		dst.w = sine(src.w, pp);
+	}
+
+	void ShaderCore::tan(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = tangent(src.x, pp);
+		dst.y = tangent(src.y, pp);
+		dst.z = tangent(src.z, pp);
+		dst.w = tangent(src.w, pp);
+	}
+
+	void ShaderCore::acos(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arccos(src.x, pp);
+		dst.y = arccos(src.y, pp);
+		dst.z = arccos(src.z, pp);
+		dst.w = arccos(src.w, pp);
+	}
+
+	void ShaderCore::asin(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arcsin(src.x, pp);
+		dst.y = arcsin(src.y, pp);
+		dst.z = arcsin(src.z, pp);
+		dst.w = arcsin(src.w, pp);
+	}
+
+	void ShaderCore::atan(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arctan(src.x, pp);
+		dst.y = arctan(src.y, pp);
+		dst.z = arctan(src.z, pp);
+		dst.w = arctan(src.w, pp);
+	}
+
+	void ShaderCore::atan2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp)
+	{
+		dst.x = arctan(src0.x, src1.x, pp);
+		dst.y = arctan(src0.y, src1.y, pp);
+		dst.z = arctan(src0.z, src1.z, pp);
+		dst.w = arctan(src0.w, src1.w, pp);
+	}
+
+	void ShaderCore::cosh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = cosineh(src.x, pp);
+		dst.y = cosineh(src.y, pp);
+		dst.z = cosineh(src.z, pp);
+		dst.w = cosineh(src.w, pp);
+	}
+
+	void ShaderCore::sinh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = sineh(src.x, pp);
+		dst.y = sineh(src.y, pp);
+		dst.z = sineh(src.z, pp);
+		dst.w = sineh(src.w, pp);
+	}
+
+	void ShaderCore::tanh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = tangenth(src.x, pp);
+		dst.y = tangenth(src.y, pp);
+		dst.z = tangenth(src.z, pp);
+		dst.w = tangenth(src.w, pp);
+	}
+
+	void ShaderCore::acosh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arccosh(src.x, pp);
+		dst.y = arccosh(src.y, pp);
+		dst.z = arccosh(src.z, pp);
+		dst.w = arccosh(src.w, pp);
+	}
+
+	void ShaderCore::asinh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arcsinh(src.x, pp);
+		dst.y = arcsinh(src.y, pp);
+		dst.z = arcsinh(src.z, pp);
+		dst.w = arcsinh(src.w, pp);
+	}
+
+	void ShaderCore::atanh(Vector4f &dst, const Vector4f &src, bool pp)
+	{
+		dst.x = arctanh(src.x, pp);
+		dst.y = arctanh(src.y, pp);
+		dst.z = arctanh(src.z, pp);
+		dst.w = arctanh(src.w, pp);
+	}
+
+	void ShaderCore::expp(Vector4f &dst, const Vector4f &src, unsigned short shaderModel)
+	{
+		if(shaderModel < 0x0200)
+		{
+			Float4 frc = Frac(src.x);
+			Float4 floor = src.x - frc;
+
+			dst.x = exponential2(floor, true);
+			dst.y = frc;
+			dst.z = exponential2(src.x, true);
+			dst.w = Float4(1.0f);
+		}
+		else   // Version >= 2.0
+		{
+			exp2x(dst, src, true);   // FIXME: 10-bit precision suffices
+		}
+	}
+
+	void ShaderCore::logp(Vector4f &dst, const Vector4f &src, unsigned short shaderModel)
+	{
+		if(shaderModel < 0x0200)
+		{
+			Float4 tmp0;
+			Float4 tmp1;
+			Float4 t;
+			Int4 r;
+
+			tmp0 = Abs(src.x);
+			tmp1 = tmp0;
+
+			// X component
+			r = As<Int4>(As<UInt4>(tmp0) >> 23) - Int4(127);
+			dst.x = Float4(r);
+
+			// Y component
+			dst.y = As<Float4>((As<Int4>(tmp1) & Int4(0x007FFFFF)) | As<Int4>(Float4(1.0f)));
+
+			// Z component
+			dst.z = logarithm2(src.x, true, true);
+
+			// W component
+			dst.w = 1.0f;
+		}
+		else
+		{
+			log2x(dst, src, true);
+		}
+	}
+
+	void ShaderCore::cmp0(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		cmp0(dst.x, src0.x, src1.x, src2.x);
+		cmp0(dst.y, src0.y, src1.y, src2.y);
+		cmp0(dst.z, src0.z, src1.z, src2.z);
+		cmp0(dst.w, src0.w, src1.w, src2.w);
+	}
+
+	void ShaderCore::select(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2)
+	{
+		select(dst.x, As<Int4>(src0.x), src1.x, src2.x);
+		select(dst.y, As<Int4>(src0.y), src1.y, src2.y);
+		select(dst.z, As<Int4>(src0.z), src1.z, src2.z);
+		select(dst.w, As<Int4>(src0.w), src1.w, src2.w);
+	}
+
+	void ShaderCore::extract(Float4 &dst, const Vector4f &src0, const Float4 &src1)
+	{
+		select(dst, CmpEQ(As<Int4>(src1), Int4(1)), src0.y, src0.x);
+		select(dst, CmpEQ(As<Int4>(src1), Int4(2)), src0.z, dst);
+		select(dst, CmpEQ(As<Int4>(src1), Int4(3)), src0.w, dst);
+	}
+
+	void ShaderCore::insert(Vector4f &dst, const Vector4f &src, const Float4 &element, const Float4 &index)
+	{
+		select(dst.x, CmpEQ(As<Int4>(index), Int4(0)), element, src.x);
+		select(dst.y, CmpEQ(As<Int4>(index), Int4(1)), element, src.y);
+		select(dst.z, CmpEQ(As<Int4>(index), Int4(2)), element, src.z);
+		select(dst.w, CmpEQ(As<Int4>(index), Int4(3)), element, src.w);
+	}
+
+	void ShaderCore::sgn(Float4 &dst, const Float4 &src)
+	{
+		Int4 neg = As<Int4>(CmpLT(src, Float4(-0.0f))) & As<Int4>(Float4(-1.0f));
+		Int4 pos = As<Int4>(CmpNLE(src, Float4(+0.0f))) & As<Int4>(Float4(1.0f));
+		dst = As<Float4>(neg | pos);
+	}
+
+	void ShaderCore::isgn(Float4 &dst, const Float4 &src)
+	{
+		Int4 neg = CmpLT(As<Int4>(src), Int4(0)) & Int4(-1);
+		Int4 pos = CmpNLE(As<Int4>(src), Int4(0)) & Int4(1);
+		dst = As<Float4>(neg | pos);
+	}
+
+	void ShaderCore::cmp0(Float4 &dst, const Float4 &src0, const Float4 &src1, const Float4 &src2)
+	{
+		Int4 pos = CmpLE(Float4(0.0f), src0);
+		select(dst, pos, src1, src2);
+	}
+
+	void ShaderCore::cmp0i(Float4 &dst, const Float4 &src0, const Float4 &src1, const Float4 &src2)
+	{
+		Int4 pos = CmpEQ(Int4(0), As<Int4>(src0));
+		select(dst, pos, src1, src2);
+	}
+
+	void ShaderCore::select(Float4 &dst, RValue<Int4> src0, const Float4 &src1, const Float4 &src2)
+	{
+		// FIXME: LLVM vector select
+		dst = As<Float4>((src0 & As<Int4>(src1)) | (~src0 & As<Int4>(src2)));
+	}
+
+	void ShaderCore::cmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control)
+	{
+		switch(control)
+		{
+		case Shader::CONTROL_GT:
+			dst.x = As<Float4>(CmpNLE(src0.x, src1.x));
+			dst.y = As<Float4>(CmpNLE(src0.y, src1.y));
+			dst.z = As<Float4>(CmpNLE(src0.z, src1.z));
+			dst.w = As<Float4>(CmpNLE(src0.w, src1.w));
+			break;
+		case Shader::CONTROL_EQ:
+			dst.x = As<Float4>(CmpEQ(src0.x, src1.x));
+			dst.y = As<Float4>(CmpEQ(src0.y, src1.y));
+			dst.z = As<Float4>(CmpEQ(src0.z, src1.z));
+			dst.w = As<Float4>(CmpEQ(src0.w, src1.w));
+			break;
+		case Shader::CONTROL_GE:
+			dst.x = As<Float4>(CmpNLT(src0.x, src1.x));
+			dst.y = As<Float4>(CmpNLT(src0.y, src1.y));
+			dst.z = As<Float4>(CmpNLT(src0.z, src1.z));
+			dst.w = As<Float4>(CmpNLT(src0.w, src1.w));
+			break;
+		case Shader::CONTROL_LT:
+			dst.x = As<Float4>(CmpLT(src0.x, src1.x));
+			dst.y = As<Float4>(CmpLT(src0.y, src1.y));
+			dst.z = As<Float4>(CmpLT(src0.z, src1.z));
+			dst.w = As<Float4>(CmpLT(src0.w, src1.w));
+			break;
+		case Shader::CONTROL_NE:
+			dst.x = As<Float4>(CmpNEQ(src0.x, src1.x));
+			dst.y = As<Float4>(CmpNEQ(src0.y, src1.y));
+			dst.z = As<Float4>(CmpNEQ(src0.z, src1.z));
+			dst.w = As<Float4>(CmpNEQ(src0.w, src1.w));
+			break;
+		case Shader::CONTROL_LE:
+			dst.x = As<Float4>(CmpLE(src0.x, src1.x));
+			dst.y = As<Float4>(CmpLE(src0.y, src1.y));
+			dst.z = As<Float4>(CmpLE(src0.z, src1.z));
+			dst.w = As<Float4>(CmpLE(src0.w, src1.w));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void ShaderCore::icmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control)
+	{
+		switch(control)
+		{
+		case Shader::CONTROL_GT:
+			dst.x = As<Float4>(CmpNLE(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpNLE(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpNLE(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpNLE(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		case Shader::CONTROL_EQ:
+			dst.x = As<Float4>(CmpEQ(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpEQ(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpEQ(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpEQ(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		case Shader::CONTROL_GE:
+			dst.x = As<Float4>(CmpNLT(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpNLT(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpNLT(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpNLT(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		case Shader::CONTROL_LT:
+			dst.x = As<Float4>(CmpLT(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpLT(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpLT(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpLT(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		case Shader::CONTROL_NE:
+			dst.x = As<Float4>(CmpNEQ(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpNEQ(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpNEQ(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpNEQ(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		case Shader::CONTROL_LE:
+			dst.x = As<Float4>(CmpLE(As<Int4>(src0.x), As<Int4>(src1.x)));
+			dst.y = As<Float4>(CmpLE(As<Int4>(src0.y), As<Int4>(src1.y)));
+			dst.z = As<Float4>(CmpLE(As<Int4>(src0.z), As<Int4>(src1.z)));
+			dst.w = As<Float4>(CmpLE(As<Int4>(src0.w), As<Int4>(src1.w)));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void ShaderCore::ucmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control)
+	{
+		switch(control)
+		{
+		case Shader::CONTROL_GT:
+			dst.x = As<Float4>(CmpNLE(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpNLE(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpNLE(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpNLE(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		case Shader::CONTROL_EQ:
+			dst.x = As<Float4>(CmpEQ(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpEQ(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpEQ(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpEQ(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		case Shader::CONTROL_GE:
+			dst.x = As<Float4>(CmpNLT(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpNLT(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpNLT(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpNLT(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		case Shader::CONTROL_LT:
+			dst.x = As<Float4>(CmpLT(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpLT(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpLT(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpLT(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		case Shader::CONTROL_NE:
+			dst.x = As<Float4>(CmpNEQ(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpNEQ(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpNEQ(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpNEQ(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		case Shader::CONTROL_LE:
+			dst.x = As<Float4>(CmpLE(As<UInt4>(src0.x), As<UInt4>(src1.x)));
+			dst.y = As<Float4>(CmpLE(As<UInt4>(src0.y), As<UInt4>(src1.y)));
+			dst.z = As<Float4>(CmpLE(As<UInt4>(src0.z), As<UInt4>(src1.z)));
+			dst.w = As<Float4>(CmpLE(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void ShaderCore::all(Float4 &dst, const Vector4f &src)
+	{
+		dst = As<Float4>(As<Int4>(src.x) & As<Int4>(src.y) & As<Int4>(src.z) & As<Int4>(src.w));
+	}
+
+	void ShaderCore::any(Float4 &dst, const Vector4f &src)
+	{
+		dst = As<Float4>(As<Int4>(src.x) | As<Int4>(src.y) | As<Int4>(src.z) | As<Int4>(src.w));
+	}
+
+	void ShaderCore::bitwise_not(Vector4f &dst, const Vector4f &src)
+	{
+		dst.x = As<Float4>(As<Int4>(src.x) ^ Int4(0xFFFFFFFF));
+		dst.y = As<Float4>(As<Int4>(src.y) ^ Int4(0xFFFFFFFF));
+		dst.z = As<Float4>(As<Int4>(src.z) ^ Int4(0xFFFFFFFF));
+		dst.w = As<Float4>(As<Int4>(src.w) ^ Int4(0xFFFFFFFF));
+	}
+
+	void ShaderCore::bitwise_or(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) | As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) | As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) | As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) | As<Int4>(src1.w));
+	}
+
+	void ShaderCore::bitwise_xor(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) ^ As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) ^ As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) ^ As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) ^ As<Int4>(src1.w));
+	}
+
+	void ShaderCore::bitwise_and(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(As<Int4>(src0.x) & As<Int4>(src1.x));
+		dst.y = As<Float4>(As<Int4>(src0.y) & As<Int4>(src1.y));
+		dst.z = As<Float4>(As<Int4>(src0.z) & As<Int4>(src1.z));
+		dst.w = As<Float4>(As<Int4>(src0.w) & As<Int4>(src1.w));
+	}
+
+	void ShaderCore::equal(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(CmpEQ(As<UInt4>(src0.x), As<UInt4>(src1.x)) &
+		                   CmpEQ(As<UInt4>(src0.y), As<UInt4>(src1.y)) &
+		                   CmpEQ(As<UInt4>(src0.z), As<UInt4>(src1.z)) &
+		                   CmpEQ(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+		dst.y = dst.x;
+		dst.z = dst.x;
+		dst.w = dst.x;
+	}
+
+	void ShaderCore::notEqual(Vector4f &dst, const Vector4f &src0, const Vector4f &src1)
+	{
+		dst.x = As<Float4>(CmpNEQ(As<UInt4>(src0.x), As<UInt4>(src1.x)) |
+		                   CmpNEQ(As<UInt4>(src0.y), As<UInt4>(src1.y)) |
+		                   CmpNEQ(As<UInt4>(src0.z), As<UInt4>(src1.z)) |
+		                   CmpNEQ(As<UInt4>(src0.w), As<UInt4>(src1.w)));
+		dst.y = dst.x;
+		dst.z = dst.x;
+		dst.w = dst.x;
+	}
+}
diff --git a/src/Pipeline/ShaderCore.hpp b/src/Pipeline/ShaderCore.hpp
new file mode 100644
index 0000000..4dc109f
--- /dev/null
+++ b/src/Pipeline/ShaderCore.hpp
@@ -0,0 +1,382 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_ShaderCore_hpp
+#define sw_ShaderCore_hpp
+
+#include "Shader.hpp"
+#include "Reactor/Reactor.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	class Vector4s
+	{
+	public:
+		Vector4s();
+		Vector4s(unsigned short x, unsigned short y, unsigned short z, unsigned short w);
+		Vector4s(const Vector4s &rhs);
+
+		Short4 &operator[](int i);
+		Vector4s &operator=(const Vector4s &rhs);
+
+		Short4 x;
+		Short4 y;
+		Short4 z;
+		Short4 w;
+	};
+
+	class Vector4f
+	{
+	public:
+		Vector4f();
+		Vector4f(float x, float y, float z, float w);
+		Vector4f(const Vector4f &rhs);
+
+		Float4 &operator[](int i);
+		Vector4f &operator=(const Vector4f &rhs);
+
+		Float4 x;
+		Float4 y;
+		Float4 z;
+		Float4 w;
+	};
+
+	Float4 exponential2(RValue<Float4> x, bool pp = false);
+	Float4 logarithm2(RValue<Float4> x, bool abs, bool pp = false);
+	Float4 exponential(RValue<Float4> x, bool pp = false);
+	Float4 logarithm(RValue<Float4> x, bool abs, bool pp = false);
+	Float4 power(RValue<Float4> x, RValue<Float4> y, bool pp = false);
+	Float4 reciprocal(RValue<Float4> x, bool pp = false, bool finite = false, bool exactAtPow2 = false);
+	Float4 reciprocalSquareRoot(RValue<Float4> x, bool abs, bool pp = false);
+	Float4 modulo(RValue<Float4> x, RValue<Float4> y);
+	Float4 sine_pi(RValue<Float4> x, bool pp = false);     // limited to [-pi, pi] range
+	Float4 cosine_pi(RValue<Float4> x, bool pp = false);   // limited to [-pi, pi] range
+	Float4 sine(RValue<Float4> x, bool pp = false);
+	Float4 cosine(RValue<Float4> x, bool pp = false);
+	Float4 tangent(RValue<Float4> x, bool pp = false);
+	Float4 arccos(RValue<Float4> x, bool pp = false);
+	Float4 arcsin(RValue<Float4> x, bool pp = false);
+	Float4 arctan(RValue<Float4> x, bool pp = false);
+	Float4 arctan(RValue<Float4> y, RValue<Float4> x, bool pp = false);
+	Float4 sineh(RValue<Float4> x, bool pp = false);
+	Float4 cosineh(RValue<Float4> x, bool pp = false);
+	Float4 tangenth(RValue<Float4> x, bool pp = false);
+	Float4 arccosh(RValue<Float4> x, bool pp = false);  // Limited to x >= 1
+	Float4 arcsinh(RValue<Float4> x, bool pp = false);
+	Float4 arctanh(RValue<Float4> x, bool pp = false);  // Limited to ]-1, 1[ range
+
+	Float4 dot2(const Vector4f &v0, const Vector4f &v1);
+	Float4 dot3(const Vector4f &v0, const Vector4f &v1);
+	Float4 dot4(const Vector4f &v0, const Vector4f &v1);
+
+	void transpose4x4(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3);
+	void transpose4x3(Short4 &row0, Short4 &row1, Short4 &row2, Short4 &row3);
+	void transpose4x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3);
+	void transpose4x3(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3);
+	void transpose4x2(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3);
+	void transpose4x1(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3);
+	void transpose2x4(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3);
+	void transpose4xN(Float4 &row0, Float4 &row1, Float4 &row2, Float4 &row3, int N);
+
+	class Register
+	{
+	public:
+		Register(const Reference<Float4> &x, const Reference<Float4> &y, const Reference<Float4> &z, const Reference<Float4> &w) : x(x), y(y), z(z), w(w)
+		{
+		}
+
+		Reference<Float4> &operator[](int i)
+		{
+			switch(i)
+			{
+			default:
+			case 0: return x;
+			case 1: return y;
+			case 2: return z;
+			case 3: return w;
+			}
+		}
+
+		Register &operator=(const Register &rhs)
+		{
+			x = rhs.x;
+			y = rhs.y;
+			z = rhs.z;
+			w = rhs.w;
+
+			return *this;
+		}
+
+		Register &operator=(const Vector4f &rhs)
+		{
+			x = rhs.x;
+			y = rhs.y;
+			z = rhs.z;
+			w = rhs.w;
+
+			return *this;
+		}
+
+		operator Vector4f()
+		{
+			Vector4f v;
+
+			v.x = x;
+			v.y = y;
+			v.z = z;
+			v.w = w;
+
+			return v;
+		}
+
+		Reference<Float4> x;
+		Reference<Float4> y;
+		Reference<Float4> z;
+		Reference<Float4> w;
+	};
+
+	class RegisterFile
+	{
+	public:
+		RegisterFile(int size, bool indirectAddressable) : size(size), indirectAddressable(indirectAddressable)
+		{
+			if(indirectAddressable)
+			{
+				x = new Array<Float4>(size);
+				y = new Array<Float4>(size);
+				z = new Array<Float4>(size);
+				w = new Array<Float4>(size);
+			}
+			else
+			{
+				x = new Array<Float4>[size];
+				y = new Array<Float4>[size];
+				z = new Array<Float4>[size];
+				w = new Array<Float4>[size];
+			}
+		}
+
+		~RegisterFile()
+		{
+			if(indirectAddressable)
+			{
+				delete x;
+				delete y;
+				delete z;
+				delete w;
+			}
+			else
+			{
+				delete[] x;
+				delete[] y;
+				delete[] z;
+				delete[] w;
+			}
+		}
+
+		Register operator[](int i)
+		{
+			if(indirectAddressable)
+			{
+				return Register(x[0][i], y[0][i], z[0][i], w[0][i]);
+			}
+			else
+			{
+				return Register(x[i][0], y[i][0], z[i][0], w[i][0]);
+			}
+		}
+
+		Register operator[](RValue<Int> i)
+		{
+			ASSERT(indirectAddressable);
+
+			return Register(x[0][i], y[0][i], z[0][i], w[0][i]);
+		}
+
+		const Vector4f operator[](RValue<Int4> i);   // Gather operation (read only).
+
+		void scatter_x(Int4 i, RValue<Float4> r);
+		void scatter_y(Int4 i, RValue<Float4> r);
+		void scatter_z(Int4 i, RValue<Float4> r);
+		void scatter_w(Int4 i, RValue<Float4> r);
+
+	protected:
+		const int size;
+		const bool indirectAddressable;
+		Array<Float4> *x;
+		Array<Float4> *y;
+		Array<Float4> *z;
+		Array<Float4> *w;
+	};
+
+	template<int S, bool I = false>
+	class RegisterArray : public RegisterFile
+	{
+	public:
+		RegisterArray(bool indirectAddressable = I) : RegisterFile(S, indirectAddressable)
+		{
+		}
+	};
+
+	class ShaderCore
+	{
+		typedef Shader::Control Control;
+
+	public:
+		void mov(Vector4f &dst, const Vector4f &src, bool integerDestination = false);
+		void neg(Vector4f &dst, const Vector4f &src);
+		void ineg(Vector4f &dst, const Vector4f &src);
+		void f2b(Vector4f &dst, const Vector4f &src);
+		void b2f(Vector4f &dst, const Vector4f &src);
+		void f2i(Vector4f &dst, const Vector4f &src);
+		void i2f(Vector4f &dst, const Vector4f &src);
+		void f2u(Vector4f &dst, const Vector4f &src);
+		void u2f(Vector4f &dst, const Vector4f &src);
+		void i2b(Vector4f &dst, const Vector4f &src);
+		void b2i(Vector4f &dst, const Vector4f &src);
+		void add(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void iadd(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void sub(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void isub(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void mad(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void imad(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void mul(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void imul(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void rcpx(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void div(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void idiv(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void udiv(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void mod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void imod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void umod(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void shl(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void ishr(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void ushr(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void rsqx(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void sqrt(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void rsq(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void len2(Float4 &dst, const Vector4f &src, bool pp = false);
+		void len3(Float4 &dst, const Vector4f &src, bool pp = false);
+		void len4(Float4 &dst, const Vector4f &src, bool pp = false);
+		void dist1(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void dist2(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void dist3(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void dist4(Float4 &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void dp1(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void dp2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void dp2add(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void dp3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void dp4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void det2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void det3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void det4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2, const Vector4f &src3);
+		void min(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void imin(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void umin(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void max(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void imax(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void umax(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void slt(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void step(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void exp2x(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void exp2(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void exp(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void log2x(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void log2(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void log(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void lit(Vector4f &dst, const Vector4f &src);
+		void att(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void lrp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void isinf(Vector4f &dst, const Vector4f &src);
+		void isnan(Vector4f &dst, const Vector4f &src);
+		void smooth(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void packHalf2x16(Vector4f &dst, const Vector4f &src);
+		void unpackHalf2x16(Vector4f &dst, const Vector4f &src);
+		void packSnorm2x16(Vector4f &dst, const Vector4f &src);
+		void packUnorm2x16(Vector4f &dst, const Vector4f &src);
+		void unpackSnorm2x16(Vector4f &dst, const Vector4f &src);
+		void unpackUnorm2x16(Vector4f &dst, const Vector4f &src);
+		void frc(Vector4f &dst, const Vector4f &src);
+		void trunc(Vector4f &dst, const Vector4f &src);
+		void floor(Vector4f &dst, const Vector4f &src);
+		void round(Vector4f &dst, const Vector4f &src);
+		void roundEven(Vector4f &dst, const Vector4f &src);
+		void ceil(Vector4f &dst, const Vector4f &src);
+		void powx(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void pow(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void crs(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void forward1(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void forward2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void forward3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void forward4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void reflect1(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void reflect2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void reflect3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void reflect4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void refract1(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Float4 &src2);
+		void refract2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Float4 &src2);
+		void refract3(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Float4 &src2);
+		void refract4(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Float4 &src2);
+		void sgn(Vector4f &dst, const Vector4f &src);
+		void isgn(Vector4f &dst, const Vector4f &src);
+		void abs(Vector4f &dst, const Vector4f &src);
+		void iabs(Vector4f &dst, const Vector4f &src);
+		void nrm2(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void nrm3(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void nrm4(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void sincos(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void cos(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void sin(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void tan(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void acos(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void asin(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void atan(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void atan2(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, bool pp = false);
+		void cosh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void sinh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void tanh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void acosh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void asinh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void atanh(Vector4f &dst, const Vector4f &src, bool pp = false);
+		void expp(Vector4f &dst, const Vector4f &src, unsigned short shaderModel);
+		void logp(Vector4f &dst, const Vector4f &src, unsigned short shaderModel);
+		void cmp0(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void cmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control);
+		void icmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control);
+		void ucmp(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, Control control);
+		void select(Vector4f &dst, const Vector4f &src0, const Vector4f &src1, const Vector4f &src2);
+		void extract(Float4 &dst, const Vector4f &src0, const Float4 &src1);
+		void insert(Vector4f &dst, const Vector4f &src, const Float4 &element, const Float4 &index);
+		void all(Float4 &dst, const Vector4f &src);
+		void any(Float4 &dst, const Vector4f &src);
+		void bitwise_not(Vector4f &dst, const Vector4f &src);
+		void bitwise_or(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void bitwise_xor(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void bitwise_and(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void equal(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+		void notEqual(Vector4f &dst, const Vector4f &src0, const Vector4f &src1);
+
+	private:
+		void sgn(Float4 &dst, const Float4 &src);
+		void isgn(Float4 &dst, const Float4 &src);
+		void cmp0(Float4 &dst, const Float4 &src0, const Float4 &src1, const Float4 &src2);
+		void cmp0i(Float4 &dst, const Float4 &src0, const Float4 &src1, const Float4 &src2);
+		void select(Float4 &dst, RValue<Int4> src0, const Float4 &src1, const Float4 &src2);
+		void floatToHalfBits(Float4& dst, const Float4& floatBits, bool storeInUpperBits);
+		void halfToFloatBits(Float4& dst, const Float4& halfBits);
+	};
+}
+
+#endif   // sw_ShaderCore_hpp
diff --git a/src/Pipeline/VertexPipeline.cpp b/src/Pipeline/VertexPipeline.cpp
new file mode 100644
index 0000000..129d8a8
--- /dev/null
+++ b/src/Pipeline/VertexPipeline.cpp
@@ -0,0 +1,953 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VertexPipeline.hpp"
+
+#include "Renderer/Vertex.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#undef max
+#undef min
+
+namespace sw
+{
+	extern bool secondaryColor;
+
+	VertexPipeline::VertexPipeline(const VertexProcessor::State &state) : VertexRoutine(state, 0)
+	{
+	}
+
+	VertexPipeline::~VertexPipeline()
+	{
+	}
+
+	Vector4f VertexPipeline::transformBlend(const Register &src, const Pointer<Byte> &matrix, bool homogeneous)
+	{
+		Vector4f dst;
+
+		if(state.vertexBlendMatrixCount == 0)
+		{
+			dst = transform(src, matrix, homogeneous);
+		}
+		else
+		{
+			UInt index0[4];
+			UInt index1[4];
+			UInt index2[4];
+			UInt index3[4];
+
+			if(state.indexedVertexBlendEnable)
+			{
+				for(int i = 0; i < 4; i++)
+				{
+					Float4 B = v[BlendIndices].x;
+					UInt indices;
+
+					switch(i)
+					{
+					case 0: indices = As<UInt>(Float(B.x)); break;
+					case 1: indices = As<UInt>(Float(B.y)); break;
+					case 2: indices = As<UInt>(Float(B.z)); break;
+					case 3: indices = As<UInt>(Float(B.w)); break;
+					}
+
+					index0[i] = (indices & 0x000000FF) << 6;
+					index1[i] = (indices & 0x0000FF00) >> 2;
+					index2[i] = (indices & 0x00FF0000) >> 10;
+					index3[i] = (indices & 0xFF000000) >> 18;
+				}
+			}
+			else
+			{
+				for(int i = 0; i < 4; i++)
+				{
+					index0[i] = 0 * 64;
+					index1[i] = 1 * 64;
+					index2[i] = 2 * 64;
+					index3[i] = 3 * 64;
+				}
+			}
+
+			Float4 weight0;
+			Float4 weight1;
+			Float4 weight2;
+			Float4 weight3;
+
+			switch(state.vertexBlendMatrixCount)
+			{
+			case 4: weight2 = v[BlendWeight].z;
+			case 3: weight1 = v[BlendWeight].y;
+			case 2: weight0 = v[BlendWeight].x;
+			case 1:
+				break;
+			}
+
+			if(state.vertexBlendMatrixCount == 1)
+			{
+				dst = transform(src, matrix, index0, homogeneous);
+			}
+			else if(state.vertexBlendMatrixCount == 2)
+			{
+				weight1 = Float4(1.0f) - weight0;
+
+				Vector4f pos0;
+				Vector4f pos1;
+
+				pos0 = transform(src, matrix, index0, homogeneous);
+				pos1 = transform(src, matrix, index1, homogeneous);
+
+				dst.x = pos0.x * weight0 + pos1.x * weight1;   // FIXME: Vector4f operators
+				dst.y = pos0.y * weight0 + pos1.y * weight1;
+				dst.z = pos0.z * weight0 + pos1.z * weight1;
+				dst.w = pos0.w * weight0 + pos1.w * weight1;
+			}
+			else if(state.vertexBlendMatrixCount == 3)
+			{
+				weight2 = Float4(1.0f) - (weight0 + weight1);
+
+				Vector4f pos0;
+				Vector4f pos1;
+				Vector4f pos2;
+
+				pos0 = transform(src, matrix, index0, homogeneous);
+				pos1 = transform(src, matrix, index1, homogeneous);
+				pos2 = transform(src, matrix, index2, homogeneous);
+
+				dst.x = pos0.x * weight0 + pos1.x * weight1 + pos2.x * weight2;
+				dst.y = pos0.y * weight0 + pos1.y * weight1 + pos2.y * weight2;
+				dst.z = pos0.z * weight0 + pos1.z * weight1 + pos2.z * weight2;
+				dst.w = pos0.w * weight0 + pos1.w * weight1 + pos2.w * weight2;
+			}
+			else if(state.vertexBlendMatrixCount == 4)
+			{
+				weight3 = Float4(1.0f) - (weight0 + weight1 + weight2);
+
+				Vector4f pos0;
+				Vector4f pos1;
+				Vector4f pos2;
+				Vector4f pos3;
+
+				pos0 = transform(src, matrix, index0, homogeneous);
+				pos1 = transform(src, matrix, index1, homogeneous);
+				pos2 = transform(src, matrix, index2, homogeneous);
+				pos3 = transform(src, matrix, index3, homogeneous);
+
+				dst.x = pos0.x * weight0 + pos1.x * weight1 + pos2.x * weight2 + pos3.x * weight3;
+				dst.y = pos0.y * weight0 + pos1.y * weight1 + pos2.y * weight2 + pos3.y * weight3;
+				dst.z = pos0.z * weight0 + pos1.z * weight1 + pos2.z * weight2 + pos3.z * weight3;
+				dst.w = pos0.w * weight0 + pos1.w * weight1 + pos2.w * weight2 + pos3.w * weight3;
+			}
+		}
+
+		return dst;
+	}
+
+	void VertexPipeline::pipeline(UInt &index)
+	{
+		Vector4f position;
+		Vector4f normal;
+
+		if(!state.preTransformed)
+		{
+			position = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.transformT)), true);
+		}
+		else
+		{
+			position = v[PositionT];
+		}
+
+		o[Pos].x = position.x;
+		o[Pos].y = position.y;
+		o[Pos].z = position.z;
+		o[Pos].w = position.w;
+
+		Vector4f vertexPosition = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
+
+		if(state.vertexNormalActive)
+		{
+			normal = transformBlend(v[Normal], Pointer<Byte>(data + OFFSET(DrawData,ff.normalTransformT)), false);
+
+			if(state.normalizeNormals)
+			{
+				normal = normalize(normal);
+			}
+		}
+
+		if(!state.vertexLightingActive)
+		{
+			// FIXME: Don't process if not used at all
+			if(state.diffuseActive && state.input[Color0])
+			{
+				Vector4f diffuse = v[Color0];
+
+				o[C0].x = diffuse.x;
+				o[C0].y = diffuse.y;
+				o[C0].z = diffuse.z;
+				o[C0].w = diffuse.w;
+			}
+			else
+			{
+				o[C0].x = Float4(1.0f);
+				o[C0].y = Float4(1.0f);
+				o[C0].z = Float4(1.0f);
+				o[C0].w = Float4(1.0f);
+			}
+
+			// FIXME: Don't process if not used at all
+			if(state.specularActive && state.input[Color1])
+			{
+				Vector4f specular = v[Color1];
+
+				o[C1].x = specular.x;
+				o[C1].y = specular.y;
+				o[C1].z = specular.z;
+				o[C1].w = specular.w;
+			}
+			else
+			{
+				o[C1].x = Float4(0.0f);
+				o[C1].y = Float4(0.0f);
+				o[C1].z = Float4(0.0f);
+				o[C1].w = Float4(1.0f);
+			}
+		}
+		else
+		{
+			o[C0].x = Float4(0.0f);
+			o[C0].y = Float4(0.0f);
+			o[C0].z = Float4(0.0f);
+			o[C0].w = Float4(0.0f);
+
+			o[C1].x = Float4(0.0f);
+			o[C1].y = Float4(0.0f);
+			o[C1].z = Float4(0.0f);
+			o[C1].w = Float4(0.0f);
+
+			Vector4f ambient;
+			Float4 globalAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.globalAmbient));   // FIXME: Unpack
+
+			ambient.x = globalAmbient.x;
+			ambient.y = globalAmbient.y;
+			ambient.z = globalAmbient.z;
+
+			for(int i = 0; i < 8; i++)
+			{
+				if(!(state.vertexLightActive & (1 << i)))
+				{
+					continue;
+				}
+
+				Vector4f L;    // Light vector
+				Float4 att;   // Attenuation
+
+				// Attenuation
+				{
+					Float4 d;   // Distance
+
+					L.x = L.y = L.z = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightPosition[i]));   // FIXME: Unpack
+					L.x = L.x.xxxx;
+					L.y = L.y.yyyy;
+					L.z = L.z.zzzz;
+
+					L.x -= vertexPosition.x;
+					L.y -= vertexPosition.y;
+					L.z -= vertexPosition.z;
+					d = dot3(L, L);
+					d = RcpSqrt_pp(d);     // FIXME: Sufficient precision?
+					L.x *= d;
+					L.y *= d;
+					L.z *= d;
+					d = Rcp_pp(d);       // FIXME: Sufficient precision?
+
+					Float4 q = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationQuadratic[i]));
+					Float4 l = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationLinear[i]));
+					Float4 c = *Pointer<Float4>(data + OFFSET(DrawData,ff.attenuationConstant[i]));
+
+					att = Rcp_pp((q * d + l) * d + c);
+				}
+
+				// Ambient per light
+				{
+					Float4 lightAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightAmbient[i]));   // FIXME: Unpack
+
+					ambient.x = ambient.x + lightAmbient.x * att;
+					ambient.y = ambient.y + lightAmbient.y * att;
+					ambient.z = ambient.z + lightAmbient.z * att;
+				}
+
+				// Diffuse
+				if(state.vertexNormalActive)
+				{
+					Float4 dot;
+
+					dot = dot3(L, normal);
+					dot = Max(dot, Float4(0.0f));
+					dot *= att;
+
+					Vector4f diff;
+
+					if(state.vertexDiffuseMaterialSourceActive == MATERIAL_MATERIAL)
+					{
+						diff.x = diff.y = diff.z = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialDiffuse));   // FIXME: Unpack
+						diff.x = diff.x.xxxx;
+						diff.y = diff.y.yyyy;
+						diff.z = diff.z.zzzz;
+					}
+					else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR1)
+					{
+						diff = v[Color0];
+					}
+					else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR2)
+					{
+						diff = v[Color1];
+					}
+					else ASSERT(false);
+
+					Float4 lightDiffuse = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightDiffuse[i]));
+
+					o[C0].x = o[C0].x + diff.x * dot * lightDiffuse.x;   // FIXME: Clamp first?
+					o[C0].y = o[C0].y + diff.y * dot * lightDiffuse.y;   // FIXME: Clamp first?
+					o[C0].z = o[C0].z + diff.z * dot * lightDiffuse.z;   // FIXME: Clamp first?
+				}
+
+				// Specular
+				if(state.vertexSpecularActive)
+				{
+					Vector4f S;
+					Vector4f C;   // Camera vector
+					Float4 pow;
+
+					pow = *Pointer<Float>(data + OFFSET(DrawData,ff.materialShininess));
+
+					S.x = Float4(0.0f) - vertexPosition.x;
+					S.y = Float4(0.0f) - vertexPosition.y;
+					S.z = Float4(0.0f) - vertexPosition.z;
+					C = normalize(S);
+
+					S.x = L.x + C.x;
+					S.y = L.y + C.y;
+					S.z = L.z + C.z;
+					C = normalize(S);
+
+					Float4 dot = Max(dot3(C, normal), Float4(0.0f));   // FIXME: max(dot3(C, normal), 0)
+
+					Float4 P = power(dot, pow);
+					P *= att;
+
+					Vector4f spec;
+
+					if(state.vertexSpecularMaterialSourceActive == MATERIAL_MATERIAL)
+					{
+						Float4 materialSpecular = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialSpecular));   // FIXME: Unpack
+
+						spec.x = materialSpecular.x;
+						spec.y = materialSpecular.y;
+						spec.z = materialSpecular.z;
+					}
+					else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR1)
+					{
+						spec = v[Color0];
+					}
+					else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR2)
+					{
+						spec = v[Color1];
+					}
+					else ASSERT(false);
+
+					Float4 lightSpecular = *Pointer<Float4>(data + OFFSET(DrawData,ff.lightSpecular[i]));
+
+					spec.x *= lightSpecular.x;
+					spec.y *= lightSpecular.y;
+					spec.z *= lightSpecular.z;
+
+					spec.x *= P;
+					spec.y *= P;
+					spec.z *= P;
+
+					spec.x = Max(spec.x, Float4(0.0f));
+					spec.y = Max(spec.y, Float4(0.0f));
+					spec.z = Max(spec.z, Float4(0.0f));
+
+					if(secondaryColor)
+					{
+						o[C1].x = o[C1].x + spec.x;
+						o[C1].y = o[C1].y + spec.y;
+						o[C1].z = o[C1].z + spec.z;
+					}
+					else
+					{
+						o[C0].x = o[C0].x + spec.x;
+						o[C0].y = o[C0].y + spec.y;
+						o[C0].z = o[C0].z + spec.z;
+					}
+				}
+			}
+
+			if(state.vertexAmbientMaterialSourceActive == MATERIAL_MATERIAL)
+			{
+				Float4 materialAmbient = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialAmbient));   // FIXME: Unpack
+
+				ambient.x = ambient.x * materialAmbient.x;
+				ambient.y = ambient.y * materialAmbient.y;
+				ambient.z = ambient.z * materialAmbient.z;
+			}
+			else if(state.vertexAmbientMaterialSourceActive == MATERIAL_COLOR1)
+			{
+				Vector4f materialDiffuse = v[Color0];
+
+				ambient.x = ambient.x * materialDiffuse.x;
+				ambient.y = ambient.y * materialDiffuse.y;
+				ambient.z = ambient.z * materialDiffuse.z;
+			}
+			else if(state.vertexAmbientMaterialSourceActive == MATERIAL_COLOR2)
+			{
+				Vector4f materialSpecular = v[Color1];
+
+				ambient.x = ambient.x * materialSpecular.x;
+				ambient.y = ambient.y * materialSpecular.y;
+				ambient.z = ambient.z * materialSpecular.z;
+			}
+			else ASSERT(false);
+
+			o[C0].x = o[C0].x + ambient.x;
+			o[C0].y = o[C0].y + ambient.y;
+			o[C0].z = o[C0].z + ambient.z;
+
+			// Emissive
+			if(state.vertexEmissiveMaterialSourceActive == MATERIAL_MATERIAL)
+			{
+				Float4 materialEmission = *Pointer<Float4>(data + OFFSET(DrawData,ff.materialEmission));   // FIXME: Unpack
+
+				o[C0].x = o[C0].x + materialEmission.x;
+				o[C0].y = o[C0].y + materialEmission.y;
+				o[C0].z = o[C0].z + materialEmission.z;
+			}
+			else if(state.vertexEmissiveMaterialSourceActive == MATERIAL_COLOR1)
+			{
+				Vector4f materialSpecular = v[Color0];
+
+				o[C0].x = o[C0].x + materialSpecular.x;
+				o[C0].y = o[C0].y + materialSpecular.y;
+				o[C0].z = o[C0].z + materialSpecular.z;
+			}
+			else if(state.vertexEmissiveMaterialSourceActive == MATERIAL_COLOR2)
+			{
+				Vector4f materialSpecular = v[Color1];
+
+				o[C0].x = o[C0].x + materialSpecular.x;
+				o[C0].y = o[C0].y + materialSpecular.y;
+				o[C0].z = o[C0].z + materialSpecular.z;
+			}
+			else ASSERT(false);
+
+			// Diffuse alpha component
+			if(state.vertexDiffuseMaterialSourceActive == MATERIAL_MATERIAL)
+			{
+				o[C0].w = Float4(*Pointer<Float4>(data + OFFSET(DrawData,ff.materialDiffuse[0]))).wwww;   // FIXME: Unpack
+			}
+			else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR1)
+			{
+				Vector4f alpha = v[Color0];
+				o[C0].w = alpha.w;
+			}
+			else if(state.vertexDiffuseMaterialSourceActive == MATERIAL_COLOR2)
+			{
+				Vector4f alpha = v[Color1];
+				o[C0].w = alpha.w;
+			}
+			else ASSERT(false);
+
+			if(state.vertexSpecularActive)
+			{
+				// Specular alpha component
+				if(state.vertexSpecularMaterialSourceActive == MATERIAL_MATERIAL)
+				{
+					o[C1].w = Float4(*Pointer<Float4>(data + OFFSET(DrawData,ff.materialSpecular[3]))).wwww;   // FIXME: Unpack
+				}
+				else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR1)
+				{
+					Vector4f alpha = v[Color0];
+					o[C1].w = alpha.w;
+				}
+				else if(state.vertexSpecularMaterialSourceActive == MATERIAL_COLOR2)
+				{
+					Vector4f alpha = v[Color1];
+					o[C1].w = alpha.w;
+				}
+				else ASSERT(false);
+			}
+		}
+
+		if(state.fogActive)
+		{
+			Float4 f;
+
+			if(!state.rangeFogActive)
+			{
+				f = Abs(vertexPosition.z);
+			}
+			else
+			{
+				f = Sqrt(dot3(vertexPosition, vertexPosition));   // FIXME: f = length(vertexPosition);
+			}
+
+			switch(state.vertexFogMode)
+			{
+			case FOG_NONE:
+				if(state.specularActive)
+				{
+					o[Fog].x = o[C1].w;
+				}
+				else
+				{
+					o[Fog].x = Float4(0.0f);
+				}
+				break;
+			case FOG_LINEAR:
+				o[Fog].x = f * *Pointer<Float4>(data + OFFSET(DrawData,fog.scale)) + *Pointer<Float4>(data + OFFSET(DrawData,fog.offset));
+				break;
+			case FOG_EXP:
+				o[Fog].x = exponential2(f * *Pointer<Float4>(data + OFFSET(DrawData,fog.densityE)), true);
+				break;
+			case FOG_EXP2:
+				o[Fog].x = exponential2((f * f) * *Pointer<Float4>(data + OFFSET(DrawData,fog.density2E)), true);
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+
+		for(int stage = 0; stage < 8; stage++)
+		{
+			processTextureCoordinate(stage, normal, position);
+		}
+
+		processPointSize();
+	}
+
+	void VertexPipeline::processTextureCoordinate(int stage, Vector4f &normal, Vector4f &position)
+	{
+		if(state.output[T0 + stage].write)
+		{
+			int i = state.textureState[stage].texCoordIndexActive;
+
+			switch(state.textureState[stage].texGenActive)
+			{
+			case TEXGEN_NONE:
+				{
+					Vector4f &&varying = v[TexCoord0 + i];
+
+					o[T0 + stage].x = varying.x;
+					o[T0 + stage].y = varying.y;
+					o[T0 + stage].z = varying.z;
+					o[T0 + stage].w = varying.w;
+				}
+				break;
+			case TEXGEN_PASSTHRU:
+				{
+					Vector4f &&varying = v[TexCoord0 + i];
+
+					o[T0 + stage].x = varying.x;
+					o[T0 + stage].y = varying.y;
+					o[T0 + stage].z = varying.z;
+					o[T0 + stage].w = varying.w;
+
+					if(state.input[TexCoord0 + i])
+					{
+						switch(state.input[TexCoord0 + i].count)
+						{
+						case 1:
+							o[T0 + stage].y = Float4(1.0f);
+							o[T0 + stage].z = Float4(0.0f);
+							o[T0 + stage].w = Float4(0.0f);
+							break;
+						case 2:
+							o[T0 + stage].z = Float4(1.0f);
+							o[T0 + stage].w = Float4(0.0f);
+							break;
+						case 3:
+							o[T0 + stage].w = Float4(1.0f);
+							break;
+						case 4:
+							break;
+						default:
+							ASSERT(false);
+						}
+					}
+				}
+				break;
+			case TEXGEN_NORMAL:
+				{
+					Vector4f Nc;   // Normal vector in camera space
+
+					if(state.vertexNormalActive)
+					{
+						Nc = normal;
+					}
+					else
+					{
+						Nc.x = Float4(0.0f);
+						Nc.y = Float4(0.0f);
+						Nc.z = Float4(0.0f);
+					}
+
+					Nc.w = Float4(1.0f);
+
+					o[T0 + stage].x = Nc.x;
+					o[T0 + stage].y = Nc.y;
+					o[T0 + stage].z = Nc.z;
+					o[T0 + stage].w = Nc.w;
+				}
+				break;
+			case TEXGEN_POSITION:
+				{
+					Vector4f Pn = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);   // Position in camera space
+
+					Pn.w = Float4(1.0f);
+
+					o[T0 + stage].x = Pn.x;
+					o[T0 + stage].y = Pn.y;
+					o[T0 + stage].z = Pn.z;
+					o[T0 + stage].w = Pn.w;
+				}
+				break;
+			case TEXGEN_REFLECTION:
+				{
+					Vector4f R;   // Reflection vector
+
+					if(state.vertexNormalActive)
+					{
+						Vector4f Nc;   // Normal vector in camera space
+
+						Nc = normal;
+
+						if(state.localViewerActive)
+						{
+							Vector4f Ec;   // Eye vector in camera space
+							Vector4f N2;
+
+							Ec = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
+							Ec = normalize(Ec);
+
+							// R = E - 2 * N * (E . N)
+							Float4 dot = Float4(2.0f) * dot3(Ec, Nc);
+
+							R.x = Ec.x - Nc.x * dot;
+							R.y = Ec.y - Nc.y * dot;
+							R.z = Ec.z - Nc.z * dot;
+						}
+						else
+						{
+							// u = -2 * Nz * Nx
+							// v = -2 * Nz * Ny
+							// w = 1 - 2 * Nz * Nz
+
+							R.x = -Float4(2.0f) * Nc.z * Nc.x;
+							R.y = -Float4(2.0f) * Nc.z * Nc.y;
+							R.z = Float4(1.0f) - Float4(2.0f) * Nc.z * Nc.z;
+						}
+					}
+					else
+					{
+						R.x = Float4(0.0f);
+						R.y = Float4(0.0f);
+						R.z = Float4(0.0f);
+					}
+
+					R.w = Float4(1.0f);
+
+					o[T0 + stage].x = R.x;
+					o[T0 + stage].y = R.y;
+					o[T0 + stage].z = R.z;
+					o[T0 + stage].w = R.w;
+				}
+				break;
+			case TEXGEN_SPHEREMAP:
+				{
+					Vector4f R;   // Reflection vector
+
+					if(state.vertexNormalActive)
+					{
+						Vector4f Nc;   // Normal vector in camera space
+
+						Nc = normal;
+
+						if(state.localViewerActive)
+						{
+							Vector4f Ec;   // Eye vector in camera space
+							Vector4f N2;
+
+							Ec = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
+							Ec = normalize(Ec);
+
+							// R = E - 2 * N * (E . N)
+							Float4 dot = Float4(2.0f) * dot3(Ec, Nc);
+
+							R.x = Ec.x - Nc.x * dot;
+							R.y = Ec.y - Nc.y * dot;
+							R.z = Ec.z - Nc.z * dot;
+						}
+						else
+						{
+							// u = -2 * Nz * Nx
+							// v = -2 * Nz * Ny
+							// w = 1 - 2 * Nz * Nz
+
+							R.x = -Float4(2.0f) * Nc.z * Nc.x;
+							R.y = -Float4(2.0f) * Nc.z * Nc.y;
+							R.z = Float4(1.0f) - Float4(2.0f) * Nc.z * Nc.z;
+						}
+					}
+					else
+					{
+						R.x = Float4(0.0f);
+						R.y = Float4(0.0f);
+						R.z = Float4(0.0f);
+					}
+
+					R.z -= Float4(1.0f);
+					R = normalize(R);
+					R.x = Float4(0.5f) * R.x + Float4(0.5f);
+					R.y = Float4(0.5f) * R.y + Float4(0.5f);
+
+					R.z = Float4(1.0f);
+					R.w = Float4(0.0f);
+
+					o[T0 + stage].x = R.x;
+					o[T0 + stage].y = R.y;
+					o[T0 + stage].z = R.z;
+					o[T0 + stage].w = R.w;
+				}
+				break;
+			default:
+				ASSERT(false);
+			}
+
+			Vector4f texTrans0;
+			Vector4f texTrans1;
+			Vector4f texTrans2;
+			Vector4f texTrans3;
+
+			Vector4f T;
+			Vector4f t;
+
+			T.x = o[T0 + stage].x;
+			T.y = o[T0 + stage].y;
+			T.z = o[T0 + stage].z;
+			T.w = o[T0 + stage].w;
+
+			switch(state.textureState[stage].textureTransformCountActive)
+			{
+			case 4:
+				texTrans3.x = texTrans3.y = texTrans3.z = texTrans3.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][3]));   // FIXME: Unpack
+				texTrans3.x = texTrans3.x.xxxx;
+				texTrans3.y = texTrans3.y.yyyy;
+				texTrans3.z = texTrans3.z.zzzz;
+				texTrans3.w = texTrans3.w.wwww;
+				t.w = dot4(T, texTrans3);
+			case 3:
+				texTrans2.x = texTrans2.y = texTrans2.z = texTrans2.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][2]));   // FIXME: Unpack
+				texTrans2.x = texTrans2.x.xxxx;
+				texTrans2.y = texTrans2.y.yyyy;
+				texTrans2.z = texTrans2.z.zzzz;
+				texTrans2.w = texTrans2.w.wwww;
+				t.z = dot4(T, texTrans2);
+			case 2:
+				texTrans1.x = texTrans1.y = texTrans1.z = texTrans1.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][1]));   // FIXME: Unpack
+				texTrans1.x = texTrans1.x.xxxx;
+				texTrans1.y = texTrans1.y.yyyy;
+				texTrans1.z = texTrans1.z.zzzz;
+				texTrans1.w = texTrans1.w.wwww;
+				t.y = dot4(T, texTrans1);
+			case 1:
+				texTrans0.x = texTrans0.y = texTrans0.z = texTrans0.w = *Pointer<Float4>(data + OFFSET(DrawData,ff.textureTransform[stage][0]));   // FIXME: Unpack
+				texTrans0.x = texTrans0.x.xxxx;
+				texTrans0.y = texTrans0.y.yyyy;
+				texTrans0.z = texTrans0.z.zzzz;
+				texTrans0.w = texTrans0.w.wwww;
+				t.x = dot4(T, texTrans0);
+
+				o[T0 + stage].x = t.x;
+				o[T0 + stage].y = t.y;
+				o[T0 + stage].z = t.z;
+				o[T0 + stage].w = t.w;
+			case 0:
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+	}
+
+	void VertexPipeline::processPointSize()
+	{
+		if(!state.pointSizeActive)
+		{
+			return;   // Use global pointsize
+		}
+
+		if(state.input[PointSize])
+		{
+			o[Pts].y = v[PointSize].x;
+		}
+		else
+		{
+			o[Pts].y = *Pointer<Float4>(data + OFFSET(DrawData,point.pointSize));
+		}
+
+		if(state.pointScaleActive && !state.preTransformed)
+		{
+			Vector4f p = transformBlend(v[Position], Pointer<Byte>(data + OFFSET(DrawData,ff.cameraTransformT)), true);
+
+			Float4 d = Sqrt(dot3(p, p));   // FIXME: length(p);
+
+			Float4 A = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleA));   // FIXME: Unpack
+			Float4 B = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleB));   // FIXME: Unpack
+			Float4 C = *Pointer<Float>(data + OFFSET(DrawData,point.pointScaleC));   // FIXME: Unpack
+
+			A = RcpSqrt_pp(A + d * (B + d * C));
+
+			o[Pts].y = o[Pts].y * Float4(*Pointer<Float>(data + OFFSET(DrawData,viewportHeight))) * A;   // FIXME: Unpack
+		}
+	}
+
+	Vector4f VertexPipeline::transform(const Register &src, const Pointer<Byte> &matrix, bool homogeneous)
+	{
+		Vector4f dst;
+
+		if(homogeneous)
+		{
+			Float4 m[4][4];
+
+			for(int j = 0; j < 4; j++)
+			{
+				for(int i = 0; i < 4; i++)
+				{
+					m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j);
+				}
+			}
+
+			dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2] + src.w * m[0][3];
+			dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2] + src.w * m[1][3];
+			dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2] + src.w * m[2][3];
+			dst.w = src.x * m[3][0] + src.y * m[3][1] + src.z * m[3][2] + src.w * m[3][3];
+		}
+		else
+		{
+			Float4 m[3][3];
+
+			for(int j = 0; j < 3; j++)
+			{
+				for(int i = 0; i < 3; i++)
+				{
+					m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j);
+					m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j);
+				}
+			}
+
+			dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2];
+			dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2];
+			dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2];
+		}
+
+		return dst;
+	}
+
+	Vector4f VertexPipeline::transform(const Register &src, const Pointer<Byte> &matrix, UInt index[4], bool homogeneous)
+	{
+		Vector4f dst;
+
+		if(homogeneous)
+		{
+			Float4 m[4][4];
+
+			for(int j = 0; j < 4; j++)
+			{
+				for(int i = 0; i < 4; i++)
+				{
+					m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j + index[0]);
+					m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j + index[1]);
+					m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j + index[2]);
+					m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j + index[3]);
+				}
+			}
+
+			dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2] + m[0][3];
+			dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2] + m[1][3];
+			dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2] + m[2][3];
+			dst.w = src.x * m[3][0] + src.y * m[3][1] + src.z * m[3][2] + m[3][3];
+		}
+		else
+		{
+			Float4 m[3][3];
+
+			for(int j = 0; j < 3; j++)
+			{
+				for(int i = 0; i < 3; i++)
+				{
+					m[j][i].x = *Pointer<Float>(matrix + 16 * i + 4 * j + index[0]);
+					m[j][i].y = *Pointer<Float>(matrix + 16 * i + 4 * j + index[1]);
+					m[j][i].z = *Pointer<Float>(matrix + 16 * i + 4 * j + index[2]);
+					m[j][i].w = *Pointer<Float>(matrix + 16 * i + 4 * j + index[3]);
+				}
+			}
+
+			dst.x = src.x * m[0][0] + src.y * m[0][1] + src.z * m[0][2];
+			dst.y = src.x * m[1][0] + src.y * m[1][1] + src.z * m[1][2];
+			dst.z = src.x * m[2][0] + src.y * m[2][1] + src.z * m[2][2];
+		}
+
+		return dst;
+	}
+
+	Vector4f VertexPipeline::normalize(Vector4f &src)
+	{
+		Vector4f dst;
+
+		Float4 rcpLength = RcpSqrt_pp(dot3(src, src));
+
+		dst.x = src.x * rcpLength;
+		dst.y = src.y * rcpLength;
+		dst.z = src.z * rcpLength;
+
+		return dst;
+	}
+
+	Float4 VertexPipeline::power(Float4 &src0, Float4 &src1)
+	{
+		Float4 dst = src0;
+
+		dst = dst * dst;
+		dst = dst * dst;
+		dst = Float4(As<Int4>(dst) - As<Int4>(Float4(1.0f)));
+
+		dst *= src1;
+
+		dst = As<Float4>(Int4(dst) + As<Int4>(Float4(1.0f)));
+		dst = RcpSqrt_pp(dst);
+		dst = RcpSqrt_pp(dst);
+
+		return dst;
+	}
+}
diff --git a/src/Pipeline/VertexPipeline.hpp b/src/Pipeline/VertexPipeline.hpp
new file mode 100644
index 0000000..0736afb
--- /dev/null
+++ b/src/Pipeline/VertexPipeline.hpp
@@ -0,0 +1,45 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_VertexPipeline_hpp
+#define sw_VertexPipeline_hpp
+
+#include "VertexRoutine.hpp"
+
+#include "Renderer/Context.hpp"
+#include "Renderer/VertexProcessor.hpp"
+
+namespace sw
+{
+	class VertexPipeline : public VertexRoutine
+	{
+	public:
+		VertexPipeline(const VertexProcessor::State &state);
+
+		virtual ~VertexPipeline();
+
+	private:
+		void pipeline(UInt &index) override;
+		void processTextureCoordinate(int stage, Vector4f &normal, Vector4f &position);
+		void processPointSize();
+
+		Vector4f transformBlend(const Register &src, const Pointer<Byte> &matrix, bool homogenous);
+		Vector4f transform(const Register &src, const Pointer<Byte> &matrix, bool homogenous);
+		Vector4f transform(const Register &src, const Pointer<Byte> &matrix, UInt index[4], bool homogenous);
+		Vector4f normalize(Vector4f &src);
+		Float4 power(Float4 &src0, Float4 &src1);
+	};
+};
+
+#endif   // sw_VertexPipeline_hpp
diff --git a/src/Pipeline/VertexProgram.cpp b/src/Pipeline/VertexProgram.cpp
new file mode 100644
index 0000000..ad4e37b
--- /dev/null
+++ b/src/Pipeline/VertexProgram.cpp
@@ -0,0 +1,1650 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VertexProgram.hpp"
+
+#include "VertexShader.hpp"
+#include "SamplerCore.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Renderer/Vertex.hpp"
+#include "Common/Half.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	VertexProgram::VertexProgram(const VertexProcessor::State &state, const VertexShader *shader)
+		: VertexRoutine(state, shader), shader(shader), r(shader->indirectAddressableTemporaries)
+	{
+		ifDepth = 0;
+		loopRepDepth = 0;
+		currentLabel = -1;
+		whileTest = false;
+
+		for(int i = 0; i < 2048; i++)
+		{
+			labelBlock[i] = 0;
+		}
+
+		loopDepth = -1;
+		enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+
+		if(shader->containsBreakInstruction())
+		{
+			enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		}
+
+		if(shader->containsContinueInstruction())
+		{
+			enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		}
+
+		if(shader->isInstanceIdDeclared())
+		{
+			instanceID = *Pointer<Int>(data + OFFSET(DrawData,instanceID));
+		}
+	}
+
+	VertexProgram::~VertexProgram()
+	{
+	}
+
+	void VertexProgram::pipeline(UInt &index)
+	{
+		if(!state.preTransformed)
+		{
+			program(index);
+		}
+		else
+		{
+			passThrough();
+		}
+	}
+
+	void VertexProgram::program(UInt &index)
+	{
+	//	shader->print("VertexShader-%0.8X.txt", state.shaderID);
+
+		unsigned short shaderModel = shader->getShaderModel();
+
+		enableIndex = 0;
+		stackIndex = 0;
+
+		if(shader->containsLeaveInstruction())
+		{
+			enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		}
+
+		if(shader->isVertexIdDeclared())
+		{
+			if(state.textureSampling)
+			{
+				vertexID = Int4(index);
+			}
+			else
+			{
+				vertexID = Insert(vertexID, As<Int>(index), 0);
+				vertexID = Insert(vertexID, As<Int>(index + 1), 1);
+				vertexID = Insert(vertexID, As<Int>(index + 2), 2);
+				vertexID = Insert(vertexID, As<Int>(index + 3), 3);
+			}
+		}
+
+		// Create all call site return blocks up front
+		for(size_t i = 0; i < shader->getLength(); i++)
+		{
+			const Shader::Instruction *instruction = shader->getInstruction(i);
+			Shader::Opcode opcode = instruction->opcode;
+
+			if(opcode == Shader::OPCODE_CALL || opcode == Shader::OPCODE_CALLNZ)
+			{
+				const Dst &dst = instruction->dst;
+
+				ASSERT(callRetBlock[dst.label].size() == dst.callSite);
+				callRetBlock[dst.label].push_back(Nucleus::createBasicBlock());
+			}
+		}
+
+		for(size_t i = 0; i < shader->getLength(); i++)
+		{
+			const Shader::Instruction *instruction = shader->getInstruction(i);
+			Shader::Opcode opcode = instruction->opcode;
+
+			if(opcode == Shader::OPCODE_DCL || opcode == Shader::OPCODE_DEF || opcode == Shader::OPCODE_DEFI || opcode == Shader::OPCODE_DEFB)
+			{
+				continue;
+			}
+
+			Dst dst = instruction->dst;
+			Src src0 = instruction->src[0];
+			Src src1 = instruction->src[1];
+			Src src2 = instruction->src[2];
+			Src src3 = instruction->src[3];
+			Src src4 = instruction->src[4];
+
+			bool predicate = instruction->predicate;
+			Control control = instruction->control;
+			bool integer = dst.type == Shader::PARAMETER_ADDR;
+			bool pp = dst.partialPrecision;
+
+			Vector4f d;
+			Vector4f s0;
+			Vector4f s1;
+			Vector4f s2;
+			Vector4f s3;
+			Vector4f s4;
+
+			if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegister(src0);
+			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegister(src1);
+			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegister(src2);
+			if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegister(src3);
+			if(src4.type != Shader::PARAMETER_VOID) s4 = fetchRegister(src4);
+
+			switch(opcode)
+			{
+			case Shader::OPCODE_VS_1_0:                                     break;
+			case Shader::OPCODE_VS_1_1:                                     break;
+			case Shader::OPCODE_VS_2_0:                                     break;
+			case Shader::OPCODE_VS_2_x:                                     break;
+			case Shader::OPCODE_VS_2_sw:                                    break;
+			case Shader::OPCODE_VS_3_0:                                     break;
+			case Shader::OPCODE_VS_3_sw:                                    break;
+			case Shader::OPCODE_DCL:                                        break;
+			case Shader::OPCODE_DEF:                                        break;
+			case Shader::OPCODE_DEFI:                                       break;
+			case Shader::OPCODE_DEFB:                                       break;
+			case Shader::OPCODE_NOP:                                        break;
+			case Shader::OPCODE_ABS:        abs(d, s0);                     break;
+			case Shader::OPCODE_IABS:       iabs(d, s0);                    break;
+			case Shader::OPCODE_ADD:        add(d, s0, s1);                 break;
+			case Shader::OPCODE_IADD:       iadd(d, s0, s1);                break;
+			case Shader::OPCODE_CRS:        crs(d, s0, s1);                 break;
+			case Shader::OPCODE_FORWARD1:   forward1(d, s0, s1, s2);        break;
+			case Shader::OPCODE_FORWARD2:   forward2(d, s0, s1, s2);        break;
+			case Shader::OPCODE_FORWARD3:   forward3(d, s0, s1, s2);        break;
+			case Shader::OPCODE_FORWARD4:   forward4(d, s0, s1, s2);        break;
+			case Shader::OPCODE_REFLECT1:   reflect1(d, s0, s1);            break;
+			case Shader::OPCODE_REFLECT2:   reflect2(d, s0, s1);            break;
+			case Shader::OPCODE_REFLECT3:   reflect3(d, s0, s1);            break;
+			case Shader::OPCODE_REFLECT4:   reflect4(d, s0, s1);            break;
+			case Shader::OPCODE_REFRACT1:   refract1(d, s0, s1, s2.x);      break;
+			case Shader::OPCODE_REFRACT2:   refract2(d, s0, s1, s2.x);      break;
+			case Shader::OPCODE_REFRACT3:   refract3(d, s0, s1, s2.x);      break;
+			case Shader::OPCODE_REFRACT4:   refract4(d, s0, s1, s2.x);      break;
+			case Shader::OPCODE_DP1:        dp1(d, s0, s1);                 break;
+			case Shader::OPCODE_DP2:        dp2(d, s0, s1);                 break;
+			case Shader::OPCODE_DP3:        dp3(d, s0, s1);                 break;
+			case Shader::OPCODE_DP4:        dp4(d, s0, s1);                 break;
+			case Shader::OPCODE_DET2:       det2(d, s0, s1);                break;
+			case Shader::OPCODE_DET3:       det3(d, s0, s1, s2);            break;
+			case Shader::OPCODE_DET4:       det4(d, s0, s1, s2, s3);        break;
+			case Shader::OPCODE_ATT:        att(d, s0, s1);                 break;
+			case Shader::OPCODE_EXP2X:      exp2x(d, s0, pp);               break;
+			case Shader::OPCODE_EXP2:       exp2(d, s0, pp);                break;
+			case Shader::OPCODE_EXPP:       expp(d, s0, shaderModel);       break;
+			case Shader::OPCODE_EXP:        exp(d, s0, pp);                 break;
+			case Shader::OPCODE_FRC:        frc(d, s0);                     break;
+			case Shader::OPCODE_TRUNC:      trunc(d, s0);                   break;
+			case Shader::OPCODE_FLOOR:      floor(d, s0);                   break;
+			case Shader::OPCODE_ROUND:      round(d, s0);                   break;
+			case Shader::OPCODE_ROUNDEVEN:  roundEven(d, s0);               break;
+			case Shader::OPCODE_CEIL:       ceil(d, s0);                    break;
+			case Shader::OPCODE_LIT:        lit(d, s0);                     break;
+			case Shader::OPCODE_LOG2X:      log2x(d, s0, pp);               break;
+			case Shader::OPCODE_LOG2:       log2(d, s0, pp);                break;
+			case Shader::OPCODE_LOGP:       logp(d, s0, shaderModel);       break;
+			case Shader::OPCODE_LOG:        log(d, s0, pp);                 break;
+			case Shader::OPCODE_LRP:        lrp(d, s0, s1, s2);             break;
+			case Shader::OPCODE_STEP:       step(d, s0, s1);                break;
+			case Shader::OPCODE_SMOOTH:     smooth(d, s0, s1, s2);          break;
+			case Shader::OPCODE_ISINF:      isinf(d, s0);                   break;
+			case Shader::OPCODE_ISNAN:      isnan(d, s0);                   break;
+			case Shader::OPCODE_FLOATBITSTOINT:
+			case Shader::OPCODE_FLOATBITSTOUINT:
+			case Shader::OPCODE_INTBITSTOFLOAT:
+			case Shader::OPCODE_UINTBITSTOFLOAT: d = s0;                    break;
+			case Shader::OPCODE_PACKSNORM2x16:   packSnorm2x16(d, s0);      break;
+			case Shader::OPCODE_PACKUNORM2x16:   packUnorm2x16(d, s0);      break;
+			case Shader::OPCODE_PACKHALF2x16:    packHalf2x16(d, s0);       break;
+			case Shader::OPCODE_UNPACKSNORM2x16: unpackSnorm2x16(d, s0);    break;
+			case Shader::OPCODE_UNPACKUNORM2x16: unpackUnorm2x16(d, s0);    break;
+			case Shader::OPCODE_UNPACKHALF2x16:  unpackHalf2x16(d, s0);     break;
+			case Shader::OPCODE_M3X2:       M3X2(d, s0, src1);              break;
+			case Shader::OPCODE_M3X3:       M3X3(d, s0, src1);              break;
+			case Shader::OPCODE_M3X4:       M3X4(d, s0, src1);              break;
+			case Shader::OPCODE_M4X3:       M4X3(d, s0, src1);              break;
+			case Shader::OPCODE_M4X4:       M4X4(d, s0, src1);              break;
+			case Shader::OPCODE_MAD:        mad(d, s0, s1, s2);             break;
+			case Shader::OPCODE_IMAD:       imad(d, s0, s1, s2);            break;
+			case Shader::OPCODE_MAX:        max(d, s0, s1);                 break;
+			case Shader::OPCODE_IMAX:       imax(d, s0, s1);                break;
+			case Shader::OPCODE_UMAX:       umax(d, s0, s1);                break;
+			case Shader::OPCODE_MIN:        min(d, s0, s1);                 break;
+			case Shader::OPCODE_IMIN:       imin(d, s0, s1);                break;
+			case Shader::OPCODE_UMIN:       umin(d, s0, s1);                break;
+			case Shader::OPCODE_MOV:        mov(d, s0, integer);            break;
+			case Shader::OPCODE_MOVA:       mov(d, s0, true);               break;
+			case Shader::OPCODE_NEG:        neg(d, s0);                     break;
+			case Shader::OPCODE_INEG:       ineg(d, s0);                    break;
+			case Shader::OPCODE_F2B:        f2b(d, s0);                     break;
+			case Shader::OPCODE_B2F:        b2f(d, s0);                     break;
+			case Shader::OPCODE_F2I:        f2i(d, s0);                     break;
+			case Shader::OPCODE_I2F:        i2f(d, s0);                     break;
+			case Shader::OPCODE_F2U:        f2u(d, s0);                     break;
+			case Shader::OPCODE_U2F:        u2f(d, s0);                     break;
+			case Shader::OPCODE_I2B:        i2b(d, s0);                     break;
+			case Shader::OPCODE_B2I:        b2i(d, s0);                     break;
+			case Shader::OPCODE_MUL:        mul(d, s0, s1);                 break;
+			case Shader::OPCODE_IMUL:       imul(d, s0, s1);                break;
+			case Shader::OPCODE_NRM2:       nrm2(d, s0, pp);                break;
+			case Shader::OPCODE_NRM3:       nrm3(d, s0, pp);                break;
+			case Shader::OPCODE_NRM4:       nrm4(d, s0, pp);                break;
+			case Shader::OPCODE_POWX:       powx(d, s0, s1, pp);            break;
+			case Shader::OPCODE_POW:        pow(d, s0, s1, pp);             break;
+			case Shader::OPCODE_RCPX:       rcpx(d, s0, pp);                break;
+			case Shader::OPCODE_DIV:        div(d, s0, s1);                 break;
+			case Shader::OPCODE_IDIV:       idiv(d, s0, s1);                break;
+			case Shader::OPCODE_UDIV:       udiv(d, s0, s1);                break;
+			case Shader::OPCODE_MOD:        mod(d, s0, s1);                 break;
+			case Shader::OPCODE_IMOD:       imod(d, s0, s1);                break;
+			case Shader::OPCODE_UMOD:       umod(d, s0, s1);                break;
+			case Shader::OPCODE_SHL:        shl(d, s0, s1);                 break;
+			case Shader::OPCODE_ISHR:       ishr(d, s0, s1);                break;
+			case Shader::OPCODE_USHR:       ushr(d, s0, s1);                break;
+			case Shader::OPCODE_RSQX:       rsqx(d, s0, pp);                break;
+			case Shader::OPCODE_SQRT:       sqrt(d, s0, pp);                break;
+			case Shader::OPCODE_RSQ:        rsq(d, s0, pp);                 break;
+			case Shader::OPCODE_LEN2:       len2(d.x, s0, pp);              break;
+			case Shader::OPCODE_LEN3:       len3(d.x, s0, pp);              break;
+			case Shader::OPCODE_LEN4:       len4(d.x, s0, pp);              break;
+			case Shader::OPCODE_DIST1:      dist1(d.x, s0, s1, pp);         break;
+			case Shader::OPCODE_DIST2:      dist2(d.x, s0, s1, pp);         break;
+			case Shader::OPCODE_DIST3:      dist3(d.x, s0, s1, pp);         break;
+			case Shader::OPCODE_DIST4:      dist4(d.x, s0, s1, pp);         break;
+			case Shader::OPCODE_SGE:        step(d, s1, s0);                break;
+			case Shader::OPCODE_SGN:        sgn(d, s0);                     break;
+			case Shader::OPCODE_ISGN:       isgn(d, s0);                    break;
+			case Shader::OPCODE_SINCOS:     sincos(d, s0, pp);              break;
+			case Shader::OPCODE_COS:        cos(d, s0, pp);                 break;
+			case Shader::OPCODE_SIN:        sin(d, s0, pp);                 break;
+			case Shader::OPCODE_TAN:        tan(d, s0);                     break;
+			case Shader::OPCODE_ACOS:       acos(d, s0);                    break;
+			case Shader::OPCODE_ASIN:       asin(d, s0);                    break;
+			case Shader::OPCODE_ATAN:       atan(d, s0);                    break;
+			case Shader::OPCODE_ATAN2:      atan2(d, s0, s1);               break;
+			case Shader::OPCODE_COSH:       cosh(d, s0, pp);                break;
+			case Shader::OPCODE_SINH:       sinh(d, s0, pp);                break;
+			case Shader::OPCODE_TANH:       tanh(d, s0, pp);                break;
+			case Shader::OPCODE_ACOSH:      acosh(d, s0, pp);               break;
+			case Shader::OPCODE_ASINH:      asinh(d, s0, pp);               break;
+			case Shader::OPCODE_ATANH:      atanh(d, s0, pp);               break;
+			case Shader::OPCODE_SLT:        slt(d, s0, s1);                 break;
+			case Shader::OPCODE_SUB:        sub(d, s0, s1);                 break;
+			case Shader::OPCODE_ISUB:       isub(d, s0, s1);                break;
+			case Shader::OPCODE_BREAK:      BREAK();                        break;
+			case Shader::OPCODE_BREAKC:     BREAKC(s0, s1, control);        break;
+			case Shader::OPCODE_BREAKP:     BREAKP(src0);                   break;
+			case Shader::OPCODE_CONTINUE:   CONTINUE();                     break;
+			case Shader::OPCODE_TEST:       TEST();                         break;
+			case Shader::OPCODE_CALL:       CALL(dst.label, dst.callSite);  break;
+			case Shader::OPCODE_CALLNZ:     CALLNZ(dst.label, dst.callSite, src0); break;
+			case Shader::OPCODE_ELSE:       ELSE();                         break;
+			case Shader::OPCODE_ENDIF:      ENDIF();                        break;
+			case Shader::OPCODE_ENDLOOP:    ENDLOOP();                      break;
+			case Shader::OPCODE_ENDREP:     ENDREP();                       break;
+			case Shader::OPCODE_ENDWHILE:   ENDWHILE();                     break;
+			case Shader::OPCODE_ENDSWITCH:  ENDSWITCH();                    break;
+			case Shader::OPCODE_IF:         IF(src0);                       break;
+			case Shader::OPCODE_IFC:        IFC(s0, s1, control);           break;
+			case Shader::OPCODE_LABEL:      LABEL(dst.index);               break;
+			case Shader::OPCODE_LOOP:       LOOP(src1);                     break;
+			case Shader::OPCODE_REP:        REP(src0);                      break;
+			case Shader::OPCODE_WHILE:      WHILE(src0);                    break;
+			case Shader::OPCODE_SWITCH:     SWITCH();                       break;
+			case Shader::OPCODE_RET:        RET();                          break;
+			case Shader::OPCODE_LEAVE:      LEAVE();                        break;
+			case Shader::OPCODE_CMP:        cmp(d, s0, s1, control);        break;
+			case Shader::OPCODE_ICMP:       icmp(d, s0, s1, control);       break;
+			case Shader::OPCODE_UCMP:       ucmp(d, s0, s1, control);       break;
+			case Shader::OPCODE_SELECT:     select(d, s0, s1, s2);          break;
+			case Shader::OPCODE_EXTRACT:    extract(d.x, s0, s1.x);         break;
+			case Shader::OPCODE_INSERT:     insert(d, s0, s1.x, s2.x);      break;
+			case Shader::OPCODE_ALL:        all(d.x, s0);                   break;
+			case Shader::OPCODE_ANY:        any(d.x, s0);                   break;
+			case Shader::OPCODE_NOT:        bitwise_not(d, s0);             break;
+			case Shader::OPCODE_OR:         bitwise_or(d, s0, s1);          break;
+			case Shader::OPCODE_XOR:        bitwise_xor(d, s0, s1);         break;
+			case Shader::OPCODE_AND:        bitwise_and(d, s0, s1);         break;
+			case Shader::OPCODE_EQ:         equal(d, s0, s1);               break;
+			case Shader::OPCODE_NE:         notEqual(d, s0, s1);            break;
+			case Shader::OPCODE_TEXLDL:     TEXLOD(d, s0, src1, s0.w);      break;
+			case Shader::OPCODE_TEXLOD:     TEXLOD(d, s0, src1, s2.x);      break;
+			case Shader::OPCODE_TEX:        TEX(d, s0, src1);               break;
+			case Shader::OPCODE_TEXOFFSET:  TEXOFFSET(d, s0, src1, s2);     break;
+			case Shader::OPCODE_TEXLODOFFSET: TEXLODOFFSET(d, s0, src1, s2, s3.x); break;
+			case Shader::OPCODE_TEXELFETCH: TEXELFETCH(d, s0, src1, s2.x);  break;
+			case Shader::OPCODE_TEXELFETCHOFFSET: TEXELFETCHOFFSET(d, s0, src1, s2, s3.x); break;
+			case Shader::OPCODE_TEXGRAD:    TEXGRAD(d, s0, src1, s2, s3);   break;
+			case Shader::OPCODE_TEXGRADOFFSET: TEXGRADOFFSET(d, s0, src1, s2, s3, s4); break;
+			case Shader::OPCODE_TEXSIZE:    TEXSIZE(d, s0.x, src1);         break;
+			case Shader::OPCODE_END:                                        break;
+			default:
+				ASSERT(false);
+			}
+
+			if(dst.type != Shader::PARAMETER_VOID && dst.type != Shader::PARAMETER_LABEL && opcode != Shader::OPCODE_NOP)
+			{
+				if(dst.saturate)
+				{
+					if(dst.x) d.x = Max(d.x, Float4(0.0f));
+					if(dst.y) d.y = Max(d.y, Float4(0.0f));
+					if(dst.z) d.z = Max(d.z, Float4(0.0f));
+					if(dst.w) d.w = Max(d.w, Float4(0.0f));
+
+					if(dst.x) d.x = Min(d.x, Float4(1.0f));
+					if(dst.y) d.y = Min(d.y, Float4(1.0f));
+					if(dst.z) d.z = Min(d.z, Float4(1.0f));
+					if(dst.w) d.w = Min(d.w, Float4(1.0f));
+				}
+
+				if(instruction->isPredicated())
+				{
+					Vector4f pDst;   // FIXME: Rename
+
+					switch(dst.type)
+					{
+					case Shader::PARAMETER_VOID: break;
+					case Shader::PARAMETER_TEMP:
+						if(dst.rel.type == Shader::PARAMETER_VOID)
+						{
+							if(dst.x) pDst.x = r[dst.index].x;
+							if(dst.y) pDst.y = r[dst.index].y;
+							if(dst.z) pDst.z = r[dst.index].z;
+							if(dst.w) pDst.w = r[dst.index].w;
+						}
+						else if(!dst.rel.dynamic)
+						{
+							Int a = dst.index + relativeAddress(dst.rel);
+
+							if(dst.x) pDst.x = r[a].x;
+							if(dst.y) pDst.y = r[a].y;
+							if(dst.z) pDst.z = r[a].z;
+							if(dst.w) pDst.w = r[a].w;
+						}
+						else
+						{
+							Int4 a = dst.index + dynamicAddress(dst.rel);
+
+							if(dst.x) pDst.x = r[a].x;
+							if(dst.y) pDst.y = r[a].y;
+							if(dst.z) pDst.z = r[a].z;
+							if(dst.w) pDst.w = r[a].w;
+						}
+						break;
+					case Shader::PARAMETER_ADDR: pDst = a0; break;
+					case Shader::PARAMETER_RASTOUT:
+						switch(dst.index)
+						{
+						case 0:
+							if(dst.x) pDst.x = o[Pos].x;
+							if(dst.y) pDst.y = o[Pos].y;
+							if(dst.z) pDst.z = o[Pos].z;
+							if(dst.w) pDst.w = o[Pos].w;
+							break;
+						case 1:
+							pDst.x = o[Fog].x;
+							break;
+						case 2:
+							pDst.x = o[Pts].y;
+							break;
+						default:
+							ASSERT(false);
+						}
+						break;
+					case Shader::PARAMETER_ATTROUT:
+						if(dst.x) pDst.x = o[C0 + dst.index].x;
+						if(dst.y) pDst.y = o[C0 + dst.index].y;
+						if(dst.z) pDst.z = o[C0 + dst.index].z;
+						if(dst.w) pDst.w = o[C0 + dst.index].w;
+						break;
+					case Shader::PARAMETER_TEXCRDOUT:
+				//	case Shader::PARAMETER_OUTPUT:
+						if(shaderModel < 0x0300)
+						{
+							if(dst.x) pDst.x = o[T0 + dst.index].x;
+							if(dst.y) pDst.y = o[T0 + dst.index].y;
+							if(dst.z) pDst.z = o[T0 + dst.index].z;
+							if(dst.w) pDst.w = o[T0 + dst.index].w;
+						}
+						else if(dst.rel.type == Shader::PARAMETER_VOID)   // Not relative
+						{
+							if(dst.x) pDst.x = o[dst.index].x;
+							if(dst.y) pDst.y = o[dst.index].y;
+							if(dst.z) pDst.z = o[dst.index].z;
+							if(dst.w) pDst.w = o[dst.index].w;
+						}
+						else if(!dst.rel.dynamic)
+						{
+							Int a = dst.index + relativeAddress(dst.rel);
+
+							if(dst.x) pDst.x = o[a].x;
+							if(dst.y) pDst.y = o[a].y;
+							if(dst.z) pDst.z = o[a].z;
+							if(dst.w) pDst.w = o[a].w;
+						}
+						else
+						{
+							Int4 a = dst.index + dynamicAddress(dst.rel);
+
+							if(dst.x) pDst.x = o[a].x;
+							if(dst.y) pDst.y = o[a].y;
+							if(dst.z) pDst.z = o[a].z;
+							if(dst.w) pDst.w = o[a].w;
+						}
+						break;
+					case Shader::PARAMETER_LABEL:                break;
+					case Shader::PARAMETER_PREDICATE: pDst = p0; break;
+					case Shader::PARAMETER_INPUT:                break;
+					default:
+						ASSERT(false);
+					}
+
+					Int4 enable = enableMask(instruction);
+
+					Int4 xEnable = enable;
+					Int4 yEnable = enable;
+					Int4 zEnable = enable;
+					Int4 wEnable = enable;
+
+					if(predicate)
+					{
+						unsigned char pSwizzle = instruction->predicateSwizzle;
+
+						Float4 xPredicate = p0[(pSwizzle >> 0) & 0x03];
+						Float4 yPredicate = p0[(pSwizzle >> 2) & 0x03];
+						Float4 zPredicate = p0[(pSwizzle >> 4) & 0x03];
+						Float4 wPredicate = p0[(pSwizzle >> 6) & 0x03];
+
+						if(!instruction->predicateNot)
+						{
+							if(dst.x) xEnable = xEnable & As<Int4>(xPredicate);
+							if(dst.y) yEnable = yEnable & As<Int4>(yPredicate);
+							if(dst.z) zEnable = zEnable & As<Int4>(zPredicate);
+							if(dst.w) wEnable = wEnable & As<Int4>(wPredicate);
+						}
+						else
+						{
+							if(dst.x) xEnable = xEnable & ~As<Int4>(xPredicate);
+							if(dst.y) yEnable = yEnable & ~As<Int4>(yPredicate);
+							if(dst.z) zEnable = zEnable & ~As<Int4>(zPredicate);
+							if(dst.w) wEnable = wEnable & ~As<Int4>(wPredicate);
+						}
+					}
+
+					if(dst.x) d.x = As<Float4>(As<Int4>(d.x) & xEnable);
+					if(dst.y) d.y = As<Float4>(As<Int4>(d.y) & yEnable);
+					if(dst.z) d.z = As<Float4>(As<Int4>(d.z) & zEnable);
+					if(dst.w) d.w = As<Float4>(As<Int4>(d.w) & wEnable);
+
+					if(dst.x) d.x = As<Float4>(As<Int4>(d.x) | (As<Int4>(pDst.x) & ~xEnable));
+					if(dst.y) d.y = As<Float4>(As<Int4>(d.y) | (As<Int4>(pDst.y) & ~yEnable));
+					if(dst.z) d.z = As<Float4>(As<Int4>(d.z) | (As<Int4>(pDst.z) & ~zEnable));
+					if(dst.w) d.w = As<Float4>(As<Int4>(d.w) | (As<Int4>(pDst.w) & ~wEnable));
+				}
+
+				switch(dst.type)
+				{
+				case Shader::PARAMETER_VOID:
+					break;
+				case Shader::PARAMETER_TEMP:
+					if(dst.rel.type == Shader::PARAMETER_VOID)
+					{
+						if(dst.x) r[dst.index].x = d.x;
+						if(dst.y) r[dst.index].y = d.y;
+						if(dst.z) r[dst.index].z = d.z;
+						if(dst.w) r[dst.index].w = d.w;
+					}
+					else if(!dst.rel.dynamic)
+					{
+						Int a = dst.index + relativeAddress(dst.rel);
+
+						if(dst.x) r[a].x = d.x;
+						if(dst.y) r[a].y = d.y;
+						if(dst.z) r[a].z = d.z;
+						if(dst.w) r[a].w = d.w;
+					}
+					else
+					{
+						Int4 a = dst.index + dynamicAddress(dst.rel);
+
+						if(dst.x) r.scatter_x(a, d.x);
+						if(dst.y) r.scatter_y(a, d.y);
+						if(dst.z) r.scatter_z(a, d.z);
+						if(dst.w) r.scatter_w(a, d.w);
+					}
+					break;
+				case Shader::PARAMETER_ADDR:
+					if(dst.x) a0.x = d.x;
+					if(dst.y) a0.y = d.y;
+					if(dst.z) a0.z = d.z;
+					if(dst.w) a0.w = d.w;
+					break;
+				case Shader::PARAMETER_RASTOUT:
+					switch(dst.index)
+					{
+					case 0:
+						if(dst.x) o[Pos].x = d.x;
+						if(dst.y) o[Pos].y = d.y;
+						if(dst.z) o[Pos].z = d.z;
+						if(dst.w) o[Pos].w = d.w;
+						break;
+					case 1:
+						o[Fog].x = d.x;
+						break;
+					case 2:
+						o[Pts].y = d.x;
+						break;
+					default:	ASSERT(false);
+					}
+					break;
+				case Shader::PARAMETER_ATTROUT:
+					if(dst.x) o[C0 + dst.index].x = d.x;
+					if(dst.y) o[C0 + dst.index].y = d.y;
+					if(dst.z) o[C0 + dst.index].z = d.z;
+					if(dst.w) o[C0 + dst.index].w = d.w;
+					break;
+				case Shader::PARAMETER_TEXCRDOUT:
+			//	case Shader::PARAMETER_OUTPUT:
+					if(shaderModel < 0x0300)
+					{
+						if(dst.x) o[T0 + dst.index].x = d.x;
+						if(dst.y) o[T0 + dst.index].y = d.y;
+						if(dst.z) o[T0 + dst.index].z = d.z;
+						if(dst.w) o[T0 + dst.index].w = d.w;
+					}
+					else if(dst.rel.type == Shader::PARAMETER_VOID)   // Not relative
+					{
+						if(dst.x) o[dst.index].x = d.x;
+						if(dst.y) o[dst.index].y = d.y;
+						if(dst.z) o[dst.index].z = d.z;
+						if(dst.w) o[dst.index].w = d.w;
+					}
+					else if(!dst.rel.dynamic)
+					{
+						Int a = dst.index + relativeAddress(dst.rel);
+
+						if(dst.x) o[a].x = d.x;
+						if(dst.y) o[a].y = d.y;
+						if(dst.z) o[a].z = d.z;
+						if(dst.w) o[a].w = d.w;
+					}
+					else
+					{
+						Int4 a = dst.index + dynamicAddress(dst.rel);
+
+						if(dst.x) o.scatter_x(a, d.x);
+						if(dst.y) o.scatter_y(a, d.y);
+						if(dst.z) o.scatter_z(a, d.z);
+						if(dst.w) o.scatter_w(a, d.w);
+					}
+					break;
+				case Shader::PARAMETER_LABEL:             break;
+				case Shader::PARAMETER_PREDICATE: p0 = d; break;
+				case Shader::PARAMETER_INPUT:             break;
+				default:
+					ASSERT(false);
+				}
+			}
+		}
+
+		if(currentLabel != -1)
+		{
+			Nucleus::setInsertBlock(returnBlock);
+		}
+	}
+
+	void VertexProgram::passThrough()
+	{
+		if(shader)
+		{
+			for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
+			{
+				unsigned char usage = shader->getOutput(i, 0).usage;
+
+				switch(usage)
+				{
+				case 0xFF:
+					continue;
+				case Shader::USAGE_PSIZE:
+					o[i].y = v[i].x;
+					break;
+				case Shader::USAGE_TEXCOORD:
+					o[i].x = v[i].x;
+					o[i].y = v[i].y;
+					o[i].z = v[i].z;
+					o[i].w = v[i].w;
+					break;
+				case Shader::USAGE_POSITION:
+					o[i].x = v[i].x;
+					o[i].y = v[i].y;
+					o[i].z = v[i].z;
+					o[i].w = v[i].w;
+					break;
+				case Shader::USAGE_COLOR:
+					o[i].x = v[i].x;
+					o[i].y = v[i].y;
+					o[i].z = v[i].z;
+					o[i].w = v[i].w;
+					break;
+				case Shader::USAGE_FOG:
+					o[i].x = v[i].x;
+					break;
+				default:
+					ASSERT(false);
+				}
+			}
+		}
+		else
+		{
+			o[Pos].x = v[PositionT].x;
+			o[Pos].y = v[PositionT].y;
+			o[Pos].z = v[PositionT].z;
+			o[Pos].w = v[PositionT].w;
+
+			for(int i = 0; i < 2; i++)
+			{
+				o[C0 + i].x = v[Color0 + i].x;
+				o[C0 + i].y = v[Color0 + i].y;
+				o[C0 + i].z = v[Color0 + i].z;
+				o[C0 + i].w = v[Color0 + i].w;
+			}
+
+			for(int i = 0; i < 8; i++)
+			{
+				o[T0 + i].x = v[TexCoord0 + i].x;
+				o[T0 + i].y = v[TexCoord0 + i].y;
+				o[T0 + i].z = v[TexCoord0 + i].z;
+				o[T0 + i].w = v[TexCoord0 + i].w;
+			}
+
+			o[Pts].y = v[PointSize].x;
+		}
+	}
+
+	Vector4f VertexProgram::fetchRegister(const Src &src, unsigned int offset)
+	{
+		Vector4f reg;
+		unsigned int i = src.index + offset;
+
+		switch(src.type)
+		{
+		case Shader::PARAMETER_TEMP:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg = r[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = r[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = r[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_CONST:
+			reg = readConstant(src, offset);
+			break;
+		case Shader::PARAMETER_INPUT:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg = v[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = v[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = v[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_VOID: return r[0];   // Dummy
+		case Shader::PARAMETER_FLOAT4LITERAL:
+			reg.x = Float4(src.value[0]);
+			reg.y = Float4(src.value[1]);
+			reg.z = Float4(src.value[2]);
+			reg.w = Float4(src.value[3]);
+			break;
+		case Shader::PARAMETER_ADDR:      reg = a0; break;
+		case Shader::PARAMETER_CONSTBOOL: return r[0];   // Dummy
+		case Shader::PARAMETER_CONSTINT:  return r[0];   // Dummy
+		case Shader::PARAMETER_LOOP:      return r[0];   // Dummy
+		case Shader::PARAMETER_PREDICATE: return r[0];   // Dummy
+		case Shader::PARAMETER_SAMPLER:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg.x = As<Float4>(Int4(i));
+			}
+			else if(src.rel.type == Shader::PARAMETER_TEMP)
+			{
+				reg.x = As<Float4>(Int4(i) + As<Int4>(r[src.rel.index].x));
+			}
+			return reg;
+		case Shader::PARAMETER_OUTPUT:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg = o[i];
+			}
+			else if(!src.rel.dynamic)
+			{
+				reg = o[i + relativeAddress(src.rel, src.bufferIndex)];
+			}
+			else
+			{
+				reg = o[i + dynamicAddress(src.rel)];
+			}
+			break;
+		case Shader::PARAMETER_MISCTYPE:
+			if(src.index == Shader::InstanceIDIndex)
+			{
+				reg.x = As<Float>(instanceID);
+			}
+			else if(src.index == Shader::VertexIDIndex)
+			{
+				reg.x = As<Float4>(vertexID);
+			}
+			else ASSERT(false);
+			return reg;
+		default:
+			ASSERT(false);
+		}
+
+		const Float4 &x = reg[(src.swizzle >> 0) & 0x3];
+		const Float4 &y = reg[(src.swizzle >> 2) & 0x3];
+		const Float4 &z = reg[(src.swizzle >> 4) & 0x3];
+		const Float4 &w = reg[(src.swizzle >> 6) & 0x3];
+
+		Vector4f mod;
+
+		switch(src.modifier)
+		{
+		case Shader::MODIFIER_NONE:
+			mod.x = x;
+			mod.y = y;
+			mod.z = z;
+			mod.w = w;
+			break;
+		case Shader::MODIFIER_NEGATE:
+			mod.x = -x;
+			mod.y = -y;
+			mod.z = -z;
+			mod.w = -w;
+			break;
+		case Shader::MODIFIER_ABS:
+			mod.x = Abs(x);
+			mod.y = Abs(y);
+			mod.z = Abs(z);
+			mod.w = Abs(w);
+			break;
+		case Shader::MODIFIER_ABS_NEGATE:
+			mod.x = -Abs(x);
+			mod.y = -Abs(y);
+			mod.z = -Abs(z);
+			mod.w = -Abs(w);
+			break;
+		case Shader::MODIFIER_NOT:
+			mod.x = As<Float4>(As<Int4>(x) ^ Int4(0xFFFFFFFF));
+			mod.y = As<Float4>(As<Int4>(y) ^ Int4(0xFFFFFFFF));
+			mod.z = As<Float4>(As<Int4>(z) ^ Int4(0xFFFFFFFF));
+			mod.w = As<Float4>(As<Int4>(w) ^ Int4(0xFFFFFFFF));
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		return mod;
+	}
+
+	RValue<Pointer<Byte>> VertexProgram::uniformAddress(int bufferIndex, unsigned int index)
+	{
+		if(bufferIndex == -1)
+		{
+			return data + OFFSET(DrawData, vs.c[index]);
+		}
+		else
+		{
+			return *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, vs.u[bufferIndex])) + index;
+		}
+	}
+
+	RValue<Pointer<Byte>> VertexProgram::uniformAddress(int bufferIndex, unsigned int index, Int &offset)
+	{
+		return uniformAddress(bufferIndex, index) + offset * sizeof(float4);
+	}
+
+	Vector4f VertexProgram::readConstant(const Src &src, unsigned int offset)
+	{
+		Vector4f c;
+		unsigned int i = src.index + offset;
+
+		if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+		{
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i));
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+
+			if(shader->containsDefineInstruction())   // Constant may be known at compile time
+			{
+				for(size_t j = 0; j < shader->getLength(); j++)
+				{
+					const Shader::Instruction &instruction = *shader->getInstruction(j);
+
+					if(instruction.opcode == Shader::OPCODE_DEF)
+					{
+						if(instruction.dst.index == i)
+						{
+							c.x = Float4(instruction.src[0].value[0]);
+							c.y = Float4(instruction.src[0].value[1]);
+							c.z = Float4(instruction.src[0].value[2]);
+							c.w = Float4(instruction.src[0].value[3]);
+
+							break;
+						}
+					}
+				}
+			}
+		}
+		else if(!src.rel.dynamic || src.rel.type == Shader::PARAMETER_LOOP)
+		{
+			Int a = relativeAddress(src.rel, src.bufferIndex);
+
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, i, a));
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+		}
+		else
+		{
+			int component = src.rel.swizzle & 0x03;
+			Float4 a;
+
+			switch(src.rel.type)
+			{
+			case Shader::PARAMETER_ADDR:     a = a0[component]; break;
+			case Shader::PARAMETER_TEMP:     a = r[src.rel.index][component]; break;
+			case Shader::PARAMETER_INPUT:    a = v[src.rel.index][component]; break;
+			case Shader::PARAMETER_OUTPUT:   a = o[src.rel.index][component]; break;
+			case Shader::PARAMETER_CONST:    a = *Pointer<Float>(uniformAddress(src.bufferIndex, src.rel.index) + component * sizeof(float)); break;
+			case Shader::PARAMETER_MISCTYPE:
+				switch(src.rel.index)
+				{
+				case Shader::InstanceIDIndex: a = As<Float4>(Int4(instanceID)); break;
+				case Shader::VertexIDIndex:   a = As<Float4>(vertexID);         break;
+				default: ASSERT(false);
+				}
+				break;
+			default: ASSERT(false);
+			}
+
+			Int4 index = Int4(i) + As<Int4>(a) * Int4(src.rel.scale);
+
+			index = Min(As<UInt4>(index), UInt4(VERTEX_UNIFORM_VECTORS));   // Clamp to constant register range, c[VERTEX_UNIFORM_VECTORS] = {0, 0, 0, 0}
+
+			Int index0 = Extract(index, 0);
+			Int index1 = Extract(index, 1);
+			Int index2 = Extract(index, 2);
+			Int index3 = Extract(index, 3);
+
+			c.x = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index0), 16);
+			c.y = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index1), 16);
+			c.z = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index2), 16);
+			c.w = *Pointer<Float4>(uniformAddress(src.bufferIndex, 0, index3), 16);
+
+			transpose4x4(c.x, c.y, c.z, c.w);
+		}
+
+		return c;
+	}
+
+	Int VertexProgram::relativeAddress(const Shader::Relative &rel, int bufferIndex)
+	{
+		ASSERT(!rel.dynamic);
+
+		if(rel.type == Shader::PARAMETER_TEMP)
+		{
+			return As<Int>(Extract(r[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_INPUT)
+		{
+			return As<Int>(Extract(v[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_OUTPUT)
+		{
+			return As<Int>(Extract(o[rel.index].x, 0)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_CONST)
+		{
+			return *Pointer<Int>(uniformAddress(bufferIndex, rel.index)) * rel.scale;
+		}
+		else if(rel.type == Shader::PARAMETER_LOOP)
+		{
+			return aL[loopDepth];
+		}
+		else ASSERT(false);
+
+		return 0;
+	}
+
+	Int4 VertexProgram::dynamicAddress(const Shader::Relative &rel)
+	{
+		int component = rel.swizzle & 0x03;
+		Float4 a;
+
+		switch(rel.type)
+		{
+		case Shader::PARAMETER_ADDR:     a = a0[component]; break;
+		case Shader::PARAMETER_TEMP:     a = r[rel.index][component]; break;
+		case Shader::PARAMETER_INPUT:    a = v[rel.index][component]; break;
+		case Shader::PARAMETER_OUTPUT:   a = o[rel.index][component]; break;
+		case Shader::PARAMETER_MISCTYPE:
+			switch(rel.index)
+			{
+			case Shader::InstanceIDIndex: a = As<Float>(instanceID); break;
+			case Shader::VertexIDIndex:   a = As<Float4>(vertexID);  break;
+			default: ASSERT(false);
+			}
+			break;
+		default: ASSERT(false);
+		}
+
+		return As<Int4>(a) * Int4(rel.scale);
+	}
+
+	Int4 VertexProgram::enableMask(const Shader::Instruction *instruction)
+	{
+		Int4 enable = instruction->analysisBranch ? Int4(enableStack[enableIndex]) : Int4(0xFFFFFFFF);
+
+		if(!whileTest)
+		{
+			if(shader->containsBreakInstruction() && instruction->analysisBreak)
+			{
+				enable &= enableBreak;
+			}
+
+			if(shader->containsContinueInstruction() && instruction->analysisContinue)
+			{
+				enable &= enableContinue;
+			}
+
+			if(shader->containsLeaveInstruction() && instruction->analysisLeave)
+			{
+				enable &= enableLeave;
+			}
+		}
+
+		return enable;
+	}
+
+	void VertexProgram::M3X2(Vector4f &dst, Vector4f &src0, Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+	}
+
+	void VertexProgram::M3X3(Vector4f &dst, Vector4f &src0, Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+		dst.z = dot3(src0, row2);
+	}
+
+	void VertexProgram::M3X4(Vector4f &dst, Vector4f &src0, Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+		Vector4f row3 = fetchRegister(src1, 3);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+		dst.z = dot3(src0, row2);
+		dst.w = dot3(src0, row3);
+	}
+
+	void VertexProgram::M4X3(Vector4f &dst, Vector4f &src0, Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+	}
+
+	void VertexProgram::M4X4(Vector4f &dst, Vector4f &src0, Src &src1)
+	{
+		Vector4f row0 = fetchRegister(src1, 0);
+		Vector4f row1 = fetchRegister(src1, 1);
+		Vector4f row2 = fetchRegister(src1, 2);
+		Vector4f row3 = fetchRegister(src1, 3);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+		dst.w = dot4(src0, row3);
+	}
+
+	void VertexProgram::BREAK()
+	{
+		enableBreak = enableBreak & ~enableStack[enableIndex];
+	}
+
+	void VertexProgram::BREAKC(Vector4f &src0, Vector4f &src1, Control control)
+	{
+		Int4 condition;
+
+		switch(control)
+		{
+		case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+		case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);  break;
+		case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+		case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x);  break;
+		case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+		case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);  break;
+		default:
+			ASSERT(false);
+		}
+
+		BREAK(condition);
+	}
+
+	void VertexProgram::BREAKP(const Src &predicateRegister)   // FIXME: Factor out parts common with BREAKC
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		BREAK(condition);
+	}
+
+	void VertexProgram::BREAK(Int4 &condition)
+	{
+		condition &= enableStack[enableIndex];
+
+		enableBreak = enableBreak & ~condition;
+	}
+
+	void VertexProgram::CONTINUE()
+	{
+		enableContinue = enableContinue & ~enableStack[enableIndex];
+	}
+
+	void VertexProgram::TEST()
+	{
+		whileTest = true;
+	}
+
+	void VertexProgram::CALL(int labelIndex, int callSiteIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = enableLeave;
+
+		Nucleus::createBr(labelBlock[labelIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableLeave = restoreLeave;
+	}
+
+	void VertexProgram::CALLNZ(int labelIndex, int callSiteIndex, const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			CALLNZb(labelIndex, callSiteIndex, src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			CALLNZp(labelIndex, callSiteIndex, src);
+		}
+		else ASSERT(false);
+	}
+
+	void VertexProgram::CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister)
+	{
+		Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0));   // FIXME
+
+		if(boolRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = !condition;
+		}
+
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = enableLeave;
+
+		branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableLeave = restoreLeave;
+	}
+
+	void VertexProgram::CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		condition &= enableStack[enableIndex];
+
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			callStack[stackIndex++] = UInt(callSiteIndex);
+		}
+
+		enableIndex++;
+		enableStack[enableIndex] = condition;
+		Int4 restoreLeave = enableLeave;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		enableIndex--;
+		enableLeave = restoreLeave;
+	}
+
+	void VertexProgram::ELSE()
+	{
+		ifDepth--;
+
+		BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		if(isConditionalIf[ifDepth])
+		{
+			Int4 condition = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
+			Bool notAllFalse = SignMask(condition) != 0;
+
+			branch(notAllFalse, falseBlock, endBlock);
+
+			enableStack[enableIndex] = ~enableStack[enableIndex] & enableStack[enableIndex - 1];
+		}
+		else
+		{
+			Nucleus::createBr(endBlock);
+			Nucleus::setInsertBlock(falseBlock);
+		}
+
+		ifFalseBlock[ifDepth] = endBlock;
+
+		ifDepth++;
+	}
+
+	void VertexProgram::ENDIF()
+	{
+		ifDepth--;
+
+		BasicBlock *endBlock = ifFalseBlock[ifDepth];
+
+		Nucleus::createBr(endBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		if(isConditionalIf[ifDepth])
+		{
+			enableIndex--;
+		}
+	}
+
+	void VertexProgram::ENDLOOP()
+	{
+		loopRepDepth--;
+
+		aL[loopDepth] = aL[loopDepth] + increment[loopDepth];   // FIXME: +=
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		loopDepth--;
+		enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void VertexProgram::ENDREP()
+	{
+		loopRepDepth--;
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		loopDepth--;
+		enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void VertexProgram::ENDWHILE()
+	{
+		loopRepDepth--;
+
+		BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		enableIndex--;
+		whileTest = false;
+	}
+
+	void VertexProgram::ENDSWITCH()
+	{
+		loopRepDepth--;
+
+		BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(endBlock);
+		Nucleus::setInsertBlock(endBlock);
+	}
+
+	void VertexProgram::IF(const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			IFb(src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			IFp(src);
+		}
+		else
+		{
+			Int4 condition = As<Int4>(fetchRegister(src).x);
+			IF(condition);
+		}
+	}
+
+	void VertexProgram::IFb(const Src &boolRegister)
+	{
+		ASSERT(ifDepth < 24 + 4);
+
+		Bool condition = (*Pointer<Byte>(data + OFFSET(DrawData,vs.b[boolRegister.index])) != Byte(0));   // FIXME
+
+		if(boolRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = !condition;
+		}
+
+		BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		branch(condition, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = false;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+	}
+
+	void VertexProgram::IFp(const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		IF(condition);
+	}
+
+	void VertexProgram::IFC(Vector4f &src0, Vector4f &src1, Control control)
+	{
+		Int4 condition;
+
+		switch(control)
+		{
+		case Shader::CONTROL_GT: condition = CmpNLE(src0.x, src1.x); break;
+		case Shader::CONTROL_EQ: condition = CmpEQ(src0.x, src1.x);  break;
+		case Shader::CONTROL_GE: condition = CmpNLT(src0.x, src1.x); break;
+		case Shader::CONTROL_LT: condition = CmpLT(src0.x, src1.x);  break;
+		case Shader::CONTROL_NE: condition = CmpNEQ(src0.x, src1.x); break;
+		case Shader::CONTROL_LE: condition = CmpLE(src0.x, src1.x);  break;
+		default:
+			ASSERT(false);
+		}
+
+		IF(condition);
+	}
+
+	void VertexProgram::IF(Int4 &condition)
+	{
+		condition &= enableStack[enableIndex];
+
+		enableIndex++;
+		enableStack[enableIndex] = condition;
+
+		BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		Bool notAllFalse = SignMask(condition) != 0;
+
+		branch(notAllFalse, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = true;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+	}
+
+	void VertexProgram::LABEL(int labelIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		Nucleus::setInsertBlock(labelBlock[labelIndex]);
+		currentLabel = labelIndex;
+	}
+
+	void VertexProgram::LOOP(const Src &integerRegister)
+	{
+		loopDepth++;
+
+		iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+		aL[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][1]));
+		increment[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][2]));
+
+		// FIXME: Compiles to two instructions?
+		If(increment[loopDepth] == 0)
+		{
+			increment[loopDepth] = 1;
+		}
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(iteration[loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		iteration[loopDepth] = iteration[loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+	}
+
+	void VertexProgram::REP(const Src &integerRegister)
+	{
+		loopDepth++;
+
+		iteration[loopDepth] = *Pointer<Int>(data + OFFSET(DrawData,vs.i[integerRegister.index][0]));
+		aL[loopDepth] = aL[loopDepth - 1];
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(iteration[loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		iteration[loopDepth] = iteration[loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+	}
+
+	void VertexProgram::WHILE(const Src &temporaryRegister)
+	{
+		enableIndex++;
+
+		BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		BasicBlock *testBlock = Nucleus::createBasicBlock();
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		Int4 restoreBreak = enableBreak;
+		Int4 restoreContinue = enableContinue;
+
+		// TODO: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+		enableContinue = restoreContinue;
+
+		const Vector4f &src = fetchRegister(temporaryRegister);
+		Int4 condition = As<Int4>(src.x);
+		condition &= enableStack[enableIndex - 1];
+		if(shader->containsLeaveInstruction()) condition &= enableLeave;
+		if(shader->containsBreakInstruction()) condition &= enableBreak;
+		enableStack[enableIndex] = condition;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, loopBlock, endBlock);
+
+		Nucleus::setInsertBlock(endBlock);
+		enableBreak = restoreBreak;
+
+		Nucleus::setInsertBlock(loopBlock);
+
+		loopRepDepth++;
+	}
+
+	void VertexProgram::SWITCH()
+	{
+		BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = nullptr;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		Int4 restoreBreak = enableBreak;
+
+		BasicBlock *currentBlock = Nucleus::getInsertBlock();
+
+		Nucleus::setInsertBlock(endBlock);
+		enableBreak = restoreBreak;
+
+		Nucleus::setInsertBlock(currentBlock);
+
+		loopRepDepth++;
+	}
+
+	void VertexProgram::RET()
+	{
+		if(currentLabel == -1)
+		{
+			returnBlock = Nucleus::createBasicBlock();
+			Nucleus::createBr(returnBlock);
+		}
+		else
+		{
+			BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+
+			if(callRetBlock[currentLabel].size() > 1)   // Pop the return destination from the call stack
+			{
+				// FIXME: Encapsulate
+				UInt index = callStack[--stackIndex];
+
+				Value *value = index.loadValue();
+				SwitchCases *switchCases = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
+
+				for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
+				{
+					Nucleus::addSwitchCase(switchCases, i, callRetBlock[currentLabel][i]);
+				}
+			}
+			else if(callRetBlock[currentLabel].size() == 1)   // Jump directly to the unique return destination
+			{
+				Nucleus::createBr(callRetBlock[currentLabel][0]);
+			}
+			else   // Function isn't called
+			{
+				Nucleus::createBr(unreachableBlock);
+			}
+
+			Nucleus::setInsertBlock(unreachableBlock);
+			Nucleus::createUnreachable();
+		}
+	}
+
+	void VertexProgram::LEAVE()
+	{
+		enableLeave = enableLeave & ~enableStack[enableIndex];
+
+		// FIXME: Return from function if all instances left
+		// FIXME: Use enableLeave in other control-flow constructs
+	}
+
+	void VertexProgram::TEX(Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), (src0), Base);
+	}
+
+	void VertexProgram::TEXOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), (src0), (src0), offset, {Base, Offset});
+	}
+
+	void VertexProgram::TEXLOD(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Lod);
+	}
+
+	void VertexProgram::TEXLODOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Lod, Offset});
+	}
+
+	void VertexProgram::TEXELFETCH(Vector4f &dst, Vector4f &src0, const Src& src1, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), (src0), Fetch);
+	}
+
+	void VertexProgram::TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &offset, Float4 &lod)
+	{
+		dst = sampleTexture(src1, src0, lod, (src0), (src0), offset, {Fetch, Offset});
+	}
+
+	void VertexProgram::TEXGRAD(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, src0, Grad);
+	}
+
+	void VertexProgram::TEXGRADOFFSET(Vector4f &dst, Vector4f &src0, const Src& src1, Vector4f &dsx, Vector4f &dsy, Vector4f &offset)
+	{
+		dst = sampleTexture(src1, src0, (src0.x), dsx, dsy, offset, {Grad, Offset});
+	}
+
+	void VertexProgram::TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1)
+	{
+		Pointer<Byte> texture = data + OFFSET(DrawData, mipmap[TEXTURE_IMAGE_UNITS]) + src1.index * sizeof(Texture);
+		dst = SamplerCore::textureSize(texture, lod);
+	}
+
+	Vector4f VertexProgram::sampleTexture(const Src &s, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+	{
+		Vector4f tmp;
+
+		if(s.type == Shader::PARAMETER_SAMPLER && s.rel.type == Shader::PARAMETER_VOID)
+		{
+			tmp = sampleTexture(s.index, uvwq, lod, dsx, dsy, offset, function);
+		}
+		else
+		{
+			Int index = As<Int>(Float(fetchRegister(s).x.x));
+
+			for(int i = 0; i < VERTEX_TEXTURE_IMAGE_UNITS; i++)
+			{
+				if(shader->usesSampler(i))
+				{
+					If(index == i)
+					{
+						tmp = sampleTexture(i, uvwq, lod, dsx, dsy, offset, function);
+						// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
+					}
+				}
+			}
+		}
+
+		Vector4f c;
+		c.x = tmp[(s.swizzle >> 0) & 0x3];
+		c.y = tmp[(s.swizzle >> 2) & 0x3];
+		c.z = tmp[(s.swizzle >> 4) & 0x3];
+		c.w = tmp[(s.swizzle >> 6) & 0x3];
+
+		return c;
+	}
+
+	Vector4f VertexProgram::sampleTexture(int sampler, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function)
+	{
+		Pointer<Byte> texture = data + OFFSET(DrawData, mipmap[TEXTURE_IMAGE_UNITS]) + sampler * sizeof(Texture);
+		return SamplerCore(constants, state.sampler[sampler]).sampleTexture(texture, uvwq.x, uvwq.y, uvwq.z, uvwq.w, lod, dsx, dsy, offset, function);
+	}
+}
diff --git a/src/Pipeline/VertexProgram.hpp b/src/Pipeline/VertexProgram.hpp
new file mode 100644
index 0000000..3c4199c
--- /dev/null
+++ b/src/Pipeline/VertexProgram.hpp
@@ -0,0 +1,139 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_VertexProgram_hpp
+#define sw_VertexProgram_hpp
+
+#include "VertexRoutine.hpp"
+#include "ShaderCore.hpp"
+
+#include "SamplerCore.hpp"
+#include "Renderer/Stream.hpp"
+#include "Common/Types.hpp"
+
+namespace sw
+{
+	struct Stream;
+	class VertexShader;
+
+	class VertexProgram : public VertexRoutine, public ShaderCore
+	{
+	public:
+		VertexProgram(const VertexProcessor::State &state, const VertexShader *vertexShader);
+
+		virtual ~VertexProgram();
+
+	private:
+		const VertexShader *const shader;
+
+		RegisterArray<NUM_TEMPORARY_REGISTERS> r;   // Temporary registers
+		Vector4f a0;
+		Array<Int, 4> aL;
+		Vector4f p0;
+
+		Array<Int, 4> increment;
+		Array<Int, 4> iteration;
+
+		Int loopDepth;
+		Int stackIndex;   // FIXME: Inc/decrement callStack
+		Array<UInt, 16> callStack;
+
+		Int enableIndex;
+		Array<Int4, 1 + 24> enableStack;
+		Int4 enableBreak;
+		Int4 enableContinue;
+		Int4 enableLeave;
+
+		Int instanceID;
+		Int4 vertexID;
+
+		typedef Shader::DestinationParameter Dst;
+		typedef Shader::SourceParameter Src;
+		typedef Shader::Control Control;
+		typedef Shader::Usage Usage;
+
+		void pipeline(UInt &index) override;
+		void program(UInt &index);
+		void passThrough();
+
+		Vector4f fetchRegister(const Src &src, unsigned int offset = 0);
+		Vector4f readConstant(const Src &src, unsigned int offset = 0);
+		RValue<Pointer<Byte>> uniformAddress(int bufferIndex, unsigned int index);
+		RValue<Pointer<Byte>> uniformAddress(int bufferIndex, unsigned int index, Int &offset);
+		Int relativeAddress(const Shader::Relative &rel, int bufferIndex = -1);
+		Int4 dynamicAddress(const Shader::Relative &rel);
+		Int4 enableMask(const Shader::Instruction *instruction);
+
+		void M3X2(Vector4f &dst, Vector4f &src0, Src &src1);
+		void M3X3(Vector4f &dst, Vector4f &src0, Src &src1);
+		void M3X4(Vector4f &dst, Vector4f &src0, Src &src1);
+		void M4X3(Vector4f &dst, Vector4f &src0, Src &src1);
+		void M4X4(Vector4f &dst, Vector4f &src0, Src &src1);
+		void BREAK();
+		void BREAKC(Vector4f &src0, Vector4f &src1, Control);
+		void BREAKP(const Src &predicateRegister);
+		void BREAK(Int4 &condition);
+		void CONTINUE();
+		void TEST();
+		void CALL(int labelIndex, int callSiteIndex);
+		void CALLNZ(int labelIndex, int callSiteIndex, const Src &src);
+		void CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister);
+		void CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister);
+		void ELSE();
+		void ENDIF();
+		void ENDLOOP();
+		void ENDREP();
+		void ENDWHILE();
+		void ENDSWITCH();
+		void IF(const Src &src);
+		void IFb(const Src &boolRegister);
+		void IFp(const Src &predicateRegister);
+		void IFC(Vector4f &src0, Vector4f &src1, Control);
+		void IF(Int4 &condition);
+		void LABEL(int labelIndex);
+		void LOOP(const Src &integerRegister);
+		void REP(const Src &integerRegister);
+		void WHILE(const Src &temporaryRegister);
+		void SWITCH();
+		void RET();
+		void LEAVE();
+		void TEX(Vector4f &dst, Vector4f &src, const Src&);
+		void TEXOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset);
+		void TEXLOD(Vector4f &dst, Vector4f &src, const Src&, Float4 &lod);
+		void TEXLODOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset, Float4 &lod);
+		void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Float4 &lod);
+		void TEXELFETCHOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &offset, Float4 &lod);
+		void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &dsx, Vector4f &dsy);
+		void TEXGRADOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &dsx, Vector4f &dsy, Vector4f &offset);
+		void TEXSIZE(Vector4f &dst, Float4 &lod, const Src&);
+
+		Vector4f sampleTexture(const Src &s, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+		Vector4f sampleTexture(int sampler, Vector4f &uvwq, Float4 &lod, Vector4f &dsx, Vector4f &dsy, Vector4f &offset, SamplerFunction function);
+
+		int ifDepth;
+		int loopRepDepth;
+		int currentLabel;
+		bool whileTest;
+
+		BasicBlock *ifFalseBlock[24 + 24];
+		BasicBlock *loopRepTestBlock[4];
+		BasicBlock *loopRepEndBlock[4];
+		BasicBlock *labelBlock[2048];
+		std::vector<BasicBlock*> callRetBlock[2048];
+		BasicBlock *returnBlock;
+		bool isConditionalIf[24 + 24];
+	};
+}
+
+#endif   // sw_VertexProgram_hpp
diff --git a/src/Pipeline/VertexRoutine.cpp b/src/Pipeline/VertexRoutine.cpp
new file mode 100644
index 0000000..9b8d336
--- /dev/null
+++ b/src/Pipeline/VertexRoutine.cpp
@@ -0,0 +1,788 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VertexRoutine.hpp"
+
+#include "VertexShader.hpp"
+#include "Constants.hpp"
+#include "Renderer/Vertex.hpp"
+#include "Renderer/Renderer.hpp"
+#include "Common/Half.hpp"
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool halfIntegerCoordinates;     // Pixel centers are not at integer coordinates
+	extern bool symmetricNormalizedDepth;   // [-1, 1] instead of [0, 1]
+
+	VertexRoutine::VertexRoutine(const VertexProcessor::State &state, const VertexShader *shader)
+		: v(shader && shader->indirectAddressableInput),
+		  o(shader && shader->indirectAddressableOutput),
+		  state(state)
+	{
+	}
+
+	VertexRoutine::~VertexRoutine()
+	{
+	}
+
+	void VertexRoutine::generate()
+	{
+		const bool textureSampling = state.textureSampling;
+
+		Pointer<Byte> cache = task + OFFSET(VertexTask,vertexCache);
+		Pointer<Byte> vertexCache = cache + OFFSET(VertexCache,vertex);
+		Pointer<Byte> tagCache = cache + OFFSET(VertexCache,tag);
+
+		UInt vertexCount = *Pointer<UInt>(task + OFFSET(VertexTask,vertexCount));
+		UInt primitiveNumber = *Pointer<UInt>(task + OFFSET(VertexTask, primitiveStart));
+		UInt indexInPrimitive = 0;
+
+		constants = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,constants));
+
+		Do
+		{
+			UInt index = *Pointer<UInt>(batch);
+			UInt tagIndex = index & 0x0000003C;
+			UInt indexQ = !textureSampling ? UInt(index & 0xFFFFFFFC) : index;   // FIXME: TEXLDL hack to have independent LODs, hurts performance.
+
+			If(*Pointer<UInt>(tagCache + tagIndex) != indexQ)
+			{
+				*Pointer<UInt>(tagCache + tagIndex) = indexQ;
+
+				readInput(indexQ);
+				pipeline(indexQ);
+				postTransform();
+				computeClipFlags();
+
+				Pointer<Byte> cacheLine0 = vertexCache + tagIndex * UInt((int)sizeof(Vertex));
+				writeCache(cacheLine0);
+			}
+
+			UInt cacheIndex = index & 0x0000003F;
+			Pointer<Byte> cacheLine = vertexCache + cacheIndex * UInt((int)sizeof(Vertex));
+			writeVertex(vertex, cacheLine);
+
+			if(state.transformFeedbackEnabled != 0)
+			{
+				transformFeedback(vertex, primitiveNumber, indexInPrimitive);
+
+				indexInPrimitive++;
+				If(indexInPrimitive == 3)
+				{
+					primitiveNumber++;
+					indexInPrimitive = 0;
+				}
+			}
+
+			vertex += sizeof(Vertex);
+			batch += sizeof(unsigned int);
+			vertexCount--;
+		}
+		Until(vertexCount == 0)
+
+		Return();
+	}
+
+	void VertexRoutine::readInput(UInt &index)
+	{
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			Pointer<Byte> input = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData,input) + sizeof(void*) * i);
+			UInt stride = *Pointer<UInt>(data + OFFSET(DrawData,stride) + sizeof(unsigned int) * i);
+
+			v[i] = readStream(input, stride, state.input[i], index);
+		}
+	}
+
+	void VertexRoutine::computeClipFlags()
+	{
+		int pos = state.positionRegister;
+
+		Int4 maxX = CmpLT(o[pos].w, o[pos].x);
+		Int4 maxY = CmpLT(o[pos].w, o[pos].y);
+		Int4 maxZ = CmpLT(o[pos].w, o[pos].z);
+		Int4 minX = CmpNLE(-o[pos].w, o[pos].x);
+		Int4 minY = CmpNLE(-o[pos].w, o[pos].y);
+		Int4 minZ = symmetricNormalizedDepth ? CmpNLE(-o[pos].w, o[pos].z) : CmpNLE(Float4(0.0f), o[pos].z);
+
+		clipFlags = *Pointer<Int>(constants + OFFSET(Constants,maxX) + SignMask(maxX) * 4);   // FIXME: Array indexing
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxY) + SignMask(maxY) * 4);
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,maxZ) + SignMask(maxZ) * 4);
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minX) + SignMask(minX) * 4);
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minY) + SignMask(minY) * 4);
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,minZ) + SignMask(minZ) * 4);
+
+		Int4 finiteX = CmpLE(Abs(o[pos].x), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
+		Int4 finiteY = CmpLE(Abs(o[pos].y), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
+		Int4 finiteZ = CmpLE(Abs(o[pos].z), *Pointer<Float4>(constants + OFFSET(Constants,maxPos)));
+
+		Int4 finiteXYZ = finiteX & finiteY & finiteZ;
+		clipFlags |= *Pointer<Int>(constants + OFFSET(Constants,fini) + SignMask(finiteXYZ) * 4);
+
+		if(state.preTransformed)
+		{
+			clipFlags &= 0xFBFBFBFB;   // Don't clip against far clip plane
+		}
+	}
+
+	Vector4f VertexRoutine::readStream(Pointer<Byte> &buffer, UInt &stride, const Stream &stream, const UInt &index)
+	{
+		const bool textureSampling = state.textureSampling;
+
+		Vector4f v;
+
+		Pointer<Byte> source0 = buffer + index * stride;
+		Pointer<Byte> source1 = source0 + (!textureSampling ? stride : 0);
+		Pointer<Byte> source2 = source1 + (!textureSampling ? stride : 0);
+		Pointer<Byte> source3 = source2 + (!textureSampling ? stride : 0);
+
+		bool isNativeFloatAttrib = (stream.attribType == VertexShader::ATTRIBTYPE_FLOAT) || stream.normalized;
+
+		switch(stream.type)
+		{
+		case STREAMTYPE_FLOAT:
+			{
+				if(stream.count == 0)
+				{
+					// Null stream, all default components
+				}
+				else
+				{
+					if(stream.count == 1)
+					{
+						v.x.x = *Pointer<Float>(source0);
+						v.x.y = *Pointer<Float>(source1);
+						v.x.z = *Pointer<Float>(source2);
+						v.x.w = *Pointer<Float>(source3);
+					}
+					else
+					{
+						v.x = *Pointer<Float4>(source0);
+						v.y = *Pointer<Float4>(source1);
+						v.z = *Pointer<Float4>(source2);
+						v.w = *Pointer<Float4>(source3);
+
+						transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+					}
+
+					switch(stream.attribType)
+					{
+					case VertexShader::ATTRIBTYPE_INT:
+						if(stream.count >= 1) v.x = As<Float4>(Int4(v.x));
+						if(stream.count >= 2) v.x = As<Float4>(Int4(v.y));
+						if(stream.count >= 3) v.x = As<Float4>(Int4(v.z));
+						if(stream.count >= 4) v.x = As<Float4>(Int4(v.w));
+						break;
+					case VertexShader::ATTRIBTYPE_UINT:
+						if(stream.count >= 1) v.x = As<Float4>(UInt4(v.x));
+						if(stream.count >= 2) v.x = As<Float4>(UInt4(v.y));
+						if(stream.count >= 3) v.x = As<Float4>(UInt4(v.z));
+						if(stream.count >= 4) v.x = As<Float4>(UInt4(v.w));
+						break;
+					default:
+						break;
+					}
+				}
+			}
+			break;
+		case STREAMTYPE_BYTE:
+			if(isNativeFloatAttrib) // Stream: UByte, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<Byte4>(source0));
+				v.y = Float4(*Pointer<Byte4>(source1));
+				v.z = Float4(*Pointer<Byte4>(source2));
+				v.w = Float4(*Pointer<Byte4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+				}
+			}
+			else // Stream: UByte, Shader attrib: Int / UInt
+			{
+				v.x = As<Float4>(Int4(*Pointer<Byte4>(source0)));
+				v.y = As<Float4>(Int4(*Pointer<Byte4>(source1)));
+				v.z = As<Float4>(Int4(*Pointer<Byte4>(source2)));
+				v.w = As<Float4>(Int4(*Pointer<Byte4>(source3)));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_SBYTE:
+			if(isNativeFloatAttrib) // Stream: SByte, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<SByte4>(source0));
+				v.y = Float4(*Pointer<SByte4>(source1));
+				v.z = Float4(*Pointer<SByte4>(source2));
+				v.w = Float4(*Pointer<SByte4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleSByte));
+				}
+			}
+			else // Stream: SByte, Shader attrib: Int / UInt
+			{
+				v.x = As<Float4>(Int4(*Pointer<SByte4>(source0)));
+				v.y = As<Float4>(Int4(*Pointer<SByte4>(source1)));
+				v.z = As<Float4>(Int4(*Pointer<SByte4>(source2)));
+				v.w = As<Float4>(Int4(*Pointer<SByte4>(source3)));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_COLOR:
+			{
+				v.x = Float4(*Pointer<Byte4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+				v.y = Float4(*Pointer<Byte4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+				v.z = Float4(*Pointer<Byte4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+				v.w = Float4(*Pointer<Byte4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleByte));
+
+				transpose4x4(v.x, v.y, v.z, v.w);
+
+				// Swap red and blue
+				Float4 t = v.x;
+				v.x = v.z;
+				v.z = t;
+			}
+			break;
+		case STREAMTYPE_SHORT:
+			if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<Short4>(source0));
+				v.y = Float4(*Pointer<Short4>(source1));
+				v.z = Float4(*Pointer<Short4>(source2));
+				v.w = Float4(*Pointer<Short4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleShort));
+				}
+			}
+			else // Stream: Short, Shader attrib: Int/UInt, no type conversion
+			{
+				v.x = As<Float4>(Int4(*Pointer<Short4>(source0)));
+				v.y = As<Float4>(Int4(*Pointer<Short4>(source1)));
+				v.z = As<Float4>(Int4(*Pointer<Short4>(source2)));
+				v.w = As<Float4>(Int4(*Pointer<Short4>(source3)));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_USHORT:
+			if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<UShort4>(source0));
+				v.y = Float4(*Pointer<UShort4>(source1));
+				v.z = Float4(*Pointer<UShort4>(source2));
+				v.w = Float4(*Pointer<UShort4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants,unscaleUShort));
+				}
+			}
+			else // Stream: UShort, Shader attrib: Int/UInt, no type conversion
+			{
+				v.x = As<Float4>(Int4(*Pointer<UShort4>(source0)));
+				v.y = As<Float4>(Int4(*Pointer<UShort4>(source1)));
+				v.z = As<Float4>(Int4(*Pointer<UShort4>(source2)));
+				v.w = As<Float4>(Int4(*Pointer<UShort4>(source3)));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_INT:
+			if(isNativeFloatAttrib) // Stream: Int, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<Int4>(source0));
+				v.y = Float4(*Pointer<Int4>(source1));
+				v.z = Float4(*Pointer<Int4>(source2));
+				v.w = Float4(*Pointer<Int4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleInt));
+				}
+			}
+			else // Stream: Int, Shader attrib: Int/UInt, no type conversion
+			{
+				v.x = *Pointer<Float4>(source0);
+				v.y = *Pointer<Float4>(source1);
+				v.z = *Pointer<Float4>(source2);
+				v.w = *Pointer<Float4>(source3);
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_UINT:
+			if(isNativeFloatAttrib) // Stream: UInt, Shader attrib: Float
+			{
+				v.x = Float4(*Pointer<UInt4>(source0));
+				v.y = Float4(*Pointer<UInt4>(source1));
+				v.z = Float4(*Pointer<UInt4>(source2));
+				v.w = Float4(*Pointer<UInt4>(source3));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+
+				if(stream.normalized)
+				{
+					if(stream.count >= 1) v.x *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
+					if(stream.count >= 2) v.y *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
+					if(stream.count >= 3) v.z *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
+					if(stream.count >= 4) v.w *= *Pointer<Float4>(constants + OFFSET(Constants, unscaleUInt));
+				}
+			}
+			else // Stream: UInt, Shader attrib: Int/UInt, no type conversion
+			{
+				v.x = *Pointer<Float4>(source0);
+				v.y = *Pointer<Float4>(source1);
+				v.z = *Pointer<Float4>(source2);
+				v.w = *Pointer<Float4>(source3);
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_UDEC3:
+			{
+				// FIXME: Vectorize
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source0);
+
+					v.x.x = Float(x & 0x000003FF);
+					v.x.y = Float(y & 0x000FFC00);
+					v.x.z = Float(z & 0x3FF00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source1);
+
+					v.y.x = Float(x & 0x000003FF);
+					v.y.y = Float(y & 0x000FFC00);
+					v.y.z = Float(z & 0x3FF00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source2);
+
+					v.z.x = Float(x & 0x000003FF);
+					v.z.y = Float(y & 0x000FFC00);
+					v.z.z = Float(z & 0x3FF00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source3);
+
+					v.w.x = Float(x & 0x000003FF);
+					v.w.y = Float(y & 0x000FFC00);
+					v.w.z = Float(z & 0x3FF00000);
+				}
+
+				transpose4x3(v.x, v.y, v.z, v.w);
+
+				v.y *= Float4(1.0f / 0x00000400);
+				v.z *= Float4(1.0f / 0x00100000);
+			}
+			break;
+		case STREAMTYPE_DEC3N:
+			{
+				// FIXME: Vectorize
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source0);
+
+					v.x.x = Float((x << 22) & 0xFFC00000);
+					v.x.y = Float((y << 12) & 0xFFC00000);
+					v.x.z = Float((z << 2)  & 0xFFC00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source1);
+
+					v.y.x = Float((x << 22) & 0xFFC00000);
+					v.y.y = Float((y << 12) & 0xFFC00000);
+					v.y.z = Float((z << 2)  & 0xFFC00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source2);
+
+					v.z.x = Float((x << 22) & 0xFFC00000);
+					v.z.y = Float((y << 12) & 0xFFC00000);
+					v.z.z = Float((z << 2)  & 0xFFC00000);
+				}
+
+				{
+					Int x, y, z;
+
+					x = y = z = *Pointer<Int>(source3);
+
+					v.w.x = Float((x << 22) & 0xFFC00000);
+					v.w.y = Float((y << 12) & 0xFFC00000);
+					v.w.z = Float((z << 2)  & 0xFFC00000);
+				}
+
+				transpose4x3(v.x, v.y, v.z, v.w);
+
+				v.x *= Float4(1.0f / 0x00400000 / 511.0f);
+				v.y *= Float4(1.0f / 0x00400000 / 511.0f);
+				v.z *= Float4(1.0f / 0x00400000 / 511.0f);
+			}
+			break;
+		case STREAMTYPE_FIXED:
+			{
+				v.x = Float4(*Pointer<Int4>(source0)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+				v.y = Float4(*Pointer<Int4>(source1)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+				v.z = Float4(*Pointer<Int4>(source2)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+				v.w = Float4(*Pointer<Int4>(source3)) * *Pointer<Float4>(constants + OFFSET(Constants,unscaleFixed));
+
+				transpose4xN(v.x, v.y, v.z, v.w, stream.count);
+			}
+			break;
+		case STREAMTYPE_HALF:
+			{
+				if(stream.count >= 1)
+				{
+					UShort x0 = *Pointer<UShort>(source0 + 0);
+					UShort x1 = *Pointer<UShort>(source1 + 0);
+					UShort x2 = *Pointer<UShort>(source2 + 0);
+					UShort x3 = *Pointer<UShort>(source3 + 0);
+
+					v.x.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x0) * 4);
+					v.x.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x1) * 4);
+					v.x.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x2) * 4);
+					v.x.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(x3) * 4);
+				}
+
+				if(stream.count >= 2)
+				{
+					UShort y0 = *Pointer<UShort>(source0 + 2);
+					UShort y1 = *Pointer<UShort>(source1 + 2);
+					UShort y2 = *Pointer<UShort>(source2 + 2);
+					UShort y3 = *Pointer<UShort>(source3 + 2);
+
+					v.y.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y0) * 4);
+					v.y.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y1) * 4);
+					v.y.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y2) * 4);
+					v.y.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(y3) * 4);
+				}
+
+				if(stream.count >= 3)
+				{
+					UShort z0 = *Pointer<UShort>(source0 + 4);
+					UShort z1 = *Pointer<UShort>(source1 + 4);
+					UShort z2 = *Pointer<UShort>(source2 + 4);
+					UShort z3 = *Pointer<UShort>(source3 + 4);
+
+					v.z.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z0) * 4);
+					v.z.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z1) * 4);
+					v.z.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z2) * 4);
+					v.z.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(z3) * 4);
+				}
+
+				if(stream.count >= 4)
+				{
+					UShort w0 = *Pointer<UShort>(source0 + 6);
+					UShort w1 = *Pointer<UShort>(source1 + 6);
+					UShort w2 = *Pointer<UShort>(source2 + 6);
+					UShort w3 = *Pointer<UShort>(source3 + 6);
+
+					v.w.x = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w0) * 4);
+					v.w.y = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w1) * 4);
+					v.w.z = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w2) * 4);
+					v.w.w = *Pointer<Float>(constants + OFFSET(Constants,half2float) + Int(w3) * 4);
+				}
+			}
+			break;
+		case STREAMTYPE_INDICES:
+			{
+				v.x.x = *Pointer<Float>(source0);
+				v.x.y = *Pointer<Float>(source1);
+				v.x.z = *Pointer<Float>(source2);
+				v.x.w = *Pointer<Float>(source3);
+			}
+			break;
+		case STREAMTYPE_2_10_10_10_INT:
+			{
+				Int4 src;
+				src = Insert(src, *Pointer<Int>(source0), 0);
+				src = Insert(src, *Pointer<Int>(source1), 1);
+				src = Insert(src, *Pointer<Int>(source2), 2);
+				src = Insert(src, *Pointer<Int>(source3), 3);
+
+				v.x = Float4((src << 22) >> 22);
+				v.y = Float4((src << 12) >> 22);
+				v.z = Float4((src << 02) >> 22);
+				v.w = Float4(src >> 30);
+
+				if(stream.normalized)
+				{
+					v.x = Max(v.x * Float4(1.0f / 0x1FF), Float4(-1.0f));
+					v.y = Max(v.y * Float4(1.0f / 0x1FF), Float4(-1.0f));
+					v.z = Max(v.z * Float4(1.0f / 0x1FF), Float4(-1.0f));
+					v.w = Max(v.w, Float4(-1.0f));
+				}
+			}
+			break;
+		case STREAMTYPE_2_10_10_10_UINT:
+			{
+				Int4 src;
+				src = Insert(src, *Pointer<Int>(source0), 0);
+				src = Insert(src, *Pointer<Int>(source1), 1);
+				src = Insert(src, *Pointer<Int>(source2), 2);
+				src = Insert(src, *Pointer<Int>(source3), 3);
+
+				v.x = Float4(src & Int4(0x3FF));
+				v.y = Float4((src >> 10) & Int4(0x3FF));
+				v.z = Float4((src >> 20) & Int4(0x3FF));
+				v.w = Float4((src >> 30) & Int4(0x3));
+
+				if(stream.normalized)
+				{
+					v.x *= Float4(1.0f / 0x3FF);
+					v.y *= Float4(1.0f / 0x3FF);
+					v.z *= Float4(1.0f / 0x3FF);
+					v.w *= Float4(1.0f / 0x3);
+				}
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+
+		if(stream.count < 1) v.x = Float4(0.0f);
+		if(stream.count < 2) v.y = Float4(0.0f);
+		if(stream.count < 3) v.z = Float4(0.0f);
+		if(stream.count < 4) v.w = isNativeFloatAttrib ? As<Float4>(Float4(1.0f)) : As<Float4>(Int4(0));
+
+		return v;
+	}
+
+	void VertexRoutine::postTransform()
+	{
+		int pos = state.positionRegister;
+
+		// Backtransform
+		if(state.preTransformed)
+		{
+			Float4 rhw = Float4(1.0f) / o[pos].w;
+
+			Float4 W = *Pointer<Float4>(data + OFFSET(DrawData,Wx16)) * Float4(1.0f / 16.0f);
+			Float4 H = *Pointer<Float4>(data + OFFSET(DrawData,Hx16)) * Float4(1.0f / 16.0f);
+			Float4 L = *Pointer<Float4>(data + OFFSET(DrawData,X0x16)) * Float4(1.0f / 16.0f);
+			Float4 T = *Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) * Float4(1.0f / 16.0f);
+
+			o[pos].x = (o[pos].x - L) / W * rhw;
+			o[pos].y = (o[pos].y - T) / H * rhw;
+			o[pos].z = o[pos].z * rhw;
+			o[pos].w = rhw;
+		}
+
+		if(!halfIntegerCoordinates && !state.preTransformed)
+		{
+			o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelX)) * o[pos].w;
+			o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,halfPixelY)) * o[pos].w;
+		}
+
+		if(state.superSampling)
+		{
+			o[pos].x = o[pos].x + *Pointer<Float4>(data + OFFSET(DrawData,XXXX)) * o[pos].w;
+			o[pos].y = o[pos].y + *Pointer<Float4>(data + OFFSET(DrawData,YYYY)) * o[pos].w;
+		}
+	}
+
+	void VertexRoutine::writeCache(Pointer<Byte> &cacheLine)
+	{
+		Vector4f v;
+
+		for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
+		{
+			if(state.output[i].write)
+			{
+				v.x = o[i].x;
+				v.y = o[i].y;
+				v.z = o[i].z;
+				v.w = o[i].w;
+
+				if(state.output[i].xClamp)
+				{
+					v.x = Max(v.x, Float4(0.0f));
+					v.x = Min(v.x, Float4(1.0f));
+				}
+
+				if(state.output[i].yClamp)
+				{
+					v.y = Max(v.y, Float4(0.0f));
+					v.y = Min(v.y, Float4(1.0f));
+				}
+
+				if(state.output[i].zClamp)
+				{
+					v.z = Max(v.z, Float4(0.0f));
+					v.z = Min(v.z, Float4(1.0f));
+				}
+
+				if(state.output[i].wClamp)
+				{
+					v.w = Max(v.w, Float4(0.0f));
+					v.w = Min(v.w, Float4(1.0f));
+				}
+
+				if(state.output[i].write == 0x01)
+				{
+					*Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0) = v.x.x;
+					*Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1) = v.x.y;
+					*Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2) = v.x.z;
+					*Pointer<Float>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3) = v.x.w;
+				}
+				else
+				{
+					if(state.output[i].write == 0x03)
+					{
+						transpose2x4(v.x, v.y, v.z, v.w);
+					}
+					else
+					{
+						transpose4x4(v.x, v.y, v.z, v.w);
+					}
+
+					*Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 0, 16) = v.x;
+					*Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 1, 16) = v.y;
+					*Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 2, 16) = v.z;
+					*Pointer<Float4>(cacheLine + OFFSET(Vertex,v[i]) + sizeof(Vertex) * 3, 16) = v.w;
+				}
+			}
+		}
+
+		*Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 0) = (clipFlags >> 0)  & 0x0000000FF;
+		*Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 1) = (clipFlags >> 8)  & 0x0000000FF;
+		*Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 2) = (clipFlags >> 16) & 0x0000000FF;
+		*Pointer<Int>(cacheLine + OFFSET(Vertex,clipFlags) + sizeof(Vertex) * 3) = (clipFlags >> 24) & 0x0000000FF;
+
+		// Viewport transform
+		int pos = state.positionRegister;
+
+		v.x = o[pos].x;
+		v.y = o[pos].y;
+		v.z = o[pos].z;
+		v.w = o[pos].w;
+
+		if(symmetricNormalizedDepth)
+		{
+			v.z = (v.z + v.w) * Float4(0.5f);   // [-1, 1] -> [0, 1]
+		}
+
+		Float4 w = As<Float4>(As<Int4>(v.w) | (As<Int4>(CmpEQ(v.w, Float4(0.0f))) & As<Int4>(Float4(1.0f))));
+		Float4 rhw = Float4(1.0f) / w;
+
+		v.x = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,X0x16)) + v.x * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Wx16))));
+		v.y = As<Float4>(RoundInt(*Pointer<Float4>(data + OFFSET(DrawData,Y0x16)) + v.y * rhw * *Pointer<Float4>(data + OFFSET(DrawData,Hx16))));
+		v.z = v.z * rhw;
+		v.w = rhw;
+
+		transpose4x4(v.x, v.y, v.z, v.w);
+
+		*Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 0, 16) = v.x;
+		*Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 1, 16) = v.y;
+		*Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 2, 16) = v.z;
+		*Pointer<Float4>(cacheLine + OFFSET(Vertex,X) + sizeof(Vertex) * 3, 16) = v.w;
+	}
+
+	void VertexRoutine::writeVertex(const Pointer<Byte> &vertex, Pointer<Byte> &cache)
+	{
+		for(int i = 0; i < MAX_VERTEX_OUTPUTS; i++)
+		{
+			if(state.output[i].write)
+			{
+				*Pointer<Int4>(vertex + OFFSET(Vertex,v[i]), 16) = *Pointer<Int4>(cache + OFFSET(Vertex,v[i]), 16);
+			}
+		}
+
+		*Pointer<Int4>(vertex + OFFSET(Vertex,X)) = *Pointer<Int4>(cache + OFFSET(Vertex,X));
+		*Pointer<Int>(vertex + OFFSET(Vertex,clipFlags)) = *Pointer<Int>(cache + OFFSET(Vertex,clipFlags));
+	}
+
+	void VertexRoutine::transformFeedback(const Pointer<Byte> &vertex, const UInt &primitiveNumber, const UInt &indexInPrimitive)
+	{
+		If(indexInPrimitive < state.verticesPerPrimitive)
+		{
+			UInt tOffset = primitiveNumber * state.verticesPerPrimitive + indexInPrimitive;
+
+			for(int i = 0; i < MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS; i++)
+			{
+				if(state.transformFeedbackEnabled & (1ULL << i))
+				{
+					UInt reg = *Pointer<UInt>(data + OFFSET(DrawData, vs.reg[i]));
+					UInt row = *Pointer<UInt>(data + OFFSET(DrawData, vs.row[i]));
+					UInt col = *Pointer<UInt>(data + OFFSET(DrawData, vs.col[i]));
+					UInt str = *Pointer<UInt>(data + OFFSET(DrawData, vs.str[i]));
+
+					Pointer<Byte> t = *Pointer<Pointer<Byte>>(data + OFFSET(DrawData, vs.t[i])) + (tOffset * str * sizeof(float));
+					Pointer<Byte> v = vertex + OFFSET(Vertex, v) + reg * sizeof(float);
+
+					For(UInt r = 0, r < row, r++)
+					{
+						UInt rOffsetX = r * col * sizeof(float);
+						UInt rOffset4 = r * sizeof(float4);
+
+						For(UInt c = 0, c < col, c++)
+						{
+							UInt cOffset = c * sizeof(float);
+							*Pointer<Float>(t + rOffsetX + cOffset) = *Pointer<Float>(v + rOffset4 + cOffset);
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/Pipeline/VertexRoutine.hpp b/src/Pipeline/VertexRoutine.hpp
new file mode 100644
index 0000000..905118b
--- /dev/null
+++ b/src/Pipeline/VertexRoutine.hpp
@@ -0,0 +1,71 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_VertexRoutine_hpp
+#define sw_VertexRoutine_hpp
+
+#include "Renderer/Color.hpp"
+#include "Renderer/VertexProcessor.hpp"
+#include "ShaderCore.hpp"
+#include "VertexShader.hpp"
+
+namespace sw
+{
+	class VertexRoutinePrototype : public Function<Void(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)>
+	{
+	public:
+		VertexRoutinePrototype() : vertex(Arg<0>()), batch(Arg<1>()), task(Arg<2>()), data(Arg<3>()) {}
+		virtual ~VertexRoutinePrototype() {};
+
+	protected:
+		Pointer<Byte> vertex;
+		Pointer<Byte> batch;
+		Pointer<Byte> task;
+		Pointer<Byte> data;
+	};
+
+	class VertexRoutine : public VertexRoutinePrototype
+	{
+	public:
+		VertexRoutine(const VertexProcessor::State &state, const VertexShader *shader);
+		virtual ~VertexRoutine();
+
+		void generate();
+
+	protected:
+		Pointer<Byte> constants;
+
+		Int clipFlags;
+
+		RegisterArray<MAX_VERTEX_INPUTS> v;    // Input registers
+		RegisterArray<MAX_VERTEX_OUTPUTS> o;   // Output registers
+
+		const VertexProcessor::State &state;
+
+	private:
+		virtual void pipeline(UInt &index) = 0;
+
+		typedef VertexProcessor::State::Input Stream;
+
+		Vector4f readStream(Pointer<Byte> &buffer, UInt &stride, const Stream &stream, const UInt &index);
+		void readInput(UInt &index);
+		void computeClipFlags();
+		void postTransform();
+		void writeCache(Pointer<Byte> &cacheLine);
+		void writeVertex(const Pointer<Byte> &vertex, Pointer<Byte> &cacheLine);
+		void transformFeedback(const Pointer<Byte> &vertex, const UInt &primitiveNumber, const UInt &indexInPrimitive);
+	};
+}
+
+#endif   // sw_VertexRoutine_hpp
diff --git a/src/Pipeline/VertexShader.cpp b/src/Pipeline/VertexShader.cpp
new file mode 100644
index 0000000..8f1c4f8
--- /dev/null
+++ b/src/Pipeline/VertexShader.cpp
@@ -0,0 +1,330 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VertexShader.hpp"
+
+#include "Renderer/Vertex.hpp"
+#include "Common/Debug.hpp"
+
+#include <string.h>
+
+namespace sw
+{
+	VertexShader::VertexShader(const VertexShader *vs) : Shader()
+	{
+		shaderModel = 0x0300;
+		positionRegister = Pos;
+		pointSizeRegister = Unused;
+		instanceIdDeclared = false;
+		vertexIdDeclared = false;
+		textureSampling = false;
+
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			input[i] = Semantic();
+			attribType[i] = ATTRIBTYPE_FLOAT;
+		}
+
+		if(vs)   // Make a copy
+		{
+			for(size_t i = 0; i < vs->getLength(); i++)
+			{
+				append(new sw::Shader::Instruction(*vs->getInstruction(i)));
+			}
+
+			memcpy(output, vs->output, sizeof(output));
+			memcpy(input, vs->input, sizeof(input));
+			memcpy(attribType, vs->attribType, sizeof(attribType));
+			positionRegister = vs->positionRegister;
+			pointSizeRegister = vs->pointSizeRegister;
+			instanceIdDeclared = vs->instanceIdDeclared;
+			vertexIdDeclared = vs->vertexIdDeclared;
+			usedSamplers = vs->usedSamplers;
+
+			optimize();
+			analyze();
+		}
+	}
+
+	VertexShader::VertexShader(const unsigned long *token) : Shader()
+	{
+		parse(token);
+
+		positionRegister = Pos;
+		pointSizeRegister = Unused;
+		instanceIdDeclared = false;
+		vertexIdDeclared = false;
+		textureSampling = false;
+
+		for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
+		{
+			input[i] = Semantic();
+			attribType[i] = ATTRIBTYPE_FLOAT;
+		}
+
+		optimize();
+		analyze();
+	}
+
+	VertexShader::~VertexShader()
+	{
+	}
+
+	int VertexShader::validate(const unsigned long *const token)
+	{
+		if(!token)
+		{
+			return 0;
+		}
+
+		unsigned short version = (unsigned short)(token[0] & 0x0000FFFF);
+		unsigned char majorVersion = (unsigned char)((token[0] & 0x0000FF00) >> 8);
+		ShaderType shaderType = (ShaderType)((token[0] & 0xFFFF0000) >> 16);
+
+		if(shaderType != SHADER_VERTEX || majorVersion > 3)
+		{
+			return 0;
+		}
+
+		int instructionCount = 1;
+
+		for(int i = 0; token[i] != 0x0000FFFF; i++)
+		{
+			if((token[i] & 0x0000FFFF) == 0x0000FFFE)   // Comment token
+			{
+				int length = (token[i] & 0x7FFF0000) >> 16;
+
+				i += length;
+			}
+			else
+			{
+				Shader::Opcode opcode = (Shader::Opcode)(token[i] & 0x0000FFFF);
+
+				switch(opcode)
+				{
+				case Shader::OPCODE_TEXCOORD:
+				case Shader::OPCODE_TEXKILL:
+				case Shader::OPCODE_TEX:
+				case Shader::OPCODE_TEXBEM:
+				case Shader::OPCODE_TEXBEML:
+				case Shader::OPCODE_TEXREG2AR:
+				case Shader::OPCODE_TEXREG2GB:
+				case Shader::OPCODE_TEXM3X2PAD:
+				case Shader::OPCODE_TEXM3X2TEX:
+				case Shader::OPCODE_TEXM3X3PAD:
+				case Shader::OPCODE_TEXM3X3TEX:
+				case Shader::OPCODE_RESERVED0:
+				case Shader::OPCODE_TEXM3X3SPEC:
+				case Shader::OPCODE_TEXM3X3VSPEC:
+				case Shader::OPCODE_TEXREG2RGB:
+				case Shader::OPCODE_TEXDP3TEX:
+				case Shader::OPCODE_TEXM3X2DEPTH:
+				case Shader::OPCODE_TEXDP3:
+				case Shader::OPCODE_TEXM3X3:
+				case Shader::OPCODE_TEXDEPTH:
+				case Shader::OPCODE_CMP0:
+				case Shader::OPCODE_BEM:
+				case Shader::OPCODE_DP2ADD:
+				case Shader::OPCODE_DFDX:
+				case Shader::OPCODE_DFDY:
+				case Shader::OPCODE_TEXLDD:
+					return 0;   // Unsupported operation
+				default:
+					instructionCount++;
+					break;
+				}
+
+				i += size(token[i], version);
+			}
+		}
+
+		return instructionCount;
+	}
+
+	bool VertexShader::containsTextureSampling() const
+	{
+		return textureSampling;
+	}
+
+	void VertexShader::setInput(int inputIdx, const sw::Shader::Semantic& semantic, AttribType aType)
+	{
+		input[inputIdx] = semantic;
+		attribType[inputIdx] = aType;
+	}
+
+	void VertexShader::setOutput(int outputIdx, int nbComponents, const sw::Shader::Semantic& semantic)
+	{
+		for(int i = 0; i < nbComponents; ++i)
+		{
+			output[outputIdx][i] = semantic;
+		}
+	}
+
+	void VertexShader::setPositionRegister(int posReg)
+	{
+		setOutput(posReg, 4, sw::Shader::Semantic(sw::Shader::USAGE_POSITION, 0));
+		positionRegister = posReg;
+	}
+
+	void VertexShader::setPointSizeRegister(int ptSizeReg)
+	{
+		setOutput(ptSizeReg, 4, sw::Shader::Semantic(sw::Shader::USAGE_PSIZE, 0));
+		pointSizeRegister = ptSizeReg;
+	}
+
+	const sw::Shader::Semantic& VertexShader::getInput(int inputIdx) const
+	{
+		return input[inputIdx];
+	}
+
+	VertexShader::AttribType VertexShader::getAttribType(int inputIdx) const
+	{
+		return attribType[inputIdx];
+	}
+
+	const sw::Shader::Semantic& VertexShader::getOutput(int outputIdx, int component) const
+	{
+		return output[outputIdx][component];
+	}
+
+	void VertexShader::analyze()
+	{
+		analyzeInput();
+		analyzeOutput();
+		analyzeDirtyConstants();
+		analyzeTextureSampling();
+		analyzeDynamicBranching();
+		analyzeSamplers();
+		analyzeCallSites();
+		analyzeIndirectAddressing();
+	}
+
+	void VertexShader::analyzeInput()
+	{
+		for(unsigned int i = 0; i < instruction.size(); i++)
+		{
+			if(instruction[i]->opcode == Shader::OPCODE_DCL &&
+			   instruction[i]->dst.type == Shader::PARAMETER_INPUT)
+			{
+				int index = instruction[i]->dst.index;
+
+				input[index] = Semantic(instruction[i]->usage, instruction[i]->usageIndex);
+			}
+		}
+	}
+
+	void VertexShader::analyzeOutput()
+	{
+		if(shaderModel < 0x0300)
+		{
+			output[Pos][0] = Semantic(Shader::USAGE_POSITION, 0);
+			output[Pos][1] = Semantic(Shader::USAGE_POSITION, 0);
+			output[Pos][2] = Semantic(Shader::USAGE_POSITION, 0);
+			output[Pos][3] = Semantic(Shader::USAGE_POSITION, 0);
+
+			for(const auto &inst : instruction)
+			{
+				const DestinationParameter &dst = inst->dst;
+
+				switch(dst.type)
+				{
+				case Shader::PARAMETER_RASTOUT:
+					switch(dst.index)
+					{
+					case 0:
+						// Position already assumed written
+						break;
+					case 1:
+						output[Fog][0] = Semantic(Shader::USAGE_FOG, 0);
+						break;
+					case 2:
+						output[Pts][1] = Semantic(Shader::USAGE_PSIZE, 0);
+						pointSizeRegister = Pts;
+						break;
+					default: ASSERT(false);
+					}
+					break;
+				case Shader::PARAMETER_ATTROUT:
+					if(dst.index == 0)
+					{
+						if(dst.x) output[C0][0] = Semantic(Shader::USAGE_COLOR, 0);
+						if(dst.y) output[C0][1] = Semantic(Shader::USAGE_COLOR, 0);
+						if(dst.z) output[C0][2] = Semantic(Shader::USAGE_COLOR, 0);
+						if(dst.w) output[C0][3] = Semantic(Shader::USAGE_COLOR, 0);
+					}
+					else if(dst.index == 1)
+					{
+						if(dst.x) output[C1][0] = Semantic(Shader::USAGE_COLOR, 1);
+						if(dst.y) output[C1][1] = Semantic(Shader::USAGE_COLOR, 1);
+						if(dst.z) output[C1][2] = Semantic(Shader::USAGE_COLOR, 1);
+						if(dst.w) output[C1][3] = Semantic(Shader::USAGE_COLOR, 1);
+					}
+					else ASSERT(false);
+					break;
+				case Shader::PARAMETER_TEXCRDOUT:
+					if(dst.x) output[T0 + dst.index][0] = Semantic(Shader::USAGE_TEXCOORD, dst.index);
+					if(dst.y) output[T0 + dst.index][1] = Semantic(Shader::USAGE_TEXCOORD, dst.index);
+					if(dst.z) output[T0 + dst.index][2] = Semantic(Shader::USAGE_TEXCOORD, dst.index);
+					if(dst.w) output[T0 + dst.index][3] = Semantic(Shader::USAGE_TEXCOORD, dst.index);
+					break;
+				default:
+					break;
+				}
+			}
+		}
+		else   // Shader Model 3.0 input declaration
+		{
+			for(const auto &inst : instruction)
+			{
+				if(inst->opcode == Shader::OPCODE_DCL &&
+				   inst->dst.type == Shader::PARAMETER_OUTPUT)
+				{
+					unsigned char usage = inst->usage;
+					unsigned char usageIndex = inst->usageIndex;
+
+					const DestinationParameter &dst = inst->dst;
+
+					if(dst.x) output[dst.index][0] = Semantic(usage, usageIndex);
+					if(dst.y) output[dst.index][1] = Semantic(usage, usageIndex);
+					if(dst.z) output[dst.index][2] = Semantic(usage, usageIndex);
+					if(dst.w) output[dst.index][3] = Semantic(usage, usageIndex);
+
+					if(usage == Shader::USAGE_POSITION && usageIndex == 0)
+					{
+						positionRegister = dst.index;
+					}
+
+					if(usage == Shader::USAGE_PSIZE && usageIndex == 0)
+					{
+						pointSizeRegister = dst.index;
+					}
+				}
+			}
+		}
+	}
+
+	void VertexShader::analyzeTextureSampling()
+	{
+		textureSampling = false;
+
+		for(const auto &inst : instruction)
+		{
+			if(inst->src[1].type == PARAMETER_SAMPLER)
+			{
+				textureSampling = true;
+				break;
+			}
+		}
+	}
+}
diff --git a/src/Pipeline/VertexShader.hpp b/src/Pipeline/VertexShader.hpp
new file mode 100644
index 0000000..9a9a0a6
--- /dev/null
+++ b/src/Pipeline/VertexShader.hpp
@@ -0,0 +1,78 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_VertexShader_hpp
+#define sw_VertexShader_hpp
+
+#include "Shader.hpp"
+#include "Main/Config.hpp"
+
+namespace sw
+{
+	class VertexShader : public Shader
+	{
+	public:
+		enum AttribType : unsigned char
+		{
+			ATTRIBTYPE_FLOAT,
+			ATTRIBTYPE_INT,
+			ATTRIBTYPE_UINT,
+
+			ATTRIBTYPE_LAST = ATTRIBTYPE_UINT
+		};
+
+		explicit VertexShader(const VertexShader *vs = 0);
+		explicit VertexShader(const unsigned long *token);
+
+		virtual ~VertexShader();
+
+		static int validate(const unsigned long *const token);   // Returns number of instructions if valid
+		bool containsTextureSampling() const;
+
+		void setInput(int inputIdx, const Semantic& semantic, AttribType attribType = ATTRIBTYPE_FLOAT);
+		void setOutput(int outputIdx, int nbComponents, const Semantic& semantic);
+		void setPositionRegister(int posReg);
+		void setPointSizeRegister(int ptSizeReg);
+		void declareInstanceId() { instanceIdDeclared = true; }
+		void declareVertexId() { vertexIdDeclared = true; }
+
+		const Semantic& getInput(int inputIdx) const;
+		const Semantic& getOutput(int outputIdx, int component) const;
+		AttribType getAttribType(int inputIndex) const;
+		int getPositionRegister() const { return positionRegister; }
+		int getPointSizeRegister() const { return pointSizeRegister; }
+		bool isInstanceIdDeclared() const { return instanceIdDeclared; }
+		bool isVertexIdDeclared() const { return vertexIdDeclared; }
+
+	private:
+		void analyze();
+		void analyzeInput();
+		void analyzeOutput();
+		void analyzeTextureSampling();
+
+		Semantic input[MAX_VERTEX_INPUTS];
+		Semantic output[MAX_VERTEX_OUTPUTS][4];
+
+		AttribType attribType[MAX_VERTEX_INPUTS];
+
+		int positionRegister;
+		int pointSizeRegister;
+
+		bool instanceIdDeclared;
+		bool vertexIdDeclared;
+		bool textureSampling;
+	};
+}
+
+#endif   // sw_VertexShader_hpp
diff --git a/src/System/CPUID.cpp b/src/System/CPUID.cpp
new file mode 100644
index 0000000..c080034
--- /dev/null
+++ b/src/System/CPUID.cpp
@@ -0,0 +1,301 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "CPUID.hpp"
+
+#if defined(_WIN32)
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <intrin.h>
+	#include <float.h>
+#else
+	#include <unistd.h>
+	#include <sched.h>
+	#include <sys/types.h>
+#endif
+
+namespace sw
+{
+	bool CPUID::MMX = detectMMX();
+	bool CPUID::CMOV = detectCMOV();
+	bool CPUID::SSE = detectSSE();
+	bool CPUID::SSE2 = detectSSE2();
+	bool CPUID::SSE3 = detectSSE3();
+	bool CPUID::SSSE3 = detectSSSE3();
+	bool CPUID::SSE4_1 = detectSSE4_1();
+	int CPUID::cores = detectCoreCount();
+	int CPUID::affinity = detectAffinity();
+
+	bool CPUID::enableMMX = true;
+	bool CPUID::enableCMOV = true;
+	bool CPUID::enableSSE = true;
+	bool CPUID::enableSSE2 = true;
+	bool CPUID::enableSSE3 = true;
+	bool CPUID::enableSSSE3 = true;
+	bool CPUID::enableSSE4_1 = true;
+
+	void CPUID::setEnableMMX(bool enable)
+	{
+		enableMMX = enable;
+
+		if(!enableMMX)
+		{
+			enableSSE = false;
+			enableSSE2 = false;
+			enableSSE3 = false;
+			enableSSSE3 = false;
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableCMOV(bool enable)
+	{
+		enableCMOV = enable;
+
+		if(!CMOV)
+		{
+			enableSSE = false;
+			enableSSE2 = false;
+			enableSSE3 = false;
+			enableSSSE3 = false;
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableSSE(bool enable)
+	{
+		enableSSE = enable;
+
+		if(enableSSE)
+		{
+			enableMMX = true;
+			enableCMOV = true;
+		}
+		else
+		{
+			enableSSE2 = false;
+			enableSSE3 = false;
+			enableSSSE3 = false;
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableSSE2(bool enable)
+	{
+		enableSSE2 = enable;
+
+		if(enableSSE2)
+		{
+			enableMMX = true;
+			enableCMOV = true;
+			enableSSE = true;
+		}
+		else
+		{
+			enableSSE3 = false;
+			enableSSSE3 = false;
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableSSE3(bool enable)
+	{
+		enableSSE3 = enable;
+
+		if(enableSSE3)
+		{
+			enableMMX = true;
+			enableCMOV = true;
+			enableSSE = true;
+			enableSSE2 = true;
+		}
+		else
+		{
+			enableSSSE3 = false;
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableSSSE3(bool enable)
+	{
+		enableSSSE3 = enable;
+
+		if(enableSSSE3)
+		{
+			enableMMX = true;
+			enableCMOV = true;
+			enableSSE = true;
+			enableSSE2 = true;
+			enableSSE3 = true;
+		}
+		else
+		{
+			enableSSE4_1 = false;
+		}
+	}
+
+	void CPUID::setEnableSSE4_1(bool enable)
+	{
+		enableSSE4_1 = enable;
+
+		if(enableSSE4_1)
+		{
+			enableMMX = true;
+			enableCMOV = true;
+			enableSSE = true;
+			enableSSE2 = true;
+			enableSSE3 = true;
+			enableSSSE3 = true;
+		}
+	}
+
+	static void cpuid(int registers[4], int info)
+	{
+		#if defined(__i386__) || defined(__x86_64__)
+			#if defined(_WIN32)
+				__cpuid(registers, info);
+			#else
+				__asm volatile("cpuid": "=a" (registers[0]), "=b" (registers[1]), "=c" (registers[2]), "=d" (registers[3]): "a" (info));
+			#endif
+		#else
+			registers[0] = 0;
+			registers[1] = 0;
+			registers[2] = 0;
+			registers[3] = 0;
+		#endif
+	}
+
+	bool CPUID::detectMMX()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return MMX = (registers[3] & 0x00800000) != 0;
+	}
+
+	bool CPUID::detectCMOV()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return CMOV = (registers[3] & 0x00008000) != 0;
+	}
+
+	bool CPUID::detectSSE()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return SSE = (registers[3] & 0x02000000) != 0;
+	}
+
+	bool CPUID::detectSSE2()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return SSE2 = (registers[3] & 0x04000000) != 0;
+	}
+
+	bool CPUID::detectSSE3()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return SSE3 = (registers[2] & 0x00000001) != 0;
+	}
+
+	bool CPUID::detectSSSE3()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return SSSE3 = (registers[2] & 0x00000200) != 0;
+	}
+
+	bool CPUID::detectSSE4_1()
+	{
+		int registers[4];
+		cpuid(registers, 1);
+		return SSE4_1 = (registers[2] & 0x00080000) != 0;
+	}
+
+	int CPUID::detectCoreCount()
+	{
+		int cores = 0;
+
+		#if defined(_WIN32)
+			DWORD_PTR processAffinityMask = 1;
+			DWORD_PTR systemAffinityMask = 1;
+
+			GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
+
+			while(systemAffinityMask)
+			{
+				if(systemAffinityMask & 1)
+				{
+					cores++;
+				}
+
+				systemAffinityMask >>= 1;
+			}
+		#else
+			cores = sysconf(_SC_NPROCESSORS_ONLN);
+		#endif
+
+		if(cores < 1)  cores = 1;
+		if(cores > 16) cores = 16;
+
+		return cores;   // FIXME: Number of physical cores
+	}
+
+	int CPUID::detectAffinity()
+	{
+		int cores = 0;
+
+		#if defined(_WIN32)
+			DWORD_PTR processAffinityMask = 1;
+			DWORD_PTR systemAffinityMask = 1;
+
+			GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
+
+			while(processAffinityMask)
+			{
+				if(processAffinityMask & 1)
+				{
+					cores++;
+				}
+
+				processAffinityMask >>= 1;
+			}
+		#else
+			return detectCoreCount();   // FIXME: Assumes no affinity limitation
+		#endif
+
+		if(cores < 1)  cores = 1;
+		if(cores > 16) cores = 16;
+
+		return cores;
+	}
+
+	void CPUID::setFlushToZero(bool enable)
+	{
+		#if defined(_MSC_VER)
+			_controlfp(enable ? _DN_FLUSH : _DN_SAVE, _MCW_DN);
+		#else
+			// Unimplemented
+		#endif
+	}
+
+	void CPUID::setDenormalsAreZero(bool enable)
+	{
+		// Unimplemented
+	}
+}
diff --git a/src/System/CPUID.hpp b/src/System/CPUID.hpp
new file mode 100644
index 0000000..3c21cd7
--- /dev/null
+++ b/src/System/CPUID.hpp
@@ -0,0 +1,137 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_CPUID_hpp
+#define sw_CPUID_hpp
+
+namespace sw
+{
+	#if !defined(__i386__) && defined(_M_IX86)
+		#define __i386__ 1
+	#endif
+
+	#if !defined(__x86_64__) && (defined(_M_AMD64) || defined (_M_X64))
+		#define __x86_64__ 1
+	#endif
+
+	class CPUID
+	{
+	public:
+		static bool supportsMMX();
+		static bool supportsCMOV();
+		static bool supportsMMX2();   // MMX instructions added by SSE: pshufw, pmulhuw, pmovmskb, pavgw/b, pextrw, pinsrw, pmaxsw/ub, etc.
+		static bool supportsSSE();
+		static bool supportsSSE2();
+		static bool supportsSSE3();
+		static bool supportsSSSE3();
+		static bool supportsSSE4_1();
+		static int coreCount();
+		static int processAffinity();
+
+		static void setEnableMMX(bool enable);
+		static void setEnableCMOV(bool enable);
+		static void setEnableSSE(bool enable);
+		static void setEnableSSE2(bool enable);
+		static void setEnableSSE3(bool enable);
+		static void setEnableSSSE3(bool enable);
+		static void setEnableSSE4_1(bool enable);
+
+		static void setFlushToZero(bool enable);        // Denormal results are written as zero
+		static void setDenormalsAreZero(bool enable);   // Denormal inputs are read as zero
+
+	private:
+		static bool MMX;
+		static bool CMOV;
+		static bool SSE;
+		static bool SSE2;
+		static bool SSE3;
+		static bool SSSE3;
+		static bool SSE4_1;
+		static int cores;
+		static int affinity;
+
+		static bool enableMMX;
+		static bool enableCMOV;
+		static bool enableSSE;
+		static bool enableSSE2;
+		static bool enableSSE3;
+		static bool enableSSSE3;
+		static bool enableSSE4_1;
+
+		static bool detectMMX();
+		static bool detectCMOV();
+		static bool detectSSE();
+		static bool detectSSE2();
+		static bool detectSSE3();
+		static bool detectSSSE3();
+		static bool detectSSE4_1();
+		static int detectCoreCount();
+		static int detectAffinity();
+	};
+}
+
+namespace sw
+{
+	inline bool CPUID::supportsMMX()
+	{
+		return MMX && enableMMX;
+	}
+
+	inline bool CPUID::supportsCMOV()
+	{
+		return CMOV && enableCMOV;
+	}
+
+	inline bool CPUID::supportsMMX2()
+	{
+		return supportsSSE();   // Coincides with 64-bit integer vector instructions supported by SSE
+	}
+
+	inline bool CPUID::supportsSSE()
+	{
+		return SSE && enableSSE;
+	}
+
+	inline bool CPUID::supportsSSE2()
+	{
+		return SSE2 && enableSSE2;
+	}
+
+	inline bool CPUID::supportsSSE3()
+	{
+		return SSE3 && enableSSE3;
+	}
+
+	inline bool CPUID::supportsSSSE3()
+	{
+		return SSSE3 && enableSSSE3;
+	}
+
+	inline bool CPUID::supportsSSE4_1()
+	{
+		return SSE4_1 && enableSSE4_1;
+	}
+
+	inline int CPUID::coreCount()
+	{
+		return cores;
+	}
+
+	inline int CPUID::processAffinity()
+	{
+		return affinity;
+	}
+}
+
+#endif   // sw_CPUID_hpp
diff --git a/src/System/Configurator.cpp b/src/System/Configurator.cpp
new file mode 100644
index 0000000..ead1d28
--- /dev/null
+++ b/src/System/Configurator.cpp
@@ -0,0 +1,255 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Configurator.hpp"
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+#if defined(__unix__)
+#include <unistd.h>
+#endif
+
+namespace sw
+{
+	Configurator::Configurator(string iniPath)
+	{
+		path = iniPath;
+
+		readFile();
+	}
+
+	Configurator::~Configurator()
+	{
+	}
+
+	bool Configurator::readFile()
+	{
+		#if defined(__unix__)
+			if(access(path.c_str(), R_OK) != 0)
+			{
+				return false;
+			}
+		#endif
+
+		fstream file(path.c_str(), ios::in);
+		if(file.fail()) return false;
+
+		string line;
+		string keyName;
+
+		while(getline(file, line))
+		{
+			if(line.length())
+			{
+				if(line[line.length() - 1] == '\r')
+				{
+					line = line.substr(0, line.length() - 1);
+				}
+
+				if(!isprint(line[0]))
+				{
+				//	printf("Failing on char %d\n", line[0]);
+					file.close();
+					return false;
+				}
+
+				string::size_type pLeft = line.find_first_of(";#[=");
+
+				if(pLeft != string::npos)
+				{
+					switch(line[pLeft])
+					{
+					case '[':
+						{
+							string::size_type pRight = line.find_last_of("]");
+
+							if(pRight != string::npos && pRight > pLeft)
+							{
+								keyName = line.substr(pLeft + 1, pRight - pLeft - 1);
+								addKeyName(keyName);
+							}
+						}
+						break;
+					case '=':
+						{
+							string valueName = line.substr(0, pLeft);
+							string value = line.substr(pLeft + 1);
+							addValue(keyName, valueName, value);
+						}
+						break;
+					case ';':
+					case '#':
+						// Ignore comments
+						break;
+					}
+				}
+			}
+		}
+
+		file.close();
+
+		if(names.size())
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	void Configurator::writeFile(std::string title)
+	{
+		#if defined(__unix__)
+			if(access(path.c_str(), W_OK) != 0)
+			{
+				return;
+			}
+		#endif
+
+		fstream file(path.c_str(), ios::out);
+		if(file.fail()) return;
+
+		file << "; " << title << endl << endl;
+
+		for(unsigned int keyID = 0; keyID < sections.size(); keyID++)
+		{
+			file << "[" << names[keyID] << "]" << endl;
+
+			for(unsigned int valueID = 0; valueID < sections[keyID].names.size(); valueID++)
+			{
+				file << sections[keyID].names[valueID] << "=" << sections[keyID].values[valueID] << endl;
+			}
+
+			file << endl;
+		}
+
+		file.close();
+	}
+
+	int Configurator::findKey(string keyName) const
+	{
+		for(unsigned int keyID = 0; keyID < names.size(); keyID++)
+		{
+			if(names[keyID] == keyName)
+			{
+				return keyID;
+			}
+		}
+
+		return -1;
+	}
+
+	int Configurator::findValue(unsigned int keyID, string valueName) const
+	{
+		if(!sections.size() || keyID >= sections.size())
+		{
+			return -1;
+		}
+
+		for(unsigned int valueID = 0; valueID < sections[keyID].names.size(); ++valueID)
+		{
+			if(sections[keyID].names[valueID] == valueName)
+			{
+				return valueID;
+			}
+		}
+
+		return -1;
+	}
+
+	unsigned int Configurator::addKeyName(string keyName)
+	{
+		names.resize(names.size() + 1, keyName);
+		sections.resize(sections.size() + 1);
+		return (unsigned int)names.size() - 1;
+	}
+
+	void Configurator::addValue(string const keyName, string const valueName, string const value)
+	{
+		int keyID = findKey(keyName);
+
+		if(keyID == -1)
+		{
+			keyID = addKeyName(keyName);
+		}
+
+		int valueID = findValue(keyID, valueName);
+
+		if(valueID == -1)
+		{
+			sections[keyID].names.resize(sections[keyID].names.size() + 1, valueName);
+			sections[keyID].values.resize(sections[keyID].values.size() + 1, value);
+		}
+		else
+		{
+			sections[keyID].values[valueID] = value;
+		}
+	}
+
+	string Configurator::getValue(string keyName, string valueName, string defaultValue) const
+	{
+		int keyID = findKey(keyName);
+		if(keyID == -1) return defaultValue;
+		int valueID = findValue((unsigned int)keyID, valueName);
+		if(valueID == -1) return defaultValue;
+
+		return sections[keyID].values[valueID];
+	}
+
+	int Configurator::getInteger(string keyName, string valueName, int defaultValue) const
+	{
+		char svalue[256];
+
+		sprintf(svalue, "%d", defaultValue);
+
+		return atoi(getValue(keyName, valueName, svalue).c_str());
+	}
+
+	bool Configurator::getBoolean(string keyName, string valueName, bool defaultValue) const
+	{
+		return getInteger(keyName, valueName, (int)defaultValue) != 0;
+	}
+
+	double Configurator::getFloat(string keyName, string valueName, double defaultValue) const
+	{
+		char svalue[256];
+
+		sprintf(svalue, "%f", defaultValue);
+
+		return atof(getValue(keyName, valueName, svalue).c_str());
+	}
+
+	unsigned int Configurator::getFormatted(string keyName, string valueName, char *format,
+											void *v1, void *v2, void *v3, void *v4,
+											void *v5, void *v6, void *v7, void *v8,
+											void *v9, void *v10, void *v11, void *v12,
+											void *v13, void *v14, void *v15, void *v16)
+	{
+		string value = getValue(keyName, valueName);
+
+		if(!value.length()) return false;
+
+		unsigned int nVals = sscanf(value.c_str(), format,
+									v1, v2, v3, v4, v5, v6, v7, v8,
+									v9, v10, v11, v12, v13, v14, v15, v16);
+
+		return nVals;
+	}
+}
diff --git a/src/System/Configurator.hpp b/src/System/Configurator.hpp
new file mode 100644
index 0000000..6fd930c
--- /dev/null
+++ b/src/System/Configurator.hpp
@@ -0,0 +1,66 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Configurator_hpp
+#define sw_Configurator_hpp
+
+#include <string>
+#include <vector>
+
+#include <stdlib.h>
+
+namespace sw
+{
+	class Configurator
+	{
+	public:
+		Configurator(std::string iniPath = "");
+
+		~Configurator();
+
+		std::string getValue(std::string sectionName, std::string valueName, std::string defaultValue = "") const;
+		int getInteger(std::string sectionName, std::string valueName, int defaultValue = 0) const;
+		bool getBoolean(std::string sectionName, std::string valueName, bool defaultValue = false) const;
+		double getFloat(std::string sectionName, std::string valueName, double defaultValue = 0.0) const;
+		unsigned int getFormatted(std::string sectionName, std::string valueName, char *format,
+		                          void *v1 = 0, void *v2 = 0, void *v3 = 0, void *v4 = 0,
+		                          void *v5 = 0, void *v6 = 0, void *v7 = 0, void *v8 = 0,
+		                          void *v9 = 0, void *v10 = 0, void *v11 = 0, void *v12 = 0,
+		                          void *v13 = 0, void *v14 = 0, void *v15 = 0, void *v16 = 0);
+
+		void addValue(std::string sectionName, std::string valueName, std::string value);
+
+		void writeFile(std::string title = "Configuration File");
+
+	private:
+		bool readFile();
+
+		unsigned int addKeyName(std::string sectionName);
+		int findKey(std::string sectionName) const;
+		int findValue(unsigned int sectionID, std::string valueName) const;
+
+		std::string path;
+
+		struct Section
+		{
+			std::vector<std::string> names;
+			std::vector<std::string> values;
+		};
+
+		std::vector<Section> sections;
+		std::vector<std::string> names;
+	};
+}
+
+#endif   // sw_Configurator_hpp
diff --git a/src/System/Debug.cpp b/src/System/Debug.cpp
new file mode 100644
index 0000000..acf469e
--- /dev/null
+++ b/src/System/Debug.cpp
@@ -0,0 +1,39 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Debug.hpp"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+namespace sw
+{
+void trace(const char *format, ...)
+{
+	if(false)
+	{
+		FILE *file = fopen("debug.txt", "a");
+
+		if(file)
+		{
+			va_list vararg;
+			va_start(vararg, format);
+			vfprintf(file, format, vararg);
+			va_end(vararg);
+
+			fclose(file);
+		}
+	}
+}
+}
diff --git a/src/System/Debug.hpp b/src/System/Debug.hpp
new file mode 100644
index 0000000..9758c3b
--- /dev/null
+++ b/src/System/Debug.hpp
@@ -0,0 +1,58 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Debug_hpp
+#define Debug_hpp
+
+#if defined(__ANDROID__) && !defined(ANDROID_HOST_BUILD)
+#include "DebugAndroid.hpp"
+#else
+
+#include <assert.h>
+#include <stdio.h>
+
+#undef min
+#undef max
+
+namespace sw
+{
+void trace(const char *format, ...);
+inline void trace() {}
+}
+
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+	#define TRACE(format, ...) sw::trace("[0x%0.8X]%s(" format ")\n", this, __FUNCTION__, ##__VA_ARGS__)
+#else
+	#define TRACE(...) ((void)0)
+#endif
+
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+	#define UNIMPLEMENTED(...) do { \
+		sw::trace("\t! Unimplemented: %s(%d): ", __FUNCTION__, __LINE__); \
+		sw::trace(__VA_ARGS__); \
+		sw::trace("\n"); \
+		ASSERT(false); \
+	} while(0)
+#else
+	#define UNIMPLEMENTED(...) ((void)0)
+#endif
+
+#if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
+	#define ASSERT(expression) {if(!(expression)) sw::trace("\t! Assert failed in %s(%d): " #expression "\n", __FUNCTION__, __LINE__); assert(expression);}
+#else
+	#define ASSERT assert
+#endif
+
+#endif   // !__ANDROID__
+#endif   // Debug_hpp
diff --git a/src/System/DebugAndroid.cpp b/src/System/DebugAndroid.cpp
new file mode 100644
index 0000000..c511fc3
--- /dev/null
+++ b/src/System/DebugAndroid.cpp
@@ -0,0 +1,53 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "DebugAndroid.hpp"
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <cutils/properties.h>
+
+void AndroidEnterDebugger()
+{
+	ALOGE(__FUNCTION__);
+#ifndef NDEBUG
+	static volatile int * const makefault = nullptr;
+	char value[PROPERTY_VALUE_MAX];
+	property_get("debug.db.uid", value, "-1");
+	int debug_uid = atoi(value);
+	if((debug_uid >= 0) && (geteuid() < static_cast<uid_t>(debug_uid)))
+	{
+		ALOGE("Waiting for debugger: gdbserver :${PORT} --attach %u. Look for thread %u", getpid(), gettid());
+		volatile int waiting = 1;
+		while (waiting) {
+			sleep(1);
+		}
+	}
+	else
+	{
+		ALOGE("No debugger");
+	}
+#endif
+}
+
+void trace(const char *format, ...)
+{
+#ifndef NDEBUG
+	va_list vararg;
+	va_start(vararg, format);
+	android_vprintLog(ANDROID_LOG_VERBOSE, NULL, LOG_TAG, format, vararg);
+	va_end(vararg);
+#endif
+}
diff --git a/src/System/DebugAndroid.hpp b/src/System/DebugAndroid.hpp
new file mode 100644
index 0000000..eced194
--- /dev/null
+++ b/src/System/DebugAndroid.hpp
@@ -0,0 +1,99 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef DebugAndroid_hpp
+#define DebugAndroid_hpp
+
+#if ANDROID_PLATFORM_SDK_VERSION < 27
+#include <cutils/log.h>
+#elif ANDROID_PLATFORM_SDK_VERSION >= 27
+#include <log/log.h>
+#else
+#error "ANDROID_PLATFORM_SDK_VERSION is not defined"
+#endif
+
+#include <cassert>
+
+// On Android Virtual Devices we heavily depend on logging, even in
+// production builds. We do this because AVDs are components of larger
+// systems, and may be configured in ways that are difficult to
+// reproduce locally. For example some system run tests against
+// third-party code that we cannot access.  Aborting (cf. assert) on
+// unimplemented functionality creates two problems. First, it produces
+// a service failure where none is needed. Second, it puts the
+// customer on the critical path for notifying us of a problem.
+// The alternative, skipping unimplemented functionality silently, is
+// arguably worse: neither the service provider nor the customer will
+// learn that unimplemented functionality may have compromised the test
+// results.
+// Logging invocations of unimplemented functionality is useful to both
+// service provider and the customer. The service provider can learn
+// that the functionality is needed. The customer learns that the test
+// results may be compromised.
+
+/**
+ * Enter the debugger with a memory fault iff debuggerd is set to capture this
+ * process. Otherwise return.
+ */
+void AndroidEnterDebugger();
+
+#define ASSERT(E) do { \
+		if (!(E)) { \
+			ALOGE("badness: assertion_failed %s in %s at %s:%d", #E,	\
+				  __FUNCTION__, __FILE__, __LINE__);					\
+			AndroidEnterDebugger();										\
+		}																\
+	} while(0)
+
+#undef assert
+#define assert(E) ASSERT(E)
+
+#define ERR(format, ...)												\
+	do {																\
+		ALOGE("badness: err %s %s:%d (" format ")", __FUNCTION__, __FILE__, \
+			  __LINE__, ##__VA_ARGS__);									\
+		AndroidEnterDebugger();											\
+	} while(0)
+
+#define FIXME(format, ...)												\
+	do {																\
+		ALOGE("badness: fixme %s %s:%d (" format ")", __FUNCTION__, __FILE__, \
+			  __LINE__, ##__VA_ARGS__);									\
+		AndroidEnterDebugger();											\
+	} while(0)
+
+// TODO: Handle __VA_ARGS__ (can be empty)
+#define UNIMPLEMENTED(...) do {						\
+		ALOGE("badness: unimplemented: %s %s:%d",	\
+			  __FUNCTION__, __FILE__, __LINE__);	\
+		AndroidEnterDebugger();						\
+	} while(0)
+
+#define UNREACHABLE(value) do {                                         \
+		ALOGE("badness: unreachable case reached: %s %s:%d. %s: %d", \
+			  __FUNCTION__, __FILE__, __LINE__, #value, value);			\
+		AndroidEnterDebugger();                                         \
+	} while(0)
+
+#ifndef NDEBUG
+	#define TRACE(format, ...)								   \
+		ALOGV("%s %s:%d (" format ")", __FUNCTION__, __FILE__, \
+			  __LINE__, ##__VA_ARGS__)
+#else
+	#define TRACE(...) ((void)0)
+#endif
+
+void trace(const char *format, ...);
+
+#endif   // DebugAndroid_hpp
diff --git a/src/System/GrallocAndroid.cpp b/src/System/GrallocAndroid.cpp
new file mode 100644
index 0000000..c877e9933
--- /dev/null
+++ b/src/System/GrallocAndroid.cpp
@@ -0,0 +1,106 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "GrallocAndroid.hpp"
+#include "Debug.hpp"
+
+#ifdef HAVE_GRALLOC1
+#include <sync/sync.h>
+#endif
+
+GrallocModule *GrallocModule::getInstance()
+{
+	static GrallocModule instance;
+	return &instance;
+}
+
+GrallocModule::GrallocModule()
+{
+	const hw_module_t *module = nullptr;
+	hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
+
+	m_major_version = (module->module_api_version >> 8) & 0xff;
+	switch(m_major_version)
+	{
+	case 0:
+		m_module = reinterpret_cast<const gralloc_module_t*>(module);
+		break;
+	case 1:
+#ifdef HAVE_GRALLOC1
+		gralloc1_open(module, &m_gralloc1_device);
+		m_gralloc1_lock = (GRALLOC1_PFN_LOCK) m_gralloc1_device->getFunction(m_gralloc1_device, GRALLOC1_FUNCTION_LOCK);
+		m_gralloc1_unlock = (GRALLOC1_PFN_UNLOCK)m_gralloc1_device->getFunction(m_gralloc1_device, GRALLOC1_FUNCTION_UNLOCK);
+		break;
+#endif
+	default:
+		TRACE("unknown gralloc major version (%d)", m_major_version);
+		break;
+	}
+}
+
+int GrallocModule::lock(buffer_handle_t handle, int usage, int left, int top, int width, int height, void **vaddr)
+{
+	switch(m_major_version)
+	{
+	case 0:
+		{
+			return m_module->lock(m_module, handle, usage, left, top, width, height, vaddr);
+		}
+	case 1:
+#ifdef HAVE_GRALLOC1
+		{
+			gralloc1_rect_t outRect{};
+			outRect.left = left;
+			outRect.top = top;
+			outRect.width = width;
+			outRect.height = height;
+			return m_gralloc1_lock(m_gralloc1_device, handle, usage, usage, &outRect, vaddr, -1);
+		}
+#endif
+	default:
+		{
+			TRACE("no gralloc module to lock");
+			return -1;
+		}
+	}
+}
+
+int GrallocModule::unlock(buffer_handle_t handle)
+{
+	switch(m_major_version)
+	{
+	case 0:
+		{
+			return m_module->unlock(m_module, handle);
+		}
+	case 1:
+#ifdef HAVE_GRALLOC1
+		{
+			int32_t fenceFd = -1;
+			int error = m_gralloc1_unlock(m_gralloc1_device, handle, &fenceFd);
+			if (!error)
+			{
+				sync_wait(fenceFd, -1);
+				close(fenceFd);
+			}
+			return error;
+		}
+#endif
+	default:
+		{
+			TRACE("no gralloc module to unlock");
+			return -1;
+		}
+	}
+}
diff --git a/src/System/GrallocAndroid.hpp b/src/System/GrallocAndroid.hpp
new file mode 100644
index 0000000..fe0b15a
--- /dev/null
+++ b/src/System/GrallocAndroid.hpp
@@ -0,0 +1,44 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRALLOC_ANDROID
+#define GRALLOC_ANDROID
+
+#include <hardware/gralloc.h>
+
+#ifdef HAVE_GRALLOC1
+#include <hardware/gralloc1.h>
+#endif
+
+#include <unistd.h> // for close()
+
+class GrallocModule
+{
+public:
+	static GrallocModule *getInstance();
+	int lock(buffer_handle_t handle, int usage, int left, int top, int width, int height, void **vaddr);
+	int unlock(buffer_handle_t handle);
+
+private:
+	GrallocModule();
+	uint8_t m_major_version;
+	const gralloc_module_t *m_module;
+#ifdef HAVE_GRALLOC1
+	gralloc1_device_t *m_gralloc1_device = nullptr;
+	GRALLOC1_PFN_LOCK m_gralloc1_lock = nullptr;
+	GRALLOC1_PFN_UNLOCK m_gralloc1_unlock = nullptr;
+#endif
+};
+
+#endif  // GRALLOC_ANDROID
diff --git a/src/System/Half.cpp b/src/System/Half.cpp
new file mode 100644
index 0000000..cde8190
--- /dev/null
+++ b/src/System/Half.cpp
@@ -0,0 +1,102 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Half.hpp"
+
+namespace sw
+{
+	half::half(float fp32)
+	{
+		unsigned int fp32i = *(unsigned int*)&fp32;
+		unsigned int sign = (fp32i & 0x80000000) >> 16;
+		unsigned int abs = fp32i & 0x7FFFFFFF;
+
+		if(abs > 0x47FFEFFF)   // Infinity
+		{
+			fp16i = sign | 0x7FFF;
+		}
+		else if(abs < 0x38800000)   // Denormal
+		{
+			unsigned int mantissa = (abs & 0x007FFFFF) | 0x00800000;
+			int e = 113 - (abs >> 23);
+
+			if(e < 24)
+			{
+				abs = mantissa >> e;
+			}
+			else
+			{
+				abs = 0;
+			}
+
+			fp16i = sign | (abs + 0x00000FFF + ((abs >> 13) & 1)) >> 13;
+		}
+		else
+		{
+			fp16i = sign | (abs + 0xC8000000 + 0x00000FFF + ((abs >> 13) & 1)) >> 13;
+		}
+	}
+
+	half::operator float() const
+	{
+		unsigned int fp32i;
+
+		int s = (fp16i >> 15) & 0x00000001;
+		int e = (fp16i >> 10) & 0x0000001F;
+		int m =  fp16i        & 0x000003FF;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				fp32i = s << 31;
+
+				return (float&)fp32i;
+			}
+			else
+			{
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		fp32i = (s << 31) | (e << 23) | m;
+
+		return (float&)fp32i;
+	}
+
+	half &half::operator=(half h)
+	{
+		fp16i = h.fp16i;
+
+		return *this;
+	}
+
+
+	half &half::operator=(float f)
+	{
+		*this = half(f);
+
+		return *this;
+	}
+}
diff --git a/src/System/Half.hpp b/src/System/Half.hpp
new file mode 100644
index 0000000..f2d378e
--- /dev/null
+++ b/src/System/Half.hpp
@@ -0,0 +1,93 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Half_hpp
+#define sw_Half_hpp
+
+namespace sw
+{
+	class half
+	{
+	public:
+		half() = default;
+		explicit half(float f);
+
+		operator float() const;
+
+		half &operator=(half h);
+		half &operator=(float f);
+
+	private:
+		unsigned short fp16i;
+	};
+
+	inline half shortAsHalf(short s)
+	{
+		union
+		{
+			half h;
+			short s;
+		} hs;
+
+		hs.s = s;
+
+		return hs.h;
+	}
+
+	class RGB9E5
+	{
+		unsigned int R : 9;
+		unsigned int G : 9;
+		unsigned int B : 9;
+		unsigned int E : 5;
+
+	public:
+		void toRGB16F(half rgb[3]) const
+		{
+			constexpr int offset = 24;   // Exponent bias (15) + number of mantissa bits per component (9) = 24
+
+			const float factor = (1u << E) * (1.0f / (1 << offset));
+			rgb[0] = half(R * factor);
+			rgb[1] = half(G * factor);
+			rgb[2] = half(B * factor);
+		}
+	};
+
+	class R11G11B10F
+	{
+		unsigned int R : 11;
+		unsigned int G : 11;
+		unsigned int B : 10;
+
+		static inline half float11ToFloat16(unsigned short fp11)
+		{
+			return shortAsHalf(fp11 << 4);   // Sign bit 0
+		}
+
+		static inline half float10ToFloat16(unsigned short fp10)
+		{
+			return shortAsHalf(fp10 << 5);   // Sign bit 0
+		}
+
+	public:
+		void toRGB16F(half rgb[3]) const
+		{
+			rgb[0] = float11ToFloat16(R);
+			rgb[1] = float11ToFloat16(G);
+			rgb[2] = float10ToFloat16(B);
+		}
+	};
+}
+
+#endif   // sw_Half_hpp
diff --git a/src/System/Math.cpp b/src/System/Math.cpp
new file mode 100644
index 0000000..290d4ab
--- /dev/null
+++ b/src/System/Math.cpp
@@ -0,0 +1,49 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Math.hpp"
+
+namespace sw
+{
+	inline uint64_t FNV_1a(uint64_t hash, unsigned char data)
+	{
+		return (hash ^ data) * 1099511628211;
+	}
+
+	uint64_t FNV_1a(const unsigned char *data, int size)
+	{
+		int64_t hash = 0xCBF29CE484222325;
+
+		for(int i = 0; i < size; i++)
+		{
+			hash = FNV_1a(hash, data[i]);
+		}
+
+		return hash;
+	}
+
+	unsigned char sRGB8toLinear8(unsigned char value)
+	{
+		static unsigned char sRGBtoLinearTable[256] = { 255 };
+		if(sRGBtoLinearTable[0] == 255)
+		{
+			for(int i = 0; i < 256; i++)
+			{
+				sRGBtoLinearTable[i] = static_cast<unsigned char>(sw::sRGBtoLinear(static_cast<float>(i) / 255.0f) * 255.0f + 0.5f);
+			}
+		}
+
+		return sRGBtoLinearTable[value];
+	}
+}
diff --git a/src/System/Math.hpp b/src/System/Math.hpp
new file mode 100644
index 0000000..a35d2e0
--- /dev/null
+++ b/src/System/Math.hpp
@@ -0,0 +1,385 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Math_hpp
+#define sw_Math_hpp
+
+#include "Types.hpp"
+#include "Half.hpp"
+
+#include <cmath>
+#if defined(_MSC_VER)
+	#include <intrin.h>
+#endif
+
+namespace sw
+{
+	using std::abs;
+
+	#undef min
+	#undef max
+
+	template<class T>
+	inline T max(T a, T b)
+	{
+		return a > b ? a : b;
+	}
+
+	template<class T>
+	inline T min(T a, T b)
+	{
+		return a < b ? a : b;
+	}
+
+	template<class T>
+	inline T max(T a, T b, T c)
+	{
+		return max(max(a, b), c);
+	}
+
+	template<class T>
+	inline T min(T a, T b, T c)
+	{
+		return min(min(a, b), c);
+	}
+
+	template<class T>
+	inline T max(T a, T b, T c, T d)
+	{
+		return max(max(a, b), max(c, d));
+	}
+
+	template<class T>
+	inline T min(T a, T b, T c, T d)
+	{
+		return min(min(a, b), min(c, d));
+	}
+
+	template<class T>
+	inline void swap(T &a, T &b)
+	{
+		T t = a;
+		a = b;
+		b = t;
+	}
+
+	template <typename destType, typename sourceType>
+	destType bitCast(const sourceType &source)
+	{
+		union
+		{
+			sourceType s;
+			destType d;
+		} sd;
+		sd.s = source;
+		return sd.d;
+	}
+
+	inline int iround(float x)
+	{
+		return (int)floor(x + 0.5f);
+	//	return _mm_cvtss_si32(_mm_load_ss(&x));   // FIXME: Demands SSE support
+	}
+
+	inline int ifloor(float x)
+	{
+		return (int)floor(x);
+	}
+
+	inline int ceilFix4(int x)
+	{
+		return (x + 0xF) & 0xFFFFFFF0;
+	}
+
+	inline int ceilInt4(int x)
+	{
+		return (x + 0xF) >> 4;
+	}
+
+	#define BITS(x)    ( \
+	!!((x) & 0x80000000) + \
+	!!((x) & 0xC0000000) + \
+	!!((x) & 0xE0000000) + \
+	!!((x) & 0xF0000000) + \
+	!!((x) & 0xF8000000) + \
+	!!((x) & 0xFC000000) + \
+	!!((x) & 0xFE000000) + \
+	!!((x) & 0xFF000000) + \
+	!!((x) & 0xFF800000) + \
+	!!((x) & 0xFFC00000) + \
+	!!((x) & 0xFFE00000) + \
+	!!((x) & 0xFFF00000) + \
+	!!((x) & 0xFFF80000) + \
+	!!((x) & 0xFFFC0000) + \
+	!!((x) & 0xFFFE0000) + \
+	!!((x) & 0xFFFF0000) + \
+	!!((x) & 0xFFFF8000) + \
+	!!((x) & 0xFFFFC000) + \
+	!!((x) & 0xFFFFE000) + \
+	!!((x) & 0xFFFFF000) + \
+	!!((x) & 0xFFFFF800) + \
+	!!((x) & 0xFFFFFC00) + \
+	!!((x) & 0xFFFFFE00) + \
+	!!((x) & 0xFFFFFF00) + \
+	!!((x) & 0xFFFFFF80) + \
+	!!((x) & 0xFFFFFFC0) + \
+	!!((x) & 0xFFFFFFE0) + \
+	!!((x) & 0xFFFFFFF0) + \
+	!!((x) & 0xFFFFFFF8) + \
+	!!((x) & 0xFFFFFFFC) + \
+	!!((x) & 0xFFFFFFFE) + \
+	!!((x) & 0xFFFFFFFF))
+
+	#define MAX(x, y) ((x) > (y) ? (x) : (y))
+	#define MIN(x, y) ((x) < (y) ? (x) : (y))
+
+	inline float exp2(float x)
+	{
+		return exp2f(x);
+	}
+
+	inline int exp2(int x)
+	{
+		return 1 << x;
+	}
+
+	inline unsigned long log2(int x)
+	{
+		#if defined(_MSC_VER)
+			unsigned long y;
+			_BitScanReverse(&y, x);
+			return y;
+		#else
+			return 31 - __builtin_clz(x);
+		#endif
+	}
+
+	inline int ilog2(float x)
+	{
+		unsigned int y = *(unsigned int*)&x;
+
+		return ((y & 0x7F800000) >> 23) - 127;
+	}
+
+	inline float log2(float x)
+	{
+		return logf(x) * 1.44269504f;   // 1.0 / log[e](2)
+	}
+
+	inline bool isPow2(int x)
+	{
+		return (x & -x) == x;
+	}
+
+	template<class T>
+	inline T clamp(T x, T a, T b)
+	{
+		if(x < a) x = a;
+		if(x > b) x = b;
+
+		return x;
+	}
+
+	inline float clamp01(float x)
+	{
+		return clamp(x, 0.0f, 1.0f);
+	}
+
+	inline int ceilPow2(int x)
+	{
+		int i = 1;
+
+		while(i < x)
+		{
+			i <<= 1;
+		}
+
+		return i;
+	}
+
+	inline int floorDiv(int a, int b)
+	{
+		return a / b + ((a % b) >> 31);
+	}
+
+	inline int floorMod(int a, int b)
+	{
+		int r = a % b;
+		return r + ((r >> 31) & b);
+	}
+
+	inline int ceilDiv(int a, int b)
+	{
+		return a / b - (-(a % b) >> 31);
+	}
+
+	inline int ceilMod(int a, int b)
+	{
+		int r = a % b;
+		return r - ((-r >> 31) & b);
+	}
+
+	template<const int n>
+	inline unsigned int unorm(float x)
+	{
+		static const unsigned int max = 0xFFFFFFFF >> (32 - n);
+		static const float maxf = static_cast<float>(max);
+
+		if(x >= 1.0f)
+		{
+			return max;
+		}
+		else if(x <= 0.0f)
+		{
+			return 0;
+		}
+		else
+		{
+			return static_cast<unsigned int>(maxf * x + 0.5f);
+		}
+	}
+
+	template<const int n>
+	inline int snorm(float x)
+	{
+		static const unsigned int min = 0x80000000 >> (32 - n);
+		static const unsigned int max = 0xFFFFFFFF >> (32 - n + 1);
+		static const float maxf = static_cast<float>(max);
+		static const unsigned int range = 0xFFFFFFFF >> (32 - n);
+
+		if(x >= 0.0f)
+		{
+			if(x >= 1.0f)
+			{
+				return max;
+			}
+			else
+			{
+				return static_cast<int>(maxf * x + 0.5f);
+			}
+		}
+		else
+		{
+			if(x <= -1.0f)
+			{
+				return min;
+			}
+			else
+			{
+				return static_cast<int>(maxf * x - 0.5f) & range;
+			}
+		}
+	}
+
+	template<const int n>
+	inline unsigned int ucast(float x)
+	{
+		static const unsigned int max = 0xFFFFFFFF >> (32 - n);
+		static const float maxf = static_cast<float>(max);
+
+		if(x >= maxf)
+		{
+			return max;
+		}
+		else if(x <= 0.0f)
+		{
+			return 0;
+		}
+		else
+		{
+			return static_cast<unsigned int>(x + 0.5f);
+		}
+	}
+
+	template<const int n>
+	inline int scast(float x)
+	{
+		static const unsigned int min = 0x80000000 >> (32 - n);
+		static const unsigned int max = 0xFFFFFFFF >> (32 - n + 1);
+		static const float maxf = static_cast<float>(max);
+		static const float minf = static_cast<float>(min);
+		static const unsigned int range = 0xFFFFFFFF >> (32 - n);
+
+		if(x > 0.0f)
+		{
+			if(x >= maxf)
+			{
+				return max;
+			}
+			else
+			{
+				return static_cast<int>(x + 0.5f);
+			}
+		}
+		else
+		{
+			if(x <= -minf)
+			{
+				return min;
+			}
+			else
+			{
+				return static_cast<int>(x - 0.5f) & range;
+			}
+		}
+	}
+
+	inline float sRGBtoLinear(float c)
+	{
+		if(c <= 0.04045f)
+		{
+			return c * 0.07739938f;   // 1.0f / 12.92f;
+		}
+		else
+		{
+			return powf((c + 0.055f) * 0.9478673f, 2.4f);   // 1.0f / 1.055f
+		}
+	}
+
+	inline float linearToSRGB(float c)
+	{
+		if(c <= 0.0031308f)
+		{
+			return c * 12.92f;
+		}
+		else
+		{
+			return 1.055f * powf(c, 0.4166667f) - 0.055f;   // 1.0f / 2.4f
+		}
+	}
+
+	unsigned char sRGB8toLinear8(unsigned char value);
+
+	uint64_t FNV_1a(const unsigned char *data, int size);   // Fowler-Noll-Vo hash function
+
+	// Round up to the next multiple of alignment
+	template<typename T>
+	inline T align(T value, unsigned int alignment)
+	{
+		return ((value + alignment - 1) / alignment) * alignment;
+	}
+
+	template<unsigned int alignment, typename T>
+	inline T align(T value)
+	{
+		return ((value + alignment - 1) / alignment) * alignment;
+	}
+
+	inline int clampToSignedInt(unsigned int x)
+	{
+		return static_cast<int>(min(x, 0x7FFFFFFFu));
+	}
+}
+
+#endif   // sw_Math_hpp
diff --git a/src/System/Memory.cpp b/src/System/Memory.cpp
new file mode 100644
index 0000000..45fef40
--- /dev/null
+++ b/src/System/Memory.cpp
@@ -0,0 +1,262 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Memory.hpp"
+
+#include "Types.hpp"
+#include "Debug.hpp"
+
+#if defined(_WIN32)
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <intrin.h>
+#else
+	#include <errno.h>
+	#include <sys/mman.h>
+	#include <stdlib.h>
+	#include <unistd.h>
+#endif
+
+#include <memory.h>
+
+#undef allocate
+#undef deallocate
+
+#if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined (_M_X64)) && !defined(__x86__)
+#define __x86__
+#endif
+
+namespace sw
+{
+namespace
+{
+struct Allocation
+{
+//	size_t bytes;
+	unsigned char *block;
+};
+
+void *allocateRaw(size_t bytes, size_t alignment)
+{
+	ASSERT((alignment & (alignment - 1)) == 0);   // Power of 2 alignment.
+
+	#if defined(LINUX_ENABLE_NAMED_MMAP)
+		void *allocation;
+		int result = posix_memalign(&allocation, alignment, bytes);
+		if(result != 0)
+		{
+			errno = result;
+			allocation = nullptr;
+		}
+		return allocation;
+	#else
+		unsigned char *block = new unsigned char[bytes + sizeof(Allocation) + alignment];
+		unsigned char *aligned = nullptr;
+
+		if(block)
+		{
+			aligned = (unsigned char*)((uintptr_t)(block + sizeof(Allocation) + alignment - 1) & -(intptr_t)alignment);
+			Allocation *allocation = (Allocation*)(aligned - sizeof(Allocation));
+
+		//	allocation->bytes = bytes;
+			allocation->block = block;
+		}
+
+		return aligned;
+	#endif
+}
+
+#if defined(LINUX_ENABLE_NAMED_MMAP)
+// Create a file descriptor for anonymous memory with the given
+// name. Returns -1 on failure.
+// TODO: remove once libc wrapper exists.
+int memfd_create(const char* name, unsigned int flags)
+{
+	#if __aarch64__
+	#define __NR_memfd_create 279
+	#elif __arm__
+	#define __NR_memfd_create 279
+	#elif __powerpc64__
+	#define __NR_memfd_create 360
+	#elif __i386__
+	#define __NR_memfd_create 356
+	#elif __x86_64__
+	#define __NR_memfd_create 319
+	#endif /* __NR_memfd_create__ */
+	#ifdef __NR_memfd_create
+		// In the event of no system call this returns -1 with errno set
+		// as ENOSYS.
+		return syscall(__NR_memfd_create, name, flags);
+	#else
+		return -1;
+	#endif
+}
+
+// Returns a file descriptor for use with an anonymous mmap, if
+// memfd_create fails, -1 is returned. Note, the mappings should be
+// MAP_PRIVATE so that underlying pages aren't shared.
+int anonymousFd()
+{
+	static int fd = memfd_create("SwiftShader JIT", 0);
+	return fd;
+}
+
+// Ensure there is enough space in the "anonymous" fd for length.
+void ensureAnonFileSize(int anonFd, size_t length)
+{
+	static size_t fileSize = 0;
+	if(length > fileSize)
+	{
+		ftruncate(anonFd, length);
+		fileSize = length;
+	}
+}
+#endif  // defined(LINUX_ENABLE_NAMED_MMAP)
+
+}  // anonymous namespace
+
+size_t memoryPageSize()
+{
+	static int pageSize = 0;
+
+	if(pageSize == 0)
+	{
+		#if defined(_WIN32)
+			SYSTEM_INFO systemInfo;
+			GetSystemInfo(&systemInfo);
+			pageSize = systemInfo.dwPageSize;
+		#else
+			pageSize = sysconf(_SC_PAGESIZE);
+		#endif
+	}
+
+	return pageSize;
+}
+
+void *allocate(size_t bytes, size_t alignment)
+{
+	void *memory = allocateRaw(bytes, alignment);
+
+	if(memory)
+	{
+		memset(memory, 0, bytes);
+	}
+
+	return memory;
+}
+
+void deallocate(void *memory)
+{
+	#if defined(LINUX_ENABLE_NAMED_MMAP)
+		free(memory);
+	#else
+		if(memory)
+		{
+			unsigned char *aligned = (unsigned char*)memory;
+			Allocation *allocation = (Allocation*)(aligned - sizeof(Allocation));
+
+			delete[] allocation->block;
+		}
+	#endif
+}
+
+void *allocateExecutable(size_t bytes)
+{
+	size_t pageSize = memoryPageSize();
+	size_t length = (bytes + pageSize - 1) & ~(pageSize - 1);
+	void *mapping;
+
+	#if defined(LINUX_ENABLE_NAMED_MMAP)
+		// Try to name the memory region for the executable code,
+		// to aid profilers.
+		int anonFd = anonymousFd();
+		if(anonFd == -1)
+		{
+			mapping = mmap(nullptr, length, PROT_READ | PROT_WRITE,
+			               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+		}
+		else
+		{
+			ensureAnonFileSize(anonFd, length);
+			mapping = mmap(nullptr, length, PROT_READ | PROT_WRITE,
+			               MAP_PRIVATE, anonFd, 0);
+		}
+
+		if(mapping == MAP_FAILED)
+		{
+			mapping = nullptr;
+		}
+	#else
+		mapping = allocate(length, pageSize);
+	#endif
+
+	return mapping;
+}
+
+void markExecutable(void *memory, size_t bytes)
+{
+	#if defined(_WIN32)
+		unsigned long oldProtection;
+		VirtualProtect(memory, bytes, PAGE_EXECUTE_READ, &oldProtection);
+	#else
+		mprotect(memory, bytes, PROT_READ | PROT_EXEC);
+	#endif
+}
+
+void deallocateExecutable(void *memory, size_t bytes)
+{
+	#if defined(_WIN32)
+		unsigned long oldProtection;
+		VirtualProtect(memory, bytes, PAGE_READWRITE, &oldProtection);
+		deallocate(memory);
+	#elif defined(LINUX_ENABLE_NAMED_MMAP)
+		size_t pageSize = memoryPageSize();
+		size_t length = (bytes + pageSize - 1) & ~(pageSize - 1);
+		munmap(memory, length);
+	#else
+		mprotect(memory, bytes, PROT_READ | PROT_WRITE);
+		deallocate(memory);
+	#endif
+}
+
+void clear(uint16_t *memory, uint16_t element, size_t count)
+{
+	#if defined(_MSC_VER) && defined(__x86__) && !defined(MEMORY_SANITIZER)
+		__stosw(memory, element, count);
+	#elif defined(__GNUC__) && defined(__x86__) && !defined(MEMORY_SANITIZER)
+		__asm__("rep stosw" : : "D"(memory), "a"(element), "c"(count));
+	#else
+		for(size_t i = 0; i < count; i++)
+		{
+			memory[i] = element;
+		}
+	#endif
+}
+
+void clear(uint32_t *memory, uint32_t element, size_t count)
+{
+	#if defined(_MSC_VER) && defined(__x86__) && !defined(MEMORY_SANITIZER)
+		__stosd((unsigned long*)memory, element, count);
+	#elif defined(__GNUC__) && defined(__x86__) && !defined(MEMORY_SANITIZER)
+		__asm__("rep stosl" : : "D"(memory), "a"(element), "c"(count));
+	#else
+		for(size_t i = 0; i < count; i++)
+		{
+			memory[i] = element;
+		}
+	#endif
+}
+}
diff --git a/src/System/Memory.hpp b/src/System/Memory.hpp
new file mode 100644
index 0000000..8d3a159
--- /dev/null
+++ b/src/System/Memory.hpp
@@ -0,0 +1,36 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef Memory_hpp
+#define Memory_hpp
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace sw
+{
+size_t memoryPageSize();
+
+void *allocate(size_t bytes, size_t alignment = 16);
+void deallocate(void *memory);
+
+void *allocateExecutable(size_t bytes);   // Allocates memory that can be made executable using markExecutable()
+void markExecutable(void *memory, size_t bytes);
+void deallocateExecutable(void *memory, size_t bytes);
+
+void clear(uint16_t *memory, uint16_t element, size_t count);
+void clear(uint32_t *memory, uint32_t element, size_t count);
+}
+
+#endif   // Memory_hpp
diff --git a/src/System/MutexLock.hpp b/src/System/MutexLock.hpp
new file mode 100644
index 0000000..65e9fa4
--- /dev/null
+++ b/src/System/MutexLock.hpp
@@ -0,0 +1,199 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_MutexLock_hpp
+#define sw_MutexLock_hpp
+
+#include "Thread.hpp"
+
+#if defined(__linux__)
+// Use a pthread mutex on Linux. Since many processes may use SwiftShader
+// at the same time it's best to just have the scheduler overhead.
+#include <pthread.h>
+
+namespace sw
+{
+	class MutexLock
+	{
+	public:
+		MutexLock()
+		{
+			pthread_mutex_init(&mutex, NULL);
+		}
+
+		~MutexLock()
+		{
+			pthread_mutex_destroy(&mutex);
+		}
+
+		bool attemptLock()
+		{
+			return pthread_mutex_trylock(&mutex) == 0;
+		}
+
+		void lock()
+		{
+			pthread_mutex_lock(&mutex);
+		}
+
+		void unlock()
+		{
+			pthread_mutex_unlock(&mutex);
+		}
+
+	private:
+		pthread_mutex_t mutex;
+	};
+}
+
+#else   // !__linux__
+
+#include <atomic>
+
+namespace sw
+{
+	class BackoffLock
+	{
+	public:
+		BackoffLock()
+		{
+			mutex = 0;
+		}
+
+		bool attemptLock()
+		{
+			if(!isLocked())
+			{
+				if(mutex.exchange(true) == false)
+				{
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		void lock()
+		{
+			int backoff = 1;
+
+			while(!attemptLock())
+			{
+				if(backoff <= 64)
+				{
+					for(int i = 0; i < backoff; i++)
+					{
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+
+						nop();
+						nop();
+						nop();
+						nop();
+						nop();
+					}
+
+					backoff *= 2;
+				}
+				else
+				{
+					Thread::yield();
+
+					backoff = 1;
+				}
+			};
+		}
+
+		void unlock()
+		{
+			mutex.store(false, std::memory_order_release);
+		}
+
+		bool isLocked()
+		{
+			return mutex.load(std::memory_order_acquire);
+		}
+
+	private:
+		struct
+		{
+			// Ensure that the mutex variable is on its own 64-byte cache line to avoid false sharing
+			// Padding must be public to avoid compiler warnings
+			volatile int padding1[16];
+			std::atomic<bool> mutex;
+			volatile int padding2[15];
+		};
+	};
+
+	using MutexLock = BackoffLock;
+}
+
+#endif   // !__ANDROID__
+
+class LockGuard
+{
+public:
+	explicit LockGuard(sw::MutexLock &mutex) : mutex(&mutex)
+	{
+		mutex.lock();
+	}
+
+	explicit LockGuard(sw::MutexLock *mutex) : mutex(mutex)
+	{
+		if (mutex) mutex->lock();
+	}
+
+	~LockGuard()
+	{
+		if (mutex) mutex->unlock();
+	}
+
+protected:
+	sw::MutexLock *mutex;
+};
+
+#endif   // sw_MutexLock_hpp
diff --git a/src/System/Resource.cpp b/src/System/Resource.cpp
new file mode 100644
index 0000000..3a63810
--- /dev/null
+++ b/src/System/Resource.cpp
@@ -0,0 +1,184 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Resource.hpp"
+
+#include "Memory.hpp"
+#include "Debug.hpp"
+
+namespace sw
+{
+	Resource::Resource(size_t bytes) : size(bytes)
+	{
+		blocked = 0;
+
+		accessor = PUBLIC;
+		count = 0;
+		orphaned = false;
+
+		buffer = allocate(bytes);
+	}
+
+	Resource::~Resource()
+	{
+		deallocate(buffer);
+	}
+
+	void *Resource::lock(Accessor claimer)
+	{
+		criticalSection.lock();
+
+		while(count > 0 && accessor != claimer)
+		{
+			blocked++;
+			criticalSection.unlock();
+
+			unblock.wait();
+
+			criticalSection.lock();
+			blocked--;
+		}
+
+		accessor = claimer;
+		count++;
+
+		criticalSection.unlock();
+
+		return buffer;
+	}
+
+	void *Resource::lock(Accessor relinquisher, Accessor claimer)
+	{
+		criticalSection.lock();
+
+		// Release
+		while(count > 0 && accessor == relinquisher)
+		{
+			count--;
+
+			if(count == 0)
+			{
+				if(blocked)
+				{
+					unblock.signal();
+				}
+				else if(orphaned)
+				{
+					criticalSection.unlock();
+
+					delete this;
+
+					return 0;
+				}
+			}
+		}
+
+		// Acquire
+		while(count > 0 && accessor != claimer)
+		{
+			blocked++;
+			criticalSection.unlock();
+
+			unblock.wait();
+
+			criticalSection.lock();
+			blocked--;
+		}
+
+		accessor = claimer;
+		count++;
+
+		criticalSection.unlock();
+
+		return buffer;
+	}
+
+	void Resource::unlock()
+	{
+		criticalSection.lock();
+		ASSERT(count > 0);
+
+		count--;
+
+		if(count == 0)
+		{
+			if(blocked)
+			{
+				unblock.signal();
+			}
+			else if(orphaned)
+			{
+				criticalSection.unlock();
+
+				delete this;
+
+				return;
+			}
+		}
+
+		criticalSection.unlock();
+	}
+
+	void Resource::unlock(Accessor relinquisher)
+	{
+		criticalSection.lock();
+		ASSERT(count > 0);
+
+		while(count > 0 && accessor == relinquisher)
+		{
+			count--;
+
+			if(count == 0)
+			{
+				if(blocked)
+				{
+					unblock.signal();
+				}
+				else if(orphaned)
+				{
+					criticalSection.unlock();
+
+					delete this;
+
+					return;
+				}
+			}
+		}
+
+		criticalSection.unlock();
+	}
+
+	void Resource::destruct()
+	{
+		criticalSection.lock();
+
+		if(count == 0 && !blocked)
+		{
+			criticalSection.unlock();
+
+			delete this;
+
+			return;
+		}
+
+		orphaned = true;
+
+		criticalSection.unlock();
+	}
+
+	const void *Resource::data() const
+	{
+		return buffer;
+	}
+}
diff --git a/src/System/Resource.hpp b/src/System/Resource.hpp
new file mode 100644
index 0000000..0acfa48
--- /dev/null
+++ b/src/System/Resource.hpp
@@ -0,0 +1,60 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Resource_hpp
+#define sw_Resource_hpp
+
+#include "MutexLock.hpp"
+
+namespace sw
+{
+	enum Accessor
+	{
+		PUBLIC,    // Application/API access
+		PRIVATE,   // Renderer access, shared by multiple threads if read-only
+		MANAGED,   // Renderer access, shared read/write access if partitioned
+		EXCLUSIVE
+	};
+
+	class Resource
+	{
+	public:
+		Resource(size_t bytes);
+
+		void destruct();   // Asynchronous destructor
+
+		void *lock(Accessor claimer);
+		void *lock(Accessor relinquisher, Accessor claimer);
+		void unlock();
+		void unlock(Accessor relinquisher);
+
+		const void *data() const;
+		const size_t size;
+
+	private:
+		~Resource();   // Always call destruct() instead
+
+		MutexLock criticalSection;
+		Event unblock;
+		volatile int blocked;
+
+		volatile Accessor accessor;
+		volatile int count;
+		bool orphaned;
+
+		void *buffer;
+	};
+}
+
+#endif   // sw_Resource_hpp
diff --git a/src/System/SharedLibrary.hpp b/src/System/SharedLibrary.hpp
new file mode 100644
index 0000000..8a8c3a1
--- /dev/null
+++ b/src/System/SharedLibrary.hpp
@@ -0,0 +1,171 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SharedLibrary_hpp
+#define SharedLibrary_hpp
+
+#if defined(_WIN32)
+	#include <Windows.h>
+#else
+	#include <dlfcn.h>
+#endif
+
+#include <string>
+
+void *getLibraryHandle(const char *path);
+void *loadLibrary(const char *path);
+void freeLibrary(void *library);
+void *getProcAddress(void *library, const char *name);
+
+template<int n>
+void *loadLibrary(const std::string &libraryDirectory, const char *(&names)[n], const char *mustContainSymbol = nullptr)
+{
+	for(const char *libraryName : names)
+	{
+		std::string libraryPath = libraryDirectory + libraryName;
+		void *library = getLibraryHandle(libraryPath.c_str());
+
+		if(library)
+		{
+			if(!mustContainSymbol || getProcAddress(library, mustContainSymbol))
+			{
+				return library;
+			}
+
+			freeLibrary(library);
+		}
+	}
+
+	for(const char *libraryName : names)
+	{
+		std::string libraryPath = libraryDirectory + libraryName;
+		void *library = loadLibrary(libraryPath.c_str());
+
+		if(library)
+		{
+			if(!mustContainSymbol || getProcAddress(library, mustContainSymbol))
+			{
+				return library;
+			}
+
+			freeLibrary(library);
+		}
+	}
+
+	return nullptr;
+}
+
+#if defined(_WIN32)
+	inline void *loadLibrary(const char *path)
+	{
+		return (void*)LoadLibrary(path);
+	}
+
+	inline void *getLibraryHandle(const char *path)
+	{
+		HMODULE module = NULL;
+		GetModuleHandleEx(0, path, &module);
+		return (void*)module;
+	}
+
+	inline void freeLibrary(void *library)
+	{
+		FreeLibrary((HMODULE)library);
+	}
+
+	inline void *getProcAddress(void *library, const char *name)
+	{
+		return (void*)GetProcAddress((HMODULE)library, name);
+	}
+
+	inline std::string getModuleDirectory()
+	{
+		static int dummy_symbol = 0;
+
+		HMODULE module = NULL;
+		GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCTSTR)&dummy_symbol, &module);
+
+		char filename[1024];
+		if(module && (GetModuleFileName(module, filename, sizeof(filename)) != 0))
+		{
+			std::string directory(filename);
+			return directory.substr(0, directory.find_last_of("\\/") + 1).c_str();
+		}
+		else
+		{
+			return "";
+		}
+	}
+#else
+	inline void *loadLibrary(const char *path)
+	{
+		return dlopen(path, RTLD_LAZY | RTLD_LOCAL);
+	}
+
+	inline void *getLibraryHandle(const char *path)
+	{
+		#ifdef __ANDROID__
+			// bionic doesn't support RTLD_NOLOAD before L
+			return dlopen(path, RTLD_NOW | RTLD_LOCAL);
+		#else
+			void *resident = dlopen(path, RTLD_LAZY | RTLD_NOLOAD | RTLD_LOCAL);
+
+			if(resident)
+			{
+				return dlopen(path, RTLD_LAZY | RTLD_LOCAL);   // Increment reference count
+			}
+
+			return nullptr;
+		#endif
+	}
+
+	inline void freeLibrary(void *library)
+	{
+		if(library)
+		{
+			dlclose(library);
+		}
+	}
+
+	inline void *getProcAddress(void *library, const char *name)
+	{
+		void *symbol = dlsym(library, name);
+
+		if(!symbol)
+		{
+			const char *reason = dlerror();   // Silence the error
+			(void)reason;
+		}
+
+		return symbol;
+	}
+
+	inline std::string getModuleDirectory()
+	{
+		static int dummy_symbol = 0;
+
+		Dl_info dl_info;
+		if(dladdr(&dummy_symbol, &dl_info) != 0)
+		{
+			std::string directory(dl_info.dli_fname);
+			return directory.substr(0, directory.find_last_of("\\/") + 1).c_str();
+		}
+		else
+		{
+			return "";
+		}
+	}
+#endif
+
+#endif   // SharedLibrary_hpp
diff --git a/src/System/Socket.cpp b/src/System/Socket.cpp
new file mode 100644
index 0000000..b098031
--- /dev/null
+++ b/src/System/Socket.cpp
@@ -0,0 +1,110 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Socket.hpp"
+
+#if defined(_WIN32)
+	#include <ws2tcpip.h>
+#else
+	#include <unistd.h>
+	#include <netdb.h>
+	#include <netinet/in.h>
+	#include <sys/select.h>
+#endif
+
+namespace sw
+{
+	Socket::Socket(SOCKET socket) : socket(socket)
+	{
+	}
+
+	Socket::Socket(const char *address, const char *port)
+	{
+		#if defined(_WIN32)
+			socket = INVALID_SOCKET;
+		#else
+			socket = -1;
+		#endif
+
+		addrinfo hints = {};
+		hints.ai_family = AF_INET;
+		hints.ai_socktype = SOCK_STREAM;
+		hints.ai_protocol = IPPROTO_TCP;
+		hints.ai_flags = AI_PASSIVE;
+
+		addrinfo *info = 0;
+		getaddrinfo(address, port, &hints, &info);
+
+		if(info)
+		{
+			socket = ::socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+			bind(socket, info->ai_addr, (int)info->ai_addrlen);
+		}
+	}
+
+	Socket::~Socket()
+	{
+		#if defined(_WIN32)
+			closesocket(socket);
+		#else
+			close(socket);
+		#endif
+	}
+
+	void Socket::listen(int backlog)
+	{
+		::listen(socket, backlog);
+	}
+
+	bool Socket::select(int us)
+	{
+		fd_set sockets;
+		FD_ZERO(&sockets);
+		FD_SET(socket, &sockets);
+
+		timeval timeout = {us / 1000000, us % 1000000};
+
+		return ::select(FD_SETSIZE, &sockets, 0, 0, &timeout) >= 1;
+	}
+
+	Socket *Socket::accept()
+	{
+		return new Socket(::accept(socket, 0, 0));
+	}
+
+	int Socket::receive(char *buffer, int length)
+	{
+		return recv(socket, buffer, length, 0);
+	}
+
+	void Socket::send(const char *buffer, int length)
+	{
+		::send(socket, buffer, length, 0);
+	}
+
+	void Socket::startup()
+	{
+		#if defined(_WIN32)
+			WSADATA winsockData;
+			WSAStartup(MAKEWORD(2, 2), &winsockData);
+		#endif
+	}
+
+	void Socket::cleanup()
+	{
+		#if defined(_WIN32)
+			WSACleanup();
+		#endif
+	}
+}
diff --git a/src/System/Socket.hpp b/src/System/Socket.hpp
new file mode 100644
index 0000000..b6b9abd
--- /dev/null
+++ b/src/System/Socket.hpp
@@ -0,0 +1,49 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Socket_hpp
+#define sw_Socket_hpp
+
+#if defined(_WIN32)
+	#include <winsock2.h>
+#else
+	#include <sys/socket.h>
+	typedef int SOCKET;
+#endif
+
+namespace sw
+{
+	class Socket
+	{
+	public:
+		Socket(SOCKET socket);
+		Socket(const char *address, const char *port);
+		~Socket();
+
+		void listen(int backlog = 1);
+		bool select(int us);
+		Socket *accept();
+		
+		int receive(char *buffer, int length);
+		void send(const char *buffer, int length);
+
+		static void startup();
+		static void cleanup();
+
+	private:
+		SOCKET socket;
+	};
+}
+
+#endif   // sw_Socket_hpp
diff --git a/src/System/Thread.cpp b/src/System/Thread.cpp
new file mode 100644
index 0000000..df9a0b7
--- /dev/null
+++ b/src/System/Thread.cpp
@@ -0,0 +1,91 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Thread.hpp"
+
+namespace sw
+{
+	Thread::Thread(void (*threadFunction)(void *parameters), void *parameters)
+	{
+		Event init;
+		Entry entry = {threadFunction, parameters, &init};
+
+		#if defined(_WIN32)
+			handle = CreateThread(NULL, 1024 * 1024, startFunction, &entry, 0, NULL);
+		#else
+			pthread_create(&handle, NULL, startFunction, &entry);
+		#endif
+
+		init.wait();
+	}
+
+	Thread::~Thread()
+	{
+		join();   // Make threads exit before deleting them to not block here
+	}
+
+	void Thread::join()
+	{
+		if(!hasJoined)
+		{
+			#if defined(_WIN32)
+				WaitForSingleObject(handle, INFINITE);
+				CloseHandle(handle);
+			#else
+				pthread_join(handle, NULL);
+			#endif
+
+			hasJoined = true;
+		}
+	}
+
+	#if defined(_WIN32)
+		unsigned long __stdcall Thread::startFunction(void *parameters)
+		{
+			Entry entry = *(Entry*)parameters;
+			entry.init->signal();
+			entry.threadFunction(entry.threadParameters);
+			return 0;
+		}
+	#else
+		void *Thread::startFunction(void *parameters)
+		{
+			Entry entry = *(Entry*)parameters;
+			entry.init->signal();
+			entry.threadFunction(entry.threadParameters);
+			return nullptr;
+		}
+	#endif
+
+	Event::Event()
+	{
+		#if defined(_WIN32)
+			handle = CreateEvent(NULL, FALSE, FALSE, NULL);
+		#else
+			pthread_cond_init(&handle, NULL);
+			pthread_mutex_init(&mutex, NULL);
+			signaled = false;
+		#endif
+	}
+
+	Event::~Event()
+	{
+		#if defined(_WIN32)
+			CloseHandle(handle);
+		#else
+			pthread_cond_destroy(&handle);
+			pthread_mutex_destroy(&mutex);
+		#endif
+	}
+}
diff --git a/src/System/Thread.hpp b/src/System/Thread.hpp
new file mode 100644
index 0000000..b8280f1
--- /dev/null
+++ b/src/System/Thread.hpp
@@ -0,0 +1,338 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Thread_hpp
+#define sw_Thread_hpp
+
+#if defined(_WIN32)
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <intrin.h>
+#else
+	#include <pthread.h>
+	#include <sched.h>
+	#include <unistd.h>
+	#define TLS_OUT_OF_INDEXES (pthread_key_t)(~0)
+#endif
+
+#include <stdlib.h>
+
+#if defined(__clang__)
+#if __has_include(<atomic>) // clang has an explicit check for the availability of atomic
+#define USE_STD_ATOMIC 1
+#endif
+// atomic is available in C++11 or newer, and in Visual Studio 2012 or newer
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1700)) || (__cplusplus >= 201103L)
+#define USE_STD_ATOMIC 1
+#endif
+
+#if USE_STD_ATOMIC
+#include <atomic>
+#endif
+
+namespace sw
+{
+	class Event;
+
+	class Thread
+	{
+	public:
+		Thread(void (*threadFunction)(void *parameters), void *parameters);
+
+		~Thread();
+
+		void join();
+
+		static void yield();
+		static void sleep(int milliseconds);
+
+		#if defined(_WIN32)
+			typedef DWORD LocalStorageKey;
+		#else
+			typedef pthread_key_t LocalStorageKey;
+		#endif
+
+		static LocalStorageKey allocateLocalStorageKey(void (*destructor)(void *storage) = free);
+		static void freeLocalStorageKey(LocalStorageKey key);
+		static void *allocateLocalStorage(LocalStorageKey key, size_t size);
+		static void *getLocalStorage(LocalStorageKey key);
+		static void freeLocalStorage(LocalStorageKey key);
+
+	private:
+		struct Entry
+		{
+			void (*const threadFunction)(void *parameters);
+			void *threadParameters;
+			Event *init;
+		};
+
+		#if defined(_WIN32)
+			static unsigned long __stdcall startFunction(void *parameters);
+			HANDLE handle;
+		#else
+			static void *startFunction(void *parameters);
+			pthread_t handle;
+		#endif
+
+		bool hasJoined = false;
+	};
+
+	class Event
+	{
+		friend class Thread;
+
+	public:
+		Event();
+
+		~Event();
+
+		void signal();
+		void wait();
+
+	private:
+		#if defined(_WIN32)
+			HANDLE handle;
+		#else
+			pthread_cond_t handle;
+			pthread_mutex_t mutex;
+			volatile bool signaled;
+		#endif
+	};
+
+	#if PERF_PROFILE
+	int64_t atomicExchange(int64_t volatile *target, int64_t value);
+	int atomicExchange(int volatile *target, int value);
+	#endif
+
+	int atomicIncrement(int volatile *value);
+	int atomicDecrement(int volatile *value);
+	int atomicAdd(int volatile *target, int value);
+	void nop();
+}
+
+namespace sw
+{
+	inline void Thread::yield()
+	{
+		#if defined(_WIN32)
+			Sleep(0);
+		#elif defined(__APPLE__)
+			pthread_yield_np();
+		#else
+			sched_yield();
+		#endif
+	}
+
+	inline void Thread::sleep(int milliseconds)
+	{
+		#if defined(_WIN32)
+			Sleep(milliseconds);
+		#else
+			usleep(1000 * milliseconds);
+		#endif
+	}
+
+	inline Thread::LocalStorageKey Thread::allocateLocalStorageKey(void (*destructor)(void *storage))
+	{
+		#if defined(_WIN32)
+			return TlsAlloc();
+		#else
+			LocalStorageKey key;
+			pthread_key_create(&key, destructor);
+			return key;
+		#endif
+	}
+
+	inline void Thread::freeLocalStorageKey(LocalStorageKey key)
+	{
+		#if defined(_WIN32)
+			TlsFree(key);
+		#else
+			pthread_key_delete(key);   // Using an invalid key is an error but not undefined behavior.
+		#endif
+	}
+
+	inline void *Thread::allocateLocalStorage(LocalStorageKey key, size_t size)
+	{
+		if(key == TLS_OUT_OF_INDEXES)
+		{
+			return nullptr;
+		}
+
+		freeLocalStorage(key);
+
+		void *storage = malloc(size);
+
+		#if defined(_WIN32)
+			TlsSetValue(key, storage);
+		#else
+			pthread_setspecific(key, storage);
+		#endif
+
+		return storage;
+	}
+
+	inline void *Thread::getLocalStorage(LocalStorageKey key)
+	{
+		#if defined(_WIN32)
+			return TlsGetValue(key);
+		#else
+			if(key == TLS_OUT_OF_INDEXES)   // Avoid undefined behavior.
+			{
+				return nullptr;
+			}
+
+			return pthread_getspecific(key);
+		#endif
+	}
+
+	inline void Thread::freeLocalStorage(LocalStorageKey key)
+	{
+		free(getLocalStorage(key));
+
+		#if defined(_WIN32)
+			TlsSetValue(key, nullptr);
+		#else
+			pthread_setspecific(key, nullptr);
+		#endif
+	}
+
+	inline void Event::signal()
+	{
+		#if defined(_WIN32)
+			SetEvent(handle);
+		#else
+			pthread_mutex_lock(&mutex);
+			signaled = true;
+			pthread_cond_signal(&handle);
+			pthread_mutex_unlock(&mutex);
+		#endif
+	}
+
+	inline void Event::wait()
+	{
+		#if defined(_WIN32)
+			WaitForSingleObject(handle, INFINITE);
+		#else
+			pthread_mutex_lock(&mutex);
+			while(!signaled) pthread_cond_wait(&handle, &mutex);
+			signaled = false;
+			pthread_mutex_unlock(&mutex);
+		#endif
+	}
+
+	#if PERF_PROFILE
+	inline int64_t atomicExchange(volatile int64_t *target, int64_t value)
+	{
+		#if defined(_WIN32)
+			return InterlockedExchange64(target, value);
+		#else
+			int ret;
+			__asm__ __volatile__("lock; xchg8 %x0,(%x1)" : "=r" (ret) :"r" (target), "0" (value) : "memory" );
+			return ret;
+		#endif
+	}
+
+	inline int atomicExchange(volatile int *target, int value)
+	{
+		#if defined(_WIN32)
+			return InterlockedExchange((volatile long*)target, (long)value);
+		#else
+			int ret;
+			__asm__ __volatile__("lock; xchgl %x0,(%x1)" : "=r" (ret) :"r" (target), "0" (value) : "memory" );
+			return ret;
+		#endif
+	}
+	#endif
+
+	inline int atomicIncrement(volatile int *value)
+	{
+		#if defined(_WIN32)
+			return InterlockedIncrement((volatile long*)value);
+		#else
+			return __sync_add_and_fetch(value, 1);
+		#endif
+	}
+
+	inline int atomicDecrement(volatile int *value)
+	{
+		#if defined(_WIN32)
+			return InterlockedDecrement((volatile long*)value);
+		#else
+			return __sync_sub_and_fetch(value, 1);
+		#endif
+	}
+
+	inline int atomicAdd(volatile int* target, int value)
+	{
+		#if defined(_WIN32)
+			return InterlockedExchangeAdd((volatile long*)target, value) + value;
+		#else
+			return __sync_add_and_fetch(target, value);
+		#endif
+	}
+
+	inline void nop()
+	{
+		#if defined(_WIN32)
+			__nop();
+		#else
+			__asm__ __volatile__ ("nop");
+		#endif
+	}
+
+	#if USE_STD_ATOMIC
+		class AtomicInt
+		{
+		public:
+			AtomicInt() : ai() {}
+			AtomicInt(int i) : ai(i) {}
+
+			inline operator int() const { return ai.load(std::memory_order_acquire); }
+			inline void operator=(const AtomicInt& i) { ai.store(i.ai.load(std::memory_order_acquire), std::memory_order_release); }
+			inline void operator=(int i) { ai.store(i, std::memory_order_release); }
+			inline void operator--() { ai.fetch_sub(1, std::memory_order_acq_rel); }
+			inline void operator++() { ai.fetch_add(1, std::memory_order_acq_rel); }
+			inline int operator--(int) { return ai.fetch_sub(1, std::memory_order_acq_rel) - 1; }
+			inline int operator++(int) { return ai.fetch_add(1, std::memory_order_acq_rel) + 1; }
+			inline void operator-=(int i) { ai.fetch_sub(i, std::memory_order_acq_rel); }
+			inline void operator+=(int i) { ai.fetch_add(i, std::memory_order_acq_rel); }
+		private:
+			std::atomic<int> ai;
+		};
+	#else
+		class AtomicInt
+		{
+		public:
+			AtomicInt() {}
+			AtomicInt(int i) : vi(i) {}
+
+			inline operator int() const { return vi; } // Note: this isn't a guaranteed atomic operation
+			inline void operator=(const AtomicInt& i) { sw::atomicExchange(&vi, i.vi); }
+			inline void operator=(int i) { sw::atomicExchange(&vi, i); }
+			inline void operator--() { sw::atomicDecrement(&vi); }
+			inline void operator++() { sw::atomicIncrement(&vi); }
+			inline int operator--(int) { return sw::atomicDecrement(&vi); }
+			inline int operator++(int) { return sw::atomicIncrement(&vi); }
+			inline void operator-=(int i) { sw::atomicAdd(&vi, -i); }
+			inline void operator+=(int i) { sw::atomicAdd(&vi, i); }
+		private:
+			volatile int vi;
+		};
+	#endif
+}
+
+#endif   // sw_Thread_hpp
diff --git a/src/System/Timer.cpp b/src/System/Timer.cpp
new file mode 100644
index 0000000..8ff2cf3
--- /dev/null
+++ b/src/System/Timer.cpp
@@ -0,0 +1,95 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "Timer.hpp"
+
+#if !defined(__i386__) && defined(_M_IX86)
+	#define __i386__ 1
+#endif
+
+#if !defined(__x86_64__) && (defined(_M_AMD64) || defined (_M_X64))
+	#define __x86_64__ 1
+#endif
+
+#if defined(_WIN32)
+	#ifndef WIN32_LEAN_AND_MEAN
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+	#include <windows.h>
+	#include <intrin.h>
+#else
+	#include <sys/time.h>
+	#if defined(__i386__) || defined(__x86_64__)
+		#include <x86intrin.h>
+	#endif
+#endif
+
+namespace sw
+{
+	Timer::Timer()
+	{
+	}
+
+	Timer::~Timer()
+	{
+	}
+
+	double Timer::seconds()
+	{
+		#if defined(_WIN32)
+			return (double)counter() / (double)frequency();
+		#else
+			timeval t;
+			gettimeofday(&t, 0);
+			return (double)t.tv_sec + (double)t.tv_usec * 1.0e-6;
+		#endif
+	}
+
+	int64_t Timer::ticks()
+	{
+		#if defined(_WIN32)
+			return __rdtsc();
+		#elif defined(__i386__) || defined(__x86_64__)
+			int64_t tsc;
+			__asm volatile("rdtsc": "=A" (tsc));
+			return tsc;
+		#else
+			return 0;
+		#endif
+	}
+
+	int64_t Timer::counter()
+	{
+		#if defined(_WIN32)
+			int64_t counter;
+			QueryPerformanceCounter((LARGE_INTEGER*)&counter);
+			return counter;
+		#else
+			timeval t;
+			gettimeofday(&t, 0);
+			return t.tv_sec * 1000000 + t.tv_usec;
+		#endif
+	}
+
+	int64_t Timer::frequency()
+	{
+		#if defined(_WIN32)
+			int64_t frequency;
+			QueryPerformanceFrequency((LARGE_INTEGER*)&frequency);
+			return frequency;
+		#else
+			return 1000000;   // gettimeofday uses microsecond resolution
+		#endif
+	}
+}
diff --git a/src/System/Timer.hpp b/src/System/Timer.hpp
new file mode 100644
index 0000000..977c877
--- /dev/null
+++ b/src/System/Timer.hpp
@@ -0,0 +1,37 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Timer_hpp
+#define sw_Timer_hpp
+
+#include "Types.hpp"
+
+namespace sw
+{
+	class Timer
+	{
+	public:
+		Timer();
+
+		~Timer();
+
+		static double seconds();
+		static int64_t ticks();
+
+		static int64_t counter();
+		static int64_t frequency();
+	};
+}
+
+#endif   // sw_Timer_hpp
diff --git a/src/System/Types.hpp b/src/System/Types.hpp
new file mode 100644
index 0000000..cd08ed5
--- /dev/null
+++ b/src/System/Types.hpp
@@ -0,0 +1,157 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_Types_hpp
+#define sw_Types_hpp
+
+#include <limits>
+#include <type_traits>
+
+// GCC warns against bitfields not fitting the entire range of an enum with a fixed underlying type of unsigned int, which gets promoted to an error with -Werror and cannot be suppressed.
+// However, GCC already defaults to using unsigned int as the underlying type of an unscoped enum without a fixed underlying type. So we can just omit it.
+#if defined(__GNUC__) && !defined(__clang__)
+namespace {enum E {}; static_assert(!std::numeric_limits<std::underlying_type<E>::type>::is_signed, "expected unscoped enum whose underlying type is not fixed to be unsigned");}
+#define ENUM_UNDERLYING_TYPE_UNSIGNED_INT
+#else
+#define ENUM_UNDERLYING_TYPE_UNSIGNED_INT : unsigned int
+#endif
+
+#if defined(_MSC_VER)
+	typedef signed __int8 int8_t;
+	typedef signed __int16 int16_t;
+	typedef signed __int32 int32_t;
+	typedef signed __int64 int64_t;
+	typedef unsigned __int8 uint8_t;
+	typedef unsigned __int16 uint16_t;
+	typedef unsigned __int32 uint32_t;
+	typedef unsigned __int64 uint64_t;
+	#define ALIGN(bytes, type) __declspec(align(bytes)) type
+#else
+	#include <stdint.h>
+	#define ALIGN(bytes, type) type __attribute__((aligned(bytes)))
+#endif
+
+namespace sw
+{
+	typedef ALIGN(1, uint8_t) byte;
+	typedef ALIGN(2, uint16_t) word;
+	typedef ALIGN(4, uint32_t) dword;
+	typedef ALIGN(8, uint64_t) qword;
+	typedef ALIGN(16, uint64_t) qword2[2];
+	typedef ALIGN(4, uint8_t) byte4[4];
+	typedef ALIGN(8, uint8_t) byte8[8];
+	typedef ALIGN(16, uint8_t) byte16[16];
+	typedef ALIGN(8, uint16_t) word4[4];
+	typedef ALIGN(8, uint32_t) dword2[2];
+	typedef ALIGN(16, uint32_t) dword4[4];
+	typedef ALIGN(16, uint64_t) xword[2];
+
+	typedef ALIGN(1, int8_t) sbyte;
+	typedef ALIGN(4, int8_t) sbyte4[4];
+	typedef ALIGN(8, int8_t) sbyte8[8];
+	typedef ALIGN(16, int8_t) sbyte16[16];
+	typedef ALIGN(8, short) short4[4];
+	typedef ALIGN(8, unsigned short) ushort4[4];
+	typedef ALIGN(16, short) short8[8];
+	typedef ALIGN(16, unsigned short) ushort8[8];
+	typedef ALIGN(8, int) int2[2];
+	typedef ALIGN(8, unsigned int) uint2[2];
+	typedef ALIGN(16, unsigned int) uint4[4];
+
+	typedef ALIGN(8, float) float2[2];
+
+	ALIGN(16, struct int4
+	{
+		int x;
+		int y;
+		int z;
+		int w;
+
+		int &operator[](int i)
+		{
+			return (&x)[i];
+		}
+
+		const int &operator[](int i) const
+		{
+			return (&x)[i];
+		}
+
+		bool operator!=(const int4 &rhs)
+		{
+			return x != rhs.x || y != rhs.y || z != rhs.z || w != rhs.w;
+		}
+
+		bool operator==(const int4 &rhs)
+		{
+			return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
+		}
+	});
+
+	ALIGN(16, struct float4
+	{
+		float x;
+		float y;
+		float z;
+		float w;
+
+		float &operator[](int i)
+		{
+			return (&x)[i];
+		}
+
+		const float &operator[](int i) const
+		{
+			return (&x)[i];
+		}
+
+		bool operator!=(const float4 &rhs)
+		{
+			return x != rhs.x || y != rhs.y || z != rhs.z || w != rhs.w;
+		}
+
+		bool operator==(const float4 &rhs)
+		{
+			return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
+		}
+	});
+
+	inline float4 vector(float x, float y, float z, float w)
+	{
+		float4 v;
+
+		v.x = x;
+		v.y = y;
+		v.z = z;
+		v.w = w;
+
+		return v;
+	}
+
+	inline float4 replicate(float f)
+	{
+		float4 v;
+
+		v.x = f;
+		v.y = f;
+		v.z = f;
+		v.w = f;
+
+		return v;
+	}
+
+	#define OFFSET(s,m) (int)(size_t)&reinterpret_cast<const volatile char&>((((s*)0)->m))
+}
+
+#endif   // sw_Types_hpp
diff --git a/src/System/Version.h b/src/System/Version.h
new file mode 100644
index 0000000..72bd15d
--- /dev/null
+++ b/src/System/Version.h
@@ -0,0 +1,24 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#define MAJOR_VERSION 4
+#define MINOR_VERSION 1
+#define BUILD_VERSION 0
+#define BUILD_REVISION 2
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+#define REVISION_STRING MACRO_STRINGIFY(BUILD_REVISION)
+#define VERSION_STRING MACRO_STRINGIFY(MAJOR_VERSION) "." MACRO_STRINGIFY(MINOR_VERSION) "." MACRO_STRINGIFY(BUILD_VERSION) "." MACRO_STRINGIFY(BUILD_REVISION)
diff --git a/src/WSI/FrameBuffer.cpp b/src/WSI/FrameBuffer.cpp
new file mode 100644
index 0000000..7a8ddc1
--- /dev/null
+++ b/src/WSI/FrameBuffer.cpp
@@ -0,0 +1,638 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBuffer.hpp"
+
+#include "Renderer/Surface.hpp"
+#include "Reactor/Reactor.hpp"
+#include "Common/Timer.hpp"
+#include "Common/Debug.hpp"
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#define ASYNCHRONOUS_BLIT false   // FIXME: Currently leads to rare race conditions
+
+namespace sw
+{
+	extern bool forceWindowed;
+
+	FrameBuffer::Cursor FrameBuffer::cursor = {};
+	bool FrameBuffer::topLeftOrigin = false;
+
+	FrameBuffer::FrameBuffer(int width, int height, bool fullscreen, bool topLeftOrigin)
+	{
+		this->topLeftOrigin = topLeftOrigin;
+
+		framebuffer = nullptr;
+
+		this->width = width;
+		this->height = height;
+		format = FORMAT_X8R8G8B8;
+		stride = 0;
+
+		windowed = !fullscreen || forceWindowed;
+
+		blitFunction = nullptr;
+		blitRoutine = nullptr;
+		blitState = {};
+
+		if(ASYNCHRONOUS_BLIT)
+		{
+			terminate = false;
+			FrameBuffer *parameters = this;
+			blitThread = new Thread(threadFunction, &parameters);
+		}
+	}
+
+	FrameBuffer::~FrameBuffer()
+	{
+		if(ASYNCHRONOUS_BLIT)
+		{
+			terminate = true;
+			blitEvent.signal();
+			blitThread->join();
+			delete blitThread;
+		}
+
+		delete blitRoutine;
+	}
+
+	void FrameBuffer::setCursorImage(sw::Surface *cursorImage)
+	{
+		if(cursorImage)
+		{
+			cursor.image = cursorImage->lockExternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
+			cursorImage->unlockExternal();
+
+			cursor.width = cursorImage->getWidth();
+			cursor.height = cursorImage->getHeight();
+		}
+		else
+		{
+			cursor.width = 0;
+			cursor.height = 0;
+		}
+	}
+
+	void FrameBuffer::setCursorOrigin(int x0, int y0)
+	{
+		cursor.hotspotX = x0;
+		cursor.hotspotY = y0;
+	}
+
+	void FrameBuffer::setCursorPosition(int x, int y)
+	{
+		cursor.positionX = x;
+		cursor.positionY = y;
+	}
+
+	void FrameBuffer::copy(sw::Surface *source)
+	{
+		if(!source)
+		{
+			return;
+		}
+
+		if(!lock())
+		{
+			return;
+		}
+
+		int sourceStride = source->getInternalPitchB();
+
+		updateState = {};
+		updateState.width = width;
+		updateState.height = height;
+		updateState.destFormat = format;
+		updateState.destStride = stride;
+		updateState.sourceFormat = source->getInternalFormat();
+		updateState.sourceStride = topLeftOrigin ? sourceStride : -sourceStride;
+		updateState.cursorWidth = cursor.width;
+		updateState.cursorHeight = cursor.height;
+
+		renderbuffer = source->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
+
+		if(!topLeftOrigin)
+		{
+			renderbuffer = (byte*)renderbuffer + (height - 1) * sourceStride;
+		}
+
+		cursor.x = cursor.positionX - cursor.hotspotX;
+		cursor.y = cursor.positionY - cursor.hotspotY;
+
+		if(ASYNCHRONOUS_BLIT)
+		{
+			blitEvent.signal();
+			syncEvent.wait();
+		}
+		else
+		{
+			copyLocked();
+		}
+
+		source->unlockInternal();
+		unlock();
+
+		profiler.nextFrame();   // Assumes every copy() is a full frame
+	}
+
+	void FrameBuffer::copyLocked()
+	{
+		if(memcmp(&blitState, &updateState, sizeof(BlitState)) != 0)
+		{
+			blitState = updateState;
+			delete blitRoutine;
+
+			blitRoutine = copyRoutine(blitState);
+			blitFunction = (void(*)(void*, void*, Cursor*))blitRoutine->getEntry();
+		}
+
+		blitFunction(framebuffer, renderbuffer, &cursor);
+	}
+
+	Routine *FrameBuffer::copyRoutine(const BlitState &state)
+	{
+		const int width = state.width;
+		const int height = state.height;
+		const int dBytes = Surface::bytes(state.destFormat);
+		const int dStride = state.destStride;
+		const int sBytes = Surface::bytes(state.sourceFormat);
+		const int sStride = state.sourceStride;
+
+		Function<Void(Pointer<Byte>, Pointer<Byte>, Pointer<Byte>)> function;
+		{
+			Pointer<Byte> dst(function.Arg<0>());
+			Pointer<Byte> src(function.Arg<1>());
+			Pointer<Byte> cursor(function.Arg<2>());
+
+			For(Int y = 0, y < height, y++)
+			{
+				Pointer<Byte> d = dst + y * dStride;
+				Pointer<Byte> s = src + y * sStride;
+
+				Int x0 = 0;
+
+				switch(state.destFormat)
+				{
+				case FORMAT_X8R8G8B8:
+				case FORMAT_A8R8G8B8:
+					{
+						Int x = x0;
+
+						switch(state.sourceFormat)
+						{
+						case FORMAT_X8R8G8B8:
+						case FORMAT_A8R8G8B8:
+							For(, x < width - 3, x += 4)
+							{
+								*Pointer<Int4>(d, 1) = *Pointer<Int4>(s, sStride % 16 ? 1 : 16);
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						case FORMAT_X8B8G8R8:
+						case FORMAT_A8B8G8R8:
+							For(, x < width - 3, x += 4)
+							{
+								Int4 bgra = *Pointer<Int4>(s, sStride % 16 ? 1 : 16);
+
+								*Pointer<Int4>(d, 1) = ((bgra & Int4(0x00FF0000)) >> 16) |
+								                       ((bgra & Int4(0x000000FF)) << 16) |
+								                       (bgra & Int4(0xFF00FF00));
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						case FORMAT_A16B16G16R16:
+							For(, x < width - 1, x += 2)
+							{
+								Short4 c0 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 0), 0xC6)) >> 8;
+								Short4 c1 = As<UShort4>(Swizzle(*Pointer<Short4>(s + 8), 0xC6)) >> 8;
+
+								*Pointer<Int2>(d) = As<Int2>(PackUnsigned(c0, c1));
+
+								s += 2 * sBytes;
+								d += 2 * dBytes;
+							}
+							break;
+						case FORMAT_R5G6B5:
+							For(, x < width - 3, x += 4)
+							{
+								Int4 rgb = Int4(*Pointer<Short4>(s));
+
+								*Pointer<Int4>(d) = (((rgb & Int4(0xF800)) << 8) | ((rgb & Int4(0xE01F)) << 3)) |
+								                    (((rgb & Int4(0x07E0)) << 5) | ((rgb & Int4(0x0600)) >> 1)) |
+								                    (((rgb & Int4(0x001C)) >> 2) | Int4(0xFF000000));
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						default:
+							ASSERT(false);
+							break;
+						}
+
+						For(, x < width, x++)
+						{
+							switch(state.sourceFormat)
+							{
+							case FORMAT_X8R8G8B8:
+							case FORMAT_A8R8G8B8:
+								*Pointer<Int>(d) = *Pointer<Int>(s);
+								break;
+							case FORMAT_X8B8G8R8:
+							case FORMAT_A8B8G8R8:
+								{
+									Int rgba = *Pointer<Int>(s);
+
+									*Pointer<Int>(d) = ((rgba & Int(0x00FF0000)) >> 16) |
+									                   ((rgba & Int(0x000000FF)) << 16) |
+									                   (rgba & Int(0xFF00FF00));
+								}
+								break;
+							case FORMAT_A16B16G16R16:
+								{
+									Short4 c = As<UShort4>(Swizzle(*Pointer<Short4>(s), 0xC6)) >> 8;
+
+									*Pointer<Int>(d) = Int(As<Int2>(PackUnsigned(c, c)));
+								}
+								break;
+							case FORMAT_R5G6B5:
+								{
+									Int rgb = Int(*Pointer<Short>(s));
+
+									*Pointer<Int>(d) = 0xFF000000 |
+									                   ((rgb & 0xF800) << 8) | ((rgb & 0xE01F) << 3) |
+								                       ((rgb & 0x07E0) << 5) | ((rgb & 0x0600) >> 1) |
+								                       ((rgb & 0x001C) >> 2);
+								}
+								break;
+							default:
+								ASSERT(false);
+								break;
+							}
+
+							s += sBytes;
+							d += dBytes;
+						}
+					}
+					break;
+				case FORMAT_X8B8G8R8:
+				case FORMAT_A8B8G8R8:
+				case FORMAT_SRGB8_X8:
+				case FORMAT_SRGB8_A8:
+					{
+						Int x = x0;
+
+						switch(state.sourceFormat)
+						{
+						case FORMAT_X8B8G8R8:
+						case FORMAT_A8B8G8R8:
+							For(, x < width - 3, x += 4)
+							{
+								*Pointer<Int4>(d, 1) = *Pointer<Int4>(s, sStride % 16 ? 1 : 16);
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						case FORMAT_X8R8G8B8:
+						case FORMAT_A8R8G8B8:
+							For(, x < width - 3, x += 4)
+							{
+								Int4 bgra = *Pointer<Int4>(s, sStride % 16 ? 1 : 16);
+
+								*Pointer<Int4>(d, 1) = ((bgra & Int4(0x00FF0000)) >> 16) |
+								                       ((bgra & Int4(0x000000FF)) << 16) |
+								                       (bgra & Int4(0xFF00FF00));
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						case FORMAT_A16B16G16R16:
+							For(, x < width - 1, x += 2)
+							{
+								Short4 c0 = *Pointer<UShort4>(s + 0) >> 8;
+								Short4 c1 = *Pointer<UShort4>(s + 8) >> 8;
+
+								*Pointer<Int2>(d) = As<Int2>(PackUnsigned(c0, c1));
+
+								s += 2 * sBytes;
+								d += 2 * dBytes;
+							}
+							break;
+						case FORMAT_R5G6B5:
+							For(, x < width - 3, x += 4)
+							{
+								Int4 rgb = Int4(*Pointer<Short4>(s));
+
+								*Pointer<Int4>(d) = Int4(0xFF000000) |
+                                                    (((rgb & Int4(0x001F)) << 19) | ((rgb & Int4(0x001C)) << 14)) |
+								                    (((rgb & Int4(0x07E0)) << 5) | ((rgb & Int4(0x0600)) >> 1)) |
+								                    (((rgb & Int4(0xF800)) >> 8) | ((rgb & Int4(0xE000)) >> 13));
+
+								s += 4 * sBytes;
+								d += 4 * dBytes;
+							}
+							break;
+						default:
+							ASSERT(false);
+							break;
+						}
+
+						For(, x < width, x++)
+						{
+							switch(state.sourceFormat)
+							{
+							case FORMAT_X8B8G8R8:
+							case FORMAT_A8B8G8R8:
+								*Pointer<Int>(d) = *Pointer<Int>(s);
+								break;
+							case FORMAT_X8R8G8B8:
+							case FORMAT_A8R8G8B8:
+								{
+									Int bgra = *Pointer<Int>(s);
+									*Pointer<Int>(d) = ((bgra & Int(0x00FF0000)) >> 16) |
+									                   ((bgra & Int(0x000000FF)) << 16) |
+									                   (bgra & Int(0xFF00FF00));
+								}
+								break;
+							case FORMAT_A16B16G16R16:
+								{
+									Short4 c = *Pointer<UShort4>(s) >> 8;
+
+									*Pointer<Int>(d) = Int(As<Int2>(PackUnsigned(c, c)));
+								}
+								break;
+							case FORMAT_R5G6B5:
+								{
+									Int rgb = Int(*Pointer<Short>(s));
+
+									*Pointer<Int>(d) = 0xFF000000 |
+									                   ((rgb & 0x001F) << 19) | ((rgb & 0x001C) << 14) |
+								                       ((rgb & 0x07E0) << 5) | ((rgb & 0x0600) >> 1) |
+								                       ((rgb & 0xF800) >> 8) | ((rgb & 0xE000) >> 13);
+								}
+								break;
+							default:
+								ASSERT(false);
+								break;
+							}
+
+							s += sBytes;
+							d += dBytes;
+						}
+					}
+					break;
+				case FORMAT_R8G8B8:
+					{
+						For(Int x = x0, x < width, x++)
+						{
+							switch(state.sourceFormat)
+							{
+							case FORMAT_X8R8G8B8:
+							case FORMAT_A8R8G8B8:
+								*Pointer<Byte>(d + 0) = *Pointer<Byte>(s + 0);
+								*Pointer<Byte>(d + 1) = *Pointer<Byte>(s + 1);
+								*Pointer<Byte>(d + 2) = *Pointer<Byte>(s + 2);
+								break;
+							case FORMAT_X8B8G8R8:
+							case FORMAT_A8B8G8R8:
+								*Pointer<Byte>(d + 0) = *Pointer<Byte>(s + 2);
+								*Pointer<Byte>(d + 1) = *Pointer<Byte>(s + 1);
+								*Pointer<Byte>(d + 2) = *Pointer<Byte>(s + 0);
+								break;
+							case FORMAT_A16B16G16R16:
+								*Pointer<Byte>(d + 0) = *Pointer<Byte>(s + 5);
+								*Pointer<Byte>(d + 1) = *Pointer<Byte>(s + 3);
+								*Pointer<Byte>(d + 2) = *Pointer<Byte>(s + 1);
+								break;
+							case FORMAT_R5G6B5:
+								{
+									Int rgb = Int(*Pointer<Short>(s));
+
+									*Pointer<Byte>(d + 0) = Byte(((rgb & 0x001F) << 3) | ((rgb & 0x001C) >> 2));
+									*Pointer<Byte>(d + 1) = Byte(((rgb & 0x07E0) << 5) | ((rgb & 0x0600) >> 1));
+									*Pointer<Byte>(d + 2) = Byte(((rgb & 0xF800) << 8) | ((rgb & 0xE000) << 3));
+								}
+								break;
+							default:
+								ASSERT(false);
+								break;
+							}
+
+							s += sBytes;
+							d += dBytes;
+						}
+					}
+					break;
+				case FORMAT_R5G6B5:
+					{
+						For(Int x = x0, x < width, x++)
+						{
+							switch(state.sourceFormat)
+							{
+							case FORMAT_X8R8G8B8:
+							case FORMAT_A8R8G8B8:
+								{
+									Int c = *Pointer<Int>(s);
+
+									*Pointer<Short>(d) = Short((c & 0x00F80000) >> 8 |
+									                           (c & 0x0000FC00) >> 5 |
+									                           (c & 0x000000F8) >> 3);
+								}
+								break;
+							case FORMAT_X8B8G8R8:
+							case FORMAT_A8B8G8R8:
+								{
+									Int c = *Pointer<Int>(s);
+
+									*Pointer<Short>(d) = Short((c & 0x00F80000) >> 19 |
+									                           (c & 0x0000FC00) >> 5 |
+									                           (c & 0x000000F8) << 8);
+								}
+								break;
+							case FORMAT_A16B16G16R16:
+								{
+									Short4 cc = *Pointer<UShort4>(s) >> 8;
+									Int c = Int(As<Int2>(PackUnsigned(cc, cc)));
+
+									*Pointer<Short>(d) = Short((c & 0x00F80000) >> 19 |
+									                           (c & 0x0000FC00) >> 5 |
+									                           (c & 0x000000F8) << 8);
+								}
+								break;
+							case FORMAT_R5G6B5:
+								*Pointer<Short>(d) = *Pointer<Short>(s);
+								break;
+							default:
+								ASSERT(false);
+								break;
+							}
+
+							s += sBytes;
+							d += dBytes;
+						}
+					}
+					break;
+				default:
+					ASSERT(false);
+					break;
+				}
+			}
+
+			if(state.cursorWidth > 0 && state.cursorHeight > 0)
+			{
+				Int x0 = *Pointer<Int>(cursor + OFFSET(Cursor,x));
+				Int y0 = *Pointer<Int>(cursor + OFFSET(Cursor,y));
+
+				For(Int y1 = 0, y1 < state.cursorHeight, y1++)
+				{
+					Int y = y0 + y1;
+
+					If(y >= 0 && y < height)
+					{
+						Pointer<Byte> d = dst + y * dStride + x0 * dBytes;
+						Pointer<Byte> s = src + y * sStride + x0 * sBytes;
+						Pointer<Byte> c = *Pointer<Pointer<Byte>>(cursor + OFFSET(Cursor,image)) + y1 * state.cursorWidth * 4;
+
+						For(Int x1 = 0, x1 < state.cursorWidth, x1++)
+						{
+							Int x = x0 + x1;
+
+							If(x >= 0 && x < width)
+							{
+								blend(state, d, s, c);
+							}
+
+							c += 4;
+							s += sBytes;
+							d += dBytes;
+						}
+					}
+				}
+			}
+		}
+
+		return function(L"FrameBuffer");
+	}
+
+	void FrameBuffer::blend(const BlitState &state, const Pointer<Byte> &d, const Pointer<Byte> &s, const Pointer<Byte> &c)
+	{
+		Short4 c1;
+		Short4 c2;
+
+		c1 = Unpack(*Pointer<Byte4>(c));
+
+		switch(state.sourceFormat)
+		{
+		case FORMAT_X8R8G8B8:
+		case FORMAT_A8R8G8B8:
+			c2 = Unpack(*Pointer<Byte4>(s));
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8B8G8R8:
+			c2 = Swizzle(Unpack(*Pointer<Byte4>(s)), 0xC6);
+			break;
+		case FORMAT_A16B16G16R16:
+			c2 = Swizzle(*Pointer<Short4>(s), 0xC6);
+			break;
+		case FORMAT_R5G6B5:
+			{
+				Int rgb(*Pointer<Short>(s));
+				rgb = 0xFF000000 |
+				      ((rgb & 0xF800) << 8) | ((rgb & 0xE01F) << 3) |
+				      ((rgb & 0x07E0) << 5) | ((rgb & 0x0600) >> 1) |
+				      ((rgb & 0x001C) >> 2);
+				c2 = Unpack(As<Byte4>(rgb));
+			}
+			break;
+		default:
+			ASSERT(false);
+			break;
+		}
+
+		c1 = As<Short4>(As<UShort4>(c1) >> 9);
+		c2 = As<Short4>(As<UShort4>(c2) >> 9);
+
+		Short4 alpha = Swizzle(c1, 0xFF) & Short4(0xFFFFu, 0xFFFFu, 0xFFFFu, 0x0000);
+
+		c1 = (c1 - c2) * alpha;
+		c1 = c1 >> 7;
+		c1 = c1 + c2;
+		c1 = c1 + c1;
+
+		switch(state.destFormat)
+		{
+		case FORMAT_X8R8G8B8:
+		case FORMAT_A8R8G8B8:
+			*Pointer<Byte4>(d) = Byte4(PackUnsigned(c1, c1));
+			break;
+		case FORMAT_X8B8G8R8:
+		case FORMAT_A8B8G8R8:
+		case FORMAT_SRGB8_X8:
+		case FORMAT_SRGB8_A8:
+			{
+				c1 = Swizzle(c1, 0xC6);
+
+				*Pointer<Byte4>(d) = Byte4(PackUnsigned(c1, c1));
+			}
+			break;
+		case FORMAT_R8G8B8:
+			{
+				Int c = Int(As<Int2>(PackUnsigned(c1, c1)));
+
+				*Pointer<Byte>(d + 0) = Byte(c >> 0);
+				*Pointer<Byte>(d + 1) = Byte(c >> 8);
+				*Pointer<Byte>(d + 2) = Byte(c >> 16);
+			}
+			break;
+		case FORMAT_R5G6B5:
+			{
+				Int c = Int(As<Int2>(PackUnsigned(c1, c1)));
+
+				*Pointer<Short>(d) = Short((c & 0x00F80000) >> 8 |
+				                           (c & 0x0000FC00) >> 5 |
+				                           (c & 0x000000F8) >> 3);
+			}
+			break;
+		default:
+			ASSERT(false);
+			break;
+		}
+	}
+
+	void FrameBuffer::threadFunction(void *parameters)
+	{
+		FrameBuffer *frameBuffer = *static_cast<FrameBuffer**>(parameters);
+
+		while(!frameBuffer->terminate)
+		{
+			frameBuffer->blitEvent.wait();
+
+			if(!frameBuffer->terminate)
+			{
+				frameBuffer->copyLocked();
+
+				frameBuffer->syncEvent.signal();
+			}
+		}
+	}
+}
diff --git a/src/WSI/FrameBuffer.hpp b/src/WSI/FrameBuffer.hpp
new file mode 100644
index 0000000..dd539e1
--- /dev/null
+++ b/src/WSI/FrameBuffer.hpp
@@ -0,0 +1,106 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef	sw_FrameBuffer_hpp
+#define	sw_FrameBuffer_hpp
+
+#include "Reactor/Reactor.hpp"
+#include "Renderer/Surface.hpp"
+#include "Common/Thread.hpp"
+
+namespace sw
+{
+	class Surface;
+
+	struct BlitState
+	{
+		int width;
+		int height;
+		Format destFormat;
+		Format sourceFormat;
+		int destStride;
+		int sourceStride;
+		int cursorWidth;
+		int cursorHeight;
+	};
+
+	class [[clang::lto_visibility_public]] FrameBuffer
+	{
+	public:
+		FrameBuffer(int width, int height, bool fullscreen, bool topLeftOrigin);
+
+		virtual ~FrameBuffer() = 0;
+
+		virtual void flip(sw::Surface *source) = 0;
+		virtual void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) = 0;
+
+		virtual void *lock() = 0;
+		virtual void unlock() = 0;
+
+		static void setCursorImage(sw::Surface *cursor);
+		static void setCursorOrigin(int x0, int y0);
+		static void setCursorPosition(int x, int y);
+
+		static Routine *copyRoutine(const BlitState &state);
+
+	protected:
+		void copy(sw::Surface *source);
+
+		bool windowed;
+
+		void *framebuffer;   // Native window buffer.
+		int width;
+		int height;
+		int stride;
+		Format format;
+
+	private:
+		void copyLocked();
+
+		static void threadFunction(void *parameters);
+
+		void *renderbuffer;   // Render target buffer.
+
+		struct Cursor
+		{
+			void *image;
+			int x;
+			int y;
+			int width;
+			int height;
+			int hotspotX;
+			int hotspotY;
+			int positionX;
+			int positionY;
+		};
+
+		static Cursor cursor;
+
+		void (*blitFunction)(void *dst, void *src, Cursor *cursor);
+		Routine *blitRoutine;
+		BlitState blitState;     // State of the current blitRoutine.
+		BlitState updateState;   // State of the routine to be generated.
+
+		static void blend(const BlitState &state, const Pointer<Byte> &d, const Pointer<Byte> &s, const Pointer<Byte> &c);
+
+		Thread *blitThread;
+		Event syncEvent;
+		Event blitEvent;
+		volatile bool terminate;
+
+		static bool topLeftOrigin;
+	};
+}
+
+#endif	 //	sw_FrameBuffer_hpp
diff --git a/src/WSI/FrameBufferAndroid.cpp b/src/WSI/FrameBufferAndroid.cpp
new file mode 100644
index 0000000..0ae5f09
--- /dev/null
+++ b/src/WSI/FrameBufferAndroid.cpp
@@ -0,0 +1,145 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferAndroid.hpp"
+
+#include "Common/GrallocAndroid.hpp"
+
+#include <system/window.h>
+
+namespace sw
+{
+	inline int dequeueBuffer(ANativeWindow* window, ANativeWindowBuffer** buffer)
+	{
+		#if ANDROID_PLATFORM_SDK_VERSION > 16
+			return native_window_dequeue_buffer_and_wait(window, buffer);
+		#else
+			return window->dequeueBuffer(window, buffer);
+		#endif
+	}
+
+	inline int queueBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd)
+	{
+		#if ANDROID_PLATFORM_SDK_VERSION > 16
+			return window->queueBuffer(window, buffer, fenceFd);
+		#else
+			return window->queueBuffer(window, buffer);
+		#endif
+	}
+
+	inline int cancelBuffer(ANativeWindow* window, ANativeWindowBuffer* buffer, int fenceFd)
+	{
+		#if ANDROID_PLATFORM_SDK_VERSION > 16
+			return window->cancelBuffer(window, buffer, fenceFd);
+		#else
+			return window->cancelBuffer(window, buffer);
+		#endif
+	}
+
+	FrameBufferAndroid::FrameBufferAndroid(ANativeWindow* window, int width, int height)
+		: FrameBuffer(width, height, false, false),
+		  nativeWindow(window), buffer(nullptr)
+	{
+		nativeWindow->common.incRef(&nativeWindow->common);
+		native_window_set_usage(nativeWindow, GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
+	}
+
+	FrameBufferAndroid::~FrameBufferAndroid()
+	{
+		nativeWindow->common.decRef(&nativeWindow->common);
+	}
+
+	void FrameBufferAndroid::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+
+		if(buffer)
+		{
+			if(framebuffer)
+			{
+				framebuffer = nullptr;
+				unlock();
+			}
+
+			queueBuffer(nativeWindow, buffer, -1);
+		}
+	}
+
+	void *FrameBufferAndroid::lock()
+	{
+		if(dequeueBuffer(nativeWindow, &buffer) != 0)
+		{
+			return nullptr;
+		}
+
+		if(GrallocModule::getInstance()->lock(buffer->handle,
+		                 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
+		                 0, 0, buffer->width, buffer->height, &framebuffer) != 0)
+		{
+			TRACE("%s failed to lock buffer %p", __FUNCTION__, buffer);
+			return nullptr;
+		}
+
+		if((buffer->width < width) || (buffer->height < height))
+		{
+			TRACE("lock failed: buffer of %dx%d too small for window of %dx%d",
+			      buffer->width, buffer->height, width, height);
+			return nullptr;
+		}
+
+		switch(buffer->format)
+		{
+		case HAL_PIXEL_FORMAT_RGB_565:   format = FORMAT_R5G6B5; break;
+		case HAL_PIXEL_FORMAT_RGBA_8888: format = FORMAT_A8B8G8R8; break;
+#if ANDROID_PLATFORM_SDK_VERSION > 16
+		case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: format = FORMAT_X8B8G8R8; break;
+#endif
+		case HAL_PIXEL_FORMAT_RGBX_8888: format = FORMAT_X8B8G8R8; break;
+		case HAL_PIXEL_FORMAT_BGRA_8888: format = FORMAT_A8R8G8B8; break;
+		case HAL_PIXEL_FORMAT_RGB_888:
+			// Frame buffers are expected to have 16-bit or 32-bit colors, not 24-bit.
+			TRACE("Unsupported frame buffer format RGB_888"); ASSERT(false);
+			format = FORMAT_R8G8B8;   // Wrong component order.
+			break;
+		default:
+			TRACE("Unsupported frame buffer format %d", buffer->format); ASSERT(false);
+			format = FORMAT_NULL;
+			break;
+		}
+
+		stride = buffer->stride * Surface::bytes(format);
+		return framebuffer;
+	}
+
+	void FrameBufferAndroid::unlock()
+	{
+		if(!buffer)
+		{
+			TRACE("%s: badness unlock with no active buffer", __FUNCTION__);
+			return;
+		}
+
+		framebuffer = nullptr;
+
+		if(GrallocModule::getInstance()->unlock(buffer->handle) != 0)
+		{
+			TRACE("%s: badness unlock failed", __FUNCTION__);
+		}
+	}
+}
+
+sw::FrameBuffer *createFrameBuffer(void *display, ANativeWindow* window, int width, int height)
+{
+	return new sw::FrameBufferAndroid(window, width, height);
+}
diff --git a/src/WSI/FrameBufferAndroid.hpp b/src/WSI/FrameBufferAndroid.hpp
new file mode 100644
index 0000000..b71c32b
--- /dev/null
+++ b/src/WSI/FrameBufferAndroid.hpp
@@ -0,0 +1,47 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_FrameBufferAndroid_hpp
+#define sw_FrameBufferAndroid_hpp
+
+#include "Main/FrameBuffer.hpp"
+#include "Common/Debug.hpp"
+
+struct ANativeWindow;
+struct ANativeWindowBuffer;
+
+namespace sw
+{
+	class FrameBufferAndroid : public FrameBuffer
+	{
+	public:
+		FrameBufferAndroid(ANativeWindow *window, int width, int height);
+
+		~FrameBufferAndroid() override;
+
+		void flip(sw::Surface *source) override {blit(source, nullptr, nullptr);};
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+		bool setSwapRectangle(int l, int t, int w, int h);
+
+	private:
+		ANativeWindow *nativeWindow;
+		ANativeWindowBuffer *buffer;
+	};
+}
+
+#endif   // sw_FrameBufferAndroid
diff --git a/src/WSI/FrameBufferDD.cpp b/src/WSI/FrameBufferDD.cpp
new file mode 100644
index 0000000..46ed89f
--- /dev/null
+++ b/src/WSI/FrameBufferDD.cpp
@@ -0,0 +1,510 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferDD.hpp"
+
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool forceWindowed;
+
+	GUID secondaryDisplay = {0};
+
+	int __stdcall enumDisplayCallback(GUID* guid, char *driverDescription, char *driverName, void *context, HMONITOR monitor)
+	{
+		if(strcmp(driverName, "\\\\.\\DISPLAY2") == 0)
+		{
+			secondaryDisplay = *guid;
+		}
+
+		return 1;
+	}
+
+	FrameBufferDD::FrameBufferDD(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin) : FrameBufferWin(windowHandle, width, height, fullscreen, topLeftOrigin)
+	{
+		directDraw = 0;
+		frontBuffer = 0;
+		backBuffer = 0;
+
+		framebuffer = nullptr;
+
+		ddraw = LoadLibrary("ddraw.dll");
+		DirectDrawCreate = (DIRECTDRAWCREATE)GetProcAddress(ddraw, "DirectDrawCreate");
+		DirectDrawEnumerateExA = (DIRECTDRAWENUMERATEEXA)GetProcAddress(ddraw, "DirectDrawEnumerateExA");
+
+		if(!windowed)
+		{
+			initFullscreen();
+		}
+		else
+		{
+			initWindowed();
+		}
+	}
+
+	FrameBufferDD::~FrameBufferDD()
+	{
+		releaseAll();
+
+		FreeLibrary(ddraw);
+	}
+
+	void FrameBufferDD::createSurfaces()
+	{
+		if(backBuffer)
+		{
+			backBuffer->Release();
+			backBuffer = 0;
+		}
+
+		if(frontBuffer)
+		{
+			frontBuffer->Release();
+			frontBuffer = 0;
+		}
+
+		if(!windowed)
+		{
+			DDSURFACEDESC surfaceDescription = {0};
+			surfaceDescription.dwSize = sizeof(surfaceDescription);
+			surfaceDescription.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
+			surfaceDescription.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
+			surfaceDescription.dwBackBufferCount = 1;
+			directDraw->CreateSurface(&surfaceDescription, &frontBuffer, 0);
+
+			if(frontBuffer)
+			{
+				DDSCAPS surfaceCapabilties = {0};
+				surfaceCapabilties.dwCaps = DDSCAPS_BACKBUFFER;
+				frontBuffer->GetAttachedSurface(&surfaceCapabilties, &backBuffer);
+				backBuffer->AddRef();
+			}
+		}
+		else
+		{
+			IDirectDrawClipper *clipper;
+
+			DDSURFACEDESC ddsd = {0};
+			ddsd.dwSize = sizeof(ddsd);
+			ddsd.dwFlags = DDSD_CAPS;
+			ddsd.ddsCaps.dwCaps	= DDSCAPS_PRIMARYSURFACE;
+
+			long result = directDraw->CreateSurface(&ddsd, &frontBuffer, 0);
+			directDraw->GetDisplayMode(&ddsd);
+
+			switch(ddsd.ddpfPixelFormat.dwRGBBitCount)
+			{
+			case 32: format = FORMAT_X8R8G8B8; break;
+			case 24: format = FORMAT_R8G8B8;   break;
+			case 16: format = FORMAT_R5G6B5;   break;
+			default: format = FORMAT_NULL;     break;
+			}
+
+			if((result != DD_OK && result != DDERR_PRIMARYSURFACEALREADYEXISTS) || (format == FORMAT_NULL))
+			{
+				assert(!"Failed to initialize graphics: Incompatible display mode.");
+			}
+			else
+			{
+				ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
+				ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
+				ddsd.dwWidth = width;
+				ddsd.dwHeight = height;
+
+				directDraw->CreateSurface(&ddsd, &backBuffer, 0);
+
+				directDraw->CreateClipper(0, &clipper, 0);
+				clipper->SetHWnd(0, windowHandle);
+				frontBuffer->SetClipper(clipper);
+				clipper->Release();
+			}
+		}
+	}
+
+	bool FrameBufferDD::readySurfaces()
+	{
+		if(!frontBuffer || !backBuffer)
+		{
+			createSurfaces();
+		}
+
+		if(frontBuffer && backBuffer)
+		{
+			if(frontBuffer->IsLost() || backBuffer->IsLost())
+			{
+				restoreSurfaces();
+			}
+
+			if(frontBuffer && backBuffer)
+			{
+				if(!frontBuffer->IsLost() && !backBuffer->IsLost())
+				{
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	void FrameBufferDD::updateClipper(HWND windowOverride)
+	{
+		if(windowed)
+		{
+			if(frontBuffer)
+			{
+				HWND window = windowOverride ? windowOverride : windowHandle;
+
+				IDirectDrawClipper *clipper;
+				frontBuffer->GetClipper(&clipper);
+				clipper->SetHWnd(0, window);
+				clipper->Release();
+			}
+		}
+	}
+
+	void FrameBufferDD::restoreSurfaces()
+	{
+		long result1 = frontBuffer->Restore();
+		long result2 = backBuffer->Restore();
+
+		if(result1 != DD_OK || result2 != DD_OK)   // Surfaces could not be restored; recreate them
+		{
+			createSurfaces();
+		}
+	}
+
+	void FrameBufferDD::initFullscreen()
+	{
+		releaseAll();
+
+		if(true)   // Render to primary display
+		{
+			DirectDrawCreate(0, &directDraw, 0);
+		}
+		else   // Render to secondary display
+		{
+			DirectDrawEnumerateEx(&enumDisplayCallback, 0, DDENUM_ATTACHEDSECONDARYDEVICES);
+			DirectDrawCreate(&secondaryDisplay, &directDraw, 0);
+		}
+
+		directDraw->SetCooperativeLevel(windowHandle, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
+
+		long result;
+
+		do
+		{
+			format = FORMAT_X8R8G8B8;
+			result = directDraw->SetDisplayMode(width, height, 32);
+
+			if(result == DDERR_INVALIDMODE)
+			{
+				format = FORMAT_R8G8B8;
+				result = directDraw->SetDisplayMode(width, height, 24);
+
+				if(result == DDERR_INVALIDMODE)
+				{
+					format = FORMAT_R5G6B5;
+					result = directDraw->SetDisplayMode(width, height, 16);
+
+					if(result == DDERR_INVALIDMODE)
+					{
+						assert(!"Failed to initialize graphics: Display mode not supported.");
+					}
+				}
+			}
+
+			if(result != DD_OK)
+			{
+				Sleep(1);
+			}
+		}
+		while(result != DD_OK);
+
+		createSurfaces();
+
+		updateBounds(windowHandle);
+	}
+
+	void FrameBufferDD::initWindowed()
+	{
+		releaseAll();
+
+		DirectDrawCreate(0, &directDraw, 0);
+		directDraw->SetCooperativeLevel(windowHandle, DDSCL_NORMAL);
+
+		createSurfaces();
+
+		updateBounds(windowHandle);
+	}
+
+	void FrameBufferDD::flip(sw::Surface *source)
+	{
+		copy(source);
+
+		if(!readySurfaces())
+		{
+			return;
+		}
+
+		while(true)
+		{
+			long result;
+
+			if(windowed)
+			{
+				result = frontBuffer->Blt(&bounds, backBuffer, 0, DDBLT_WAIT, 0);
+			}
+			else
+			{
+				result = frontBuffer->Flip(0, DDFLIP_NOVSYNC);
+			}
+
+			if(result != DDERR_WASSTILLDRAWING)
+			{
+				break;
+			}
+
+			Sleep(0);
+		}
+	}
+
+	void FrameBufferDD::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+
+		if(!readySurfaces())
+		{
+			return;
+		}
+
+		RECT dRect;
+
+		if(destRect)
+		{
+			dRect.bottom = bounds.top + destRect->y1;
+			dRect.left = bounds.left + destRect->x0;
+			dRect.right = bounds.left + destRect->x1;
+			dRect.top = bounds.top + destRect->y0;
+		}
+		else
+		{
+			dRect.bottom = bounds.top + height;
+			dRect.left = bounds.left + 0;
+			dRect.right = bounds.left + width;
+			dRect.top = bounds.top + 0;
+		}
+
+		while(true)
+		{
+			long result = frontBuffer->Blt(&dRect, backBuffer, (LPRECT)sourceRect, DDBLT_WAIT, 0);
+
+			if(result != DDERR_WASSTILLDRAWING)
+			{
+				break;
+			}
+
+			Sleep(0);
+		}
+	}
+
+	void FrameBufferDD::flip(HWND windowOverride, sw::Surface *source)
+	{
+		updateClipper(windowOverride);
+		updateBounds(windowOverride);
+
+		flip(source);
+	}
+
+	void FrameBufferDD::blit(HWND windowOverride, sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		updateClipper(windowOverride);
+		updateBounds(windowOverride);
+
+		blit(source, sourceRect, destRect);
+	}
+
+	void FrameBufferDD::screenshot(void *destBuffer)
+	{
+		if(!readySurfaces())
+		{
+			return;
+		}
+
+		DDSURFACEDESC DDSD;
+		DDSD.dwSize = sizeof(DDSD);
+
+		long result = frontBuffer->Lock(0, &DDSD, DDLOCK_WAIT, 0);
+
+		if(result == DD_OK)
+		{
+			int width = DDSD.dwWidth;
+			int height = DDSD.dwHeight;
+			int stride = DDSD.lPitch;
+
+			void *sourceBuffer = DDSD.lpSurface;
+
+			for(int y = 0; y < height; y++)
+			{
+				memcpy(destBuffer, sourceBuffer, width * 4);   // FIXME: Assumes 32-bit buffer
+
+				(char*&)sourceBuffer += stride;
+				(char*&)destBuffer += 4 * width;
+			}
+
+			frontBuffer->Unlock(0);
+		}
+	}
+
+	void FrameBufferDD::setGammaRamp(GammaRamp *gammaRamp, bool calibrate)
+	{
+		IDirectDrawGammaControl *gammaControl = 0;
+
+		if(frontBuffer)
+		{
+			frontBuffer->QueryInterface(IID_IDirectDrawGammaControl, (void**)&gammaControl);
+
+			if(gammaControl)
+			{
+				gammaControl->SetGammaRamp(calibrate ? DDSGR_CALIBRATE : 0, (DDGAMMARAMP*)gammaRamp);
+
+				gammaControl->Release();
+			}
+		}
+	}
+
+	void FrameBufferDD::getGammaRamp(GammaRamp *gammaRamp)
+	{
+		IDirectDrawGammaControl *gammaControl = 0;
+
+		if(frontBuffer)
+		{
+			frontBuffer->QueryInterface(IID_IDirectDrawGammaControl, (void**)&gammaControl);
+
+			if(gammaControl)
+			{
+				gammaControl->GetGammaRamp(0, (DDGAMMARAMP*)gammaRamp);
+
+				gammaControl->Release();
+			}
+		}
+	}
+
+	void *FrameBufferDD::lock()
+	{
+		if(framebuffer)
+		{
+			return framebuffer;
+		}
+
+		if(!readySurfaces())
+		{
+			return nullptr;
+		}
+
+		DDSURFACEDESC DDSD;
+		DDSD.dwSize = sizeof(DDSD);
+
+		long result = backBuffer->Lock(0, &DDSD, DDLOCK_WAIT, 0);
+
+		if(result == DD_OK)
+		{
+			width = DDSD.dwWidth;
+			height = DDSD.dwHeight;
+			stride = DDSD.lPitch;
+
+			framebuffer = DDSD.lpSurface;
+
+			return framebuffer;
+		}
+
+		return nullptr;
+	}
+
+	void FrameBufferDD::unlock()
+	{
+		if(!framebuffer || !backBuffer) return;
+
+		backBuffer->Unlock(0);
+
+		framebuffer = nullptr;
+	}
+
+	void FrameBufferDD::drawText(int x, int y, const char *string, ...)
+	{
+		char buffer[256];
+		va_list arglist;
+
+		va_start(arglist, string);
+		vsprintf(buffer, string, arglist);
+		va_end(arglist);
+
+		HDC hdc;
+
+		backBuffer->GetDC(&hdc);
+
+		SetBkColor(hdc, RGB(0, 0, 255));
+		SetTextColor(hdc, RGB(255, 255, 255));
+
+		TextOut(hdc, x, y, buffer, lstrlen(buffer));
+
+		backBuffer->ReleaseDC(hdc);
+	}
+
+	bool FrameBufferDD::getScanline(bool &inVerticalBlank, unsigned int &scanline)
+	{
+		HRESULT result = directDraw->GetScanLine((unsigned long*)&scanline);
+
+		if(result == DD_OK)
+		{
+			inVerticalBlank = false;
+		}
+		else if(result == DDERR_VERTICALBLANKINPROGRESS)
+		{
+			inVerticalBlank = true;
+		}
+		else if(result == DDERR_UNSUPPORTED)
+		{
+			return false;
+		}
+		else ASSERT(false);
+
+		return true;
+	}
+
+	void FrameBufferDD::releaseAll()
+	{
+		unlock();
+
+		if(backBuffer)
+		{
+			backBuffer->Release();
+			backBuffer = 0;
+		}
+
+		if(frontBuffer)
+		{
+			frontBuffer->Release();
+			frontBuffer = 0;
+		}
+
+		if(directDraw)
+		{
+			directDraw->SetCooperativeLevel(0, DDSCL_NORMAL);
+			directDraw->Release();
+			directDraw = 0;
+		}
+	}
+}
diff --git a/src/WSI/FrameBufferDD.hpp b/src/WSI/FrameBufferDD.hpp
new file mode 100644
index 0000000..22d76c9
--- /dev/null
+++ b/src/WSI/FrameBufferDD.hpp
@@ -0,0 +1,69 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef	sw_FrameBufferDD_hpp
+#define	sw_FrameBufferDD_hpp
+
+#include "FrameBufferWin.hpp"
+
+#include <ddraw.h>
+
+namespace sw
+{
+	class FrameBufferDD : public FrameBufferWin
+	{
+	public:
+		FrameBufferDD(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin);
+
+		~FrameBufferDD() override;
+
+		void flip(sw::Surface *source) override;
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void flip(HWND windowOverride, sw::Surface *source) override;
+		void blit(HWND windowOverride, sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+		void setGammaRamp(GammaRamp *gammaRamp, bool calibrate) override;
+		void getGammaRamp(GammaRamp *gammaRamp) override;
+
+		void screenshot(void *destBuffer) override;
+		bool getScanline(bool &inVerticalBlank, unsigned int &scanline) override;
+
+		void drawText(int x, int y, const char *string, ...);
+
+	private:
+		void initFullscreen();
+		void initWindowed();
+		void createSurfaces();
+		bool readySurfaces();
+		void updateClipper(HWND windowOverride);
+		void restoreSurfaces();
+		void releaseAll();
+
+		HMODULE ddraw;
+		typedef HRESULT (WINAPI *DIRECTDRAWCREATE)( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
+		HRESULT (WINAPI *DirectDrawCreate)( GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter );
+		typedef HRESULT (WINAPI *DIRECTDRAWENUMERATEEXA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
+		HRESULT (WINAPI *DirectDrawEnumerateExA)( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);
+
+		IDirectDraw *directDraw;
+		IDirectDrawSurface *frontBuffer;
+		IDirectDrawSurface *backBuffer;
+	};
+}
+
+#endif	 //	sw_FrameBufferDD_hpp
diff --git a/src/WSI/FrameBufferGDI.cpp b/src/WSI/FrameBufferGDI.cpp
new file mode 100644
index 0000000..90a469e
--- /dev/null
+++ b/src/WSI/FrameBufferGDI.cpp
@@ -0,0 +1,162 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferGDI.hpp"
+
+#include "Common/Debug.hpp"
+
+namespace sw
+{
+	extern bool forceWindowed;
+
+	FrameBufferGDI::FrameBufferGDI(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin) : FrameBufferWin(windowHandle, width, height, fullscreen, topLeftOrigin)
+	{
+		if(!windowed)
+		{
+			SetWindowPos(windowHandle, HWND_TOPMOST, 0, 0, width, height, SWP_SHOWWINDOW);
+
+			DEVMODE deviceMode;
+			deviceMode.dmSize = sizeof(DEVMODE);
+			deviceMode.dmPelsWidth= width;
+			deviceMode.dmPelsHeight = height;
+			deviceMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
+
+			ChangeDisplaySettings(&deviceMode, CDS_FULLSCREEN);
+		}
+
+		init(this->windowHandle);
+
+		format = FORMAT_X8R8G8B8;
+	}
+
+	FrameBufferGDI::~FrameBufferGDI()
+	{
+		release();
+
+		if(!windowed)
+		{
+			ChangeDisplaySettings(0, 0);
+
+			RECT clientRect;
+			RECT windowRect;
+			GetClientRect(windowHandle, &clientRect);
+			GetWindowRect(windowHandle, &windowRect);
+			int windowWidth = width + (windowRect.right - windowRect.left) - (clientRect.right - clientRect.left);
+			int windowHeight = height + (windowRect.bottom - windowRect.top) - (clientRect.bottom - clientRect.top);
+			int desktopWidth = GetSystemMetrics(SM_CXSCREEN);
+			int desktopHeight = GetSystemMetrics(SM_CYSCREEN);
+			SetWindowPos(windowHandle, HWND_TOP, desktopWidth / 2 - windowWidth / 2, desktopHeight / 2 - windowHeight / 2, windowWidth, windowHeight, SWP_SHOWWINDOW);
+		}
+	}
+
+	void *FrameBufferGDI::lock()
+	{
+		stride = width * 4;
+
+		return framebuffer;
+	}
+
+	void FrameBufferGDI::unlock()
+	{
+	}
+
+	void FrameBufferGDI::flip(sw::Surface *source)
+	{
+		blit(source, nullptr, nullptr);
+	}
+
+	void FrameBufferGDI::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+
+		int sourceLeft = sourceRect ? sourceRect->x0 : 0;
+		int sourceTop = sourceRect ? sourceRect->y0 : 0;
+		int sourceWidth = sourceRect ? sourceRect->x1 - sourceRect->x0 : width;
+		int sourceHeight = sourceRect ? sourceRect->y1 - sourceRect->y0 : height;
+		int destLeft = destRect ? destRect->x0 : 0;
+		int destTop = destRect ? destRect->y0 : 0;
+		int destWidth = destRect ? destRect->x1 - destRect->x0 : bounds.right - bounds.left;
+		int destHeight = destRect ? destRect->y1 - destRect->y0 : bounds.bottom - bounds.top;
+
+		StretchBlt(windowContext, destLeft, destTop, destWidth, destHeight, bitmapContext, sourceLeft, sourceTop, sourceWidth, sourceHeight, SRCCOPY);
+	}
+
+	void FrameBufferGDI::flip(HWND windowOverride, sw::Surface *source)
+	{
+		blit(windowOverride, source, nullptr, nullptr);
+	}
+
+	void FrameBufferGDI::blit(HWND windowOverride, sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		if(windowed && windowOverride != 0 && windowOverride != bitmapWindow)
+		{
+			release();
+			init(windowOverride);
+		}
+
+		blit(source, sourceRect, destRect);
+	}
+
+	void FrameBufferGDI::setGammaRamp(GammaRamp *gammaRamp, bool calibrate)
+	{
+		SetDeviceGammaRamp(windowContext, gammaRamp);
+	}
+
+	void FrameBufferGDI::getGammaRamp(GammaRamp *gammaRamp)
+	{
+		GetDeviceGammaRamp(windowContext, gammaRamp);
+	}
+
+	void FrameBufferGDI::screenshot(void *destBuffer)
+	{
+		UNIMPLEMENTED();
+	}
+
+	bool FrameBufferGDI::getScanline(bool &inVerticalBlank, unsigned int &scanline)
+	{
+		UNIMPLEMENTED();
+
+		return false;
+	}
+
+	void FrameBufferGDI::init(HWND window)
+	{
+		bitmapWindow = window;
+
+		windowContext = GetDC(window);
+		bitmapContext = CreateCompatibleDC(windowContext);
+
+		BITMAPINFO bitmapInfo;
+		memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
+		bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFO);
+		bitmapInfo.bmiHeader.biBitCount = 32;
+		bitmapInfo.bmiHeader.biPlanes = 1;
+		bitmapInfo.bmiHeader.biHeight = -height;
+		bitmapInfo.bmiHeader.biWidth = width;
+		bitmapInfo.bmiHeader.biCompression = BI_RGB;
+
+		bitmap = CreateDIBSection(bitmapContext, &bitmapInfo, DIB_RGB_COLORS, &framebuffer, 0, 0);
+		SelectObject(bitmapContext, bitmap);
+
+		updateBounds(window);
+	}
+
+	void FrameBufferGDI::release()
+	{
+		SelectObject(bitmapContext, 0);
+		DeleteObject(bitmap);
+		ReleaseDC(bitmapWindow, windowContext);
+		DeleteDC(bitmapContext);
+	}
+}
diff --git a/src/WSI/FrameBufferGDI.hpp b/src/WSI/FrameBufferGDI.hpp
new file mode 100644
index 0000000..add2504
--- /dev/null
+++ b/src/WSI/FrameBufferGDI.hpp
@@ -0,0 +1,56 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef	sw_FrameBufferGDI_hpp
+#define	sw_FrameBufferGDI_hpp
+
+#include "FrameBufferWin.hpp"
+
+namespace sw
+{
+	class FrameBufferGDI : public FrameBufferWin
+	{
+	public:
+		FrameBufferGDI(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin);
+
+		~FrameBufferGDI() override;
+
+		void flip(sw::Surface *source) override;
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void flip(HWND windowOverride, sw::Surface *source) override;
+		void blit(HWND windowOverride, sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+		void setGammaRamp(GammaRamp *gammaRamp, bool calibrate) override;
+		void getGammaRamp(GammaRamp *gammaRamp) override;
+
+		void screenshot(void *destBuffer) override;
+		bool getScanline(bool &inVerticalBlank, unsigned int &scanline) override;
+
+	private:
+		void init(HWND bitmapWindow);
+		void release();
+
+		HDC windowContext;
+		HDC bitmapContext;
+		HWND bitmapWindow;
+
+		HBITMAP bitmap;
+	};
+}
+
+#endif	 //	sw_FrameBufferGDI_hpp
diff --git a/src/WSI/FrameBufferOSX.hpp b/src/WSI/FrameBufferOSX.hpp
new file mode 100644
index 0000000..07f8d63
--- /dev/null
+++ b/src/WSI/FrameBufferOSX.hpp
@@ -0,0 +1,49 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_FrameBufferOSX_hpp
+#define sw_FrameBufferOSX_hpp
+
+#include "Main/FrameBuffer.hpp"
+
+#import <Cocoa/Cocoa.h>
+
+@class CALayer;
+
+namespace sw
+{
+	class FrameBufferOSX : public FrameBuffer
+	{
+	public:
+		FrameBufferOSX(CALayer *layer, int width, int height);
+		~FrameBufferOSX() override;
+
+		void flip(sw::Surface *source) override;
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+	private:
+		int width;
+		int height;
+		CALayer *layer;
+		uint8_t *buffer;
+		CGDataProviderRef provider;
+		CGColorSpaceRef colorspace;
+		CGImageRef currentImage;
+	};
+}
+
+#endif   // sw_FrameBufferOSX
diff --git a/src/WSI/FrameBufferOSX.mm b/src/WSI/FrameBufferOSX.mm
new file mode 100644
index 0000000..6d58ae7
--- /dev/null
+++ b/src/WSI/FrameBufferOSX.mm
@@ -0,0 +1,103 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferOSX.hpp"
+
+#include "Common/Debug.hpp"
+
+#include <EGL/egl.h>
+#import <QuartzCore/QuartzCore.h>
+
+namespace sw {
+
+	FrameBufferOSX::FrameBufferOSX(CALayer* layer, int width, int height)
+		: FrameBuffer(width, height, false, false), width(width), height(height),
+		  layer(layer), buffer(nullptr), provider(nullptr), currentImage(nullptr)
+	{
+		format = sw::FORMAT_X8B8G8R8;
+		int bufferSize = width * height * 4 * sizeof(uint8_t);
+		buffer = new uint8_t[bufferSize];
+		provider = CGDataProviderCreateWithData(nullptr, buffer, bufferSize, nullptr);
+		colorspace = CGColorSpaceCreateDeviceRGB();
+	}
+
+	FrameBufferOSX::~FrameBufferOSX()
+	{
+		//[CATransaction begin];
+		//[layer setContents:nullptr];
+		//[CATransaction commit];
+
+		CGImageRelease(currentImage);
+		CGColorSpaceRelease(colorspace);
+		CGDataProviderRelease(provider);
+
+		delete[] buffer;
+	}
+
+	void FrameBufferOSX::flip(sw::Surface *source)
+	{
+		blit(source, nullptr, nullptr);
+	}
+
+	void FrameBufferOSX::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+
+		int bytesPerRow = width * 4 * sizeof(uint8_t);
+		CGImageRef image = CGImageCreate(width, height, 8, 32, bytesPerRow, colorspace, kCGBitmapByteOrder32Big, provider, nullptr, false, kCGRenderingIntentDefault);
+
+		[CATransaction begin];
+		[layer setContents:(id)image];
+		[CATransaction commit];
+		[CATransaction flush];
+
+		if(currentImage)
+		{
+			CGImageRelease(currentImage);
+		}
+		currentImage = image;
+	}
+
+	void *FrameBufferOSX::lock()
+	{
+		stride = width * 4 * sizeof(uint8_t);
+		framebuffer = buffer;
+		return framebuffer;
+	};
+
+	void FrameBufferOSX::unlock()
+	{
+		framebuffer = nullptr;
+	};
+}
+
+sw::FrameBuffer *createFrameBuffer(void *display, EGLNativeWindowType nativeWindow, int width, int height)
+{
+	NSObject *window = reinterpret_cast<NSObject*>(nativeWindow);
+	CALayer *layer = nullptr;
+
+	if([window isKindOfClass:[NSView class]])
+	{
+		NSView *view = reinterpret_cast<NSView*>(window);
+		[view setWantsLayer:YES];
+		layer = [view layer];
+	}
+	else if([window isKindOfClass:[CALayer class]])
+	{
+		layer = reinterpret_cast<CALayer*>(window);
+	}
+	else ASSERT(0);
+
+	return new sw::FrameBufferOSX(layer, width, height);
+}
diff --git a/src/WSI/FrameBufferOzone.cpp b/src/WSI/FrameBufferOzone.cpp
new file mode 100644
index 0000000..95e0729
--- /dev/null
+++ b/src/WSI/FrameBufferOzone.cpp
@@ -0,0 +1,54 @@
+// Copyright 2017 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferOzone.hpp"
+
+namespace sw
+{
+	FrameBufferOzone::FrameBufferOzone(intptr_t display, intptr_t window, int width, int height) : FrameBuffer(width, height, false, false)
+	{
+		buffer = sw::Surface::create(width, height, 1, format, nullptr,
+		                             sw::Surface::pitchB(width, 0, format, true),
+		                             sw::Surface::sliceB(width, height, 0, format, true));
+	}
+
+	FrameBufferOzone::~FrameBufferOzone()
+	{
+		delete buffer;
+	}
+
+	void *FrameBufferOzone::lock()
+	{
+		framebuffer = buffer->lockInternal(0, 0, 0, sw::LOCK_READWRITE, sw::PUBLIC);
+
+		return framebuffer;
+	}
+
+	void FrameBufferOzone::unlock()
+	{
+		buffer->unlockInternal();
+
+		framebuffer = nullptr;
+	}
+
+	void FrameBufferOzone::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+	}
+}
+
+NO_SANITIZE_FUNCTION sw::FrameBuffer *createFrameBuffer(void* display, intptr_t window, int width, int height)
+{
+	return new sw::FrameBufferOzone((intptr_t)display, window, width, height);
+}
diff --git a/src/WSI/FrameBufferOzone.hpp b/src/WSI/FrameBufferOzone.hpp
new file mode 100644
index 0000000..0dc9f60
--- /dev/null
+++ b/src/WSI/FrameBufferOzone.hpp
@@ -0,0 +1,40 @@
+// Copyright 2017 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_FrameBufferOzone_hpp
+#define sw_FrameBufferOzone_hpp
+
+#include "Main/FrameBuffer.hpp"
+
+namespace sw
+{
+	class FrameBufferOzone : public FrameBuffer
+	{
+	public:
+		FrameBufferOzone(intptr_t display, intptr_t window, int width, int height);
+
+		~FrameBufferOzone() override;
+
+		void flip(sw::Surface *source) override {blit(source, nullptr, nullptr);};
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+	private:
+		sw::Surface* buffer;
+	};
+}
+
+#endif   // sw_FrameBufferOzone_hpp
diff --git a/src/WSI/FrameBufferWin.cpp b/src/WSI/FrameBufferWin.cpp
new file mode 100644
index 0000000..cad8954
--- /dev/null
+++ b/src/WSI/FrameBufferWin.cpp
@@ -0,0 +1,78 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferWin.hpp"
+
+namespace sw
+{
+	FrameBufferWin::FrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin) : FrameBuffer(width, height, fullscreen, topLeftOrigin), windowHandle(windowHandle)
+	{
+		if(!windowed)
+		{
+			// Force fullscreen window style (no borders)
+			originalWindowStyle = GetWindowLong(windowHandle, GWL_STYLE);
+			SetWindowLong(windowHandle, GWL_STYLE, WS_POPUP);
+		}
+	}
+
+	FrameBufferWin::~FrameBufferWin()
+	{
+		if(!windowed && GetWindowLong(windowHandle, GWL_STYLE) == WS_POPUP)
+		{
+			SetWindowLong(windowHandle, GWL_STYLE, originalWindowStyle);
+		}
+	}
+
+	void FrameBufferWin::updateBounds(HWND windowOverride)
+	{
+		HWND window = windowOverride ? windowOverride : windowHandle;
+
+		if(windowed)
+		{
+			GetClientRect(window, &bounds);
+			ClientToScreen(window, (POINT*)&bounds);
+			ClientToScreen(window, (POINT*)&bounds + 1);
+		}
+		else
+		{
+			SetRect(&bounds, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
+		}
+	}
+}
+
+#include "FrameBufferDD.hpp"
+#include "FrameBufferGDI.hpp"
+#include "Common/Configurator.hpp"
+
+sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin)
+{
+	sw::Configurator ini("SwiftShader.ini");
+	int api = ini.getInteger("Testing", "FrameBufferAPI", 0);
+
+	if(api == 0 && topLeftOrigin)
+	{
+		return new sw::FrameBufferDD(windowHandle, width, height, fullscreen, topLeftOrigin);
+	}
+	else
+	{
+		return new sw::FrameBufferGDI(windowHandle, width, height, fullscreen, topLeftOrigin);
+	}
+
+	return 0;
+}
+
+sw::FrameBuffer *createFrameBuffer(void *display, HWND window, int width, int height)
+{
+	return createFrameBufferWin(window, width, height, false, false);
+}
diff --git a/src/WSI/FrameBufferWin.hpp b/src/WSI/FrameBufferWin.hpp
new file mode 100644
index 0000000..15c1e0e
--- /dev/null
+++ b/src/WSI/FrameBufferWin.hpp
@@ -0,0 +1,59 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef	sw_FrameBufferWin_hpp
+#define	sw_FrameBufferWin_hpp
+
+#include "FrameBuffer.hpp"
+
+namespace sw
+{
+	struct GammaRamp
+	{
+		short red[256];
+		short green[256];
+		short blue[256];
+	};
+
+	class FrameBufferWin : public FrameBuffer
+	{
+	public:
+		FrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin);
+
+		~FrameBufferWin() override;
+
+		void flip(sw::Surface *source) override = 0;
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override = 0;
+
+		virtual void flip(HWND windowOverride, sw::Surface *source) = 0;
+		virtual void blit(HWND windowOverride, sw::Surface *source, const Rect *sourceRect, const Rect *destRect) = 0;
+
+		virtual void setGammaRamp(GammaRamp *gammaRamp, bool calibrate) = 0;
+		virtual void getGammaRamp(GammaRamp *gammaRamp) = 0;
+
+		virtual void screenshot(void *destBuffer) = 0;
+		virtual bool getScanline(bool &inVerticalBlank, unsigned int &scanline) = 0;
+
+	protected:
+		void updateBounds(HWND windowOverride);
+
+		HWND windowHandle;
+		DWORD originalWindowStyle;
+		RECT bounds;
+	};
+}
+
+sw::FrameBufferWin *createFrameBufferWin(HWND windowHandle, int width, int height, bool fullscreen, bool topLeftOrigin);
+
+#endif	 //	sw_FrameBufferWin_hpp
diff --git a/src/WSI/FrameBufferX11.cpp b/src/WSI/FrameBufferX11.cpp
new file mode 100644
index 0000000..b3ae3b4
--- /dev/null
+++ b/src/WSI/FrameBufferX11.cpp
@@ -0,0 +1,192 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "FrameBufferX11.hpp"
+
+#include "libX11.hpp"
+#include "Common/Timer.hpp"
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <string.h>
+#include <assert.h>
+#include <stdlib.h>
+
+namespace sw
+{
+	static int (*PreviousXErrorHandler)(Display *display, XErrorEvent *event) = 0;
+	static bool shmBadAccess = false;
+
+	// Catches BadAcces errors so we can fall back to not using MIT-SHM
+	static int XShmErrorHandler(Display *display, XErrorEvent *event)
+	{
+		if(event->error_code == BadAccess)
+		{
+			shmBadAccess = true;
+			return 0;
+		}
+		else
+		{
+			return PreviousXErrorHandler(display, event);
+		}
+	}
+
+	FrameBufferX11::FrameBufferX11(Display *display, Window window, int width, int height) : FrameBuffer(width, height, false, false), ownX11(!display), x_display(display), x_window(window)
+	{
+		if(!x_display)
+		{
+			x_display = libX11->XOpenDisplay(0);
+			assert(x_display);
+		}
+
+		int screen = DefaultScreen(x_display);
+		x_gc = libX11->XDefaultGC(x_display, screen);
+		int depth = libX11->XDefaultDepth(x_display, screen);
+
+		XVisualInfo x_visual;
+		Status status = libX11->XMatchVisualInfo(x_display, screen, 32, TrueColor, &x_visual);
+		bool match = (status != 0 && x_visual.blue_mask == 0xFF);   // Prefer X8R8G8B8
+		Visual *visual = match ? x_visual.visual : libX11->XDefaultVisual(x_display, screen);
+
+		mit_shm = (libX11->XShmQueryExtension && libX11->XShmQueryExtension(x_display) == True);
+
+		if(mit_shm)
+		{
+			x_image = libX11->XShmCreateImage(x_display, visual, depth, ZPixmap, 0, &shminfo, width, height);
+
+			shminfo.shmid = shmget(IPC_PRIVATE, x_image->bytes_per_line * x_image->height, IPC_CREAT | SHM_R | SHM_W);
+			shminfo.shmaddr = x_image->data = (char*)shmat(shminfo.shmid, 0, 0);
+			shminfo.readOnly = False;
+
+			PreviousXErrorHandler = libX11->XSetErrorHandler(XShmErrorHandler);
+			libX11->XShmAttach(x_display, &shminfo);   // May produce a BadAccess error
+			libX11->XSync(x_display, False);
+			libX11->XSetErrorHandler(PreviousXErrorHandler);
+
+			if(shmBadAccess)
+			{
+				mit_shm = false;
+
+				XDestroyImage(x_image);
+				shmdt(shminfo.shmaddr);
+				shmctl(shminfo.shmid, IPC_RMID, 0);
+
+				shmBadAccess = false;
+			}
+		}
+
+		if(!mit_shm)
+		{
+			int bytes_per_line = width * 4;
+			int bytes_per_image = height * bytes_per_line;
+			char *buffer = (char*)malloc(bytes_per_image);
+			memset(buffer, 0, bytes_per_image);
+
+			x_image = libX11->XCreateImage(x_display, visual, depth, ZPixmap, 0, buffer, width, height, 32, bytes_per_line);
+			assert(x_image);
+
+			if(!x_image)
+			{
+				free(buffer);
+			}
+		}
+	}
+
+	FrameBufferX11::~FrameBufferX11()
+	{
+		if(!mit_shm)
+		{
+			XDestroyImage(x_image);
+		}
+		else
+		{
+			libX11->XShmDetach(x_display, &shminfo);
+			XDestroyImage(x_image);
+			shmdt(shminfo.shmaddr);
+			shmctl(shminfo.shmid, IPC_RMID, 0);
+		}
+
+		if(ownX11)
+		{
+			libX11->XCloseDisplay(x_display);
+		}
+	}
+
+	void *FrameBufferX11::lock()
+	{
+		if(x_image)
+		{
+			stride = x_image->bytes_per_line;
+			framebuffer = x_image->data;
+		}
+
+		return framebuffer;
+	}
+
+	void FrameBufferX11::unlock()
+	{
+		framebuffer = nullptr;
+	}
+
+	void FrameBufferX11::blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect)
+	{
+		copy(source);
+
+		if(!mit_shm)
+		{
+			libX11->XPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height);
+		}
+		else
+		{
+			libX11->XShmPutImage(x_display, x_window, x_gc, x_image, 0, 0, 0, 0, width, height, False);
+		}
+
+		libX11->XSync(x_display, False);
+
+		if(false)   // Draw the framerate on screen
+		{
+			static double fpsTime = sw::Timer::seconds();
+			static int frames = -1;
+
+			double time = sw::Timer::seconds();
+			double delta = time - fpsTime;
+			frames++;
+
+			static double FPS = 0.0;
+			static double maxFPS = 0.0;
+
+			if(delta > 1.0)
+			{
+				FPS = frames / delta;
+
+				fpsTime = time;
+				frames = 0;
+
+				if(FPS > maxFPS)
+				{
+					maxFPS = FPS;
+				}
+			}
+
+			char string[256];
+			sprintf(string, "FPS: %.2f (max: %.2f)", FPS, maxFPS);
+			libX11->XDrawString(x_display, x_window, x_gc, 50, 50, string, strlen(string));
+		}
+	}
+}
+
+NO_SANITIZE_FUNCTION sw::FrameBuffer *createFrameBuffer(void *display, Window window, int width, int height)
+{
+	return new sw::FrameBufferX11((::Display*)display, window, width, height);
+}
diff --git a/src/WSI/FrameBufferX11.hpp b/src/WSI/FrameBufferX11.hpp
new file mode 100644
index 0000000..dc96331
--- /dev/null
+++ b/src/WSI/FrameBufferX11.hpp
@@ -0,0 +1,52 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef sw_FrameBufferX11_hpp
+#define sw_FrameBufferX11_hpp
+
+#include "Main/FrameBuffer.hpp"
+#include "Common/Debug.hpp"
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XShm.h>
+
+namespace sw
+{
+	class FrameBufferX11 : public FrameBuffer
+	{
+	public:
+		FrameBufferX11(Display *display, Window window, int width, int height);
+
+		~FrameBufferX11() override;
+
+		void flip(sw::Surface *source) override { blit(source, nullptr, nullptr); }
+		void blit(sw::Surface *source, const Rect *sourceRect, const Rect *destRect) override;
+
+		void *lock() override;
+		void unlock() override;
+
+	private:
+		const bool ownX11;
+		Display *x_display;
+		const Window x_window;
+		XImage *x_image = nullptr;
+		GC x_gc;
+
+		bool mit_shm;
+		XShmSegmentInfo shminfo;
+	};
+}
+
+#endif   // sw_FrameBufferX11_hpp
diff --git a/src/WSI/libX11.cpp b/src/WSI/libX11.cpp
new file mode 100644
index 0000000..f3723ff
--- /dev/null
+++ b/src/WSI/libX11.cpp
@@ -0,0 +1,84 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "libX11.hpp"
+
+#include "Common/SharedLibrary.hpp"
+
+#define Bool int
+
+LibX11exports::LibX11exports(void *libX11, void *libXext)
+{
+	XOpenDisplay = (Display *(*)(char*))getProcAddress(libX11, "XOpenDisplay");
+	XGetWindowAttributes = (Status (*)(Display*, Window, XWindowAttributes*))getProcAddress(libX11, "XGetWindowAttributes");
+	XDefaultScreenOfDisplay = (Screen *(*)(Display*))getProcAddress(libX11, "XDefaultScreenOfDisplay");
+	XWidthOfScreen = (int (*)(Screen*))getProcAddress(libX11, "XWidthOfScreen");
+	XHeightOfScreen = (int (*)(Screen*))getProcAddress(libX11, "XHeightOfScreen");
+	XPlanesOfScreen = (int (*)(Screen*))getProcAddress(libX11, "XPlanesOfScreen");
+	XDefaultGC = (GC (*)(Display*, int))getProcAddress(libX11, "XDefaultGC");
+	XDefaultDepth = (int (*)(Display*, int))getProcAddress(libX11, "XDefaultDepth");
+	XMatchVisualInfo = (Status (*)(Display*, int, int, int, XVisualInfo*))getProcAddress(libX11, "XMatchVisualInfo");
+	XDefaultVisual = (Visual *(*)(Display*, int screen_number))getProcAddress(libX11, "XDefaultVisual");
+	XSetErrorHandler = (int (*(*)(int (*)(Display*, XErrorEvent*)))(Display*, XErrorEvent*))getProcAddress(libX11, "XSetErrorHandler");
+	XSync = (int (*)(Display*, Bool))getProcAddress(libX11, "XSync");
+	XCreateImage = (XImage *(*)(Display*, Visual*, unsigned int, int, int, char*, unsigned int, unsigned int, int, int))getProcAddress(libX11, "XCreateImage");
+	XCloseDisplay = (int (*)(Display*))getProcAddress(libX11, "XCloseDisplay");
+	XPutImage = (int (*)(Display*, Drawable, GC, XImage*, int, int, int, int, unsigned int, unsigned int))getProcAddress(libX11, "XPutImage");
+	XDrawString = (int (*)(Display*, Drawable, GC, int, int, char*, int))getProcAddress(libX11, "XDrawString");
+
+	XShmQueryExtension = (Bool (*)(Display*))getProcAddress(libXext, "XShmQueryExtension");
+	XShmCreateImage = (XImage *(*)(Display*, Visual*, unsigned int, int, char*, XShmSegmentInfo*, unsigned int, unsigned int))getProcAddress(libXext, "XShmCreateImage");
+	XShmAttach = (Bool (*)(Display*, XShmSegmentInfo*))getProcAddress(libXext, "XShmAttach");
+	XShmDetach = (Bool (*)(Display*, XShmSegmentInfo*))getProcAddress(libXext, "XShmDetach");
+	XShmPutImage = (int (*)(Display*, Drawable, GC, XImage*, int, int, int, int, unsigned int, unsigned int, bool))getProcAddress(libXext, "XShmPutImage");
+}
+
+LibX11exports *LibX11::operator->()
+{
+	return loadExports();
+}
+
+LibX11exports *LibX11::loadExports()
+{
+	static void *libX11 = nullptr;
+	static void *libXext = nullptr;
+	static LibX11exports *libX11exports = nullptr;
+
+	if(!libX11)
+	{
+		if(getProcAddress(RTLD_DEFAULT, "XOpenDisplay"))   // Search the global scope for pre-loaded X11 library.
+		{
+			libX11exports = new LibX11exports(RTLD_DEFAULT, RTLD_DEFAULT);
+			libX11 = (void*)-1;   // No need to load it.
+		}
+		else
+		{
+			libX11 = loadLibrary("libX11.so");
+
+			if(libX11)
+			{
+				libXext = loadLibrary("libXext.so");
+				libX11exports = new LibX11exports(libX11, libXext);
+			}
+			else
+			{
+				libX11 = (void*)-1;   // Don't attempt loading more than once.
+			}
+		}
+	}
+
+	return libX11exports;
+}
+
+LibX11 libX11;
diff --git a/src/WSI/libX11.hpp b/src/WSI/libX11.hpp
new file mode 100644
index 0000000..c188386
--- /dev/null
+++ b/src/WSI/libX11.hpp
@@ -0,0 +1,69 @@
+// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef libX11_hpp
+#define libX11_hpp
+
+#define Bool int
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XShm.h>
+
+struct LibX11exports
+{
+	LibX11exports(void *libX11, void *libXext);
+
+	Display *(*XOpenDisplay)(char *display_name);
+	Status (*XGetWindowAttributes)(Display *display, Window w, XWindowAttributes *window_attributes_return);
+	Screen *(*XDefaultScreenOfDisplay)(Display *display);
+	int (*XWidthOfScreen)(Screen *screen);
+	int (*XHeightOfScreen)(Screen *screen);
+	int (*XPlanesOfScreen)(Screen *screen);
+	GC (*XDefaultGC)(Display *display, int screen_number);
+	int (*XDefaultDepth)(Display *display, int screen_number);
+	Status (*XMatchVisualInfo)(Display *display, int screen, int depth, int screen_class, XVisualInfo *vinfo_return);
+	Visual *(*XDefaultVisual)(Display *display, int screen_number);
+	int (*(*XSetErrorHandler)(int (*handler)(Display*, XErrorEvent*)))(Display*, XErrorEvent*);
+	int (*XSync)(Display *display, Bool discard);
+	XImage *(*XCreateImage)(Display *display, Visual *visual, unsigned int depth, int format, int offset, char *data, unsigned int width, unsigned int height, int bitmap_pad, int bytes_per_line);
+	int (*XCloseDisplay)(Display *display);
+	int (*XPutImage)(Display *display, Drawable d, GC gc, XImage *image, int src_x, int src_y, int dest_x, int dest_y, unsigned int width, unsigned int height);
+	int (*XDrawString)(Display *display, Drawable d, GC gc, int x, int y, char *string, int length);
+
+	Bool (*XShmQueryExtension)(Display *display);
+	XImage *(*XShmCreateImage)(Display *display, Visual *visual, unsigned int depth, int format, char *data, XShmSegmentInfo *shminfo, unsigned int width, unsigned int height);
+	Bool (*XShmAttach)(Display *display, XShmSegmentInfo *shminfo);
+	Bool (*XShmDetach)(Display *display, XShmSegmentInfo *shminfo);
+	int (*XShmPutImage)(Display *display, Drawable d, GC gc, XImage *image, int src_x, int src_y, int dest_x, int dest_y, unsigned int width, unsigned int height, bool send_event);
+};
+
+#undef Bool
+
+class LibX11
+{
+public:
+	operator bool()
+	{
+		return loadExports();
+	}
+
+	LibX11exports *operator->();
+
+private:
+	LibX11exports *loadExports();
+};
+
+extern LibX11 libX11;
+
+#endif   // libX11_hpp