diff --git a/src/Android.mk b/src/Android.mk
index 248fd28..3372d78 100644
--- a/src/Android.mk
+++ b/src/Android.mk
@@ -55,6 +55,8 @@
 
 LOCAL_SRC_FILES += \
 	Shader/Constants.cpp \
+	Shader/PixelPipeline.cpp \
+	Shader/PixelProgram.cpp \
 	Shader/PixelRoutine.cpp \
 	Shader/PixelShader.cpp \
 	Shader/SamplerCore.cpp \
diff --git a/src/OpenGL/libGLES_CM/libGLES_CM.cbp b/src/OpenGL/libGLES_CM/libGLES_CM.cbp
index 511f127..905a884 100644
--- a/src/OpenGL/libGLES_CM/libGLES_CM.cbp
+++ b/src/OpenGL/libGLES_CM/libGLES_CM.cbp
@@ -233,6 +233,10 @@
 		<Unit filename="../../Renderer/VertexProcessor.hpp" />
 		<Unit filename="../../Shader/Constants.cpp" />
 		<Unit filename="../../Shader/Constants.hpp" />
+		<Unit filename="../../Shader/PixelPipeline.cpp" />
+		<Unit filename="../../Shader/PixelPipeline.hpp" />
+		<Unit filename="../../Shader/PixelProgram.cpp" />
+		<Unit filename="../../Shader/PixelProgram.hpp" />
 		<Unit filename="../../Shader/PixelRoutine.cpp" />
 		<Unit filename="../../Shader/PixelRoutine.hpp" />
 		<Unit filename="../../Shader/PixelShader.cpp" />
diff --git a/src/OpenGL/libGLESv2/libGLESv2.cbp b/src/OpenGL/libGLESv2/libGLESv2.cbp
index b797561..cd3d3d1 100644
--- a/src/OpenGL/libGLESv2/libGLESv2.cbp
+++ b/src/OpenGL/libGLESv2/libGLESv2.cbp
@@ -232,6 +232,10 @@
 		<Unit filename="../../Renderer/VertexProcessor.hpp" />
 		<Unit filename="../../Shader/Constants.cpp" />
 		<Unit filename="../../Shader/Constants.hpp" />
+		<Unit filename="../../Shader/PixelPipeline.cpp" />
+		<Unit filename="../../Shader/PixelPipeline.hpp" />
+		<Unit filename="../../Shader/PixelProgram.cpp" />
+		<Unit filename="../../Shader/PixelProgram.hpp" />
 		<Unit filename="../../Shader/PixelRoutine.cpp" />
 		<Unit filename="../../Shader/PixelRoutine.hpp" />
 		<Unit filename="../../Shader/PixelShader.cpp" />
diff --git a/src/Renderer/PixelProcessor.cpp b/src/Renderer/PixelProcessor.cpp
index 9f2b4ff..e21cbee 100644
--- a/src/Renderer/PixelProcessor.cpp
+++ b/src/Renderer/PixelProcessor.cpp
@@ -11,7 +11,8 @@
 
 #include "PixelProcessor.hpp"
 
-#include "QuadRasterizer.hpp"
+#include "PixelPipeline.hpp"
+#include "PixelProgram.hpp"
 #include "PixelShader.hpp"
 #include "MetaMacro.hpp"
 #include "Surface.hpp"
@@ -1057,7 +1058,16 @@
 
 		if(!routine)
 		{
-			Rasterizer *generator = new QuadRasterizer(state, context->pixelShader);
+			const bool integerPipeline = (context->pixelShaderVersion() <= 0x0104);
+			Rasterizer *generator = nullptr;
+			if(integerPipeline)
+			{
+				generator = new PixelPipeline(state, context->pixelShader);
+			}
+			else
+			{
+				generator = new PixelProgram(state, context->pixelShader);
+			}
 			generator->generate();
 			routine = generator->getRoutine();
 			delete generator;
diff --git a/src/Renderer/QuadRasterizer.cpp b/src/Renderer/QuadRasterizer.cpp
index 543c0ce..a9298d4 100644
--- a/src/Renderer/QuadRasterizer.cpp
+++ b/src/Renderer/QuadRasterizer.cpp
@@ -21,10 +21,23 @@
 {
 	extern bool veryEarlyDepthTest;
 	extern bool complementaryDepthBuffer;
+	extern bool fullPixelPositionRegister;
 
 	extern int clusterCount;
 
-	QuadRasterizer::QuadRasterizer(const PixelProcessor::State &state, const PixelShader *pixelShader) : PixelRoutine(state, pixelShader)
+	QuadRasterizer::Registers::Registers()
+	{
+		occlusion = 0;
+
+#if PERF_PROFILE
+		for(int i = 0; i < PERF_TIMERS; i++)
+		{
+			cycles[i] = 0;
+		}
+#endif
+	}
+
+	QuadRasterizer::QuadRasterizer(const PixelProcessor::State &state, const PixelShader *pixelShader) : Rasterizer(state), shader(pixelShader)
 	{
 	}
 
@@ -45,7 +58,7 @@
 			Int cluster(function.arg(2));
 			Pointer<Byte> data(function.arg(3));
 
-			Registers r(shader);
+			Registers& r = *createRegisters(shader);
 			r.constants = *Pointer<Pointer<Byte> >(data + OFFSET(DrawData,constants));
 			r.cluster = cluster;
 			r.data = data;
@@ -89,6 +102,8 @@
 			#endif
 
 			Return();
+
+			delete &r;
 		}
 
 		routine = function(L"PixelRoutine_%0.8X", state.shaderID);
@@ -317,4 +332,31 @@
 		}
 		Until(y >= yMax)
 	}
+
+	Float4 QuadRasterizer::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
+	{
+		Float4 interpolant = D;
+
+		if(!flat)
+		{
+			interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation, A), 16);
+
+			if(perspective)
+			{
+				interpolant *= rhw;
+			}
+		}
+
+		return interpolant;
+	}
+
+	bool QuadRasterizer::interpolateZ() const
+	{
+		return state.depthTestActive || state.pixelFogActive() || (shader && shader->vPosDeclared && fullPixelPositionRegister);
+	}
+
+	bool QuadRasterizer::interpolateW() const
+	{
+		return state.perspective || (shader && shader->vPosDeclared && fullPixelPositionRegister);
+	}
 }
diff --git a/src/Renderer/QuadRasterizer.hpp b/src/Renderer/QuadRasterizer.hpp
index 36184cc..c1b05c0 100644
--- a/src/Renderer/QuadRasterizer.hpp
+++ b/src/Renderer/QuadRasterizer.hpp
@@ -13,17 +13,51 @@
 #define sw_QuadRasterizer_hpp
 
 #include "Rasterizer.hpp"
-#include "PixelRoutine.hpp"
+#include "ShaderCore.hpp"
+#include "PixelShader.hpp"
+
+#include "Types.hpp"
 
 namespace sw
 {
-	class QuadRasterizer : public PixelRoutine
+	class QuadRasterizer : public Rasterizer
 	{
-	public:
-		QuadRasterizer(const PixelProcessor::State &state, const PixelShader *pixelShader);
+	protected:
+		QuadRasterizer(const PixelProcessor::State &state, const PixelShader *shader);
 
 		virtual ~QuadRasterizer();
 
+		struct Registers
+		{
+			Registers();
+
+			Pointer<Byte> constants;
+
+			Pointer<Byte> primitive;
+			Int cluster;
+			Pointer<Byte> data;
+
+			Float4 Dz[4];
+			Float4 Dw;
+			Float4 Dv[10][4];
+			Float4 Df;
+
+			UInt occlusion;
+
+#if PERF_PROFILE
+			Long cycles[PERF_TIMERS];
+#endif
+		};
+
+		virtual void quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y) = 0;
+		virtual Registers* createRegisters(const PixelShader *shader) = 0;
+
+		bool interpolateZ() const;
+		bool interpolateW() const;
+		Float4 interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+
+		const PixelShader *const shader;
+
 	private:
 		void generate();
 
diff --git a/src/Shader/PixelPipeline.cpp b/src/Shader/PixelPipeline.cpp
new file mode 100644
index 0000000..8a38bed
--- /dev/null
+++ b/src/Shader/PixelPipeline.cpp
@@ -0,0 +1,1968 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2015 Google Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of Google Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "PixelPipeline.hpp"
+#include "Renderer.hpp"
+#include "SamplerCore.hpp"
+
+namespace sw
+{
+	extern bool postBlendSRGB;
+
+	void PixelPipeline::setBuiltins(PixelRoutine::Registers &rBase, Int &x, Int &y, Float4(&z)[4], Float4 &w)
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		if(state.color[0].component & 0x1) r.diffuse.x = convertFixed12(r.vf[0].x); else r.diffuse.x = Short4(0x1000);
+		if(state.color[0].component & 0x2) r.diffuse.y = convertFixed12(r.vf[0].y); else r.diffuse.y = Short4(0x1000);
+		if(state.color[0].component & 0x4) r.diffuse.z = convertFixed12(r.vf[0].z); else r.diffuse.z = Short4(0x1000);
+		if(state.color[0].component & 0x8) r.diffuse.w = convertFixed12(r.vf[0].w); else r.diffuse.w = Short4(0x1000);
+
+		if(state.color[1].component & 0x1) r.specular.x = convertFixed12(r.vf[1].x); else r.specular.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+		if(state.color[1].component & 0x2) r.specular.y = convertFixed12(r.vf[1].y); else r.specular.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+		if(state.color[1].component & 0x4) r.specular.z = convertFixed12(r.vf[1].z); else r.specular.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+		if(state.color[1].component & 0x8) r.specular.w = convertFixed12(r.vf[1].w); else r.specular.w = Short4(0x0000, 0x0000, 0x0000, 0x0000);
+	}
+
+	void PixelPipeline::fixedFunction(Registers& r)
+	{
+		r.current = r.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)
+			{
+				sampleTexture(r, texture, stage, stage);
+			}
+
+			blendTexture(r, temp, texture, stage);
+		}
+
+		specularPixel(r.current, r.specular);
+	}
+
+	void PixelPipeline::applyShader(PixelRoutine::Registers &rBase, Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		if(!shader)
+		{
+			fixedFunction(r);
+			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 version = shader->getVersion();
+			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 = fetchRegisterS(r, src0);
+			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterS(r, src1);
+			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterS(r, src2);
+
+			Float4 u = version < 0x0104 ? r.vf[2 + dst.index].x : r.vf[2 + src0.index].x;
+			Float4 v = version < 0x0104 ? r.vf[2 + dst.index].y : r.vf[2 + src0.index].y;
+			Float4 s = version < 0x0104 ? r.vf[2 + dst.index].z : r.vf[2 + src0.index].z;
+			Float4 t = version < 0x0104 ? r.vf[2 + dst.index].w : r.vf[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(version < 0x0104)
+				{
+					TEXCOORD(d, u, v, s, dst.index);
+				}
+				else
+				{
+					if((src0.swizzle & 0x30) == 0x20)   // .xyz
+					{
+						TEXCRD(d, u, v, s, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+					else   // .xyw
+					{
+						TEXCRD(d, u, v, t, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+				}
+				break;
+			case Shader::OPCODE_TEXKILL:
+				if(version < 0x0104)
+				{
+					TEXKILL(cMask, u, v, s);
+				}
+				else if(version == 0x0104)
+				{
+					if(dst.type == Shader::PARAMETER_TEXTURE)
+					{
+						TEXKILL(cMask, u, v, s);
+					}
+					else
+					{
+						TEXKILL(cMask, r.rs[dst.index]);
+					}
+				}
+				else ASSERT(false);
+				break;
+			case Shader::OPCODE_TEX:
+				if(version < 0x0104)
+				{
+					TEX(r, d, u, v, s, dst.index, false);
+				}
+				else if(version == 0x0104)
+				{
+					if(src0.type == Shader::PARAMETER_TEXTURE)
+					{
+						if((src0.swizzle & 0x30) == 0x20)   // .xyz
+						{
+							TEX(r, d, u, v, s, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+						}
+						else   // .xyw
+						{
+							TEX(r, d, u, v, t, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+						}
+					}
+					else
+					{
+						TEXLD(r, d, s0, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
+					}
+				}
+				else ASSERT(false);
+				break;
+			case Shader::OPCODE_TEXBEM:       TEXBEM(r, d, s0, u, v, s, dst.index);                                             break;
+			case Shader::OPCODE_TEXBEML:      TEXBEML(r, d, s0, u, v, s, dst.index);                                            break;
+			case Shader::OPCODE_TEXREG2AR:    TEXREG2AR(r, d, s0, dst.index);                                                   break;
+			case Shader::OPCODE_TEXREG2GB:    TEXREG2GB(r, d, s0, dst.index);                                                   break;
+			case Shader::OPCODE_TEXM3X2PAD:   TEXM3X2PAD(r, u, v, s, s0, 0, src0.modifier == Shader::MODIFIER_SIGN);            break;
+			case Shader::OPCODE_TEXM3X2TEX:   TEXM3X2TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN); break;
+			case Shader::OPCODE_TEXM3X3PAD:   TEXM3X3PAD(r, u, v, s, s0, pad++ % 2, src0.modifier == Shader::MODIFIER_SIGN);    break;
+			case Shader::OPCODE_TEXM3X3TEX:   TEXM3X3TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN); break;
+			case Shader::OPCODE_TEXM3X3SPEC:  TEXM3X3SPEC(r, d, u, v, s, dst.index, s0, s1);                                    break;
+			case Shader::OPCODE_TEXM3X3VSPEC: TEXM3X3VSPEC(r, d, u, v, s, dst.index, s0);                                       break;
+			case Shader::OPCODE_CND:          CND(d, s0, s1, s2);                                                               break;
+			case Shader::OPCODE_TEXREG2RGB:   TEXREG2RGB(r, d, s0, dst.index);                                                  break;
+			case Shader::OPCODE_TEXDP3TEX:    TEXDP3TEX(r, d, u, v, s, dst.index, s0);                                          break;
+			case Shader::OPCODE_TEXM3X2DEPTH: TEXM3X2DEPTH(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN);          break;
+			case Shader::OPCODE_TEXDP3:       TEXDP3(r, d, u, v, s, s0);                                                        break;
+			case Shader::OPCODE_TEXM3X3:      TEXM3X3(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN);               break;
+			case Shader::OPCODE_TEXDEPTH:     TEXDEPTH(r);                                                                      break;
+			case Shader::OPCODE_CMP0:         CMP(d, s0, s1, s2);                                                               break;
+			case Shader::OPCODE_BEM:          BEM(r, 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, 0x0000, 0x0000, 0x0000)); }
+					if(dst.mask & 0x2) { d.y = Min(d.y, Short4(0x1000)); d.y = Max(d.y, Short4(0x0000, 0x0000, 0x0000, 0x0000)); }
+					if(dst.mask & 0x4) { d.z = Min(d.z, Short4(0x1000)); d.z = Max(d.z, Short4(0x0000, 0x0000, 0x0000, 0x0000)); }
+					if(dst.mask & 0x8) { d.w = Min(d.w, Short4(0x1000)); d.w = Max(d.w, Short4(0x0000, 0x0000, 0x0000, 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(r, dPairing, dst);
+				}
+
+				if(!pairing)
+				{
+					writeDestination(r, d, dst);
+				}
+			}
+		}
+	}
+
+	Bool PixelPipeline::alphaTest(PixelRoutine::Registers &rBase, Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		r.current.x = Min(r.current.x, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.x = Max(r.current.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+		r.current.y = Min(r.current.y, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.y = Max(r.current.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+		r.current.z = Min(r.current.z, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.z = Max(r.current.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+		r.current.w = Min(r.current.w, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.w = Max(r.current.w, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+
+		if(!state.alphaTestActive())
+		{
+			return true;
+		}
+
+		Int aMask;
+
+		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
+		{
+			PixelRoutine::alphaTest(r, aMask, r.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(r.current.w) * Float4(1.0f / 0x1000);
+
+			alphaToCoverage(r, 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(PixelRoutine::Registers &rBase, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		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(r, r.current);
+			}
+			else
+			{
+				r.current.x <<= 4;
+				r.current.y <<= 4;
+				r.current.z <<= 4;
+				r.current.w <<= 4;
+			}
+
+			if(state.targetFormat[0] == FORMAT_R5G6B5)
+			{
+				r.current.x &= Short4(0xF800u);
+				r.current.y &= Short4(0xFC00u);
+				r.current.z &= Short4(0xF800u);
+			}
+
+			fogBlend(r, r.current, fog, r.z[0], r.rhw);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				Pointer<Byte> buffer = cBuffer[0] + q * *Pointer<Int>(r.data + OFFSET(DrawData, colorSliceB[0]));
+				Vector4s color = r.current;
+
+				if(state.multiSampleMask & (1 << q))
+				{
+					alphaBlend(r, 0, buffer, color, x);
+					logicOperation(r, 0, buffer, color, x);
+					writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+				}
+			}
+			break;
+		case FORMAT_R32F:
+		case FORMAT_G32R32F:
+		case FORMAT_A32B32G32R32F:
+			convertSigned12(oC, r.current);
+			PixelRoutine::fogBlend(r, oC, fog, r.z[0], r.rhw);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				Pointer<Byte> buffer = cBuffer[0] + q * *Pointer<Int>(r.data + OFFSET(DrawData, colorSliceB[0]));
+				Vector4f color = oC;
+
+				if(state.multiSampleMask & (1 << q))
+				{
+					alphaBlend(r, 0, buffer, color, x);
+					writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+				}
+			}
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	void PixelPipeline::blendTexture(Registers &r, Vector4s &temp, Vector4s &texture, int stage)
+	{
+		Vector4s *arg1;
+		Vector4s *arg2;
+		Vector4s *arg3;
+		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>(r.data + OFFSET(DrawData, textureStage[stage].constantColor4[0]));
+			constant.y = *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].constantColor4[1]));
+			constant.z = *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].constantColor4[2]));
+			constant.w = *Pointer<Short4>(r.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>(r.data + OFFSET(DrawData, factor.textureFactor4[0]));
+			tfactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData, factor.textureFactor4[1]));
+			tfactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData, factor.textureFactor4[2]));
+			tfactor.w = *Pointer<Short4>(r.data + OFFSET(DrawData, factor.textureFactor4[3]));
+		}
+
+		// Premodulate
+		if(stage > 0 && textureStage.usesTexture)
+		{
+			if(state.textureStage[stage - 1].stageOperation == TextureStage::STAGE_PREMODULATE)
+			{
+				r.current.x = MulHigh(r.current.x, texture.x) << 4;
+				r.current.y = MulHigh(r.current.y, texture.y) << 4;
+				r.current.z = MulHigh(r.current.z, texture.z) << 4;
+			}
+
+			if(state.textureStage[stage - 1].stageOperationAlpha == TextureStage::STAGE_PREMODULATE)
+			{
+				r.current.w = MulHigh(r.current.w, texture.w) << 4;
+			}
+		}
+
+		if(luminance)
+		{
+			texture.x = MulHigh(texture.x, r.L) << 4;
+			texture.y = MulHigh(texture.y, r.L) << 4;
+			texture.z = MulHigh(texture.z, r.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 = &r.current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg1 = &r.diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg1 = &r.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 = &r.current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg2 = &r.diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg2 = &r.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 = &r.current;  break;
+		case TextureStage::SOURCE_DIFFUSE:	arg3 = &r.diffuse;  break;
+		case TextureStage::SOURCE_SPECULAR:	arg3 = &r.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, 0x0800, 0x0800, 0x0800));
+			res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800));
+			res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->x, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.x = MulHigh(res.x, tmp);
+				res.y = SubSat(arg1->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.y = MulHigh(res.y, tmp);
+				res.z = SubSat(arg1->z, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0000, 0x0000, 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, r.current.w) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.current.w) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.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, r.diffuse.w) << 4; res.x = AddSat(res.x, arg2->x);
+			res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.diffuse.w) << 4; res.y = AddSat(res.y, arg2->y);
+			res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.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>(r.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>(r.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>(r.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:
+			{
+				r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
+				r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
+
+				Float4 du2;
+				Float4 dv2;
+
+				du2 = r.du;
+				dv2 = r.dv;
+				r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+				dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+				r.du += dv2;
+				r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+				du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+				r.dv += du2;
+
+				perturbate = true;
+
+				res.x = r.current.x;
+				res.y = r.current.y;
+				res.z = r.current.z;
+				res.w = r.current.w;
+			}
+			break;
+		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
+			{
+				r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
+				r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
+
+				Float4 du2;
+				Float4 dv2;
+
+				du2 = r.du;
+				dv2 = r.dv;
+
+				r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+				dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+				r.du += dv2;
+				r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+				du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+				r.dv += du2;
+
+				perturbate = true;
+
+				r.L = texture.z;
+				r.L = MulHigh(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].luminanceScale4)));
+				r.L = r.L << 4;
+				r.L = AddSat(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].luminanceOffset4)));
+				r.L = Max(r.L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+				r.L = Min(r.L, Short4(0x1000));
+
+				luminance = true;
+
+				res.x = r.current.x;
+				res.y = r.current.y;
+				res.z = r.current.z;
+				res.w = r.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 = &r.current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg1 = &r.diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg1 = &r.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 = &r.current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg2 = &r.diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg2 = &r.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 = &r.current;		break;
+			case TextureStage::SOURCE_DIFFUSE:	arg3 = &r.diffuse;		break;
+			case TextureStage::SOURCE_SPECULAR:	arg3 = &r.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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, r.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, r.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>(r.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, 0x0000, 0x0000, 0x0000));
+			res.y = Max(res.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
+			res.z = Max(res.z, Short4(0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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:
+			r.current.x = res.x;
+			r.current.y = res.y;
+			r.current.z = res.z;
+			r.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(Registers &r, Vector4s &current, Float4 &f, Float4 &z, Float4 &rhw)
+	{
+		if(!state.fogActive)
+		{
+			return;
+		}
+
+		if(state.pixelFogMode != FOG_NONE)
+		{
+			pixelFog(r, f, z, rhw);
+		}
+
+		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>(r.data + OFFSET(DrawData, fog.color4[0]))));
+		current.y += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData, fog.color4[1]))));
+		current.z += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.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);
+	}
+
+	void PixelPipeline::sampleTexture(Registers &r, Vector4s &c, int coordinates, int stage, bool project)
+	{
+		Float4 u = r.vf[2 + coordinates].x;
+		Float4 v = r.vf[2 + coordinates].y;
+		Float4 w = r.vf[2 + coordinates].z;
+		Float4 q = r.vf[2 + coordinates].w;
+
+		if(perturbate)
+		{
+			u += r.du;
+			v += r.dv;
+
+			perturbate = false;
+		}
+
+		sampleTexture(r, c, stage, u, v, w, q, project);
+	}
+
+	void PixelPipeline::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project, bool bias)
+	{
+		Vector4f dsx;
+		Vector4f dsy;
+
+		sampleTexture(r, c, stage, u, v, w, q, dsx, dsy, project, bias, false);
+	}
+
+	void PixelPipeline::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+	{
+#if PERF_PROFILE
+		Long texTime = Ticks();
+#endif
+
+		Pointer<Byte> texture = r.data + OFFSET(DrawData, mipmap) + stage * sizeof(Texture);
+
+		if(!project)
+		{
+			sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
+		}
+		else
+		{
+			Float4 rq = reciprocal(q);
+
+			Float4 u_q = u * rq;
+			Float4 v_q = v * rq;
+			Float4 w_q = w * rq;
+
+			sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
+		}
+
+#if PERF_PROFILE
+		r.cycles[PERF_TEX] += Ticks() - texTime;
+#endif
+	}
+
+	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(Registers &r, Vector4s &d, const Dst &dst)
+	{
+		switch(dst.type)
+		{
+		case Shader::PARAMETER_TEMP:
+			if(dst.mask & 0x1) r.rs[dst.index].x = d.x;
+			if(dst.mask & 0x2) r.rs[dst.index].y = d.y;
+			if(dst.mask & 0x4) r.rs[dst.index].z = d.z;
+			if(dst.mask & 0x8) r.rs[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_INPUT:
+			if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
+			if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
+			if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
+			if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_CONST: ASSERT(false); break;
+		case Shader::PARAMETER_TEXTURE:
+			if(dst.mask & 0x1) r.ts[dst.index].x = d.x;
+			if(dst.mask & 0x2) r.ts[dst.index].y = d.y;
+			if(dst.mask & 0x4) r.ts[dst.index].z = d.z;
+			if(dst.mask & 0x8) r.ts[dst.index].w = d.w;
+			break;
+		case Shader::PARAMETER_COLOROUT:
+			if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
+			if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
+			if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
+			if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
+			break;
+		default:
+			ASSERT(false);
+		}
+	}
+
+	Vector4s PixelPipeline::fetchRegisterS(Registers &r, const Src &src)
+	{
+		Vector4s *reg;
+		int i = src.index;
+
+		Vector4s c;
+
+		if(src.type == Shader::PARAMETER_CONST)
+		{
+			c.x = *Pointer<Short4>(r.data + OFFSET(DrawData, ps.cW[i][0]));
+			c.y = *Pointer<Short4>(r.data + OFFSET(DrawData, ps.cW[i][1]));
+			c.z = *Pointer<Short4>(r.data + OFFSET(DrawData, ps.cW[i][2]));
+			c.w = *Pointer<Short4>(r.data + OFFSET(DrawData, ps.cW[i][3]));
+		}
+
+		switch(src.type)
+		{
+		case Shader::PARAMETER_TEMP:          reg = &r.rs[i]; break;
+		case Shader::PARAMETER_INPUT:         reg = &r.vs[i]; break;
+		case Shader::PARAMETER_CONST:         reg = &c;       break;
+		case Shader::PARAMETER_TEXTURE:       reg = &r.ts[i]; break;
+		case Shader::PARAMETER_VOID:          return r.rs[0]; // Dummy
+		case Shader::PARAMETER_FLOAT4LITERAL: return r.rs[0]; // Dummy
+		default:
+			ASSERT(false);
+		}
+
+		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, 0x0800, 0x0800, 0x0800));
+			mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			break;
+		case Shader::MODIFIER_BIAS_NEGATE:
+			mod.x = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
+			mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
+			mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
+			mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800));
+			mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
+			mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800), x);
+			mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
+			mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
+			mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 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, -0x1000, -0x1000, -0x1000));
+			mod.y = Min(mod.y, Short4(0x1000)); mod.y = Max(mod.y, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+			mod.z = Min(mod.z, Short4(0x1000)); mod.z = Max(mod.z, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
+			mod.w = Min(mod.w, Short4(0x1000)); mod.w = Max(mod.w, Short4(-0x1000, -0x1000, -0x1000, -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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000);
+		}
+	}
+
+	void PixelPipeline::TEXDP3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src)
+	{
+		TEXM3X3PAD(r, u, v, s, src, 0, false);
+
+		Short4 t0 = RoundShort4(r.u_ * Float4(0x1000));
+
+		dst.x = t0;
+		dst.y = t0;
+		dst.z = t0;
+		dst.w = t0;
+	}
+
+	void PixelPipeline::TEXDP3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
+	{
+		TEXM3X3PAD(r, u, v, s, src0, 0, false);
+
+		r.v_ = Float4(0.0f);
+		r.w_ = Float4(0.0f);
+
+		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.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(Pack(test, test)) ^ 0x0000000F;
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+	}
+
+	void PixelPipeline::TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int sampler, bool project)
+	{
+		sampleTexture(r, dst, sampler, u, v, s, s, project);
+	}
+
+	void PixelPipeline::TEXLD(Registers &r, 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);
+
+		sampleTexture(r, dst, sampler, u, v, s, s, project);
+	}
+
+	void PixelPipeline::TEXBEM(Registers &r, 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>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+		dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+		du += dv2;
+		dv *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+		du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+		dv += du2;
+
+		Float4 u_ = u + du;
+		Float4 v_ = v + dv;
+
+		sampleTexture(r, dst, stage, u_, v_, s, s);
+	}
+
+	void PixelPipeline::TEXBEML(Registers &r, 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>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][0]));
+		dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][0]));
+		du += dv2;
+		dv *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[1][1]));
+		du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4F[0][1]));
+		dv += du2;
+
+		Float4 u_ = u + du;
+		Float4 v_ = v + dv;
+
+		sampleTexture(r, dst, stage, u_, v_, s, s);
+
+		Short4 L;
+
+		L = src.z;
+		L = MulHigh(L, *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].luminanceScale4)));
+		L = L << 4;
+		L = AddSat(L, *Pointer<Short4>(r.data + OFFSET(DrawData, textureStage[stage].luminanceOffset4)));
+		L = Max(L, Short4(0x0000, 0x0000, 0x0000, 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(Registers &r, 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);
+
+		sampleTexture(r, dst, stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXREG2GB(Registers &r, 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;
+
+		sampleTexture(r, dst, stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXREG2RGB(Registers &r, 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);
+
+		sampleTexture(r, dst, stage, u, v, s, s);
+	}
+
+	void PixelPipeline::TEXM3X2DEPTH(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling)
+	{
+		TEXM3X2PAD(r, u, v, s, src, 1, signedScaling);
+
+		// z / w
+		r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
+
+		r.oDepth = r.u_;
+	}
+
+	void PixelPipeline::TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
+	{
+		TEXM3X3PAD(r, u, v, s, src0, component, signedScaling);
+	}
+
+	void PixelPipeline::TEXM3X2TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X2PAD(r, u, v, s, src0, 1, signedScaling);
+
+		r.w_ = Float4(0.0f);
+
+		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
+	}
+
+	void PixelPipeline::TEXM3X3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
+
+		dst.x = RoundShort4(r.u_ * Float4(0x1000));
+		dst.y = RoundShort4(r.v_ * Float4(0x1000));
+		dst.z = RoundShort4(r.w_ * Float4(0x1000));
+		dst.w = Short4(0x1000);
+	}
+
+	void PixelPipeline::TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
+	{
+		if(component == 0 || previousScaling != signedScaling)   // FIXME: Other source modifiers?
+		{
+			r.U = Float4(src0.x);
+			r.V = Float4(src0.y);
+			r.W = Float4(src0.z);
+
+			previousScaling = signedScaling;
+		}
+
+		Float4 x = r.U * u + r.V * v + r.W * s;
+
+		x *= Float4(1.0f / 0x1000);
+
+		switch(component)
+		{
+		case 0:	r.u_ = x; break;
+		case 1:	r.v_ = x; break;
+		case 2: r.w_ = x; break;
+		default: ASSERT(false);
+		}
+	}
+
+	void PixelPipeline::TEXM3X3SPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1)
+	{
+		TEXM3X3PAD(r, 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__ = r.u_ * E[0];
+		v__ = r.v_ * E[1];
+		w__ = r.w_ * E[2];
+		u__ += v__ + w__;
+		u__ += u__;
+		v__ = u__;
+		w__ = u__;
+		u__ *= r.u_;
+		v__ *= r.v_;
+		w__ *= r.w_;
+		r.u_ *= r.u_;
+		r.v_ *= r.v_;
+		r.w_ *= r.w_;
+		r.u_ += r.v_ + r.w_;
+		u__ -= E[0] * r.u_;
+		v__ -= E[1] * r.u_;
+		w__ -= E[2] * r.u_;
+
+		sampleTexture(r, dst, stage, u__, v__, w__, w__);
+	}
+
+	void PixelPipeline::TEXM3X3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
+	{
+		TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
+
+		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
+	}
+
+	void PixelPipeline::TEXM3X3VSPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
+	{
+		TEXM3X3PAD(r, u, v, s, src0, 2, false);
+
+		Float4 E[3];   // Eye vector
+
+		E[0] = r.vf[2 + stage - 2].w;
+		E[1] = r.vf[2 + stage - 1].w;
+		E[2] = r.vf[2 + stage - 0].w;
+
+		// Reflection
+		Float4 u__;
+		Float4 v__;
+		Float4 w__;
+
+		// (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
+		u__ = r.u_ * E[0];
+		v__ = r.v_ * E[1];
+		w__ = r.w_ * E[2];
+		u__ += v__ + w__;
+		u__ += u__;
+		v__ = u__;
+		w__ = u__;
+		u__ *= r.u_;
+		v__ *= r.v_;
+		w__ *= r.w_;
+		r.u_ *= r.u_;
+		r.v_ *= r.v_;
+		r.w_ *= r.w_;
+		r.u_ += r.v_ + r.w_;
+		u__ -= E[0] * r.u_;
+		v__ -= E[1] * r.u_;
+		w__ -= E[2] * r.u_;
+
+		sampleTexture(r, dst, stage, u__, v__, w__, w__);
+	}
+
+	void PixelPipeline::TEXDEPTH(Registers &r)
+	{
+		r.u_ = Float4(r.rs[5].x);
+		r.v_ = Float4(r.rs[5].y);
+
+		// z / w
+		r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
+
+		r.oDepth = r.u_;
+	}
+
+	void PixelPipeline::CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
+	{
+		{ Short4 t0; t0 = src0.x; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, 0x0000, 0x0000, 0x0000), src0.x); Short4 t1; t1 = src2.x; t1 &= t0; t0 = ~t0 & src1.x; t0 |= t1; dst.x = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.y); Short4 t1; t1 = src2.y; t1 &= t0; t0 = ~t0 & src1.y; t0 |= t1; dst.y = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.z); Short4 t1; t1 = src2.z; t1 &= t0; t0 = ~t0 & src1.z; t0 |= t1; dst.z = t0; };
+		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.w); Short4 t1; t1 = src2.w; t1 &= t0; t0 = ~t0 & src1.w; t0 |= t1; dst.w = t0; };
+	}
+
+	void PixelPipeline::BEM(Registers &r, 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>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[0][0]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t1 = MulHigh(src1.y, *Pointer<Short4>(r.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>(r.data + OFFSET(DrawData, textureStage[stage].bumpmapMatrix4W[0][1]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
+		t1 = MulHigh(src1.y, *Pointer<Short4>(r.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/Shader/PixelPipeline.hpp b/src/Shader/PixelPipeline.hpp
new file mode 100644
index 0000000..2b49ad7
--- /dev/null
+++ b/src/Shader/PixelPipeline.hpp
@@ -0,0 +1,118 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2015 Google Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of Google Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#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), perturbate(false), luminance(false), previousScaling(false) {}
+		virtual ~PixelPipeline() {}
+
+	protected:
+		virtual void setBuiltins(PixelRoutine::Registers &r, Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(PixelRoutine::Registers &r, Int cMask[4]);
+		virtual Bool alphaTest(PixelRoutine::Registers &r, Int cMask[4]);
+		virtual void rasterOperation(PixelRoutine::Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+		virtual QuadRasterizer::Registers* createRegisters(const PixelShader *shader) { return new PixelPipeline::Registers(shader); };
+
+	private:
+		struct Registers : public PixelRoutine::Registers
+		{
+			Registers(const PixelShader *shader) : PixelRoutine::Registers(shader), current(rs[0]), diffuse(vs[0]), specular(vs[1]) {}
+
+			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(Registers& r);
+		void blendTexture(Registers &r, Vector4s &temp, Vector4s &texture, int stage);
+		void fogBlend(Registers &r, Vector4s &current, Float4 &fog, Float4 &z, Float4 &rhw);
+		void specularPixel(Vector4s &current, Vector4s &specular);
+
+		void sampleTexture(Registers &r, Vector4s &c, int coordinates, int sampler, bool project = false);
+		void sampleTexture(Registers &r, Vector4s &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project = false, bool bias = false);
+		void sampleTexture(Registers &r, Vector4s &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
+
+		Short4 convertFixed12(RValue<Float4> cf);
+		void convertFixed12(Vector4s &cs, Vector4f &cf);
+		Float4 convertSigned12(Short4 &cs);
+		void convertSigned12(Vector4f &cf, Vector4s &cs);
+
+		void writeDestination(Registers &r, Vector4s &d, const Dst &dst);
+		Vector4s fetchRegisterS(Registers &r, 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(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src);
+		void TEXDP3TEX(Registers &r, 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(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, bool project);
+		void TEXLD(Registers &r, Vector4s &dst, Vector4s &src, int stage, bool project);
+		void TEXBEM(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXBEML(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXREG2AR(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2GB(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2RGB(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
+		void TEXM3X2DEPTH(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling);
+		void TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X2TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling);
+		void TEXM3X3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling);
+		void TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X3SPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1);
+		void TEXM3X3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool singedScaling);
+		void TEXM3X3VSPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
+		void TEXDEPTH(Registers &r);
+		void CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
+		void BEM(Registers &r, Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage);
+
+		bool perturbate;
+		bool luminance;
+		bool previousScaling;
+	};
+}
+
+#endif
diff --git a/src/Shader/PixelProgram.cpp b/src/Shader/PixelProgram.cpp
new file mode 100644
index 0000000..1dbab7a
--- /dev/null
+++ b/src/Shader/PixelProgram.cpp
@@ -0,0 +1,1559 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2015 Google Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of Google Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#include "PixelProgram.hpp"
+#include "Primitive.hpp"
+#include "Renderer.hpp"
+#include "SamplerCore.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(PixelRoutine::Registers &rBase, Int &x, Int &y, Float4(&z)[4], Float4 &w)
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		if(shader->getVersion() >= 0x0300)
+		{
+			if(shader->vPosDeclared)
+			{
+				if(!halfIntegerCoordinates)
+				{
+					r.vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
+					r.vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
+				}
+				else
+				{
+					r.vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
+					r.vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
+				}
+
+				if(fullPixelPositionRegister)
+				{
+					r.vPos.z = z[0]; // FIXME: Centroid?
+					r.vPos.w = w;    // FIXME: Centroid?
+				}
+			}
+
+			if(shader->vFaceDeclared)
+			{
+				Float4 area = *Pointer<Float>(r.primitive + OFFSET(Primitive, area));
+				Float4 face = booleanFaceRegister ? Float4(As<Float4>(CmpNLT(area, Float4(0.0f)))) : area;
+
+				r.vFace.x = face;
+				r.vFace.y = face;
+				r.vFace.z = face;
+				r.vFace.w = face;
+			}
+		}
+	}
+
+	void PixelProgram::applyShader(PixelRoutine::Registers &rBase, Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		r.enableIndex = 0;
+		r.stackIndex = 0;
+
+		if(shader->containsLeaveInstruction())
+		{
+			r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		}
+
+		bool out[4][4] = { false };
+
+		// 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;
+			}
+
+			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];
+
+			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;
+
+			if(opcode == Shader::OPCODE_TEXKILL)   // Takes destination as input
+			{
+				if(dst.type == Shader::PARAMETER_TEXTURE)
+				{
+					d.x = r.vf[2 + dst.index].x;
+					d.y = r.vf[2 + dst.index].y;
+					d.z = r.vf[2 + dst.index].z;
+					d.w = r.vf[2 + dst.index].w;
+				}
+				else
+				{
+					d = r.rf[dst.index];
+				}
+			}
+
+			if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(r, src0);
+			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(r, src1);
+			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(r, src2);
+			if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegisterF(r, src3);
+
+			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_F2B:        f2b(d, s0);                                    break;
+			case Shader::OPCODE_B2F:        b2f(d, s0);                                    break;
+			case Shader::OPCODE_ADD:        add(d, s0, s1);                                break;
+			case Shader::OPCODE_SUB:        sub(d, s0, s1);                                break;
+			case Shader::OPCODE_MUL:        mul(d, s0, s1);                                break;
+			case Shader::OPCODE_MAD:        mad(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_CMP0:       cmp0(d, s0, s1, s2);                           break;
+			case Shader::OPCODE_ICMP:       icmp(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_MOD:        mod(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_MAX:        max(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_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_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_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(r, d, s0, src1);                          break;
+			case Shader::OPCODE_M4X3:       M4X3(r, d, s0, src1);                          break;
+			case Shader::OPCODE_M3X4:       M3X4(r, d, s0, src1);                          break;
+			case Shader::OPCODE_M3X3:       M3X3(r, d, s0, src1);                          break;
+			case Shader::OPCODE_M3X2:       M3X2(r, d, s0, src1);                          break;
+			case Shader::OPCODE_TEX:        TEXLD(r, d, s0, src1, project, bias);          break;
+			case Shader::OPCODE_TEXLDD:     TEXLDD(r, d, s0, src1, s2, s3, project, bias); break;
+			case Shader::OPCODE_TEXLDL:     TEXLDL(r, d, s0, src1, project, bias);         break;
+			case Shader::OPCODE_TEXKILL:    TEXKILL(cMask, d, dst.mask);                   break;
+			case Shader::OPCODE_DISCARD:    DISCARD(r, 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(r);                                      break;
+			case Shader::OPCODE_BREAKC:     BREAKC(r, s0, s1, control);                    break;
+			case Shader::OPCODE_BREAKP:     BREAKP(r, src0);                               break;
+			case Shader::OPCODE_CONTINUE:   CONTINUE(r);                                   break;
+			case Shader::OPCODE_TEST:       TEST();                                        break;
+			case Shader::OPCODE_CALL:       CALL(r, dst.label, dst.callSite);              break;
+			case Shader::OPCODE_CALLNZ:     CALLNZ(r, dst.label, dst.callSite, src0);      break;
+			case Shader::OPCODE_ELSE:       ELSE(r);                                       break;
+			case Shader::OPCODE_ENDIF:      ENDIF(r);                                      break;
+			case Shader::OPCODE_ENDLOOP:    ENDLOOP(r);                                    break;
+			case Shader::OPCODE_ENDREP:     ENDREP(r);                                     break;
+			case Shader::OPCODE_ENDWHILE:   ENDWHILE(r);                                   break;
+			case Shader::OPCODE_IF:         IF(r, src0);                                   break;
+			case Shader::OPCODE_IFC:        IFC(r, s0, s1, control);                       break;
+			case Shader::OPCODE_LABEL:      LABEL(dst.index);                              break;
+			case Shader::OPCODE_LOOP:       LOOP(r, src1);                                 break;
+			case Shader::OPCODE_REP:        REP(r, src0);                                  break;
+			case Shader::OPCODE_WHILE:      WHILE(r, src0);                                break;
+			case Shader::OPCODE_RET:        RET(r);                                        break;
+			case Shader::OPCODE_LEAVE:      LEAVE(r);                                      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:        not(d, s0);                                    break;
+			case Shader::OPCODE_OR:         or(d.x, s0.x, s1.x);                           break;
+			case Shader::OPCODE_XOR:        xor(d.x, s0.x, s1.x);                          break;
+			case Shader::OPCODE_AND:        and(d.x, s0.x, s1.x);                          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.integer)
+				{
+					switch(opcode)
+					{
+					case Shader::OPCODE_DIV:
+						if(dst.x) d.x = Trunc(d.x);
+						if(dst.y) d.y = Trunc(d.y);
+						if(dst.z) d.z = Trunc(d.z);
+						if(dst.w) d.w = Trunc(d.w);
+						break;
+					default:
+						break;   // No truncation to integer required when arguments are integer
+					}
+				}
+
+				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.rf[dst.index].x;
+							if(dst.y) pDst.y = r.rf[dst.index].y;
+							if(dst.z) pDst.z = r.rf[dst.index].z;
+							if(dst.w) pDst.w = r.rf[dst.index].w;
+						}
+						else
+						{
+							Int a = relativeAddress(r, dst);
+
+							if(dst.x) pDst.x = r.rf[dst.index + a].x;
+							if(dst.y) pDst.y = r.rf[dst.index + a].y;
+							if(dst.z) pDst.z = r.rf[dst.index + a].z;
+							if(dst.w) pDst.w = r.rf[dst.index + a].w;
+						}
+						break;
+					case Shader::PARAMETER_COLOROUT:
+						ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
+						if(dst.x) pDst.x = r.oC[dst.index].x;
+						if(dst.y) pDst.y = r.oC[dst.index].y;
+						if(dst.z) pDst.z = r.oC[dst.index].z;
+						if(dst.w) pDst.w = r.oC[dst.index].w;
+						break;
+					case Shader::PARAMETER_PREDICATE:
+						if(dst.x) pDst.x = r.p0.x;
+						if(dst.y) pDst.y = r.p0.y;
+						if(dst.z) pDst.z = r.p0.z;
+						if(dst.w) pDst.w = r.p0.w;
+						break;
+					case Shader::PARAMETER_DEPTHOUT:
+						pDst.x = r.oDepth;
+						break;
+					default:
+						ASSERT(false);
+					}
+
+					Int4 enable = enableMask(r, instruction);
+
+					Int4 xEnable = enable;
+					Int4 yEnable = enable;
+					Int4 zEnable = enable;
+					Int4 wEnable = enable;
+
+					if(predicate)
+					{
+						unsigned char pSwizzle = instruction->predicateSwizzle;
+
+						Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
+						Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
+						Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
+						Float4 wPredicate = r.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.rf[dst.index].x = d.x;
+						if(dst.y) r.rf[dst.index].y = d.y;
+						if(dst.z) r.rf[dst.index].z = d.z;
+						if(dst.w) r.rf[dst.index].w = d.w;
+					}
+					else
+					{
+						Int a = relativeAddress(r, dst);
+
+						if(dst.x) r.rf[dst.index + a].x = d.x;
+						if(dst.y) r.rf[dst.index + a].y = d.y;
+						if(dst.z) r.rf[dst.index + a].z = d.z;
+						if(dst.w) r.rf[dst.index + a].w = d.w;
+					}
+					break;
+				case Shader::PARAMETER_COLOROUT:
+					ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
+					if(dst.x) { r.oC[dst.index].x = d.x; out[dst.index][0] = true; }
+					if(dst.y) { r.oC[dst.index].y = d.y; out[dst.index][1] = true; }
+					if(dst.z) { r.oC[dst.index].z = d.z; out[dst.index][2] = true; }
+					if(dst.w) { r.oC[dst.index].w = d.w; out[dst.index][3] = true; }
+					break;
+				case Shader::PARAMETER_PREDICATE:
+					if(dst.x) r.p0.x = d.x;
+					if(dst.y) r.p0.y = d.y;
+					if(dst.z) r.p0.z = d.z;
+					if(dst.w) r.p0.w = d.w;
+					break;
+				case Shader::PARAMETER_DEPTHOUT:
+					r.oDepth = d.x;
+					break;
+				default:
+					ASSERT(false);
+				}
+			}
+		}
+
+		if(currentLabel != -1)
+		{
+			Nucleus::setInsertBlock(returnBlock);
+		}
+
+		for(int i = 0; i < 4; i++)
+		{
+			if(state.targetFormat[i] != FORMAT_NULL)
+			{
+				if(!out[i][0]) r.oC[i].x = Float4(0.0f);
+				if(!out[i][1]) r.oC[i].y = Float4(0.0f);
+				if(!out[i][2]) r.oC[i].z = Float4(0.0f);
+				if(!out[i][3]) r.oC[i].w = Float4(0.0f);
+			}
+		}
+	}
+
+	Bool PixelProgram::alphaTest(PixelRoutine::Registers &rBase, Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		clampColor(r.oC);
+
+		if(!state.alphaTestActive())
+		{
+			return true;
+		}
+
+		Int aMask;
+
+		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
+		{
+			Short4 alpha = RoundShort4(r.oC[0].w * Float4(0x1000));
+
+			PixelRoutine::alphaTest(r, aMask, alpha);
+
+			for(unsigned int q = 0; q < state.multiSample; q++)
+			{
+				cMask[q] &= aMask;
+			}
+		}
+		else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
+		{
+			alphaToCoverage(r, cMask, r.oC[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(PixelRoutine::Registers &rBase, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
+	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
+		for(int index = 0; index < 4; index++)
+		{
+			if(!state.colorWriteActive(index))
+			{
+				continue;
+			}
+
+			if(!postBlendSRGB && state.writeSRGB)
+			{
+				r.oC[index].x = linearToSRGB(r.oC[index].x);
+				r.oC[index].y = linearToSRGB(r.oC[index].y);
+				r.oC[index].z = linearToSRGB(r.oC[index].z);
+			}
+
+			if(index == 0)
+			{
+				fogBlend(r, r.oC[index], fog, r.z[0], r.rhw);
+			}
+
+			switch(state.targetFormat[index])
+			{
+			case FORMAT_R5G6B5:
+			case FORMAT_X8R8G8B8:
+			case FORMAT_X8B8G8R8:
+			case FORMAT_A8R8G8B8:
+			case FORMAT_A8B8G8R8:
+			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>(r.data + OFFSET(DrawData, colorSliceB[index]));
+					Vector4s color;
+
+					color.x = convertFixed16(r.oC[index].x, false);
+					color.y = convertFixed16(r.oC[index].y, false);
+					color.z = convertFixed16(r.oC[index].z, false);
+					color.w = convertFixed16(r.oC[index].w, false);
+
+					if(state.multiSampleMask & (1 << q))
+					{
+						alphaBlend(r, index, buffer, color, x);
+						logicOperation(r, index, buffer, color, x);
+						writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+					}
+				}
+				break;
+			case FORMAT_R32F:
+			case FORMAT_G32R32F:
+			case FORMAT_A32B32G32R32F:
+				for(unsigned int q = 0; q < state.multiSample; q++)
+				{
+					Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData, colorSliceB[index]));
+					Vector4f color = r.oC[index];
+
+					if(state.multiSampleMask & (1 << q))
+					{
+						alphaBlend(r, index, buffer, color, x);
+						writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
+					}
+				}
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+	}
+
+	void PixelProgram::sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+	{
+		if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
+		{
+			sampleTexture(r, c, sampler.index, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
+		}
+		else
+		{
+			Int index = As<Int>(Float(fetchRegisterF(r, sampler).x.x));
+
+			for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
+			{
+				if(shader->usesSampler(i))
+				{
+					If(index == i)
+					{
+						sampleTexture(r, c, i, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
+						// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
+					}
+				}
+			}
+		}
+	}
+
+	void PixelProgram::sampleTexture(Registers &r, Vector4f &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
+	{
+#if PERF_PROFILE
+		Long texTime = Ticks();
+#endif
+
+		Pointer<Byte> texture = r.data + OFFSET(DrawData, mipmap) + stage * sizeof(Texture);
+
+		if(!project)
+		{
+			sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
+		}
+		else
+		{
+			Float4 rq = reciprocal(q);
+
+			Float4 u_q = u * rq;
+			Float4 v_q = v * rq;
+			Float4 w_q = w * rq;
+
+			sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
+		}
+
+#if PERF_PROFILE
+		r.cycles[PERF_TEX] += Ticks() - texTime;
+#endif
+	}
+
+	void PixelProgram::clampColor(Vector4f oC[4])
+	{
+		for(int index = 0; index < 4; 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_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_A32B32G32R32F:
+				break;
+			default:
+				ASSERT(false);
+			}
+		}
+	}
+
+	Int4 PixelProgram::enableMask(Registers &r, const Shader::Instruction *instruction)
+	{
+		Int4 enable = instruction->analysisBranch ? Int4(r.enableStack[r.enableIndex]) : Int4(0xFFFFFFFF);
+
+		if(!whileTest)
+		{
+			if(shader->containsBreakInstruction() && instruction->analysisBreak)
+			{
+				enable &= r.enableBreak;
+			}
+
+			if(shader->containsContinueInstruction() && instruction->analysisContinue)
+			{
+				enable &= r.enableContinue;
+			}
+
+			if(shader->containsLeaveInstruction() && instruction->analysisLeave)
+			{
+				enable &= r.enableLeave;
+			}
+		}
+
+		return enable;
+	}
+
+	Vector4f PixelProgram::fetchRegisterF(Registers &r, const Src &src, int offset)
+	{
+		Vector4f reg;
+		int i = src.index + offset;
+
+		switch(src.type)
+		{
+		case Shader::PARAMETER_TEMP:
+			if(src.rel.type == Shader::PARAMETER_VOID)
+			{
+				reg = r.rf[i];
+			}
+			else
+			{
+				Int a = relativeAddress(r, src);
+
+				reg = r.rf[i + a];
+			}
+			break;
+		case Shader::PARAMETER_INPUT:
+			{
+				if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+				{
+					reg = r.vf[i];
+				}
+				else if(src.rel.type == Shader::PARAMETER_LOOP)
+				{
+					Int aL = r.aL[r.loopDepth];
+
+					reg = r.vf[i + aL];
+				}
+				else
+				{
+					Int a = relativeAddress(r, src);
+
+					reg = r.vf[i + a];
+				}
+			}
+			break;
+		case Shader::PARAMETER_CONST:
+			reg = readConstant(r, src, offset);
+			break;
+		case Shader::PARAMETER_TEXTURE:
+			reg = r.vf[2 + i];
+			break;
+		case Shader::PARAMETER_MISCTYPE:
+			if(src.index == 0) reg = r.vPos;
+			if(src.index == 1) reg = r.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) + RoundInt(r.rf[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:
+			reg = r.oC[i];
+			break;
+		case Shader::PARAMETER_DEPTHOUT:
+			reg.x = r.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;
+	}
+
+	Vector4f PixelProgram::readConstant(Registers &r, const Src &src, int offset)
+	{
+		Vector4f c;
+
+		int i = src.index + offset;
+
+		if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+		{
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[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.type == Shader::PARAMETER_LOOP)
+		{
+			Int loopCounter = r.aL[r.loopDepth];
+
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[i]) + loopCounter * 16);
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+		}
+		else
+		{
+			Int a = relativeAddress(r, src);
+
+			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[i]) + a * 16);
+
+			c.x = c.x.xxxx;
+			c.y = c.y.yyyy;
+			c.z = c.z.zzzz;
+			c.w = c.w.wwww;
+		}
+
+		return c;
+	}
+
+	Int PixelProgram::relativeAddress(Registers &r, const Shader::Parameter &var)
+	{
+		ASSERT(var.rel.deterministic);
+
+		if(var.rel.type == Shader::PARAMETER_TEMP)
+		{
+			return RoundInt(Extract(r.rf[var.rel.index].x, 0)) * var.rel.scale;
+		}
+		else if(var.rel.type == Shader::PARAMETER_INPUT)
+		{
+			return RoundInt(Extract(r.vf[var.rel.index].x, 0)) * var.rel.scale;
+		}
+		else if(var.rel.type == Shader::PARAMETER_OUTPUT)
+		{
+			return RoundInt(Extract(r.oC[var.rel.index].x, 0)) * var.rel.scale;
+		}
+		else if(var.rel.type == Shader::PARAMETER_CONST)
+		{
+			RValue<Float4> c = *Pointer<Float4>(r.data + OFFSET(DrawData, ps.c[var.rel.index]));
+
+			return RoundInt(Extract(c, 0)) * var.rel.scale;
+		}
+		else ASSERT(false);
+
+		return 0;
+	}
+
+	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(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegisterF(r, src1, 0);
+		Vector4f row1 = fetchRegisterF(r, src1, 1);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+	}
+
+	void PixelProgram::M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegisterF(r, src1, 0);
+		Vector4f row1 = fetchRegisterF(r, src1, 1);
+		Vector4f row2 = fetchRegisterF(r, src1, 2);
+
+		dst.x = dot3(src0, row0);
+		dst.y = dot3(src0, row1);
+		dst.z = dot3(src0, row2);
+	}
+
+	void PixelProgram::M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegisterF(r, src1, 0);
+		Vector4f row1 = fetchRegisterF(r, src1, 1);
+		Vector4f row2 = fetchRegisterF(r, src1, 2);
+		Vector4f row3 = fetchRegisterF(r, 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(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegisterF(r, src1, 0);
+		Vector4f row1 = fetchRegisterF(r, src1, 1);
+		Vector4f row2 = fetchRegisterF(r, src1, 2);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+	}
+
+	void PixelProgram::M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
+	{
+		Vector4f row0 = fetchRegisterF(r, src1, 0);
+		Vector4f row1 = fetchRegisterF(r, src1, 1);
+		Vector4f row2 = fetchRegisterF(r, src1, 2);
+		Vector4f row3 = fetchRegisterF(r, src1, 3);
+
+		dst.x = dot4(src0, row0);
+		dst.y = dot4(src0, row1);
+		dst.z = dot4(src0, row2);
+		dst.w = dot4(src0, row3);
+	}
+
+	void PixelProgram::TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+	{
+		Vector4f tmp;
+		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias);
+
+		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+	}
+
+	void PixelProgram::TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3, bool project, bool bias)
+	{
+		Vector4f tmp;
+		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src2, src3, project, bias, true);
+
+		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+	}
+
+	void PixelProgram::TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
+	{
+		Vector4f tmp;
+		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias, false, true);
+
+		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
+		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
+		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
+		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
+	}
+
+	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(r));
+		//	}
+
+		for(unsigned int q = 0; q < state.multiSample; q++)
+		{
+			cMask[q] &= kill;
+		}
+
+		// FIXME: Branch to end of shader if all killed?
+	}
+
+	void PixelProgram::DISCARD(Registers &r, Int cMask[4], const Shader::Instruction *instruction)
+	{
+		Int kill = 0;
+
+		if(shader->containsDynamicBranching())
+		{
+			kill = ~SignMask(enableMask(r, 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(Registers &r)
+	{
+		llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+		if(breakDepth == 0)
+		{
+			r.enableIndex = r.enableIndex - breakDepth;
+			Nucleus::createBr(endBlock);
+		}
+		else
+		{
+			r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
+			Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+			r.enableIndex = r.enableIndex - breakDepth;
+			branch(allBreak, endBlock, deadBlock);
+		}
+
+		Nucleus::setInsertBlock(deadBlock);
+		r.enableIndex = r.enableIndex + breakDepth;
+	}
+
+	void PixelProgram::BREAKC(Registers &r, 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(r, condition);
+	}
+
+	void PixelProgram::BREAKP(Registers &r, const Src &predicateRegister)   // FIXME: Factor out parts common with BREAKC
+	{
+		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		BREAK(r, condition);
+	}
+
+	void PixelProgram::BREAK(Registers &r, Int4 &condition)
+	{
+		condition &= r.enableStack[r.enableIndex];
+
+		llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
+
+		r.enableBreak = r.enableBreak & ~condition;
+		Bool allBreak = SignMask(r.enableBreak) == 0x0;
+
+		r.enableIndex = r.enableIndex - breakDepth;
+		branch(allBreak, endBlock, continueBlock);
+
+		Nucleus::setInsertBlock(continueBlock);
+		r.enableIndex = r.enableIndex + breakDepth;
+	}
+
+	void PixelProgram::CONTINUE(Registers &r)
+	{
+		r.enableContinue = r.enableContinue & ~r.enableStack[r.enableIndex];
+	}
+
+	void PixelProgram::TEST()
+	{
+		whileTest = true;
+	}
+
+	void PixelProgram::CALL(Registers &r, int labelIndex, int callSiteIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = r.enableLeave;
+
+		Nucleus::createBr(labelBlock[labelIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		r.enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			CALLNZb(r, labelIndex, callSiteIndex, src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			CALLNZp(r, labelIndex, callSiteIndex, src);
+		}
+		else ASSERT(false);
+	}
+
+	void PixelProgram::CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister)
+	{
+		Bool condition = (*Pointer<Byte>(r.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)
+		{
+			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+		}
+
+		Int4 restoreLeave = r.enableLeave;
+
+		branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		r.enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		condition &= r.enableStack[r.enableIndex];
+
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		if(callRetBlock[labelIndex].size() > 1)
+		{
+			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
+		}
+
+		r.enableIndex++;
+		r.enableStack[r.enableIndex] = condition;
+		Int4 restoreLeave = r.enableLeave;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
+		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
+
+		r.enableIndex--;
+		r.enableLeave = restoreLeave;
+	}
+
+	void PixelProgram::ELSE(Registers &r)
+	{
+		ifDepth--;
+
+		llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
+		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		if(isConditionalIf[ifDepth])
+		{
+			Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+			Bool notAllFalse = SignMask(condition) != 0;
+
+			branch(notAllFalse, falseBlock, endBlock);
+
+			r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
+		}
+		else
+		{
+			Nucleus::createBr(endBlock);
+			Nucleus::setInsertBlock(falseBlock);
+		}
+
+		ifFalseBlock[ifDepth] = endBlock;
+
+		ifDepth++;
+	}
+
+	void PixelProgram::ENDIF(Registers &r)
+	{
+		ifDepth--;
+
+		llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
+
+		Nucleus::createBr(endBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		if(isConditionalIf[ifDepth])
+		{
+			breakDepth--;
+			r.enableIndex--;
+		}
+	}
+
+	void PixelProgram::ENDLOOP(Registers &r)
+	{
+		loopRepDepth--;
+
+		r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth];   // FIXME: +=
+
+		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		r.loopDepth--;
+		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void PixelProgram::ENDREP(Registers &r)
+	{
+		loopRepDepth--;
+
+		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		r.loopDepth--;
+		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+	}
+
+	void PixelProgram::ENDWHILE(Registers &r)
+	{
+		loopRepDepth--;
+
+		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
+		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
+
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(endBlock);
+
+		r.enableIndex--;
+		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+		whileTest = false;
+	}
+
+	void PixelProgram::IF(Registers &r, const Src &src)
+	{
+		if(src.type == Shader::PARAMETER_CONSTBOOL)
+		{
+			IFb(r, src);
+		}
+		else if(src.type == Shader::PARAMETER_PREDICATE)
+		{
+			IFp(r, src);
+		}
+		else
+		{
+			Int4 condition = As<Int4>(fetchRegisterF(r, src).x);
+			IF(r, condition);
+		}
+	}
+
+	void PixelProgram::IFb(Registers &r, const Src &boolRegister)
+	{
+		ASSERT(ifDepth < 24 + 4);
+
+		Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData, ps.b[boolRegister.index])) != Byte(0));   // FIXME
+
+		if(boolRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = !condition;
+		}
+
+		llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		branch(condition, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = false;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+	}
+
+	void PixelProgram::IFp(Registers &r, const Src &predicateRegister)
+	{
+		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
+
+		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
+		{
+			condition = ~condition;
+		}
+
+		IF(r, condition);
+	}
+
+	void PixelProgram::IFC(Registers &r, 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(r, condition);
+	}
+
+	void PixelProgram::IF(Registers &r, Int4 &condition)
+	{
+		condition &= r.enableStack[r.enableIndex];
+
+		r.enableIndex++;
+		r.enableStack[r.enableIndex] = condition;
+
+		llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
+
+		Bool notAllFalse = SignMask(condition) != 0;
+
+		branch(notAllFalse, trueBlock, falseBlock);
+
+		isConditionalIf[ifDepth] = true;
+		ifFalseBlock[ifDepth] = falseBlock;
+
+		ifDepth++;
+		breakDepth++;
+	}
+
+	void PixelProgram::LABEL(int labelIndex)
+	{
+		if(!labelBlock[labelIndex])
+		{
+			labelBlock[labelIndex] = Nucleus::createBasicBlock();
+		}
+
+		Nucleus::setInsertBlock(labelBlock[labelIndex]);
+		currentLabel = labelIndex;
+	}
+
+	void PixelProgram::LOOP(Registers &r, const Src &integerRegister)
+	{
+		r.loopDepth++;
+
+		r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+		r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][1]));
+		r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][2]));
+
+		//	If(r.increment[r.loopDepth] == 0)
+		//	{
+		//		r.increment[r.loopDepth] = 1;
+		//	}
+
+		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+		breakDepth = 0;
+	}
+
+	void PixelProgram::REP(Registers &r, const Src &integerRegister)
+	{
+		r.loopDepth++;
+
+		r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData, ps.i[integerRegister.index][0]));
+		r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
+
+		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+
+		branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
+		Nucleus::setInsertBlock(loopBlock);
+
+		r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
+
+		loopRepDepth++;
+		breakDepth = 0;
+	}
+
+	void PixelProgram::WHILE(Registers &r, const Src &temporaryRegister)
+	{
+		r.enableIndex++;
+
+		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
+		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
+
+		loopRepTestBlock[loopRepDepth] = testBlock;
+		loopRepEndBlock[loopRepDepth] = endBlock;
+
+		Int4 restoreBreak = r.enableBreak;
+		Int4 restoreContinue = r.enableContinue;
+
+		// FIXME: jump(testBlock)
+		Nucleus::createBr(testBlock);
+		Nucleus::setInsertBlock(testBlock);
+		r.enableContinue = restoreContinue;
+
+		const Vector4f &src = fetchRegisterF(r, temporaryRegister);
+		Int4 condition = As<Int4>(src.x);
+		condition &= r.enableStack[r.enableIndex - 1];
+		r.enableStack[r.enableIndex] = condition;
+
+		Bool notAllFalse = SignMask(condition) != 0;
+		branch(notAllFalse, loopBlock, endBlock);
+
+		Nucleus::setInsertBlock(endBlock);
+		r.enableBreak = restoreBreak;
+
+		Nucleus::setInsertBlock(loopBlock);
+
+		loopRepDepth++;
+		breakDepth = 0;
+	}
+
+	void PixelProgram::RET(Registers &r)
+	{
+		if(currentLabel == -1)
+		{
+			returnBlock = Nucleus::createBasicBlock();
+			Nucleus::createBr(returnBlock);
+		}
+		else
+		{
+			llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
+
+			if(callRetBlock[currentLabel].size() > 1)   // Pop the return destination from the call stack
+			{
+				// FIXME: Encapsulate
+				UInt index = r.callStack[--r.stackIndex];
+
+				llvm::Value *value = index.loadValue();
+				llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
+
+				for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
+				{
+					Nucleus::addSwitchCase(switchInst, 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(Registers &r)
+	{
+		r.enableLeave = r.enableLeave & ~r.enableStack[r.enableIndex];
+
+		// FIXME: Return from function if all instances left
+		// FIXME: Use enableLeave in other control-flow constructs
+	}
+
+}
diff --git a/src/Shader/PixelProgram.hpp b/src/Shader/PixelProgram.hpp
new file mode 100644
index 0000000..276b11c
--- /dev/null
+++ b/src/Shader/PixelProgram.hpp
@@ -0,0 +1,152 @@
+// SwiftShader Software Renderer
+//
+// Copyright(c) 2015 Google Inc.
+//
+// All rights reserved. No part of this software may be copied, distributed, transmitted,
+// transcribed, stored in a retrieval system, translated into any human or computer
+// language by any means, or disclosed to third parties without the explicit written
+// agreement of Google Inc. Without such an agreement, no rights or licenses, express
+// or implied, including but not limited to any patent rights, are granted to you.
+//
+
+#ifndef sw_PixelProgram_hpp
+#define sw_PixelProgram_hpp
+
+#include "PixelRoutine.hpp"
+
+namespace sw
+{
+	class PixelProgram : public PixelRoutine
+	{
+	public:
+		PixelProgram(const PixelProcessor::State &state, const PixelShader *shader) :
+			PixelRoutine(state, shader), ifDepth(0), loopRepDepth(0), breakDepth(0), currentLabel(-1), whileTest(false)
+		{
+			for(int i = 0; i < 2048; ++i)
+			{
+				labelBlock[i] = 0;
+			}
+		}
+		virtual ~PixelProgram() {}
+	protected:
+		virtual void setBuiltins(PixelRoutine::Registers &r, Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(PixelRoutine::Registers &r, Int cMask[4]);
+		virtual Bool alphaTest(PixelRoutine::Registers &r, Int cMask[4]);
+		virtual void rasterOperation(PixelRoutine::Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+		virtual QuadRasterizer::Registers* createRegisters(const PixelShader *shader) { return new PixelProgram::Registers(shader); };
+
+	private:
+		struct Registers : public PixelRoutine::Registers
+		{
+			Registers(const PixelShader *shader) : PixelRoutine::Registers(shader), loopDepth(-1)
+			{
+				enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+
+				if(shader && shader->containsBreakInstruction())
+				{
+					enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+				}
+
+				if(shader && shader->containsContinueInstruction())
+				{
+					enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
+				}
+			}
+
+			// 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;
+		};
+
+		void sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
+		void sampleTexture(Registers &r, Vector4f &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
+
+		// Raster operations
+		void clampColor(Vector4f oC[4]);
+
+		Int4 enableMask(Registers &r, const Shader::Instruction *instruction);
+
+		Vector4f fetchRegisterF(Registers &r, const Src &src, int offset = 0);
+		Vector4f readConstant(Registers &r, const Src &src, int offset = 0);
+		Int relativeAddress(Registers &r, const Shader::Parameter &var);
+
+		Float4 linearToSRGB(const Float4 &x);
+
+		// Instructions
+		typedef Shader::Control Control;
+
+		void M3X2(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
+		void TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+		void TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3, bool project, bool bias);
+		void TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+		void TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask);
+		void DISCARD(Registers &r, 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(Registers &r);
+		void BREAKC(Registers &r, Vector4f &src0, Vector4f &src1, Control);
+		void BREAKP(Registers &r, const Src &predicateRegister);
+		void BREAK(Registers &r, Int4 &condition);
+		void CONTINUE(Registers &r);
+		void TEST();
+		void CALL(Registers &r, int labelIndex, int callSiteIndex);
+		void CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src);
+		void CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister);
+		void CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister);
+		void ELSE(Registers &r);
+		void ENDIF(Registers &r);
+		void ENDLOOP(Registers &r);
+		void ENDREP(Registers &r);
+		void ENDWHILE(Registers &r);
+		void IF(Registers &r, const Src &src);
+		void IFb(Registers &r, const Src &boolRegister);
+		void IFp(Registers &r, const Src &predicateRegister);
+		void IFC(Registers &r, Vector4f &src0, Vector4f &src1, Control);
+		void IF(Registers &r, Int4 &condition);
+		void LABEL(int labelIndex);
+		void LOOP(Registers &r, const Src &integerRegister);
+		void REP(Registers &r, const Src &integerRegister);
+		void WHILE(Registers &r, const Src &temporaryRegister);
+		void RET(Registers &r);
+		void LEAVE(Registers &r);
+
+		int ifDepth;
+		int loopRepDepth;
+		int breakDepth;
+		int currentLabel;
+		bool whileTest;
+
+		// FIXME: Get rid of llvm::
+		llvm::BasicBlock *ifFalseBlock[24 + 24];
+		llvm::BasicBlock *loopRepTestBlock[4];
+		llvm::BasicBlock *loopRepEndBlock[4];
+		llvm::BasicBlock *labelBlock[2048];
+		std::vector<llvm::BasicBlock*> callRetBlock[2048];
+		llvm::BasicBlock *returnBlock;
+		bool isConditionalIf[24 + 24];
+	};
+}
+
+#endif
diff --git a/src/Shader/PixelRoutine.cpp b/src/Shader/PixelRoutine.cpp
index ac27a4b..b53c031 100644
--- a/src/Shader/PixelRoutine.cpp
+++ b/src/Shader/PixelRoutine.cpp
@@ -25,28 +25,29 @@
 	extern bool complementaryDepthBuffer;
 	extern bool postBlendSRGB;
 	extern bool exactColorRounding;
-	extern bool booleanFaceRegister;
-	extern bool halfIntegerCoordinates;     // Pixel centers are not at integer coordinates
-	extern bool fullPixelPositionRegister;
+	extern bool forceClearRegisters;
 
-	PixelRoutine::PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader) : Rasterizer(state), shader(shader)
+	PixelRoutine::Registers::Registers(const PixelShader *shader) :
+		QuadRasterizer::Registers(),
+		rf(shader && shader->dynamicallyIndexedTemporaries),
+		vf(shader && shader->dynamicallyIndexedInput)
 	{
-		perturbate = false;
-		luminance = false;
-		previousScaling = false;
-
-		ifDepth = 0;
-		loopRepDepth = 0;
-		breakDepth = 0;
-		currentLabel = -1;
-		whileTest = false;
-
-		for(int i = 0; i < 2048; i++)
+		if(!shader || shader->getVersion() < 0x0200 || forceClearRegisters)
 		{
-			labelBlock[i] = 0;
+			for(int i = 0; i < 10; i++)
+			{
+				vf[i].x = Float4(0.0f);
+				vf[i].y = Float4(0.0f);
+				vf[i].z = Float4(0.0f);
+				vf[i].w = Float4(0.0f);
+			}
 		}
 	}
 
+	PixelRoutine::PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader) : QuadRasterizer(state, shader)
+	{
+	}
+
 	PixelRoutine::~PixelRoutine()
 	{
 		for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
@@ -55,8 +56,10 @@
 		}
 	}
 
-	void PixelRoutine::quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
+	void PixelRoutine::quad(QuadRasterizer::Registers &rBase, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
 	{
+		Registers& r = *static_cast<Registers*>(&rBase);
+
 		#if PERF_PROFILE
 			Long pipeTime = Ticks();
 		#endif
@@ -67,7 +70,6 @@
 		}
 
 		const bool earlyDepthTest = !state.depthOverride && !state.alphaTestActive();
-		const bool integerPipeline = shaderVersion() <= 0x0104;
 
 		Int zMask[4];   // Depth mask
 		Int sMask[4];   // Stencil mask
@@ -167,11 +169,11 @@
 					{
 						if(!state.interpolant[interpolant].centroid)
 						{
-							r.vf[interpolant][component] = interpolate(xxxx, r.Dv[interpolant][component], rhw, r.primitive + OFFSET(Primitive,V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
+							r.vf[interpolant][component] = interpolate(xxxx, r.Dv[interpolant][component], rhw, r.primitive + OFFSET(Primitive, V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
 						}
 						else
 						{
-							r.vf[interpolant][component] = interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive,V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
+							r.vf[interpolant][component] = interpolateCentroid(XXXX, YYYY, rhwCentroid, r.primitive + OFFSET(Primitive, V[interpolant][component]), (state.interpolant[interpolant].flat & (1 << component)) != 0, state.perspective);
 						}
 					}
 				}
@@ -205,51 +207,7 @@
 				f = interpolate(xxxx, r.Df, rhw, r.primitive + OFFSET(Primitive,f), state.fog.flat & 0x01, state.perspective);
 			}
 
-			if(integerPipeline)
-			{
-				if(state.color[0].component & 0x1) r.diffuse.x = convertFixed12(r.vf[0].x); else r.diffuse.x = Short4(0x1000);
-				if(state.color[0].component & 0x2) r.diffuse.y = convertFixed12(r.vf[0].y); else r.diffuse.y = Short4(0x1000);
-				if(state.color[0].component & 0x4) r.diffuse.z = convertFixed12(r.vf[0].z); else r.diffuse.z = Short4(0x1000);
-				if(state.color[0].component & 0x8) r.diffuse.w = convertFixed12(r.vf[0].w); else r.diffuse.w = Short4(0x1000);
-
-				if(state.color[1].component & 0x1) r.specular.x = convertFixed12(r.vf[1].x); else r.specular.x = Short4(0x0000, 0x0000, 0x0000, 0x0000);
-				if(state.color[1].component & 0x2) r.specular.y = convertFixed12(r.vf[1].y); else r.specular.y = Short4(0x0000, 0x0000, 0x0000, 0x0000);
-				if(state.color[1].component & 0x4) r.specular.z = convertFixed12(r.vf[1].z); else r.specular.z = Short4(0x0000, 0x0000, 0x0000, 0x0000);
-				if(state.color[1].component & 0x8) r.specular.w = convertFixed12(r.vf[1].w); else r.specular.w = Short4(0x0000, 0x0000, 0x0000, 0x0000);
-			}
-			else if(shaderVersion() >= 0x0300)
-			{
-				if(shader->vPosDeclared)
-				{
-					if(!halfIntegerCoordinates)
-					{
-						r.vPos.x = Float4(Float(x)) + Float4(0, 1, 0, 1);
-						r.vPos.y = Float4(Float(y)) + Float4(0, 0, 1, 1);
-					}
-					else
-					{
-						r.vPos.x = Float4(Float(x)) + Float4(0.5f, 1.5f, 0.5f, 1.5f);
-						r.vPos.y = Float4(Float(y)) + Float4(0.5f, 0.5f, 1.5f, 1.5f);
-					}
-
-					if(fullPixelPositionRegister)
-					{
-						r.vPos.z = z[0];   // FIXME: Centroid?
-						r.vPos.w = w;      // FIXME: Centroid?
-					}
-				}
-
-				if(shader->vFaceDeclared)
-				{
-					Float4 area = *Pointer<Float>(r.primitive + OFFSET(Primitive,area));
-					Float4 face = booleanFaceRegister ? Float4(As<Float4>(CmpNLT(area, Float4(0.0f)))) : area;
-
-					r.vFace.x = face;
-					r.vFace.y = face;
-					r.vFace.z = face;
-					r.vFace.w = face;
-				}
-			}
+			setBuiltins(r, x, y, z, w);
 
 			#if PERF_PROFILE
 				r.cycles[PERF_INTERP] += Ticks() - interpTime;
@@ -263,63 +221,13 @@
 					Long shaderTime = Ticks();
 				#endif
 
-				if(shader)
-				{
-				//	shader->print("PixelShader-%0.8X.txt", state.shaderID);
-
-					if(shader->getVersion() <= 0x0104)
-					{
-						ps_1_x(r, cMask);
-					}
-					else
-					{
-						ps_2_x(r, cMask);
-					}
-				}
-				else
-				{
-					r.current = r.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)
-						{
-							sampleTexture(r, texture, stage, stage);
-						}
-
-						blendTexture(r, temp, texture, stage);
-					}
-
-					specularPixel(r.current, r.specular);
-				}
+				applyShader(r, cMask);
 
 				#if PERF_PROFILE
 					r.cycles[PERF_SHADER] += Ticks() - shaderTime;
 				#endif
 
-				if(integerPipeline)
-				{
-					r.current.x = Min(r.current.x, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.x = Max(r.current.x, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-					r.current.y = Min(r.current.y, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.y = Max(r.current.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-					r.current.z = Min(r.current.z, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.z = Max(r.current.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-					r.current.w = Min(r.current.w, Short4(0x0FFF, 0x0FFF, 0x0FFF, 0x0FFF)); r.current.w = Max(r.current.w, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-
-					alphaPass = alphaTest(r, cMask, r.current);
-				}
-				else
-				{
-					clampColor(r.oC);
-
-					alphaPass = alphaTest(r, cMask, r.oC[0]);
-				}
+				alphaPass = alphaTest(r, cMask);
 
 				if((shader && shader->containsKill()) || state.alphaTestActive())
 				{
@@ -366,14 +274,7 @@
 							AddAtomic(Pointer<Long>(&profiler.ropOperations), 4);
 						#endif
 
-						if(integerPipeline)
-						{
-							rasterOperation(r.current, r, f, cBuffer[0], x, sMask, zMask, cMask);
-						}
-						else
-						{
-							rasterOperation(r.oC, r, f, cBuffer, x, sMask, zMask, cMask);
-						}
+						rasterOperation(r, f, cBuffer, x, sMask, zMask, cMask);
 					}
 				}
 
@@ -396,23 +297,6 @@
 		#endif
 	}
 
-	Float4 PixelRoutine::interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective)
-	{
-		Float4 interpolant = D;
-
-		if(!flat)
-		{
-			interpolant += x * *Pointer<Float4>(planeEquation + OFFSET(PlaneEquation,A), 16);
-
-			if(perspective)
-			{
-				interpolant *= rhw;
-			}
-		}
-
-		return interpolant;
-	}
-
 	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);
@@ -656,912 +540,6 @@
 		return zMask != 0;
 	}
 
-	void PixelRoutine::blendTexture(Registers &r, Vector4s &temp, Vector4s &texture, int stage)
-	{
-		Vector4s *arg1;
-		Vector4s *arg2;
-		Vector4s *arg3;
-		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>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[0]));
-			constant.y = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[1]));
-			constant.z = *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].constantColor4[2]));
-			constant.w = *Pointer<Short4>(r.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>(r.data + OFFSET(DrawData,factor.textureFactor4[0]));
-			tfactor.y = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[1]));
-			tfactor.z = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[2]));
-			tfactor.w = *Pointer<Short4>(r.data + OFFSET(DrawData,factor.textureFactor4[3]));
-		}
-
-		// Premodulate
-		if(stage > 0 && textureStage.usesTexture)
-		{
-			if(state.textureStage[stage - 1].stageOperation == TextureStage::STAGE_PREMODULATE)
-			{
-				r.current.x = MulHigh(r.current.x, texture.x) << 4;
-				r.current.y = MulHigh(r.current.y, texture.y) << 4;
-				r.current.z = MulHigh(r.current.z, texture.z) << 4;
-			}
-
-			if(state.textureStage[stage - 1].stageOperationAlpha == TextureStage::STAGE_PREMODULATE)
-			{
-				r.current.w = MulHigh(r.current.w, texture.w) << 4;
-			}
-		}
-
-		if(luminance)
-		{
-			texture.x = MulHigh(texture.x, r.L) << 4;
-			texture.y = MulHigh(texture.y, r.L) << 4;
-			texture.z = MulHigh(texture.z, r.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 = &r.current;		break;
-		case TextureStage::SOURCE_DIFFUSE:	arg1 = &r.diffuse;		break;
-		case TextureStage::SOURCE_SPECULAR:	arg1 = &r.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 = &r.current;		break;
-		case TextureStage::SOURCE_DIFFUSE:	arg2 = &r.diffuse;		break;
-		case TextureStage::SOURCE_SPECULAR:	arg2 = &r.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 = &r.current;		break;
-		case TextureStage::SOURCE_DIFFUSE:	arg3 = &r.diffuse;		break;
-		case TextureStage::SOURCE_SPECULAR:	arg3 = &r.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, 0x0800, 0x0800, 0x0800));
-				res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-				res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800));
-				res.y = SubSat(res.y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-				res.z = SubSat(res.z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->x, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.x = MulHigh(res.x, tmp);
-				res.y = SubSat(arg1->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->y, Short4(0x0800, 0x0800, 0x0800, 0x0800)); res.y = MulHigh(res.y, tmp);
-				res.z = SubSat(arg1->z, Short4(0x0800, 0x0800, 0x0800, 0x0800)); tmp = SubSat(arg2->z, Short4(0x0800, 0x0800, 0x0800, 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, 0x0000, 0x0000, 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, r.current.w) << 4; res.x = AddSat(res.x, arg2->x);
-				res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.current.w) << 4; res.y = AddSat(res.y, arg2->y);
-				res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.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, r.diffuse.w) << 4; res.x = AddSat(res.x, arg2->x);
-				res.y = SubSat(arg1->y, arg2->y); res.y = MulHigh(res.y, r.diffuse.w) << 4; res.y = AddSat(res.y, arg2->y);
-				res.z = SubSat(arg1->z, arg2->z); res.z = MulHigh(res.z, r.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>(r.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>(r.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>(r.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:
-			{
-				r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
-				r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
-			
-				Float4 du2;
-				Float4 dv2;
-
-				du2 = r.du;
-				dv2 = r.dv;
-				r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
-				dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
-				r.du += dv2;
-				r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
-				du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
-				r.dv += du2;
-
-				perturbate = true;
-
-				res.x = r.current.x;
-				res.y = r.current.y;
-				res.z = r.current.z;
-				res.w = r.current.w;
-			}
-			break;
-		case TextureStage::STAGE_BUMPENVMAPLUMINANCE:
-			{
-				r.du = Float4(texture.x) * Float4(1.0f / 0x0FE0);
-				r.dv = Float4(texture.y) * Float4(1.0f / 0x0FE0);
-			
-				Float4 du2;
-				Float4 dv2;
-
-				du2 = r.du;
-				dv2 = r.dv;
-
-				r.du *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
-				dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
-				r.du += dv2;
-				r.dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
-				du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
-				r.dv += du2;
-
-				perturbate = true;
-
-				r.L = texture.z;
-				r.L = MulHigh(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
-				r.L = r.L << 4;
-				r.L = AddSat(r.L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
-				r.L = Max(r.L, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-				r.L = Min(r.L, Short4(0x1000));
-
-				luminance = true;
-
-				res.x = r.current.x;
-				res.y = r.current.y;
-				res.z = r.current.z;
-				res.w = r.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 = &r.current;		break;
-			case TextureStage::SOURCE_DIFFUSE:	arg1 = &r.diffuse;		break;
-			case TextureStage::SOURCE_SPECULAR:	arg1 = &r.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 = &r.current;		break;
-			case TextureStage::SOURCE_DIFFUSE:	arg2 = &r.diffuse;		break;
-			case TextureStage::SOURCE_SPECULAR:	arg2 = &r.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 = &r.current;		break;
-			case TextureStage::SOURCE_DIFFUSE:	arg3 = &r.diffuse;		break;
-			case TextureStage::SOURCE_SPECULAR:	arg3 = &r.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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, r.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, r.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>(r.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, 0x0000, 0x0000, 0x0000));
-			res.y = Max(res.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));
-			res.z = Max(res.z, Short4(0x0000, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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:
-			r.current.x = res.x;
-			r.current.y = res.y;
-			r.current.z = res.z;
-			r.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 PixelRoutine::alphaTest(Registers &r, Int &aMask, Short4 &alpha)
 	{
 		Short4 cmp;
@@ -1624,103 +602,6 @@
 		cMask[3] &= aMask3;
 	}
 
-	Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Vector4s &current)
-	{
-		if(!state.alphaTestActive())
-		{
-			return true;
-		}
-
-		Int aMask;
-
-		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
-		{
-			alphaTest(r, 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(r, 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;
-	}
-
-	Bool PixelRoutine::alphaTest(Registers &r, Int cMask[4], Vector4f &c0)
-	{
-		if(!state.alphaTestActive())
-		{
-			return true;
-		}
-
-		Int aMask;
-
-		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
-		{
-			Short4 alpha = RoundShort4(c0.w * Float4(0x1000));
-
-			alphaTest(r, aMask, alpha);
-
-			for(unsigned int q = 0; q < state.multiSample; q++)
-			{
-				cMask[q] &= aMask;
-			}
-		}
-		else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
-		{
-			alphaToCoverage(r, cMask, c0.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 PixelRoutine::fogBlend(Registers &r, Vector4s &current, Float4 &f, Float4 &z, Float4 &rhw)
-	{
-		if(!state.fogActive)
-		{
-			return;
-		}
-
-		if(state.pixelFogMode != FOG_NONE)
-		{
-			pixelFog(r, f, z, rhw);
-		}
-		
-		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>(r.data + OFFSET(DrawData,fog.color4[0]))));
-		current.y += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[1]))));
-		current.z += As<Short4>(MulHigh(invFog, *Pointer<UShort4>(r.data + OFFSET(DrawData,fog.color4[2]))));
-	}
-
 	void PixelRoutine::fogBlend(Registers &r, Vector4f &c0, Float4 &fog, Float4 &z, Float4 &rhw)
 	{
 		if(!state.fogActive)
@@ -1795,18 +676,6 @@
 		}
 	}
 
-	void PixelRoutine::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);
-	}
-
 	void PixelRoutine::writeDepth(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask)
 	{
 		if(!state.depthWriteEnable)
@@ -2010,294 +879,6 @@
 		}
 	}
 
-	void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int coordinates, int stage, bool project)
-	{
-		Float4 u = r.vf[2 + coordinates].x;
-		Float4 v = r.vf[2 + coordinates].y;
-		Float4 w = r.vf[2 + coordinates].z;
-		Float4 q = r.vf[2 + coordinates].w;
-
-		if(perturbate)
-		{
-			u += r.du;
-			v += r.dv;
-
-			perturbate = false;
-		}
-
-		sampleTexture(r, c, stage, u, v, w, q, project);
-	}
-
-	void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project, bool bias)
-	{
-		Vector4f dsx;
-		Vector4f dsy;
-
-		sampleTexture(r, c, stage, u, v, w, q, dsx, dsy, project, bias, false);
-	}
-
-	void PixelRoutine::sampleTexture(Registers &r, Vector4s &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
-	{
-		#if PERF_PROFILE
-			Long texTime = Ticks();
-		#endif
-
-		Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
-
-		if(!project)
-		{
-			sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
-		}
-		else
-		{
-			Float4 rq = reciprocal(q);
-
-			Float4 u_q = u * rq;
-			Float4 v_q = v * rq;
-			Float4 w_q = w * rq;
-
-			sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
-		}
-
-		#if PERF_PROFILE
-			r.cycles[PERF_TEX] += Ticks() - texTime;
-		#endif
-	}
-
-	void PixelRoutine::sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
-	{
-		if(sampler.type == Shader::PARAMETER_SAMPLER && sampler.rel.type == Shader::PARAMETER_VOID)
-		{	
-			sampleTexture(r, c, sampler.index, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);	
-		}
-		else
-		{
-			Int index = As<Int>(Float(fetchRegisterF(r, sampler).x.x));
-
-			for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++)
-			{
-				if(shader->usesSampler(i))
-				{
-					If(index == i)
-					{
-						sampleTexture(r, c, i, u, v, w, q, dsx, dsy, project, bias, gradients, lodProvided);
-						// FIXME: When the sampler states are the same, we could use one sampler and just index the texture
-					}
-				}
-			}
-		}
-	}
-
-	void PixelRoutine::sampleTexture(Registers &r, Vector4f &c, int stage, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project, bool bias, bool gradients, bool lodProvided)
-	{
-		#if PERF_PROFILE
-			Long texTime = Ticks();
-		#endif
-
-		Pointer<Byte> texture = r.data + OFFSET(DrawData,mipmap) + stage * sizeof(Texture);
-
-		if(!project)
-		{
-			sampler[stage]->sampleTexture(texture, c, u, v, w, q, dsx, dsy, bias, gradients, lodProvided);
-		}
-		else
-		{
-			Float4 rq = reciprocal(q);
-
-			Float4 u_q = u * rq;
-			Float4 v_q = v * rq;
-			Float4 w_q = w * rq;
-
-			sampler[stage]->sampleTexture(texture, c, u_q, v_q, w_q, q, dsx, dsy, bias, gradients, lodProvided);
-		}
-
-		#if PERF_PROFILE
-			r.cycles[PERF_TEX] += Ticks() - texTime;
-		#endif
-	}
-
-	void PixelRoutine::clampColor(Vector4f oC[4])
-	{
-		for(int index = 0; index < 4; 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_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_A32B32G32R32F:
-				break;
-			default:
-				ASSERT(false);
-			}
-		}
-	}
-
-	void PixelRoutine::rasterOperation(Vector4s &current, Registers &r, Float4 &fog, Pointer<Byte> &cBuffer, 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(r, 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(r, current, fog, r.z[0], r.rhw);
-
-			for(unsigned int q = 0; q < state.multiSample; q++)
-			{
-				Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
-				Vector4s color = current;
-
-				if(state.multiSampleMask & (1 << q))
-				{
-					alphaBlend(r, 0, buffer, color, x);
-					logicOperation(r, 0, buffer, color, x);
-					writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
-				}
-			}
-			break;
-		case FORMAT_R32F:
-		case FORMAT_G32R32F:
-		case FORMAT_A32B32G32R32F:
-			convertSigned12(oC, current);
-			fogBlend(r, oC, fog, r.z[0], r.rhw);
-			
-			for(unsigned int q = 0; q < state.multiSample; q++)
-			{
-				Pointer<Byte> buffer = cBuffer + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[0]));
-				Vector4f color = oC;
-
-				if(state.multiSampleMask & (1 << q))
-				{
-					alphaBlend(r, 0, buffer, color, x);
-					writeColor(r, 0, buffer, x, color, sMask[q], zMask[q], cMask[q]);
-				}
-			}
-			break;
-		default:
-			ASSERT(false);
-		}
-	}
-
-	void PixelRoutine::rasterOperation(Vector4f oC[4], Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4])
-	{
-		for(int index = 0; index < 4; index++)
-		{
-			if(!state.colorWriteActive(index))
-			{
-				continue;
-			}
-
-			if(!postBlendSRGB && state.writeSRGB)
-			{
-				oC[index].x = linearToSRGB(oC[index].x);
-				oC[index].y = linearToSRGB(oC[index].y);
-				oC[index].z = linearToSRGB(oC[index].z);
-			}
-
-			if(index == 0)
-			{
-				fogBlend(r, oC[index], fog, r.z[0], r.rhw);
-			}
-
-			switch(state.targetFormat[index])
-			{
-			case FORMAT_R5G6B5:
-			case FORMAT_X8R8G8B8:
-			case FORMAT_X8B8G8R8:
-			case FORMAT_A8R8G8B8:
-			case FORMAT_A8B8G8R8:
-			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>(r.data + OFFSET(DrawData,colorSliceB[index]));
-					Vector4s color;
-
-					color.x = convertFixed16(oC[index].x, false);
-					color.y = convertFixed16(oC[index].y, false);
-					color.z = convertFixed16(oC[index].z, false);
-					color.w = convertFixed16(oC[index].w, false);
-
-					if(state.multiSampleMask & (1 << q))
-					{
-						alphaBlend(r, index, buffer, color, x);
-						logicOperation(r, index, buffer, color, x);
-						writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
-					}
-				}
-				break;
-			case FORMAT_R32F:
-			case FORMAT_G32R32F:
-			case FORMAT_A32B32G32R32F:
-				for(unsigned int q = 0; q < state.multiSample; q++)
-				{
-					Pointer<Byte> buffer = cBuffer[index] + q * *Pointer<Int>(r.data + OFFSET(DrawData,colorSliceB[index]));
-					Vector4f color = oC[index];
-
-					if(state.multiSampleMask & (1 << q))
-					{
-						alphaBlend(r, index, buffer, color, x);
-						writeColor(r, index, buffer, x, color, sMask[q], zMask[q], cMask[q]);
-					}
-				}
-				break;
-			default:
-				ASSERT(false);
-			}
-		}
-	}
-
 	void PixelRoutine::blendFactor(Registers &r, const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive)
 	{
 		switch(blendFactorActive)
@@ -3741,629 +2322,11 @@
 		}
 	}
 
-	void PixelRoutine::ps_1_x(Registers &r, Int cMask[4])
-	{
-		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 version = shader->getVersion();
-			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 = fetchRegisterS(r, src0);
-			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterS(r, src1);
-			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterS(r, src2);
-
-			Float4 u = version < 0x0104 ? r.vf[2 + dst.index].x : r.vf[2 + src0.index].x;
-			Float4 v = version < 0x0104 ? r.vf[2 + dst.index].y : r.vf[2 + src0.index].y;
-			Float4 s = version < 0x0104 ? r.vf[2 + dst.index].z : r.vf[2 + src0.index].z;
-			Float4 t = version < 0x0104 ? r.vf[2 + dst.index].w : r.vf[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(version < 0x0104)
-				{
-					TEXCOORD(d, u, v, s, dst.index);
-				}
-				else
-				{
-					if((src0.swizzle & 0x30) == 0x20)   // .xyz
-					{
-						TEXCRD(d, u, v, s, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
-					}
-					else   // .xyw
-					{
-						TEXCRD(d, u, v, t, src0.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
-					}
-				}
-				break;
-			case Shader::OPCODE_TEXKILL:
-				if(version < 0x0104)
-				{
-					TEXKILL(cMask, u, v, s);
-				}
-				else if(version == 0x0104)
-				{
-					if(dst.type == Shader::PARAMETER_TEXTURE)
-					{
-						TEXKILL(cMask, u, v, s);
-					}
-					else
-					{
-						TEXKILL(cMask, r.rs[dst.index]);
-					}
-				}
-				else ASSERT(false);
-				break;
-			case Shader::OPCODE_TEX:
-				if(version < 0x0104)
-				{
-					TEX(r, d, u, v, s, dst.index, false);
-				}
-				else if(version == 0x0104)
-				{
-					if(src0.type == Shader::PARAMETER_TEXTURE)
-					{
-						if((src0.swizzle & 0x30) == 0x20)   // .xyz
-						{
-							TEX(r, d, u, v, s, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
-						}
-						else   // .xyw
-						{
-							TEX(r, d, u, v, t, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
-						}
-					}
-					else
-					{
-						TEXLD(r, d, s0, dst.index, src0.modifier == Shader::MODIFIER_DZ || src0.modifier == Shader::MODIFIER_DW);
-					}
-				}
-				else ASSERT(false);
-				break;
-			case Shader::OPCODE_TEXBEM:			TEXBEM(r, d, s0, u, v, s, dst.index);	break;
-			case Shader::OPCODE_TEXBEML:		TEXBEML(r, d, s0, u, v, s, dst.index);	break;
-			case Shader::OPCODE_TEXREG2AR:		TEXREG2AR(r, d, s0, dst.index);					break;
-			case Shader::OPCODE_TEXREG2GB:		TEXREG2GB(r, d, s0, dst.index);					break;
-			case Shader::OPCODE_TEXM3X2PAD:		TEXM3X2PAD(r, u, v, s, s0, 0, src0.modifier == Shader::MODIFIER_SIGN);	break;
-			case Shader::OPCODE_TEXM3X2TEX:		TEXM3X2TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN);	break;
-			case Shader::OPCODE_TEXM3X3PAD:		TEXM3X3PAD(r, u, v, s, s0, pad++ % 2, src0.modifier == Shader::MODIFIER_SIGN);	break;
-			case Shader::OPCODE_TEXM3X3TEX:		TEXM3X3TEX(r, d, u, v, s, dst.index, s0, src0.modifier == Shader::MODIFIER_SIGN);	break;
-			case Shader::OPCODE_TEXM3X3SPEC:	TEXM3X3SPEC(r, d, u, v, s, dst.index, s0, s1);		break;
-			case Shader::OPCODE_TEXM3X3VSPEC:	TEXM3X3VSPEC(r, d, u, v, s, dst.index, s0);		break;
-			case Shader::OPCODE_CND:			CND(d, s0, s1, s2);								break;
-			case Shader::OPCODE_TEXREG2RGB:		TEXREG2RGB(r, d, s0, dst.index);				break;
-			case Shader::OPCODE_TEXDP3TEX:		TEXDP3TEX(r, d, u, v, s, dst.index, s0);	break;
-			case Shader::OPCODE_TEXM3X2DEPTH:	TEXM3X2DEPTH(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN);	break;
-			case Shader::OPCODE_TEXDP3:			TEXDP3(r, d, u, v, s, s0);				break;
-			case Shader::OPCODE_TEXM3X3:		TEXM3X3(r, d, u, v, s, s0, src0.modifier == Shader::MODIFIER_SIGN); 	break;
-			case Shader::OPCODE_TEXDEPTH:		TEXDEPTH(r);									break;
-			case Shader::OPCODE_CMP0:			CMP(d, s0, s1, s2);								break;
-			case Shader::OPCODE_BEM:			BEM(r, 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, 0x0000, 0x0000, 0x0000));}
-					if(dst.mask & 0x2) {d.y = Min(d.y, Short4(0x1000)); d.y = Max(d.y, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
-					if(dst.mask & 0x4) {d.z = Min(d.z, Short4(0x1000)); d.z = Max(d.z, Short4(0x0000, 0x0000, 0x0000, 0x0000));}
-					if(dst.mask & 0x8) {d.w = Min(d.w, Short4(0x1000)); d.w = Max(d.w, Short4(0x0000, 0x0000, 0x0000, 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(r, dPairing, dst);
-				}
-			
-				if(!pairing)
-				{
-					writeDestination(r, d, dst);
-				}
-			}
-		}
-	}
-
-	void PixelRoutine::ps_2_x(Registers &r, Int cMask[4])
-	{
-		r.enableIndex = 0;
-		r.stackIndex = 0;
-
-		if(shader->containsLeaveInstruction())
-		{
-			r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-		}
-
-		bool out[4][4] = {false};
-
-		// 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;
-			}
-
-			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];
-
-			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;
-
-			if(opcode == Shader::OPCODE_TEXKILL)   // Takes destination as input
-			{
-				if(dst.type == Shader::PARAMETER_TEXTURE)
-				{
-					d.x = r.vf[2 + dst.index].x;
-					d.y = r.vf[2 + dst.index].y;
-					d.z = r.vf[2 + dst.index].z;
-					d.w = r.vf[2 + dst.index].w;
-				}
-				else
-				{
-					d = r.rf[dst.index];
-				}
-			}
-
-			if(src0.type != Shader::PARAMETER_VOID) s0 = fetchRegisterF(r, src0);
-			if(src1.type != Shader::PARAMETER_VOID) s1 = fetchRegisterF(r, src1);
-			if(src2.type != Shader::PARAMETER_VOID) s2 = fetchRegisterF(r, src2);
-			if(src3.type != Shader::PARAMETER_VOID) s3 = fetchRegisterF(r, src3);
-
-			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_F2B:		f2b(d, s0);										break;
-			case Shader::OPCODE_B2F:		b2f(d, s0);										break;
-			case Shader::OPCODE_ADD:		add(d, s0, s1);									break;
-			case Shader::OPCODE_SUB:		sub(d, s0, s1);									break;
-			case Shader::OPCODE_MUL:		mul(d, s0, s1);									break;
-			case Shader::OPCODE_MAD:		mad(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_CMP0:		cmp0(d, s0, s1, s2);							break;
-			case Shader::OPCODE_ICMP:		icmp(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_MOD:		mod(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_MAX:		max(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_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_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_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(r, d, s0, src1);							break;
-			case Shader::OPCODE_M4X3:		M4X3(r, d, s0, src1);							break;
-			case Shader::OPCODE_M3X4:		M3X4(r, d, s0, src1);							break;
-			case Shader::OPCODE_M3X3:		M3X3(r, d, s0, src1);							break;
-			case Shader::OPCODE_M3X2:		M3X2(r, d, s0, src1);							break;
-			case Shader::OPCODE_TEX:		TEXLD(r, d, s0, src1, project, bias);			break;
-			case Shader::OPCODE_TEXLDD:		TEXLDD(r, d, s0, src1, s2, s3, project, bias);	break;
-			case Shader::OPCODE_TEXLDL:		TEXLDL(r, d, s0, src1, project, bias);			break;
-			case Shader::OPCODE_TEXKILL:	TEXKILL(cMask, d, dst.mask);					break;
-			case Shader::OPCODE_DISCARD:	DISCARD(r, 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(r);										break;
-			case Shader::OPCODE_BREAKC:		BREAKC(r, s0, s1, control);						break;
-			case Shader::OPCODE_BREAKP:		BREAKP(r, src0);								break;
-			case Shader::OPCODE_CONTINUE:	CONTINUE(r);									break;
-			case Shader::OPCODE_TEST:		TEST();											break;
-			case Shader::OPCODE_CALL:		CALL(r, dst.label, dst.callSite);               break;
-			case Shader::OPCODE_CALLNZ:		CALLNZ(r, dst.label, dst.callSite, src0);       break;
-			case Shader::OPCODE_ELSE:		ELSE(r);										break;
-			case Shader::OPCODE_ENDIF:		ENDIF(r);										break;
-			case Shader::OPCODE_ENDLOOP:	ENDLOOP(r);										break;
-			case Shader::OPCODE_ENDREP:		ENDREP(r);										break;
-			case Shader::OPCODE_ENDWHILE:	ENDWHILE(r);	     							break;
-			case Shader::OPCODE_IF:			IF(r, src0);									break;
-			case Shader::OPCODE_IFC:		IFC(r, s0, s1, control);						break;
-			case Shader::OPCODE_LABEL:		LABEL(dst.index);								break;
-			case Shader::OPCODE_LOOP:		LOOP(r, src1);									break;
-			case Shader::OPCODE_REP:		REP(r, src0);									break;
-			case Shader::OPCODE_WHILE:		WHILE(r, src0);									break;
-			case Shader::OPCODE_RET:		RET(r);											break;
-			case Shader::OPCODE_LEAVE:		LEAVE(r);										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:		not(d, s0);										break;
-			case Shader::OPCODE_OR:			or(d.x, s0.x, s1.x);							break;
-			case Shader::OPCODE_XOR:		xor(d.x, s0.x, s1.x);							break;
-			case Shader::OPCODE_AND:		and(d.x, s0.x, s1.x);							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.integer)
-				{
-					switch(opcode)
-					{
-					case Shader::OPCODE_DIV:
-						if(dst.x) d.x = Trunc(d.x);
-						if(dst.y) d.y = Trunc(d.y);
-						if(dst.z) d.z = Trunc(d.z);
-						if(dst.w) d.w = Trunc(d.w);
-						break;
-					default:
-						break;   // No truncation to integer required when arguments are integer
-					}
-				}
-
-				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.rf[dst.index].x;
-							if(dst.y) pDst.y = r.rf[dst.index].y;
-							if(dst.z) pDst.z = r.rf[dst.index].z;
-							if(dst.w) pDst.w = r.rf[dst.index].w;
-						}
-						else
-						{
-							Int a = relativeAddress(r, dst);
-
-							if(dst.x) pDst.x = r.rf[dst.index + a].x;
-							if(dst.y) pDst.y = r.rf[dst.index + a].y;
-							if(dst.z) pDst.z = r.rf[dst.index + a].z;
-							if(dst.w) pDst.w = r.rf[dst.index + a].w;
-						}
-						break;
-					case Shader::PARAMETER_COLOROUT:
-						ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
-						if(dst.x) pDst.x = r.oC[dst.index].x;
-						if(dst.y) pDst.y = r.oC[dst.index].y;
-						if(dst.z) pDst.z = r.oC[dst.index].z;
-						if(dst.w) pDst.w = r.oC[dst.index].w;
-						break;
-					case Shader::PARAMETER_PREDICATE:
-						if(dst.x) pDst.x = r.p0.x;
-						if(dst.y) pDst.y = r.p0.y;
-						if(dst.z) pDst.z = r.p0.z;
-						if(dst.w) pDst.w = r.p0.w;
-						break;
-					case Shader::PARAMETER_DEPTHOUT:
-						pDst.x = r.oDepth;
-						break;
-					default:
-						ASSERT(false);
-					}
-				
-					Int4 enable = enableMask(r, instruction);
-
-					Int4 xEnable = enable;
-					Int4 yEnable = enable;
-					Int4 zEnable = enable;
-					Int4 wEnable = enable;
-
-					if(predicate)
-					{
-						unsigned char pSwizzle = instruction->predicateSwizzle;
-
-						Float4 xPredicate = r.p0[(pSwizzle >> 0) & 0x03];
-						Float4 yPredicate = r.p0[(pSwizzle >> 2) & 0x03];
-						Float4 zPredicate = r.p0[(pSwizzle >> 4) & 0x03];
-						Float4 wPredicate = r.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.rf[dst.index].x = d.x;
-						if(dst.y) r.rf[dst.index].y = d.y;
-						if(dst.z) r.rf[dst.index].z = d.z;
-						if(dst.w) r.rf[dst.index].w = d.w;
-					}
-					else
-					{
-						Int a = relativeAddress(r, dst);
-
-						if(dst.x) r.rf[dst.index + a].x = d.x;
-						if(dst.y) r.rf[dst.index + a].y = d.y;
-						if(dst.z) r.rf[dst.index + a].z = d.z;
-						if(dst.w) r.rf[dst.index + a].w = d.w;
-					}
-					break;
-				case Shader::PARAMETER_COLOROUT:
-					ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
-					if(dst.x) {r.oC[dst.index].x = d.x; out[dst.index][0] = true;}
-					if(dst.y) {r.oC[dst.index].y = d.y; out[dst.index][1] = true;}
-					if(dst.z) {r.oC[dst.index].z = d.z; out[dst.index][2] = true;}
-					if(dst.w) {r.oC[dst.index].w = d.w; out[dst.index][3] = true;}
-					break;
-				case Shader::PARAMETER_PREDICATE:
-					if(dst.x) r.p0.x = d.x;
-					if(dst.y) r.p0.y = d.y;
-					if(dst.z) r.p0.z = d.z;
-					if(dst.w) r.p0.w = d.w;
-					break;
-				case Shader::PARAMETER_DEPTHOUT:
-					r.oDepth = d.x;
-					break;
-				default:
-					ASSERT(false);
-				}
-			}
-		}
-
-		if(currentLabel != -1)
-		{
-			Nucleus::setInsertBlock(returnBlock);
-		}
-
-		for(int i = 0; i < 4; i++)
-		{
-			if(state.targetFormat[i] != FORMAT_NULL)
-			{
-				if(!out[i][0]) r.oC[i].x = Float4(0.0f);
-				if(!out[i][1]) r.oC[i].y = Float4(0.0f);
-				if(!out[i][2]) r.oC[i].z = Float4(0.0f);
-				if(!out[i][3]) r.oC[i].w = Float4(0.0f);
-			}
-		}
-	}
-
-	Short4 PixelRoutine::convertFixed12(RValue<Float4> cf)
-	{
-		return RoundShort4(cf * Float4(0x1000));
-	}
-
-	void PixelRoutine::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);
-	}
-
 	UShort4 PixelRoutine::convertFixed16(Float4 &cf, bool saturate)
 	{
 		return UShort4(cf * Float4(0xFFFF), saturate);
 	}
 
-	void PixelRoutine::convertFixed16(Vector4s &cs, Vector4f &cf, bool saturate)
-	{
-		cs.x = convertFixed16(cf.x, saturate);
-		cs.y = convertFixed16(cf.y, saturate);
-		cs.z = convertFixed16(cf.z, saturate);
-		cs.w = convertFixed16(cf.w, saturate);
-	}
-
-	Float4 PixelRoutine::convertSigned12(Short4 &cs)
-	{
-		return Float4(cs) * Float4(1.0f / 0x0FFE);
-	}
-
-	void PixelRoutine::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);
-	}
-
-	Float4 PixelRoutine::convertUnsigned16(UShort4 cs)
-	{
-		return Float4(cs) * Float4(1.0f / 0xFFFF);
-	}
-
 	void PixelRoutine::sRGBtoLinear16_12_16(Registers &r, Vector4s &c)
 	{
 		c.x = As<UShort4>(c.x) >> 4;
@@ -4422,14 +2385,6 @@
 		c.z = Insert(c.z, *Pointer<Short>(LUT + 2 * Int(Extract(c.z, 3))), 3);
 	}
 
-	Float4 PixelRoutine::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));
-	}
-
 	Float4 PixelRoutine::sRGBtoLinear(const Float4 &x)   // Approximates x^2.2
 	{
 		Float4 linear = x * x;
@@ -4438,1592 +2393,8 @@
 		return Min(Max(linear, Float4(0.0f)), Float4(1.0f));
 	}
 
-	void PixelRoutine::MOV(Vector4s &dst, Vector4s &src0)
-	{
-		dst.x = src0.x;
-		dst.y = src0.y;
-		dst.z = src0.z;
-		dst.w = src0.w;
-	}
-
-	void PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000);
-		}
-
-		dst.w = Short4(0x1000);
-	}
-
-	void PixelRoutine::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, 0x0000, 0x0000, 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, 0x0000, 0x0000, 0x0000);
-		}
-	}
-
-	void PixelRoutine::TEXDP3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src)
-	{
-		TEXM3X3PAD(r, u, v, s, src, 0, false);
-
-		Short4 t0 = RoundShort4(r.u_ * Float4(0x1000));
-
-		dst.x = t0;
-		dst.y = t0;
-		dst.z = t0;
-		dst.w = t0;
-	}
-
-	void PixelRoutine::TEXDP3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
-	{
-		TEXM3X3PAD(r, u, v, s, src0, 0, false);
-
-		r.v_ = Float4(0.0f);
-		r.w_ = Float4(0.0f);
-
-		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
-	}
-
-	void PixelRoutine::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 PixelRoutine::TEXKILL(Int cMask[4], Vector4s &src)
-	{
-		Short4 test = src.x | src.y | src.z;
-		Int kill = SignMask(Pack(test, test)) ^ 0x0000000F;
-
-		for(unsigned int q = 0; q < state.multiSample; q++)
-		{
-			cMask[q] &= kill;
-		}
-	}
-
-	void PixelRoutine::TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int sampler, bool project)
-	{
-		sampleTexture(r, dst, sampler, u, v, s, s, project);
-	}
-
-	void PixelRoutine::TEXLD(Registers &r, 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);
-
-		sampleTexture(r, dst, sampler, u, v, s, s, project);
-	}
-
-	void PixelRoutine::TEXBEM(Registers &r, 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>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
-		dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
-		du += dv2;
-		dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
-		du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
-		dv += du2;
-
-		Float4 u_ = u + du;
-		Float4 v_ = v + dv;
-
-		sampleTexture(r, dst, stage, u_, v_, s, s);
-	}
-
-	void PixelRoutine::TEXBEML(Registers &r, 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>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][0]));
-		dv2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][0]));
-		du += dv2;
-		dv *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[1][1]));
-		du2 *= *Pointer<Float4>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4F[0][1]));
-		dv += du2;
-
-		Float4 u_ = u + du;
-		Float4 v_ = v + dv;
-
-		sampleTexture(r, dst, stage, u_, v_, s, s);
-
-		Short4 L;
-
-		L = src.z;
-		L = MulHigh(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceScale4)));
-		L = L << 4;
-		L = AddSat(L, *Pointer<Short4>(r.data + OFFSET(DrawData,textureStage[stage].luminanceOffset4)));
-		L = Max(L, Short4(0x0000, 0x0000, 0x0000, 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 PixelRoutine::TEXREG2AR(Registers &r, 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);
-
-		sampleTexture(r, dst, stage, u, v, s, s);
-	}
-
-	void PixelRoutine::TEXREG2GB(Registers &r, 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;
-
-		sampleTexture(r, dst, stage, u, v, s, s);
-	}
-
-	void PixelRoutine::TEXREG2RGB(Registers &r, 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);
-
-		sampleTexture(r, dst, stage, u, v, s, s);
-	}
-
-	void PixelRoutine::TEXM3X2DEPTH(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling)
-	{
-		TEXM3X2PAD(r, u, v, s, src, 1, signedScaling);
-
-		// z / w
-		r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
-
-		r.oDepth = r.u_;
-	}
-
-	void PixelRoutine::TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
-	{
-		TEXM3X3PAD(r, u, v, s, src0, component, signedScaling);
-	}
-
-	void PixelRoutine::TEXM3X2TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
-	{
-		TEXM3X2PAD(r, u, v, s, src0, 1, signedScaling);
-
-		r.w_ = Float4(0.0f);
-
-		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
-	}
-
-	void PixelRoutine::TEXM3X3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling)
-	{
-		TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
-
-		dst.x = RoundShort4(r.u_ * Float4(0x1000));
-		dst.y = RoundShort4(r.v_ * Float4(0x1000));
-		dst.z = RoundShort4(r.w_ * Float4(0x1000));
-		dst.w = Short4(0x1000);
-	}
-
-	void PixelRoutine::TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling)
-	{
-		if(component == 0 || previousScaling != signedScaling)   // FIXME: Other source modifiers?
-		{
-			r.U = Float4(src0.x);
-			r.V = Float4(src0.y);
-			r.W = Float4(src0.z);
-
-			previousScaling = signedScaling;
-		}
-
-		Float4 x = r.U * u + r.V * v + r.W * s;
-
-		x *= Float4(1.0f / 0x1000);
-
-		switch(component)
-		{
-		case 0:	r.u_ = x; break;
-		case 1:	r.v_ = x; break;
-		case 2: r.w_ = x; break;
-		default: ASSERT(false);
-		}
-	}
-
-	void PixelRoutine::TEXM3X3SPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1)
-	{
-		TEXM3X3PAD(r, 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__ = r.u_ * E[0];
-		v__ = r.v_ * E[1];
-		w__ = r.w_ * E[2];
-		u__ += v__ + w__;
-		u__ += u__;
-		v__ = u__;
-		w__ = u__;
-		u__ *= r.u_;
-		v__ *= r.v_;
-		w__ *= r.w_;
-		r.u_ *= r.u_;
-		r.v_ *= r.v_;
-		r.w_ *= r.w_;
-		r.u_ += r.v_ + r.w_;
-		u__ -= E[0] * r.u_;
-		v__ -= E[1] * r.u_;
-		w__ -= E[2] * r.u_;
-
-		sampleTexture(r, dst, stage,  u__, v__, w__, w__);
-	}
-
-	void PixelRoutine::TEXM3X3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling)
-	{
-		TEXM3X3PAD(r, u, v, s, src0, 2, signedScaling);
-
-		sampleTexture(r, dst, stage, r.u_, r.v_, r.w_, r.w_);
-	}
-
-	void PixelRoutine::TEXM3X3VSPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0)
-	{
-		TEXM3X3PAD(r, u, v, s, src0, 2, false);
-
-		Float4 E[3];   // Eye vector
-
-		E[0] = r.vf[2 + stage - 2].w;
-		E[1] = r.vf[2 + stage - 1].w;
-		E[2] = r.vf[2 + stage - 0].w;
-
-		// Reflection
-		Float4 u__;
-		Float4 v__;
-		Float4 w__;
-
-		// (u'', v'', w'') = 2 * (N . E) * N - E * (N . N)
-		u__ = r.u_ * E[0];
-		v__ = r.v_ * E[1];
-		w__ = r.w_ * E[2];
-		u__ += v__ + w__;
-		u__ += u__;
-		v__ = u__;
-		w__ = u__;
-		u__ *= r.u_;
-		v__ *= r.v_;
-		w__ *= r.w_;
-		r.u_ *= r.u_;
-		r.v_ *= r.v_;
-		r.w_ *= r.w_;
-		r.u_ += r.v_ + r.w_;
-		u__ -= E[0] * r.u_;
-		v__ -= E[1] * r.u_;
-		w__ -= E[2] * r.u_;
-
-		sampleTexture(r, dst, stage, u__, v__, w__, w__);
-	}
-
-	void PixelRoutine::TEXDEPTH(Registers &r)
-	{
-		r.u_ = Float4(r.rs[5].x);
-		r.v_ = Float4(r.rs[5].y);
-
-		// z / w
-		r.u_ *= Rcp_pp(r.v_);   // FIXME: Set result to 1.0 when division by zero
-
-		r.oDepth = r.u_;
-	}
-
-	void PixelRoutine::CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
-	{
-		{Short4 t0; t0 = src0.x; t0 = CmpGT(t0, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800)); Short4 t1; t1 = src1.w; t1 = t1 & t0; t0 = ~t0 & src2.w; t0 = t0 | t1; dst.w = t0;};
-	}
-
-	void PixelRoutine::CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2)
-	{
-		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.x); Short4 t1; t1 = src2.x; t1 &= t0; t0 = ~t0 & src1.x; t0 |= t1; dst.x = t0;};
-		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.y); Short4 t1; t1 = src2.y; t1 &= t0; t0 = ~t0 & src1.y; t0 |= t1; dst.y = t0;};
-		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.z); Short4 t1; t1 = src2.z; t1 &= t0; t0 = ~t0 & src1.z; t0 |= t1; dst.z = t0;};
-		{Short4 t0 = CmpGT(Short4(0x0000, 0x0000, 0x0000, 0x0000), src0.w); Short4 t1; t1 = src2.w; t1 &= t0; t0 = ~t0 & src1.w; t0 |= t1; dst.w = t0;};
-	}
-
-	void PixelRoutine::BEM(Registers &r, 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>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][0]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
-		t1 = MulHigh(src1.y, *Pointer<Short4>(r.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>(r.data + OFFSET(DrawData,textureStage[stage].bumpmapMatrix4W[0][1]))); t0 = t0 << 4;   // FIXME: Matrix components range? Overflow hazard.
-		t1 = MulHigh(src1.y, *Pointer<Short4>(r.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;
-	}
-
-	void PixelRoutine::M3X2(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
-	{
-		Vector4f row0 = fetchRegisterF(r, src1, 0);
-		Vector4f row1 = fetchRegisterF(r, src1, 1);
-
-		dst.x = dot3(src0, row0);
-		dst.y = dot3(src0, row1);
-	}
-
-	void PixelRoutine::M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
-	{
-		Vector4f row0 = fetchRegisterF(r, src1, 0);
-		Vector4f row1 = fetchRegisterF(r, src1, 1);
-		Vector4f row2 = fetchRegisterF(r, src1, 2);
-
-		dst.x = dot3(src0, row0);
-		dst.y = dot3(src0, row1);
-		dst.z = dot3(src0, row2);
-	}
-
-	void PixelRoutine::M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
-	{
-		Vector4f row0 = fetchRegisterF(r, src1, 0);
-		Vector4f row1 = fetchRegisterF(r, src1, 1);
-		Vector4f row2 = fetchRegisterF(r, src1, 2);
-		Vector4f row3 = fetchRegisterF(r, src1, 3);
-
-		dst.x = dot3(src0, row0);
-		dst.y = dot3(src0, row1);
-		dst.z = dot3(src0, row2);
-		dst.w = dot3(src0, row3);
-	}
-
-	void PixelRoutine::M4X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
-	{
-		Vector4f row0 = fetchRegisterF(r, src1, 0);
-		Vector4f row1 = fetchRegisterF(r, src1, 1);
-		Vector4f row2 = fetchRegisterF(r, src1, 2);
-
-		dst.x = dot4(src0, row0);
-		dst.y = dot4(src0, row1);
-		dst.z = dot4(src0, row2);
-	}
-
-	void PixelRoutine::M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1)
-	{
-		Vector4f row0 = fetchRegisterF(r, src1, 0);
-		Vector4f row1 = fetchRegisterF(r, src1, 1);
-		Vector4f row2 = fetchRegisterF(r, src1, 2);
-		Vector4f row3 = fetchRegisterF(r, src1, 3);
-
-		dst.x = dot4(src0, row0);
-		dst.y = dot4(src0, row1);
-		dst.z = dot4(src0, row2);
-		dst.w = dot4(src0, row3);
-	}
-
-	void PixelRoutine::TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
-	{
-		Vector4f tmp;
-		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias);	
-
-		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
-		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
-		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
-		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
-	}
-	
-	void PixelRoutine::TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2,  Vector4f &src3, bool project, bool bias)
-	{
-		Vector4f tmp;
-		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src2, src3, project, bias, true);
-
-		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
-		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
-		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
-		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
-	}
-	
-	void PixelRoutine::TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias)
-	{
-		Vector4f tmp;
-		sampleTexture(r, tmp, src1, src0.x, src0.y, src0.z, src0.w, src0, src0, project, bias, false, true);
-
-		dst.x = tmp[(src1.swizzle >> 0) & 0x3];
-		dst.y = tmp[(src1.swizzle >> 2) & 0x3];
-		dst.z = tmp[(src1.swizzle >> 4) & 0x3];
-		dst.w = tmp[(src1.swizzle >> 6) & 0x3];
-	}
-
-	void PixelRoutine::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(r));
-	//	}
-
-		for(unsigned int q = 0; q < state.multiSample; q++)
-		{
-			cMask[q] &= kill;
-		}
-
-		// FIXME: Branch to end of shader if all killed?
-	}
-
-	void PixelRoutine::DISCARD(Registers &r, Int cMask[4], const Shader::Instruction *instruction)
-	{
-		Int kill = 0;
-		
-		if(shader->containsDynamicBranching())
-		{
-			kill = ~SignMask(enableMask(r, instruction));
-		}
-		
-		for(unsigned int q = 0; q < state.multiSample; q++)
-		{
-			cMask[q] &= kill;
-		}
-
-		// FIXME: Branch to end of shader if all killed?
-	}
-
-	void PixelRoutine::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 PixelRoutine::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 PixelRoutine::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 PixelRoutine::BREAK(Registers &r)
-	{
-		llvm::BasicBlock *deadBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
-
-		if(breakDepth == 0)
-		{
-			r.enableIndex = r.enableIndex - breakDepth;
-			Nucleus::createBr(endBlock);
-		}
-		else
-		{
-			r.enableBreak = r.enableBreak & ~r.enableStack[r.enableIndex];
-			Bool allBreak = SignMask(r.enableBreak) == 0x0;
-
-			r.enableIndex = r.enableIndex - breakDepth;
-			branch(allBreak, endBlock, deadBlock);
-		}
-
-		Nucleus::setInsertBlock(deadBlock);
-		r.enableIndex = r.enableIndex + breakDepth;
-	}
-
-	void PixelRoutine::BREAKC(Registers &r, 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(r, condition);
-	}
-
-	void PixelRoutine::BREAKP(Registers &r, const Src &predicateRegister)   // FIXME: Factor out parts common with BREAKC
-	{
-		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
-
-		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
-		{
-			condition = ~condition;
-		}
-
-		BREAK(r, condition);
-	}
-
-	void PixelRoutine::BREAK(Registers &r, Int4 &condition)
-	{
-		condition &= r.enableStack[r.enableIndex];
-
-		llvm::BasicBlock *continueBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth - 1];
-
-		r.enableBreak = r.enableBreak & ~condition;
-		Bool allBreak = SignMask(r.enableBreak) == 0x0;
-
-		r.enableIndex = r.enableIndex - breakDepth;
-		branch(allBreak, endBlock, continueBlock);
-
-		Nucleus::setInsertBlock(continueBlock);
-		r.enableIndex = r.enableIndex + breakDepth;
-	}
-
-	void PixelRoutine::CONTINUE(Registers &r)
-	{
-		r.enableContinue = r.enableContinue & ~r.enableStack[r.enableIndex];
-	}
-
-	void PixelRoutine::TEST()
-	{
-		whileTest = true;
-	}
-
-	void PixelRoutine::CALL(Registers &r, int labelIndex, int callSiteIndex)
-	{
-		if(!labelBlock[labelIndex])
-		{
-			labelBlock[labelIndex] = Nucleus::createBasicBlock();
-		}
-
-		if(callRetBlock[labelIndex].size() > 1)
-		{
-			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
-		}
-
-		Int4 restoreLeave = r.enableLeave;
-
-		Nucleus::createBr(labelBlock[labelIndex]);
-		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
-
-		r.enableLeave = restoreLeave;
-	}
-
-	void PixelRoutine::CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src)
-	{
-		if(src.type == Shader::PARAMETER_CONSTBOOL)
-		{
-			CALLNZb(r, labelIndex, callSiteIndex, src);
-		}
-		else if(src.type == Shader::PARAMETER_PREDICATE)
-		{
-			CALLNZp(r, labelIndex, callSiteIndex, src);
-		}
-		else ASSERT(false);
-	}
-
-	void PixelRoutine::CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister)
-	{
-		Bool condition = (*Pointer<Byte>(r.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)
-		{
-			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
-		}
-
-		Int4 restoreLeave = r.enableLeave;
-
-		branch(condition, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
-		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
-
-		r.enableLeave = restoreLeave;
-	}
-
-	void PixelRoutine::CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister)
-	{
-		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
-
-		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
-		{
-			condition = ~condition;
-		}
-
-		condition &= r.enableStack[r.enableIndex];
-
-		if(!labelBlock[labelIndex])
-		{
-			labelBlock[labelIndex] = Nucleus::createBasicBlock();
-		}
-
-		if(callRetBlock[labelIndex].size() > 1)
-		{
-			r.callStack[r.stackIndex++] = UInt(callSiteIndex);
-		}
-
-		r.enableIndex++;
-		r.enableStack[r.enableIndex] = condition;
-		Int4 restoreLeave = r.enableLeave;
-
-		Bool notAllFalse = SignMask(condition) != 0;
-		branch(notAllFalse, labelBlock[labelIndex], callRetBlock[labelIndex][callSiteIndex]);
-		Nucleus::setInsertBlock(callRetBlock[labelIndex][callSiteIndex]);
-
-		r.enableIndex--;
-		r.enableLeave = restoreLeave;
-	}
-
-	void PixelRoutine::ELSE(Registers &r)
-	{
-		ifDepth--;
-
-		llvm::BasicBlock *falseBlock = ifFalseBlock[ifDepth];
-		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
-
-		if(isConditionalIf[ifDepth])
-		{
-			Int4 condition = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
-			Bool notAllFalse = SignMask(condition) != 0;
-
-			branch(notAllFalse, falseBlock, endBlock);
-
-			r.enableStack[r.enableIndex] = ~r.enableStack[r.enableIndex] & r.enableStack[r.enableIndex - 1];
-		}
-		else
-		{
-			Nucleus::createBr(endBlock);
-			Nucleus::setInsertBlock(falseBlock);
-		}
-
-		ifFalseBlock[ifDepth] = endBlock;
-
-		ifDepth++;
-	}
-
-	void PixelRoutine::ENDIF(Registers &r)
-	{
-		ifDepth--;
-
-		llvm::BasicBlock *endBlock = ifFalseBlock[ifDepth];
-
-		Nucleus::createBr(endBlock);
-		Nucleus::setInsertBlock(endBlock);
-
-		if(isConditionalIf[ifDepth])
-		{
-			breakDepth--;
-			r.enableIndex--;
-		}
-	}
-
-	void PixelRoutine::ENDLOOP(Registers &r)
-	{
-		loopRepDepth--;
-
-		r.aL[r.loopDepth] = r.aL[r.loopDepth] + r.increment[r.loopDepth];   // FIXME: +=
-
-		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
-		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
-
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(endBlock);
-
-		r.loopDepth--;
-		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-	}
-
-	void PixelRoutine::ENDREP(Registers &r)
-	{
-		loopRepDepth--;
-
-		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
-		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
-
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(endBlock);
-
-		r.loopDepth--;
-		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-	}
-
-	void PixelRoutine::ENDWHILE(Registers &r)
-	{
-		loopRepDepth--;
-
-		llvm::BasicBlock *testBlock = loopRepTestBlock[loopRepDepth];
-		llvm::BasicBlock *endBlock = loopRepEndBlock[loopRepDepth];
-
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(endBlock);
-
-		r.enableIndex--;
-		r.enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-		whileTest = false;
-	}
-
-	void PixelRoutine::IF(Registers &r, const Src &src)
-	{
-		if(src.type == Shader::PARAMETER_CONSTBOOL)
-		{
-			IFb(r, src);
-		}
-		else if(src.type == Shader::PARAMETER_PREDICATE)
-		{
-			IFp(r, src);
-		}
-		else
-		{
-			Int4 condition = As<Int4>(fetchRegisterF(r, src).x);
-			IF(r, condition);
-		}
-	}
-
-	void PixelRoutine::IFb(Registers &r, const Src &boolRegister)
-	{
-		ASSERT(ifDepth < 24 + 4);
-
-		Bool condition = (*Pointer<Byte>(r.data + OFFSET(DrawData,ps.b[boolRegister.index])) != Byte(0));   // FIXME
-
-		if(boolRegister.modifier == Shader::MODIFIER_NOT)
-		{
-			condition = !condition;
-		}
-
-		llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
-
-		branch(condition, trueBlock, falseBlock);
-
-		isConditionalIf[ifDepth] = false;
-		ifFalseBlock[ifDepth] = falseBlock;
-
-		ifDepth++;
-	}
-
-	void PixelRoutine::IFp(Registers &r, const Src &predicateRegister)
-	{
-		Int4 condition = As<Int4>(r.p0[predicateRegister.swizzle & 0x3]);
-
-		if(predicateRegister.modifier == Shader::MODIFIER_NOT)
-		{
-			condition = ~condition;
-		}
-
-		IF(r, condition);
-	}
-
-	void PixelRoutine::IFC(Registers &r, 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(r, condition);
-	}
-
-	void PixelRoutine::IF(Registers &r, Int4 &condition)
-	{
-		condition &= r.enableStack[r.enableIndex];
-
-		r.enableIndex++;
-		r.enableStack[r.enableIndex] = condition;
-
-		llvm::BasicBlock *trueBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *falseBlock = Nucleus::createBasicBlock();
-
-		Bool notAllFalse = SignMask(condition) != 0;
-
-		branch(notAllFalse, trueBlock, falseBlock);
-
-		isConditionalIf[ifDepth] = true;
-		ifFalseBlock[ifDepth] = falseBlock;
-
-		ifDepth++;
-		breakDepth++;
-	}
-
-	void PixelRoutine::LABEL(int labelIndex)
-	{
-		if(!labelBlock[labelIndex])
-		{
-			labelBlock[labelIndex] = Nucleus::createBasicBlock();
-		}
-
-		Nucleus::setInsertBlock(labelBlock[labelIndex]);
-		currentLabel = labelIndex;
-	}
-
-	void PixelRoutine::LOOP(Registers &r, const Src &integerRegister)
-	{
-		r.loopDepth++;
-
-		r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
-		r.aL[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][1]));
-		r.increment[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][2]));
-
-	//	If(r.increment[r.loopDepth] == 0)
-	//	{
-	//		r.increment[r.loopDepth] = 1;
-	//	}
-
-		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
-
-		loopRepTestBlock[loopRepDepth] = testBlock;
-		loopRepEndBlock[loopRepDepth] = endBlock;
-
-		// FIXME: jump(testBlock)
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(testBlock);
-
-		branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
-		Nucleus::setInsertBlock(loopBlock);
-
-		r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
-		
-		loopRepDepth++;
-		breakDepth = 0;
-	}
-
-	void PixelRoutine::REP(Registers &r, const Src &integerRegister)
-	{
-		r.loopDepth++;
-
-		r.iteration[r.loopDepth] = *Pointer<Int>(r.data + OFFSET(DrawData,ps.i[integerRegister.index][0]));
-		r.aL[r.loopDepth] = r.aL[r.loopDepth - 1];
-
-		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
-
-		loopRepTestBlock[loopRepDepth] = testBlock;
-		loopRepEndBlock[loopRepDepth] = endBlock;
-
-		// FIXME: jump(testBlock)
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(testBlock);
-
-		branch(r.iteration[r.loopDepth] > 0, loopBlock, endBlock);
-		Nucleus::setInsertBlock(loopBlock);
-
-		r.iteration[r.loopDepth] = r.iteration[r.loopDepth] - 1;   // FIXME: --
-
-		loopRepDepth++;
-		breakDepth = 0;
-	}
-
-	void PixelRoutine::WHILE(Registers &r, const Src &temporaryRegister)
-	{
-		r.enableIndex++;
-
-		llvm::BasicBlock *loopBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *testBlock = Nucleus::createBasicBlock();
-		llvm::BasicBlock *endBlock = Nucleus::createBasicBlock();
-		
-		loopRepTestBlock[loopRepDepth] = testBlock;
-		loopRepEndBlock[loopRepDepth] = endBlock;
-
-		Int4 restoreBreak = r.enableBreak;
-		Int4 restoreContinue = r.enableContinue;
-
-		// FIXME: jump(testBlock)
-		Nucleus::createBr(testBlock);
-		Nucleus::setInsertBlock(testBlock);
-		r.enableContinue = restoreContinue;
-
-		const Vector4f &src = fetchRegisterF(r, temporaryRegister);
-		Int4 condition = As<Int4>(src.x);
-		condition &= r.enableStack[r.enableIndex - 1];
-		r.enableStack[r.enableIndex] = condition;
-
-		Bool notAllFalse = SignMask(condition) != 0;
-		branch(notAllFalse, loopBlock, endBlock);
-		
-		Nucleus::setInsertBlock(endBlock);
-		r.enableBreak = restoreBreak;
-		
-		Nucleus::setInsertBlock(loopBlock);
-
-		loopRepDepth++;
-		breakDepth = 0;
-	}
-
-	void PixelRoutine::RET(Registers &r)
-	{
-		if(currentLabel == -1)
-		{
-			returnBlock = Nucleus::createBasicBlock();
-			Nucleus::createBr(returnBlock);
-		}
-		else
-		{
-			llvm::BasicBlock *unreachableBlock = Nucleus::createBasicBlock();
-
-			if(callRetBlock[currentLabel].size() > 1)   // Pop the return destination from the call stack
-			{
-				// FIXME: Encapsulate
-				UInt index = r.callStack[--r.stackIndex];
- 
-				llvm::Value *value = index.loadValue();
-				llvm::Value *switchInst = Nucleus::createSwitch(value, unreachableBlock, (int)callRetBlock[currentLabel].size());
-
-				for(unsigned int i = 0; i < callRetBlock[currentLabel].size(); i++)
-				{
-					Nucleus::addSwitchCase(switchInst, 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 PixelRoutine::LEAVE(Registers &r)
-	{
-		r.enableLeave = r.enableLeave & ~r.enableStack[r.enableIndex];
-
-		// FIXME: Return from function if all instances left
-		// FIXME: Use enableLeave in other control-flow constructs
-	}
-	
-	void PixelRoutine::writeDestination(Registers &r, Vector4s &d, const Dst &dst)
-	{
-		switch(dst.type)
-		{
-		case Shader::PARAMETER_TEMP:
-			if(dst.mask & 0x1) r.rs[dst.index].x = d.x;
-			if(dst.mask & 0x2) r.rs[dst.index].y = d.y;
-			if(dst.mask & 0x4) r.rs[dst.index].z = d.z;
-			if(dst.mask & 0x8) r.rs[dst.index].w = d.w;
-			break;
-		case Shader::PARAMETER_INPUT:
-			if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
-			if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
-			if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
-			if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
-			break;
-		case Shader::PARAMETER_CONST:			ASSERT(false);	break;
-		case Shader::PARAMETER_TEXTURE:
-			if(dst.mask & 0x1) r.ts[dst.index].x = d.x;
-			if(dst.mask & 0x2) r.ts[dst.index].y = d.y;
-			if(dst.mask & 0x4) r.ts[dst.index].z = d.z;
-			if(dst.mask & 0x8) r.ts[dst.index].w = d.w;
-			break;
-		case Shader::PARAMETER_COLOROUT:
-			if(dst.mask & 0x1) r.vs[dst.index].x = d.x;
-			if(dst.mask & 0x2) r.vs[dst.index].y = d.y;
-			if(dst.mask & 0x4) r.vs[dst.index].z = d.z;
-			if(dst.mask & 0x8) r.vs[dst.index].w = d.w;
-			break;
-		default:
-			ASSERT(false);
-		}
-	}
-
-	Vector4s PixelRoutine::fetchRegisterS(Registers &r, const Src &src)
-	{
-		Vector4s *reg;
-		int i = src.index;
-
-		Vector4s c;
-
-		if(src.type == Shader::PARAMETER_CONST)
-		{
-			c.x = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][0]));
-			c.y = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][1]));
-			c.z = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][2]));
-			c.w = *Pointer<Short4>(r.data + OFFSET(DrawData,ps.cW[i][3]));
-		}
-
-		switch(src.type)
-		{
-		case Shader::PARAMETER_TEMP:          reg = &r.rs[i]; break;
-		case Shader::PARAMETER_INPUT:         reg = &r.vs[i]; break;
-		case Shader::PARAMETER_CONST:         reg = &c;       break;
-		case Shader::PARAMETER_TEXTURE:       reg = &r.ts[i]; break;
-		case Shader::PARAMETER_VOID:          return r.rs[0]; // Dummy
-		case Shader::PARAMETER_FLOAT4LITERAL: return r.rs[0]; // Dummy
-		default:
-			ASSERT(false);
-		}
-
-		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, 0x0800, 0x0800, 0x0800));
-			mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-			mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-			mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-			break;
-		case Shader::MODIFIER_BIAS_NEGATE:
-			mod.x = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), x);
-			mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
-			mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
-			mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800));
-			mod.y = SubSat(y, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-			mod.z = SubSat(z, Short4(0x0800, 0x0800, 0x0800, 0x0800));
-			mod.w = SubSat(w, Short4(0x0800, 0x0800, 0x0800, 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, 0x0800, 0x0800, 0x0800), x);
-			mod.y = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), y);
-			mod.z = SubSat(Short4(0x0800, 0x0800, 0x0800, 0x0800), z);
-			mod.w = SubSat(Short4(0x0800, 0x0800, 0x0800, 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, -0x1000, -0x1000, -0x1000));
-			mod.y = Min(mod.y, Short4(0x1000)); mod.y = Max(mod.y, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
-			mod.z = Min(mod.z, Short4(0x1000)); mod.z = Max(mod.z, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
-			mod.w = Min(mod.w, Short4(0x1000)); mod.w = Max(mod.w, Short4(-0x1000, -0x1000, -0x1000, -0x1000));
-		}
-
-		return mod;
-	}
-
-	Vector4f PixelRoutine::fetchRegisterF(Registers &r, const Src &src, int offset)
-	{
-		Vector4f reg;
-		int i = src.index + offset;
-
-		switch(src.type)
-		{
-		case Shader::PARAMETER_TEMP:
-			if(src.rel.type == Shader::PARAMETER_VOID)
-			{
-				reg = r.rf[i];
-			}
-			else
-			{
-				Int a = relativeAddress(r, src);
-
-				reg = r.rf[i + a];
-			}
-			break;
-		case Shader::PARAMETER_INPUT:
-			{
-				if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
-				{
-					reg = r.vf[i];
-				}
-				else if(src.rel.type == Shader::PARAMETER_LOOP)
-				{
-					Int aL = r.aL[r.loopDepth];
-
-					reg = r.vf[i + aL];
-				}
-				else
-				{
-					Int a = relativeAddress(r, src);
-					
-					reg = r.vf[i + a];
-				}
-			}
-			break;
-		case Shader::PARAMETER_CONST:
-			reg = readConstant(r, src, offset);
-			break;
-		case Shader::PARAMETER_TEXTURE:
-			reg = r.vf[2 + i];
-			break;
-		case Shader::PARAMETER_MISCTYPE:
-			if(src.index == 0)				reg = r.vPos;
-			if(src.index == 1)				reg = r.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) + RoundInt(r.rf[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:
-			reg = r.oC[i];
-			break;
-		case Shader::PARAMETER_DEPTHOUT:
-			reg.x = r.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;
-	}
-
-	Vector4f PixelRoutine::readConstant(Registers &r, const Src &src, int offset)
-	{
-		Vector4f c;
-
-		int i = src.index + offset;
-
-		if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
-		{
-			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[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.type == Shader::PARAMETER_LOOP)
-		{
-			Int loopCounter = r.aL[r.loopDepth];
-
-			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]) + loopCounter * 16);
-
-			c.x = c.x.xxxx;
-			c.y = c.y.yyyy;
-			c.z = c.z.zzzz;
-			c.w = c.w.wwww;
-		}
-		else
-		{
-			Int a = relativeAddress(r, src);
-			
-			c.x = c.y = c.z = c.w = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[i]) + a * 16);
-
-			c.x = c.x.xxxx;
-			c.y = c.y.yyyy;
-			c.z = c.z.zzzz;
-			c.w = c.w.wwww;
-		}
-
-		return c;
-	}
-
-	Int PixelRoutine::relativeAddress(Registers &r, const Shader::Parameter &var)
-	{
-		ASSERT(var.rel.deterministic);
-
-		if(var.rel.type == Shader::PARAMETER_TEMP)
-		{
-			return RoundInt(Extract(r.rf[var.rel.index].x, 0)) * var.rel.scale;
-		}
-		else if(var.rel.type == Shader::PARAMETER_INPUT)
-		{
-			return RoundInt(Extract(r.vf[var.rel.index].x, 0)) * var.rel.scale;
-		}
-		else if(var.rel.type == Shader::PARAMETER_OUTPUT)
-		{
-			return RoundInt(Extract(r.oC[var.rel.index].x, 0)) * var.rel.scale;
-		}
-		else if(var.rel.type == Shader::PARAMETER_CONST)
-		{
-			RValue<Float4> c = *Pointer<Float4>(r.data + OFFSET(DrawData,ps.c[var.rel.index]));
-
-			return RoundInt(Extract(c, 0)) * var.rel.scale;
-		}
-		else ASSERT(false);
-
-		return 0;
-	}
-
-	Int4 PixelRoutine::enableMask(Registers &r, const Shader::Instruction *instruction)
-	{
-		Int4 enable = instruction->analysisBranch ? Int4(r.enableStack[r.enableIndex]) : Int4(0xFFFFFFFF);
-		
-		if(!whileTest)
-		{
-			if(shader->containsBreakInstruction() && instruction->analysisBreak)
-			{
-				enable &= r.enableBreak;
-			}
-
-			if(shader->containsContinueInstruction() && instruction->analysisContinue)
-			{
-				enable &= r.enableContinue;
-			}
-
-			if(shader->containsLeaveInstruction() && instruction->analysisLeave)
-			{
-				enable &= r.enableLeave;
-			}
-		}
-
-		return enable;
-	}
-
 	bool PixelRoutine::colorUsed()
 	{
 		return state.colorWriteMask || state.alphaTestActive() || state.shaderContainsKill;
 	}
-
-	unsigned short PixelRoutine::shaderVersion() const
-	{
-		return shader ? shader->getVersion() : 0x0000;
-	}
-
-	bool PixelRoutine::interpolateZ() const
-	{
-		return state.depthTestActive || state.pixelFogActive() || (shader && shader->vPosDeclared && fullPixelPositionRegister);
-	}
-
-	bool PixelRoutine::interpolateW() const
-	{
-		return state.perspective || (shader && shader->vPosDeclared && fullPixelPositionRegister);
-	}
 }
diff --git a/src/Shader/PixelRoutine.hpp b/src/Shader/PixelRoutine.hpp
index dd645f0..fd85a34 100644
--- a/src/Shader/PixelRoutine.hpp
+++ b/src/Shader/PixelRoutine.hpp
@@ -12,171 +12,62 @@
 #ifndef sw_PixelRoutine_hpp
 #define sw_PixelRoutine_hpp
 
-#include "Rasterizer.hpp"
-#include "ShaderCore.hpp"
-#include "PixelShader.hpp"
-
-#include "Types.hpp"
+#include "QuadRasterizer.hpp"
 
 namespace sw
 {
-	extern bool forceClearRegisters;
-
 	class PixelShader;
 	class SamplerCore;
 
-	class PixelRoutine : public Rasterizer, public ShaderCore
+	class PixelRoutine : public sw::QuadRasterizer, public ShaderCore
 	{
 		friend class PixelProcessor;   // FIXME
 
 	public:
 		PixelRoutine(const PixelProcessor::State &state, const PixelShader *shader);
 
-		~PixelRoutine();
+		virtual ~PixelRoutine();
 
 	protected:
-		struct Registers
+		struct Registers : public QuadRasterizer::Registers
 		{
-			Registers(const PixelShader *shader) :
-				current(rs[0]), diffuse(vs[0]), specular(vs[1]),
-				rf(shader && shader->dynamicallyIndexedTemporaries),
-				vf(shader && shader->dynamicallyIndexedInput)
-			{
-				if(!shader || shader->getVersion() < 0x0200 || forceClearRegisters)
-				{
-					for(int i = 0; i < 10; i++)
-					{
-						vf[i].x = Float4(0.0f);
-						vf[i].y = Float4(0.0f);
-						vf[i].z = Float4(0.0f);
-						vf[i].w = Float4(0.0f);
-					}
-				}
+			Registers(const PixelShader *shader);
 
-				loopDepth = -1;
-				enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-				
-				if(shader && shader->containsBreakInstruction())
-				{
-					enableBreak = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-				}
+			Float4 z[4]; // Multisampled z
+			Float4 w;    // Used as is
+			Float4 rhw;  // Reciprocal w
 
-				if(shader && shader->containsContinueInstruction())
-				{
-					enableContinue = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
-				}
+			RegisterArray<4096> rf; // Computation registers
+			RegisterArray<10> vf;   // Varying registers
 
-				occlusion = 0;
-				
-				#if PERF_PROFILE
-					for(int i = 0; i < PERF_TIMERS; i++)
-					{
-						cycles[i] = 0;
-					}
-				#endif
-			}
-
-			Pointer<Byte> constants;
-
-			Pointer<Byte> primitive;
-			Int cluster;
-			Pointer<Byte> data;
-
-			Float4 z[4];
-			Float4 w;
-			Float4 rhw;
-
-			Float4 Dz[4];
-			Float4 Dw;
-			Float4 Dv[10][4];
-			Float4 Df;
-
-			Vector4s &current;
-			Vector4s &diffuse;
-			Vector4s &specular;
-
-			Vector4s rs[6];
-			Vector4s vs[2];
-			Vector4s ts[6];
-
-			RegisterArray<4096> rf;
-			RegisterArray<10> vf;
-
-			Vector4f vPos;
-			Vector4f vFace;
-
+			// Outputs
 			Vector4f oC[4];
 			Float4 oDepth;
-
-			Vector4f p0;
-			Array<Int, 4> aL;
-
-			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;
-
-			// 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
-
-			UInt occlusion;
-
-			#if PERF_PROFILE
-				Long cycles[PERF_TIMERS];
-			#endif
 		};
 
-		typedef Shader::DestinationParameter Dst;
+
 		typedef Shader::SourceParameter Src;
-		typedef Shader::Control Control;
+		typedef Shader::DestinationParameter Dst;
 
-		void quad(Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
+		virtual void setBuiltins(Registers &r, Int &x, Int &y, Float4(&z)[4], Float4 &w) = 0;
+		virtual void applyShader(Registers &r, Int cMask[4]) = 0;
+		virtual Bool alphaTest(Registers &r, Int cMask[4]) = 0;
+		virtual void rasterOperation(Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]) = 0;
 
-		Float4 interpolate(Float4 &x, Float4 &D, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
+		virtual void quad(QuadRasterizer::Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
+
 		Float4 interpolateCentroid(Float4 &x, Float4 &y, Float4 &rhw, Pointer<Byte> planeEquation, bool flat, bool perspective);
 		void stencilTest(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask);
 		void stencilTest(Registers &r, Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW);
 		void stencilOperation(Registers &r, Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
 		void stencilOperation(Registers &r, Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW);
 		Bool depthTest(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
-		void blendTexture(Registers &r, Vector4s &temp, Vector4s &texture, int stage);
 		void alphaTest(Registers &r, Int &aMask, Short4 &alpha);
 		void alphaToCoverage(Registers &r, Int cMask[4], Float4 &alpha);
-		Bool alphaTest(Registers &r, Int cMask[4], Vector4s &current);
-		Bool alphaTest(Registers &r, Int cMask[4], Vector4f &c0);
-		void fogBlend(Registers &r, Vector4s &current, Float4 &fog, Float4 &z, Float4 &rhw);
 		void fogBlend(Registers &r, Vector4f &c0, Float4 &fog, Float4 &z, Float4 &rhw);
 		void pixelFog(Registers &r, Float4 &visibility, Float4 &z, Float4 &rhw);
-		void specularPixel(Vector4s &current, Vector4s &specular);
 
-		void sampleTexture(Registers &r, Vector4s &c, int coordinates, int sampler, bool project = false);
-		void sampleTexture(Registers &r, Vector4s &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project = false, bool bias = false);
-		void sampleTexture(Registers &r, Vector4s &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
-		void sampleTexture(Registers &r, Vector4f &c, const Src &sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
-		void sampleTexture(Registers &r, Vector4f &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, Vector4f &dsx, Vector4f &dsy, bool project = false, bool bias = false, bool gradients = false, bool lodProvided = false);
-	
 		// Raster operations
-		void clampColor(Vector4f oC[4]);
-		void rasterOperation(Vector4s &current, Registers &r, Float4 &fog, Pointer<Byte> &cBuffer, Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
-		void rasterOperation(Vector4f oC[4], Registers &r, Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
 		void blendFactor(Registers &r, const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
 		void blendFactorAlpha(Registers &r, const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
 		void readPixel(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x, Vector4s &pixel);
@@ -190,134 +81,16 @@
 		void writeStencil(Registers &r, Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
 		void writeDepth(Registers &r, Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);
 
-		void ps_1_x(Registers &r, Int cMask[4]);
-		void ps_2_x(Registers &r, Int cMask[4]);
-
-		Short4 convertFixed12(RValue<Float4> cf);
-		void convertFixed12(Vector4s &cs, Vector4f &cf);
-		Float4 convertSigned12(Short4 &cs);
-		void convertSigned12(Vector4f &cf, Vector4s &cs);
-		Float4 convertUnsigned16(UShort4 cs);
 		UShort4 convertFixed16(Float4 &cf, bool saturate = true);
-		void convertFixed16(Vector4s &cs, Vector4f &cf, bool saturate = true);
 		void sRGBtoLinear16_12_16(Registers &r, Vector4s &c);
 		void sRGBtoLinear12_16(Registers &r, Vector4s &c);
 		void linearToSRGB16_12_16(Registers &r, Vector4s &c);
 		void linearToSRGB12_16(Registers &r, Vector4s &c);
 		Float4 sRGBtoLinear(const Float4 &x);
-		Float4 linearToSRGB(const Float4 &x);
-
-		// ps_1_x 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(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src);
-		void TEXDP3TEX(Registers &r, 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(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, bool project);
-		void TEXLD(Registers &r, Vector4s &dst, Vector4s &src, int stage, bool project);
-		void TEXBEM(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
-		void TEXBEML(Registers &r, Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
-		void TEXREG2AR(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
-		void TEXREG2GB(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
-		void TEXREG2RGB(Registers &r, Vector4s &dst, Vector4s &src0, int stage);
-		void TEXM3X2DEPTH(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling);
-		void TEXM3X2PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
-		void TEXM3X2TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling);
-		void TEXM3X3(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling);
-		void TEXM3X3PAD(Registers &r, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
-		void TEXM3X3SPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1);
-		void TEXM3X3TEX(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool singedScaling);
-		void TEXM3X3VSPEC(Registers &r, Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
-		void TEXDEPTH(Registers &r);
-		void CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
-		void CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
-		void BEM(Registers &r, Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage);
-
-		// ps_2_x instructions
-		void M3X2(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
-		void M3X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
-		void M3X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
-		void M4X3(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
-		void M4X4(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1);
-		void TEXLD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
-		void TEXLDD(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2,  Vector4f &src3, bool project, bool bias);
-		void TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
-		void TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask);
-		void DISCARD(Registers &r, 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(Registers &r);
-		void BREAKC(Registers &r, Vector4f &src0, Vector4f &src1, Control);
-		void BREAKP(Registers &r, const Src &predicateRegister);
-		void BREAK(Registers &r, Int4 &condition);
-		void CONTINUE(Registers &r);
-		void TEST();
-		void CALL(Registers &r, int labelIndex, int callSiteIndex);
-		void CALLNZ(Registers &r, int labelIndex, int callSiteIndex, const Src &src);
-		void CALLNZb(Registers &r, int labelIndex, int callSiteIndex, const Src &boolRegister);
-		void CALLNZp(Registers &r, int labelIndex, int callSiteIndex, const Src &predicateRegister);
-		void ELSE(Registers &r);
-		void ENDIF(Registers &r);
-		void ENDLOOP(Registers &r);
-		void ENDREP(Registers &r);
-		void ENDWHILE(Registers &r);
-		void IF(Registers &r, const Src &src);
-		void IFb(Registers &r, const Src &boolRegister);
-		void IFp(Registers &r, const Src &predicateRegister);
-		void IFC(Registers &r, Vector4f &src0, Vector4f &src1, Control);
-		void IF(Registers &r, Int4 &condition);
-		void LABEL(int labelIndex);
-		void LOOP(Registers &r, const Src &integerRegister);
-		void REP(Registers &r, const Src &integerRegister);
-		void WHILE(Registers &r, const Src &temporaryRegister);
-		void RET(Registers &r);
-		void LEAVE(Registers &r);
-
-		void writeDestination(Registers &r, Vector4s &d, const Dst &dst);
-		Vector4s fetchRegisterS(Registers &r, const Src &src);
-		Vector4f fetchRegisterF(Registers &r, const Src &src, int offset = 0);
-		Vector4f readConstant(Registers &r, const Src &src, int offset = 0);
-		Int relativeAddress(Registers &r, const Shader::Parameter &var);
-		Int4 enableMask(Registers &r, const Shader::Instruction *instruction);
 
 		bool colorUsed();
-		unsigned short shaderVersion() const;
-		bool interpolateZ() const;
-		bool interpolateW() const;
 
-		const PixelShader *const shader;
-
-	private:
 		SamplerCore *sampler[TEXTURE_IMAGE_UNITS];
-
-		bool perturbate;
-		bool luminance;
-		bool previousScaling;
-
-		int ifDepth;
-		int loopRepDepth;
-		int breakDepth;
-		int currentLabel;
-		bool whileTest;
-
-		// FIXME: Get rid of llvm::
-		llvm::BasicBlock *ifFalseBlock[24 + 24];
-		llvm::BasicBlock *loopRepTestBlock[4];
-		llvm::BasicBlock *loopRepEndBlock[4];
-		llvm::BasicBlock *labelBlock[2048];
-		std::vector<llvm::BasicBlock*> callRetBlock[2048];
-		llvm::BasicBlock *returnBlock;
-		bool isConditionalIf[24 + 24];
 	};
 }
 
diff --git a/src/SwiftShader/SwiftShader.vcxproj b/src/SwiftShader/SwiftShader.vcxproj
index 5b4dc71..5eca09b 100644
--- a/src/SwiftShader/SwiftShader.vcxproj
+++ b/src/SwiftShader/SwiftShader.vcxproj
@@ -321,6 +321,8 @@
     <ClCompile Include="..\Main\FrameBufferWin.cpp" />
     <ClCompile Include="..\Main\Register.cpp" />
     <ClCompile Include="..\Shader\Constants.cpp" />
+    <ClCompile Include="..\Shader\PixelPipeline.cpp" />
+    <ClCompile Include="..\Shader\PixelProgram.cpp" />
     <ClCompile Include="..\Shader\PixelRoutine.cpp" />
     <ClCompile Include="..\Shader\PixelShader.cpp" />
     <ClCompile Include="..\Shader\SamplerCore.cpp" />
@@ -390,6 +392,8 @@
     <ClInclude Include="..\Main\FrameBufferWin.hpp" />
     <ClInclude Include="..\Main\Register.hpp" />
     <ClInclude Include="..\Renderer\RoutineCache.hpp" />
+    <ClInclude Include="..\Shader\PixelPipeline.hpp" />
+    <ClInclude Include="..\Shader\PixelProgram.hpp" />
     <ClInclude Include="MemoryManager.hpp" />
     <ClInclude Include="..\Shader\Constants.hpp" />
     <ClInclude Include="..\Shader\PixelRoutine.hpp" />
diff --git a/src/SwiftShader/SwiftShader.vcxproj.filters b/src/SwiftShader/SwiftShader.vcxproj.filters
index b60d548..572441c 100644
--- a/src/SwiftShader/SwiftShader.vcxproj.filters
+++ b/src/SwiftShader/SwiftShader.vcxproj.filters
@@ -179,6 +179,12 @@
     <ClCompile Include="..\Main\crc.cpp">
       <Filter>Source Files\Main</Filter>
     </ClCompile>
+    <ClCompile Include="..\Shader\PixelPipeline.cpp">
+      <Filter>Source Files\Shader</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Shader\PixelProgram.cpp">
+      <Filter>Source Files\Shader</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="MemoryManager.hpp">
@@ -356,6 +362,12 @@
     <ClInclude Include="..\Common\SharedLibrary.hpp">
       <Filter>Header Files\Common</Filter>
     </ClInclude>
+    <ClInclude Include="..\Shader\PixelProgram.hpp">
+      <Filter>Header Files\Shader</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Shader\PixelPipeline.hpp">
+      <Filter>Header Files\Shader</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="SwiftShader.ini" />