Multiple draw buffers implementation

src/Main/Config.hpp

@@ -89,6 +89,7 @@ enum
 	MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 4,
 	MAX_UNIFORM_BUFFER_BINDINGS = 36,
 	MAX_CLIP_PLANES = 6,
+	RENDERTARGETS = 4,
 };
 
 #endif   // sw_Config_hpp

src/OpenGL/libGL/Context.cpp

@@ -1718,7 +1718,7 @@ bool Context::applyRenderTarget()
     }
 
     Image *renderTarget = framebuffer->getRenderTarget();
-	device->setRenderTarget(renderTarget);
+	device->setRenderTarget(0, renderTarget);
 	if(renderTarget) renderTarget->release();
 
     Image *depthStencil = framebuffer->getDepthStencil();

src/OpenGL/libGL/Device.cpp

@@ -443,7 +443,7 @@ namespace gl
 		scissorEnable = enable;
 	}
 
-	void Device::setRenderTarget(Image *renderTarget)
+	void Device::setRenderTarget(int index, Image *renderTarget)
 	{
 		if(renderTarget)
 		{
@@ -457,7 +457,7 @@ namespace gl
 
 		this->renderTarget = renderTarget;
 
-		Renderer::setRenderTarget(0, renderTarget);
+		Renderer::setRenderTarget(index, renderTarget);
 	}
 
 	void Device::setScissorRect(const sw::Rect &rect)

src/OpenGL/libGL/Device.hpp

@@ -59,7 +59,7 @@ namespace gl
 		virtual void setPixelShader(sw::PixelShader *shader);
 		virtual void setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
 		virtual void setScissorEnable(bool enable);
-		virtual void setRenderTarget(Image *renderTarget);
+		virtual void setRenderTarget(int index, Image *renderTarget);
 		virtual void setScissorRect(const sw::Rect &rect);
 		virtual void setVertexShader(sw::VertexShader *shader);
 		virtual void setVertexShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);

src/OpenGL/libGLES_CM/Context.cpp

@@ -1705,7 +1705,7 @@ bool Context::applyRenderTarget()
     }
 
     egl::Image *renderTarget = framebuffer->getRenderTarget();
-	device->setRenderTarget(renderTarget);
+	device->setRenderTarget(0, renderTarget);
 	if(renderTarget) renderTarget->release();
 
     egl::Image *depthStencil = framebuffer->getDepthStencil();

src/OpenGL/libGLES_CM/Device.cpp

@@ -380,7 +380,7 @@ namespace es1
 		scissorEnable = enable;
 	}
 
-	void Device::setRenderTarget(egl::Image *renderTarget)
+	void Device::setRenderTarget(int index, egl::Image *renderTarget)
 	{
 		if(renderTarget)
 		{
@@ -394,7 +394,7 @@ namespace es1
 
 		this->renderTarget = renderTarget;
 
-		Renderer::setRenderTarget(0, renderTarget);
+		Renderer::setRenderTarget(index, renderTarget);
 	}
 
 	void Device::setScissorRect(const sw::Rect &rect)

src/OpenGL/libGLES_CM/Device.hpp

@@ -60,7 +60,7 @@ namespace es1
 		virtual void drawPrimitive(PrimitiveType primitiveType, unsigned int primiveCount);
 		virtual void setDepthStencilSurface(egl::Image *newDepthStencil);
 		virtual void setScissorEnable(bool enable);
-		virtual void setRenderTarget(egl::Image *renderTarget);
+		virtual void setRenderTarget(int index, egl::Image *renderTarget);
 		virtual void setScissorRect(const sw::Rect &rect);
 		virtual void setViewport(const Viewport &viewport);
 

src/OpenGL/libGLESv2/Context.cpp

@@ -2702,8 +2702,8 @@ void Context::applyScissor(int width, int height)
 
 egl::Image *Context::getScissoredImage(GLint drawbuffer, int &x0, int &y0, int &width, int &height, bool depthStencil)
 {
-	Framebuffer* framebuffer = getFramebuffer(drawbuffer);
-	egl::Image* image = depthStencil ? framebuffer->getDepthStencil() : framebuffer->getRenderTarget(0);
+	Framebuffer* framebuffer = getDrawFramebuffer();
+	egl::Image* image = depthStencil ? framebuffer->getDepthStencil() : framebuffer->getRenderTarget(drawbuffer);
 
 	applyScissor(image->getWidth(), image->getHeight());
 
@@ -2723,9 +2723,12 @@ bool Context::applyRenderTarget()
         return error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
     }
 
-	egl::Image *renderTarget = framebuffer->getRenderTarget(0);
-	device->setRenderTarget(renderTarget);
+	for(int i = 0; i < MAX_DRAW_BUFFERS; ++i)
+	{
+		egl::Image *renderTarget = framebuffer->getRenderTarget(i);
+		device->setRenderTarget(i, renderTarget);
 		if(renderTarget) renderTarget->release();
+	}
 
     egl::Image *depthStencil = framebuffer->getDepthStencil();
     device->setDepthStencilSurface(depthStencil);
@@ -3279,7 +3282,7 @@ void Context::readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
         }
     }
 
-    egl::Image *renderTarget = framebuffer->getRenderTarget(0);
+    egl::Image *renderTarget = framebuffer->getReadRenderTarget();
 
     if(!renderTarget)
     {

src/OpenGL/libGLESv2/Context.h

@@ -79,7 +79,7 @@ enum
     MAX_VERTEX_TEXTURE_IMAGE_UNITS = VERTEX_TEXTURE_IMAGE_UNITS,
     MAX_COMBINED_TEXTURE_IMAGE_UNITS = MAX_TEXTURE_IMAGE_UNITS + MAX_VERTEX_TEXTURE_IMAGE_UNITS,
     MAX_FRAGMENT_UNIFORM_VECTORS = FRAGMENT_UNIFORM_VECTORS - 3,    // Reserve space for gl_DepthRange
-    MAX_DRAW_BUFFERS = 1,
+    MAX_DRAW_BUFFERS = RENDERTARGETS,
 	MAX_ELEMENT_INDEX = 0x7FFFFFFF,
 	MAX_ELEMENTS_INDICES = 0x7FFFFFFF,
 	MAX_ELEMENTS_VERTICES = 0x7FFFFFFF,

src/OpenGL/libGLESv2/Device.cpp

@@ -31,8 +31,8 @@ namespace es2
 
 	Device::Device(Context *context) : Renderer(context, OpenGL, true), context(context)
 	{
-		depthStencil = 0;
-		renderTarget = 0;
+		depthStencil = nullptr;
+		for(int i = 0; i < RENDERTARGETS; ++i) { renderTarget[i] = nullptr; }
 
 		setDepthBufferEnable(true);
 		setFillMode(FILL_SOLID);
@@ -119,8 +119,8 @@ namespace es2
 			setClipPlane(i, plane);
 		}
 
-		pixelShader = 0;
-		vertexShader = 0;
+		pixelShader = nullptr;
+		vertexShader = nullptr;
 
 		pixelShaderDirty = true;
 		pixelShaderConstantsFDirty = 0;
@@ -147,13 +147,16 @@ namespace es2
 		if(depthStencil)
 		{
 			depthStencil->release();
-			depthStencil = 0;
+			depthStencil = nullptr;
 		}
 		
-		if(renderTarget)
+		for(int i = 0; i < RENDERTARGETS; ++i)
+		{
+			if(renderTarget[i])
 			{
-			renderTarget->release();
-			renderTarget = 0;
+				renderTarget[i]->release();
+				renderTarget[i] = nullptr;
+			}
 		}
 
 		delete context;
@@ -177,15 +180,16 @@ namespace es2
 
 	void Device::clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask)
 	{
-		if(!renderTarget)
+		for(int i = 0; i < RENDERTARGETS; ++i)
+		{
+			if(renderTarget[i])
 			{
-			return;
-		}
-
 				int x0(0), y0(0), width(0), height(0);
-		getScissoredRegion(renderTarget, x0, y0, width, height);
+				getScissoredRegion(renderTarget[i], x0, y0, width, height);
 
-		renderTarget->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+				renderTarget[i]->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+			}
+		}
 	}
 
 	void Device::clearDepth(float z)
@@ -409,21 +413,21 @@ namespace es2
 		scissorEnable = enable;
 	}
 
-	void Device::setRenderTarget(egl::Image *renderTarget)
+	void Device::setRenderTarget(int index, egl::Image *renderTarget)
 	{
 		if(renderTarget)
 		{
 			renderTarget->addRef();
 		}
 
-		if(this->renderTarget)
+		if(this->renderTarget[index])
 		{
-			this->renderTarget->release();
+			this->renderTarget[index]->release();
 		}
 
-		this->renderTarget = renderTarget;
+		this->renderTarget[index] = renderTarget;
 
-		Renderer::setRenderTarget(0, renderTarget);
+		Renderer::setRenderTarget(index, renderTarget);
 	}
 
 	void Device::setScissorRect(const sw::Rect &rect)
@@ -816,12 +820,15 @@ namespace es2
 			scissor.y0 = viewport.y0;
 			scissor.y1 = viewport.y0 + viewport.height;
 			
-			if(renderTarget)
+			for(int i = 0; i < RENDERTARGETS; ++i)
+			{
+				if(renderTarget[i])
 				{
 					scissor.x0 = max(scissor.x0, 0);
-				scissor.x1 = min(scissor.x1, renderTarget->getWidth());
+					scissor.x1 = min(scissor.x1, renderTarget[i]->getWidth());
 					scissor.y0 = max(scissor.y0, 0);
-				scissor.y1 = min(scissor.y1, renderTarget->getHeight());
+					scissor.y1 = min(scissor.y1, renderTarget[i]->getHeight());
+				}
 			}
 
 			if(depthStencil)

src/OpenGL/libGLESv2/Device.hpp

@@ -62,7 +62,7 @@ namespace es2
 		virtual void setPixelShader(sw::PixelShader *shader);
 		virtual void setPixelShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
 		virtual void setScissorEnable(bool enable);
-		virtual void setRenderTarget(egl::Image *renderTarget);
+		virtual void setRenderTarget(int index, egl::Image *renderTarget);
 		virtual void setScissorRect(const sw::Rect &rect);
 		virtual void setVertexShader(sw::VertexShader *shader);
 		virtual void setVertexShaderConstantF(unsigned int startRegister, const float *constantData, unsigned int count);
@@ -100,7 +100,7 @@ namespace es2
 		float pixelShaderConstantF[FRAGMENT_UNIFORM_VECTORS][4];
 		float vertexShaderConstantF[VERTEX_UNIFORM_VECTORS][4];
 
-		egl::Image *renderTarget;
+		egl::Image *renderTarget[RENDERTARGETS];
 		egl::Image *depthStencil;
 	};
 }

src/Renderer/Context.cpp

@@ -218,10 +218,10 @@ namespace sw
 		localViewer = true;
 		normalizeNormals = false;
 		
-		renderTarget[0] = 0;
-		renderTarget[1] = 0;
-		renderTarget[2] = 0;
-		renderTarget[3] = 0;
+		for(int i = 0; i < RENDERTARGETS; ++i)
+		{
+			renderTarget[i] = 0;
+		}
 		depthStencil = 0;
 
 		stencilEnable = false;

src/Renderer/Context.hpp

@@ -450,7 +450,7 @@ namespace sw
 		int textureTransformCount[8];
 		bool textureTransformProject[8];
 
-		Surface *renderTarget[4];
+		Surface *renderTarget[RENDERTARGETS];
 		Surface *depthStencil;
 
 		// Fog

src/Renderer/PixelProcessor.cpp

@@ -938,7 +938,7 @@ namespace sw
 		                       (context->colorWriteActive(2) << 8) |
 		                       (context->colorWriteActive(3) << 12);
 
-		for(int i = 0; i < 4; i++)
+		for(int i = 0; i < RENDERTARGETS; i++)
 		{
 			state.targetFormat[i] = context->renderTargetInternalFormat(i);
 		}

src/Renderer/PixelProcessor.hpp

@@ -73,7 +73,7 @@ namespace sw
 			BlendOperation blendOperationAlpha        : BITS(BLENDOP_LAST);
 			
 			unsigned int colorWriteMask                       : 16;   // (four times four component bit mask)
-			Format targetFormat[4];
+			Format targetFormat[RENDERTARGETS];
 			bool writeSRGB                                    : 1;
 			unsigned int multiSample                          : 3;
 			unsigned int multiSampleMask                      : 4;

src/Renderer/QuadRasterizer.cpp

@@ -111,11 +111,11 @@ namespace sw
 
 	void QuadRasterizer::rasterize(Registers &r, Int &yMin, Int &yMax)
 	{
-		Pointer<Byte> cBuffer[4];
+		Pointer<Byte> cBuffer[RENDERTARGETS];
 		Pointer<Byte> zBuffer;
 		Pointer<Byte> sBuffer;
 
-		for(int index = 0; index < 4; index++)
+		for(int index = 0; index < RENDERTARGETS; index++)
 		{
 			if(state.colorWriteActive(index))
 			{
@@ -310,7 +310,7 @@ namespace sw
 				}
 			}
 
-			for(int index = 0; index < 4; index++)
+			for(int index = 0; index < RENDERTARGETS; index++)
 			{
 				if(state.colorWriteActive(index))
 				{

src/Renderer/Renderer.cpp

@@ -567,7 +567,7 @@ namespace sw
 
 			// Target
 			{
-				for(int index = 0; index < 4; index++)
+				for(int index = 0; index < RENDERTARGETS; index++)
 				{
 					draw->renderTarget[index] = context->renderTarget[index];
 
@@ -916,7 +916,7 @@ namespace sw
 					draw.queries = 0;
 				}
 
-				for(int i = 0; i < 4; i++)
+				for(int i = 0; i < RENDERTARGETS; i++)
 				{
 					if(draw.renderTarget[i])
 					{
@@ -2052,7 +2052,7 @@ namespace sw
 
 	bool Renderer::isReadWriteTexture(int sampler)
 	{
-		for(int index = 0; index < 4; index++)
+		for(int index = 0; index < RENDERTARGETS; index++)
 		{
 			if(context->renderTarget[index] && context->texture[sampler] == context->renderTarget[index]->getResource())
 			{

src/Renderer/Renderer.hpp

@@ -172,9 +172,9 @@ namespace sw
 		float depthNear;
 		Plane clipPlane[6];
 
-		unsigned int *colorBuffer[4];
-		int colorPitchB[4];
-		int colorSliceB[4];
+		unsigned int *colorBuffer[RENDERTARGETS];
+		int colorPitchB[RENDERTARGETS];
+		int colorSliceB[RENDERTARGETS];
 		float *depthBuffer;
 		int depthPitchB;
 		int depthSliceB;
@@ -215,7 +215,7 @@ namespace sw
 
 		Resource *vertexStream[VERTEX_ATTRIBUTES];
 		Resource *indexBuffer;
-		Surface *renderTarget[4];
+		Surface *renderTarget[RENDERTARGETS];
 		Surface *depthStencil;
 		Resource *texture[TOTAL_IMAGE_UNITS];
 

src/Shader/PixelProgram.cpp

@@ -72,7 +72,13 @@ namespace sw
 			r.enableLeave = Int4(0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);
 		}
 
-		bool out[4][4] = { false };
+		for(int i = 0; i < RENDERTARGETS; i++)
+		{
+			if(state.targetFormat[i] != FORMAT_NULL)
+			{
+				r.oC[i] = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+			}
+		}
 
 		// Create all call site return blocks up front
 		for(size_t i = 0; i < shader->getLength(); i++)
@@ -362,11 +368,22 @@ namespace sw
 						}
 						break;
 					case Shader::PARAMETER_COLOROUT:
-						ASSERT(dst.rel.type == Shader::PARAMETER_VOID);
+						if(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;
+						}
+						else
+						{
+							Int a = relativeAddress(r, dst) + dst.index;
+
+							if(dst.x) pDst.x = r.oC[a].x;
+							if(dst.y) pDst.y = r.oC[a].y;
+							if(dst.z) pDst.z = r.oC[a].z;
+							if(dst.w) pDst.w = r.oC[a].w;
+						}
 						break;
 					case Shader::PARAMETER_PREDICATE:
 						if(dst.x) pDst.x = r.p0.x;
@@ -445,11 +462,22 @@ namespace sw
 					}
 					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; }
+					if(dst.rel.type == Shader::PARAMETER_VOID)
+					{
+						if(dst.x) { r.oC[dst.index].x = d.x; }
+						if(dst.y) { r.oC[dst.index].y = d.y; }
+						if(dst.z) { r.oC[dst.index].z = d.z; }
+						if(dst.w) { r.oC[dst.index].w = d.w; }
+					}
+					else
+					{
+						Int a = relativeAddress(r, dst) + dst.index;
+
+						if(dst.x) { r.oC[a].x = d.x; }
+						if(dst.y) { r.oC[a].y = d.y; }
+						if(dst.z) { r.oC[a].z = d.z; }
+						if(dst.w) { r.oC[a].w = d.w; }
+					}
 					break;
 				case Shader::PARAMETER_PREDICATE:
 					if(dst.x) r.p0.x = d.x;
@@ -471,15 +499,9 @@ namespace sw
 			Nucleus::setInsertBlock(returnBlock);
 		}
 
-		for(int i = 0; i < 4; i++)
+		for(int i = 0; i < RENDERTARGETS; 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);
-			}
+			r.c[i] = r.oC[i];
 		}
 	}
 
@@ -487,7 +509,7 @@ namespace sw
 	{
 		Registers& r = *static_cast<Registers*>(&rBase);
 
-		clampColor(r.oC);
+		clampColor(r.c);
 
 		if(!state.alphaTestActive())
 		{
@@ -498,7 +520,7 @@ namespace sw
 
 		if(state.transparencyAntialiasing == TRANSPARENCY_NONE)
 		{
-			Short4 alpha = RoundShort4(r.oC[0].w * Float4(0x1000));
+			Short4 alpha = RoundShort4(r.c[0].w * Float4(0x1000));
 
 			PixelRoutine::alphaTest(r, aMask, alpha);
 
@@ -509,7 +531,7 @@ namespace sw
 		}
 		else if(state.transparencyAntialiasing == TRANSPARENCY_ALPHA_TO_COVERAGE)
 		{
-			alphaToCoverage(r, cMask, r.oC[0].w);
+			alphaToCoverage(r, cMask, r.c[0].w);
 		}
 		else ASSERT(false);
 
@@ -527,7 +549,7 @@ namespace sw
 	{
 		Registers& r = *static_cast<Registers*>(&rBase);
 
-		for(int index = 0; index < 4; index++)
+		for(int index = 0; index < RENDERTARGETS; index++)
 		{
 			if(!state.colorWriteActive(index))
 			{
@@ -536,14 +558,14 @@ namespace sw
 
 			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);
+				r.c[index].x = linearToSRGB(r.c[index].x);
+				r.c[index].y = linearToSRGB(r.c[index].y);
+				r.c[index].z = linearToSRGB(r.c[index].z);
 			}
 
 			if(index == 0)
 			{
-				fogBlend(r, r.oC[index], fog);
+				fogBlend(r, r.c[index], fog);
 			}
 
 			switch(state.targetFormat[index])
@@ -561,10 +583,10 @@ namespace sw
 					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);
+					color.x = convertFixed16(r.c[index].x, false);
+					color.y = convertFixed16(r.c[index].y, false);
+					color.z = convertFixed16(r.c[index].z, false);
+					color.w = convertFixed16(r.c[index].w, false);
 
 					if(state.multiSampleMask & (1 << q))
 					{
@@ -580,7 +602,7 @@ namespace sw
 				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];
+					Vector4f color = r.c[index];
 
 					if(state.multiSampleMask & (1 << q))
 					{
@@ -647,9 +669,9 @@ namespace sw
 #endif
 	}
 
-	void PixelProgram::clampColor(Vector4f oC[4])
+	void PixelProgram::clampColor(Vector4f oC[RENDERTARGETS])
 	{
-		for(int index = 0; index < 4; index++)
+		for(int index = 0; index < RENDERTARGETS; index++)
 		{
 			if(!state.colorWriteActive(index) && !(index == 0 && state.alphaTestActive()))
 			{
@@ -779,7 +801,16 @@ namespace sw
 		case Shader::PARAMETER_CONSTBOOL:   return reg; // Dummy
 		case Shader::PARAMETER_LOOP:        return reg; // Dummy
 		case Shader::PARAMETER_COLOROUT:
+			if(src.rel.type == Shader::PARAMETER_VOID)   // Not relative
+			{
 				reg = r.oC[i];
+			}
+			else
+			{
+				Int a = relativeAddress(r, src);
+
+				reg = r.oC[i + a];
+			}
 			break;
 		case Shader::PARAMETER_DEPTHOUT:
 			reg.x = r.oDepth;

src/Shader/PixelProgram.hpp

@@ -60,7 +60,8 @@ namespace sw
 			RegisterArray<4096> r;
 
 			// Color outputs
-			Vector4f oC[4];
+			Vector4f c[RENDERTARGETS];
+			RegisterArray<RENDERTARGETS, true> oC;
 
 			// Shader variables
 			Vector4f vPos;
@@ -88,7 +89,7 @@ namespace sw
 		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 clampColor(Vector4f oC[RENDERTARGETS]);
 
 		Int4 enableMask(Registers &r, const Shader::Instruction *instruction);
 

src/Shader/PixelRoutine.cpp

@@ -55,7 +55,7 @@ namespace sw
 		}
 	}
 
-	void PixelRoutine::quad(QuadRasterizer::Registers &rBase, 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[RENDERTARGETS], Pointer<Byte> &zBuffer, Pointer<Byte> &sBuffer, Int cMask[4], Int &x, Int &y)
 	{
 		Registers& r = *static_cast<Registers*>(&rBase);