Derive Rasterizer from Function<>.

src/Renderer/PixelProcessor.cpp

@@ -1096,6 +1096,7 @@ namespace sw
 		{
 			const bool integerPipeline = (context->pixelShaderVersion() <= 0x0104);
 			Rasterizer *generator = nullptr;
+
 			if(integerPipeline)
 			{
 				generator = new PixelPipeline(state, context->pixelShader);
@@ -1104,8 +1105,9 @@ namespace sw
 			{
 				generator = new PixelProgram(state, context->pixelShader);
 			}
+
 			generator->generate();
-			routine = generator->getRoutine();
+			routine = (*generator)(L"PixelRoutine_%0.8X", state.shaderID);
 			delete generator;
 
 			routineCache->add(state, routine);

src/Renderer/QuadRasterizer.hpp

@@ -27,15 +27,8 @@ namespace sw
 
 		virtual ~QuadRasterizer();
 
-		struct Registers
-		{
-			Registers();
-			virtual ~Registers() {};
-
 		Pointer<Byte> constants;
-
 		Pointer<Byte> primitive;
-			Int cluster;
 		Pointer<Byte> data;
 
 		Float4 Dz[4];
@@ -48,10 +41,8 @@ namespace sw
 #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;
+		virtual void quad(Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y) = 0;
 
 		bool interpolateZ() const;
 		bool interpolateW() const;
@@ -62,7 +53,7 @@ namespace sw
 	private:
 		void generate();
 
-		void rasterize(Registers &r, Int &yMin, Int &yMax);
+		void rasterize(Int &yMin, Int &yMax);
 	};
 }
 

src/Renderer/Rasterizer.cpp

@@ -20,9 +20,4 @@ namespace sw
 	Rasterizer::~Rasterizer()
 	{
 	}
-
-	Routine *Rasterizer::getRoutine()
-	{
-		return routine;
-	}
 }

src/Renderer/Rasterizer.hpp

@@ -19,7 +19,7 @@
 
 namespace sw
 {
-	class Rasterizer
+	class Rasterizer : public Function<Void(Pointer<Byte>, Int, Int, Pointer<Byte>)>
 	{
 	public:
 		Rasterizer(const PixelProcessor::State &state);
@@ -27,11 +27,8 @@ namespace sw
 		virtual ~Rasterizer();
 
 		virtual void generate() = 0;
-		Routine *getRoutine();
 
 	protected:
-		Routine *routine;
-
 		const PixelProcessor::State &state;
 	};
 }

src/Shader/PixelPipeline.hpp

@@ -20,21 +20,16 @@ namespace sw
 	{
 	public:
 		PixelPipeline(const PixelProcessor::State &state, const PixelShader *shader) :
-			PixelRoutine(state, shader), perturbate(false), luminance(false), previousScaling(false) {}
+			PixelRoutine(state, shader), current(rs[0]), diffuse(vs[0]), specular(vs[1]), 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); };
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(Int cMask[4]);
+		virtual Bool alphaTest(Int cMask[4]);
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
 
 	private:
-		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;
@@ -55,24 +50,23 @@ namespace sw
 		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);
+		void fixedFunction();
+		void blendTexture(Vector4s &temp, Vector4s &texture, int stage);
+		void fogBlend(Vector4s &current, Float4 &fog);
 		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(Vector4s &c, int coordinates, int sampler, bool project = false);
+		void sampleTexture(Vector4s &c, int sampler, Float4 &u, Float4 &v, Float4 &w, Float4 &q, bool project = false, bool bias = false);
+		void sampleTexture(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);
+		void writeDestination(Vector4s &d, const Dst &dst);
+		Vector4s fetchRegisterS(const Src &src);
 
 		// Instructions
 		void MOV(Vector4s &dst, Vector4s &src0);
@@ -85,29 +79,29 @@ namespace sw
 		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 TEXDP3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src);
+		void TEXDP3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
 		void TEXKILL(Int cMask[4], Float4 &u, Float4 &v, Float4 &s);
 		void TEXKILL(Int cMask[4], Vector4s &dst);
-		void TEX(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 TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, bool project);
+		void TEXLD(Vector4s &dst, Vector4s &src, int stage, bool project);
+		void TEXBEM(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXBEML(Vector4s &dst, Vector4s &src, Float4 &u, Float4 &v, Float4 &s, int stage);
+		void TEXREG2AR(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2GB(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXREG2RGB(Vector4s &dst, Vector4s &src0, int stage);
+		void TEXM3X2DEPTH(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src, bool signedScaling);
+		void TEXM3X2PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X2TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool signedScaling);
+		void TEXM3X3(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, bool signedScaling);
+		void TEXM3X3PAD(Float4 &u, Float4 &v, Float4 &s, Vector4s &src0, int component, bool signedScaling);
+		void TEXM3X3SPEC(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, Vector4s &src1);
+		void TEXM3X3TEX(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0, bool singedScaling);
+		void TEXM3X3VSPEC(Vector4s &dst, Float4 &u, Float4 &v, Float4 &s, int stage, Vector4s &src0);
+		void TEXDEPTH();
 		void CND(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
 		void CMP(Vector4s &dst, Vector4s &src0, Vector4s &src1, Vector4s &src2);
-		void BEM(Registers &r, Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage);
+		void BEM(Vector4s &dst, Vector4s &src0, Vector4s &src1, int stage);
 
 		bool perturbate;
 		bool luminance;

src/Shader/PixelProgram.hpp

@@ -20,29 +20,14 @@ namespace sw
 	{
 	public:
 		PixelProgram(const PixelProcessor::State &state, const PixelShader *shader) :
-			PixelRoutine(state, shader), ifDepth(0), loopRepDepth(0), breakDepth(0), currentLabel(-1), whileTest(false)
+			PixelRoutine(state, shader), r(shader && shader->dynamicallyIndexedTemporaries),
+			loopDepth(-1), 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),
-				r(shader && shader->dynamicallyIndexedTemporaries),
-				loopDepth(-1)
-			{
 			enableStack[0] = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
 
 			if(shader && shader->containsBreakInstruction())
@@ -56,6 +41,15 @@ namespace sw
 			}
 		}
 
+		virtual ~PixelProgram() {}
+
+	protected:
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w);
+		virtual void applyShader(Int cMask[4]);
+		virtual Bool alphaTest(Int cMask[4]);
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]);
+
+	private:
 		// Temporary registers
 		RegisterArray<4096> r;
 
@@ -83,71 +77,70 @@ namespace sw
 		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);
+		void sampleTexture(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(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[RENDERTARGETS]);
 
-		Int4 enableMask(Registers &r, const Shader::Instruction *instruction);
+		Int4 enableMask(const Shader::Instruction *instruction);
 
-		Vector4f fetchRegisterF(Registers &r, const Src &src, unsigned int offset = 0);
-		Vector4f readConstant(Registers &r, const Src &src, unsigned int offset = 0);
-		Int relativeAddress(Registers &r, const Shader::Parameter &var);
+		Vector4f fetchRegisterF(const Src &src, unsigned int offset = 0);
+		Vector4f readConstant(const Src &src, unsigned int offset = 0);
+		Int relativeAddress(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 TEXSIZE(Registers &r, Vector4f &dst, Float4 &lod, const Src &src1);
+		void M3X2(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X3(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M3X4(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X3(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void M4X4(Vector4f &dst, Vector4f &src0, const Src &src1);
+		void TEXLD(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+		void TEXLDD(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, Vector4f &src3, bool project, bool bias);
+		void TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1, bool project, bool bias);
+		void TEXSIZE(Vector4f &dst, Float4 &lod, const Src &src1);
 		void TEXKILL(Int cMask[4], Vector4f &src, unsigned char mask);
-		void TEXOFFSET(Registers &r, Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, bool project, bool bias);
-		void TEXLDL(Registers &r, Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool project, bool bias);
-		void TEXELFETCH(Registers &r, Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
-		void TEXELFETCH(Registers &r, Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
-		void TEXGRAD(Registers &r, Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
-		void TEXGRAD(Registers &r, Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, Vector4f &src4);
-		void DISCARD(Registers &r, Int cMask[4], const Shader::Instruction *instruction);
+		void TEXOFFSET(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, bool project, bool bias);
+		void TEXLDL(Vector4f &dst, Vector4f &src0, const Src &src1, Vector4f &src2, bool project, bool bias);
+		void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2);
+		void TEXELFETCH(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
+		void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3);
+		void TEXGRAD(Vector4f &dst, Vector4f &src, const Src&, Vector4f &src2, Vector4f &src3, Vector4f &src4);
+		void DISCARD(Int cMask[4], const Shader::Instruction *instruction);
 		void DFDX(Vector4f &dst, Vector4f &src);
 		void DFDY(Vector4f &dst, Vector4f &src);
 		void FWIDTH(Vector4f &dst, Vector4f &src);
-		void BREAK(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 BREAK();
+		void BREAKC(Vector4f &src0, Vector4f &src1, Control);
+		void BREAKP(const Src &predicateRegister);
+		void BREAK(Int4 &condition);
+		void CONTINUE();
 		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 CALL(int labelIndex, int callSiteIndex);
+		void CALLNZ(int labelIndex, int callSiteIndex, const Src &src);
+		void CALLNZb(int labelIndex, int callSiteIndex, const Src &boolRegister);
+		void CALLNZp(int labelIndex, int callSiteIndex, const Src &predicateRegister);
+		void ELSE();
+		void ENDIF();
+		void ENDLOOP();
+		void ENDREP();
+		void ENDWHILE();
+		void IF(const Src &src);
+		void IFb(const Src &boolRegister);
+		void IFp(const Src &predicateRegister);
+		void IFC(Vector4f &src0, Vector4f &src1, Control);
+		void IF(Int4 &condition);
 		void LABEL(int labelIndex);
-		void LOOP(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 LOOP(const Src &integerRegister);
+		void REP(const Src &integerRegister);
+		void WHILE(const Src &temporaryRegister);
+		void RET();
+		void LEAVE();
 
 		int ifDepth;
 		int loopRepDepth;

src/Shader/PixelRoutine.hpp

@@ -29,10 +29,6 @@ namespace sw
 		virtual ~PixelRoutine();
 
 	protected:
-		struct Registers : public QuadRasterizer::Registers
-		{
-			Registers(const PixelShader *shader);
-
 		Float4 z[4]; // Multisampled z
 		Float4 w;    // Used as is
 		Float4 rhw;  // Reciprocal w
@@ -41,56 +37,54 @@ namespace sw
 
 		// Depth output
 		Float4 oDepth;
-		};
-
 
 		typedef Shader::SourceParameter Src;
 		typedef Shader::DestinationParameter Dst;
 
-		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;
+		virtual void setBuiltins(Int &x, Int &y, Float4(&z)[4], Float4 &w) = 0;
+		virtual void applyShader(Int cMask[4]) = 0;
+		virtual Bool alphaTest(Int cMask[4]) = 0;
+		virtual void rasterOperation(Float4 &fog, Pointer<Byte> cBuffer[4], Int &x, Int sMask[4], Int zMask[4], Int cMask[4]) = 0;
 
-		virtual void quad(QuadRasterizer::Registers &r, Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
+		virtual void quad(Pointer<Byte> cBuffer[4], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y);
 
-		void alphaTest(Registers &r, Int &aMask, Short4 &alpha);
-		void alphaToCoverage(Registers &r, Int cMask[4], Float4 &alpha);
-		void fogBlend(Registers &r, Vector4f &c0, Float4 &fog);
-		void pixelFog(Registers &r, Float4 &visibility);
+		void alphaTest(Int &aMask, Short4 &alpha);
+		void alphaToCoverage(Int cMask[4], Float4 &alpha);
+		void fogBlend(Vector4f &c0, Float4 &fog);
+		void pixelFog(Float4 &visibility);
 
 		// Raster operations
-		void alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
-		void logicOperation(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
-		void writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &i, Vector4s &current, Int &sMask, Int &zMask, Int &cMask);
-		void alphaBlend(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4f &oC, Int &x);
-		void writeColor(Registers &r, int index, Pointer<Byte> &cBuffer, Int &i, Vector4f &oC, Int &sMask, Int &zMask, Int &cMask);
+		void alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
+		void logicOperation(int index, Pointer<Byte> &cBuffer, Vector4s &current, Int &x);
+		void writeColor(int index, Pointer<Byte> &cBuffer, Int &i, Vector4s &current, Int &sMask, Int &zMask, Int &cMask);
+		void alphaBlend(int index, Pointer<Byte> &cBuffer, Vector4f &oC, Int &x);
+		void writeColor(int index, Pointer<Byte> &cBuffer, Int &i, Vector4f &oC, Int &sMask, Int &zMask, Int &cMask);
 
 		UShort4 convertFixed16(Float4 &cf, bool saturate = true);
-		void linearToSRGB12_16(Registers &r, Vector4s &c);
+		void linearToSRGB12_16(Vector4s &c);
 
 		SamplerCore *sampler[TEXTURE_IMAGE_UNITS];
 
 	private:
 		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 stencilTest(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &cMask);
+		void stencilTest(Byte8 &value, StencilCompareMode stencilCompareMode, bool CCW);
+		void stencilOperation(Byte8 &newValue, Byte8 &bufferValue, StencilOperation stencilPassOperation, StencilOperation stencilZFailOperation, StencilOperation stencilFailOperation, bool CCW, Int &zMask, Int &sMask);
+		void stencilOperation(Byte8 &output, Byte8 &bufferValue, StencilOperation operation, bool CCW);
+		Bool depthTest(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &sMask, Int &zMask, Int &cMask);
 
 		// Raster operations
-		void blendFactor(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, Int &x, Vector4s &pixel);
-		void blendFactor(Registers &r, const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
-		void blendFactorAlpha(Registers &r, const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
-		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 sRGBtoLinear16_12_16(Registers &r, Vector4s &c);
-		void sRGBtoLinear12_16(Registers &r, Vector4s &c);
-		void linearToSRGB16_12_16(Registers &r, Vector4s &c);
+		void blendFactor(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(const Vector4s &blendFactor, const Vector4s &current, const Vector4s &pixel, BlendFactor blendFactorAlphaActive);
+		void readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel);
+		void blendFactor(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorActive);
+		void blendFactorAlpha(const Vector4f &blendFactor, const Vector4f &oC, const Vector4f &pixel, BlendFactor blendFactorAlphaActive);
+		void writeStencil(Pointer<Byte> &sBuffer, int q, Int &x, Int &sMask, Int &zMask, Int &cMask);
+		void writeDepth(Pointer<Byte> &zBuffer, int q, Int &x, Float4 &z, Int &zMask);
+
+		void sRGBtoLinear16_12_16(Vector4s &c);
+		void sRGBtoLinear12_16(Vector4s &c);
+		void linearToSRGB16_12_16(Vector4s &c);
 		Float4 sRGBtoLinear(const Float4 &x);
 
 		bool colorUsed();