Blitter clear implementation

src/D3D9/Direct3DDevice9.cpp

@@ -435,19 +435,24 @@ namespace D3D9
 						D3DSURFACE_DESC description;
 						renderTarget[index]->GetDesc(&description);
 
-						float r = (float)(color & 0x00FF0000) / 0x00FF0000;
-						float g = (float)(color & 0x0000FF00) / 0x0000FF00;
-						float b = (float)(color & 0x000000FF) / 0x000000FF;
-						float a = (float)(color & 0xFF000000) / 0xFF000000;
+						float rgba[4];
+						rgba[0] = (float)(color & 0x00FF0000) / 0x00FF0000;
+						rgba[1] = (float)(color & 0x0000FF00) / 0x0000FF00;
+						rgba[2] = (float)(color & 0x000000FF) / 0x000000FF;
+						rgba[3] = (float)(color & 0xFF000000) / 0xFF000000;
 
 						if(renderState[D3DRS_SRGBWRITEENABLE] != FALSE && index == 0 && Capabilities::isSRGBwritable(description.Format))
 						{
-							r = sw::linearToSRGB(r);
-							g = sw::linearToSRGB(g);
-							b = sw::linearToSRGB(b);
+							rgba[0] = sw::linearToSRGB(rgba[0]);
+							rgba[1] = sw::linearToSRGB(rgba[1]);
+							rgba[2] = sw::linearToSRGB(rgba[2]);
 						}
 
-						renderTarget[index]->clearColorBuffer(r, g, b, a, 0xF, rect.x1, rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1);
+						sw::SliceRect sliceRect;
+						if(renderTarget[index]->getClearRect(rect.x1, rect.y1, rect.x2 - rect.x1, rect.y2 - rect.y1, sliceRect))
+						{
+							renderer->clear(rgba, sw::FORMAT_A32B32G32R32F, renderTarget[index], sliceRect, 0xF);
+						}
 					}
 				}
 			}

src/OpenGL/libGL/Device.cpp

@@ -180,7 +180,7 @@ namespace gl
 
 	void Device::clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask)
 	{
-		if(!renderTarget)
+		if(!renderTarget || !rgbaMask)
 		{
 			return;
 		}
@@ -198,7 +198,17 @@ namespace gl
 			if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
 		}
 
-		renderTarget->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+		float rgba[4];
+		rgba[0] = red;
+		rgba[1] = green;
+		rgba[2] = blue;
+		rgba[3] = alpha;
+
+		sw::SliceRect sliceRect;
+		if(renderTarget->getClearRect(x0, y0, width, height, sliceRect))
+		{
+			clear(rgba, FORMAT_A32B32G32R32F, renderTarget, sliceRect, rgbaMask);
+		}
 	}
 
 	void Device::clearDepth(float z)

src/OpenGL/libGLES_CM/Device.cpp

@@ -138,7 +138,7 @@ namespace es1
 
 	void Device::clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask)
 	{
-		if(!renderTarget)
+		if(!renderTarget || !rgbaMask)
 		{
 			return;
 		}
@@ -156,7 +156,17 @@ namespace es1
 			if(height > scissorRect.y1 - scissorRect.y0) height = scissorRect.y1 - scissorRect.y0;
 		}
 
-		renderTarget->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+		float rgba[4];
+		rgba[0] = red;
+		rgba[1] = green;
+		rgba[2] = blue;
+		rgba[3] = alpha;
+
+		sw::SliceRect sliceRect;
+		if(renderTarget->getClearRect(x0, y0, width, height, sliceRect))
+		{
+			clear(rgba, FORMAT_A32B32G32R32F, renderTarget, sliceRect, rgbaMask);
+		}
 	}
 
 	void Device::clearDepth(float z)

src/OpenGL/libGLESv2/Context.cpp

@@ -3359,7 +3359,7 @@ void Context::clear(GLbitfield mask)
 	}
 }
 
-void Context::clearColorBuffer(GLint drawbuffer, const GLint *value)
+void Context::clearColorBuffer(GLint drawbuffer, void *value, sw::Format format)
 {
 	unsigned int rgbaMask = getColorMask();
 	if(device && rgbaMask)
@@ -3367,47 +3367,27 @@ void Context::clearColorBuffer(GLint drawbuffer, const GLint *value)
 		int x0(0), y0(0), width(0), height(0);
 		egl::Image* image = getScissoredImage(drawbuffer, x0, y0, width, height, false);
 
-		float red = clamp01((float)value[0] / 0x7FFFFFFF);
-		float green = clamp01((float)value[1] / 0x7FFFFFFF);
-		float blue = clamp01((float)value[2] / 0x7FFFFFFF);
-		float alpha = clamp01((float)value[3] / 0x7FFFFFFF);
-
-		image->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+		sw::SliceRect sliceRect;
+		if(image->getClearRect(x0, y0, width, height, sliceRect))
+		{
+			device->clear(value, format, image, sliceRect, rgbaMask);
+		}
 	}
 }
 
-void Context::clearColorBuffer(GLint drawbuffer, const GLuint *value)
+void Context::clearColorBuffer(GLint drawbuffer, const GLint *value)
 {
-	unsigned int rgbaMask = getColorMask();
-	if(device && rgbaMask)
-	{
-		int x0(0), y0(0), width(0), height(0);
-		egl::Image* image = getScissoredImage(drawbuffer, x0, y0, width, height, false);
-
-		float red = (float)value[0] / 0xFFFFFFFF;
-		float green = (float)value[1] / 0xFFFFFFFF;
-		float blue = (float)value[2] / 0xFFFFFFFF;
-		float alpha = (float)value[3] / 0xFFFFFFFF;
+	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32I);
+}
 
-		image->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
-	}
+void Context::clearColorBuffer(GLint drawbuffer, const GLuint *value)
+{
+	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32UI);
 }
 
 void Context::clearColorBuffer(GLint drawbuffer, const GLfloat *value)
 {
-	unsigned int rgbaMask = getColorMask();
-	if(device && rgbaMask)
-	{
-		int x0(0), y0(0), width(0), height(0);
-		egl::Image* image = getScissoredImage(drawbuffer, x0, y0, width, height, false);
-
-		float red = clamp01(value[0]);
-		float green = clamp01(value[1]);
-		float blue = clamp01(value[2]);
-		float alpha = clamp01(value[3]);
-
-		image->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
-	}
+	clearColorBuffer(drawbuffer, (void*)value, sw::FORMAT_A32B32G32R32F);
 }
 
 void Context::clearDepthBuffer(GLint drawbuffer, const GLfloat *value)

src/OpenGL/libGLESv2/Context.h

@@ -686,6 +686,7 @@ private:
     void applyTextures();
     void applyTextures(sw::SamplerType type);
 	void applyTexture(sw::SamplerType type, int sampler, Texture *texture);
+	void clearColorBuffer(GLint drawbuffer, void *value, sw::Format format);
 
     void detachBuffer(GLuint buffer);
     void detachTexture(GLuint texture);

src/OpenGL/libGLESv2/Device.cpp

@@ -180,6 +180,17 @@ namespace es2
 
 	void Device::clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask)
 	{
+		if(!rgbaMask)
+		{
+			return;
+		}
+
+		float rgba[4];
+		rgba[0] = red;
+		rgba[1] = green;
+		rgba[2] = blue;
+		rgba[3] = alpha;
+
 		for(int i = 0; i < RENDERTARGETS; ++i)
 		{
 			if(renderTarget[i])
@@ -187,7 +198,11 @@ namespace es2
 				int x0(0), y0(0), width(0), height(0);
 				getScissoredRegion(renderTarget[i], x0, y0, width, height);
 
-				renderTarget[i]->clearColorBuffer(red, green, blue, alpha, rgbaMask, x0, y0, width, height);
+				sw::SliceRect sliceRect;
+				if(renderTarget[i]->getClearRect(x0, y0, width, height, sliceRect))
+				{
+					clear(rgba, FORMAT_A32B32G32R32F, renderTarget[i], sliceRect, rgbaMask);
+				}
 			}
 		}
 	}

src/Reactor/Nucleus.cpp

@@ -1700,6 +1700,13 @@ namespace sw
 		storeValue(integer);
 	}
 
+	UShort::UShort(RValue<Int> cast)
+	{
+		Value *integer = Nucleus::createTrunc(cast.value, UShort::getType());
+
+		storeValue(integer);
+	}
+
 	UShort::UShort()
 	{
 	}

src/Reactor/Nucleus.hpp

@@ -570,6 +570,7 @@ namespace sw
 		explicit UShort(llvm::Argument *argument);
 
 		explicit UShort(RValue<UInt> cast);
+		explicit UShort(RValue<Int> cast);
 
 		UShort();
 		UShort(unsigned short x);

src/Renderer/Blitter.hpp

@@ -22,6 +22,18 @@ namespace sw
 {
 	class Blitter
 	{
+		enum Options : unsigned char
+		{
+			FILTER_POINT = 0x00,
+			WRITE_RED = 0x01,
+			WRITE_GREEN = 0x02,
+			WRITE_BLUE = 0x04,
+			WRITE_ALPHA = 0x08,
+			WRITE_RGBA = WRITE_RED | WRITE_GREEN | WRITE_BLUE | WRITE_ALPHA,
+			FILTER_LINEAR = 0x10,
+			CLEAR_OPERATION = 0x20
+		};
+
 		struct BlitState
 		{
 			bool operator==(const BlitState &state) const
@@ -31,7 +43,7 @@ namespace sw
 
 			Format sourceFormat;
 			Format destFormat;
-			bool filter;
+			Blitter::Options options;
 		};
 
 		struct BlitData
@@ -60,16 +72,19 @@ namespace sw
 
 		virtual ~Blitter();
 
+		void clear(void* pixel, sw::Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask);
 		void blit(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, bool filter);
 		void blit3D(Surface *source, Surface *dest);
 
 	private:
 		bool read(Float4 &color, Pointer<Byte> element, Format format);
-		bool write(Float4 &color, Pointer<Byte> element, Format format);
+		bool write(Float4 &color, Pointer<Byte> element, Format format, const Blitter::Options& options);
 		bool read(Int4 &color, Pointer<Byte> element, Format format);
-		bool write(Int4 &color, Pointer<Byte> element, Format format);
+		bool write(Int4 &color, Pointer<Byte> element, Format format, const Blitter::Options& options);
 		static bool GetScale(float4& scale, Format format);
-		bool blitReactor(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, bool filter);
+		static bool ApplyScaleAndClamp(Float4& value, const BlitState& state);
+		void blit(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, const Blitter::Options& options);
+		bool blitReactor(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, const Blitter::Options& options);
 		Routine *generate(BlitState &state);
 
 		RoutineCache<BlitState> *blitCache;

src/Renderer/Renderer.cpp

@@ -189,6 +189,11 @@ namespace sw
 		delete swiftConfig;
 	}
 
+	void Renderer::clear(void *pixel, Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask)
+	{
+		blitter.clear(pixel, format, dest, dRect, rgbaMask);
+	}
+
 	void Renderer::blit(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, bool filter)
 	{
 		blitter.blit(source, sRect, dest, dRect, filter);

src/Renderer/Renderer.hpp

@@ -303,6 +303,7 @@ namespace sw
 
 		virtual ~Renderer();
 
+		virtual void clear(void* pixel, Format format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask);
 		virtual void blit(Surface *source, const SliceRect &sRect, Surface *dest, const SliceRect &dRect, bool filter);
 		virtual void blit3D(Surface *source, Surface *dest);
 		virtual void draw(DrawType drawType, unsigned int indexOffset, unsigned int count, bool update = true);

src/Renderer/Surface.hpp

@@ -282,7 +282,8 @@ namespace sw
 		inline int getMultiSampleCount() const;
 		inline int getSuperSampleCount() const;
 
-		void clearColorBuffer(float red, float green, float blue, float alpha, unsigned int rgbaMask, int x0, int y0, int width, int height);
+		bool isEntire(const SliceRect& rect) const;
+		bool getClearRect(int x0, int y0, int width, int height, SliceRect& rect) const;
 		void clearDepthBuffer(float depth, int x0, int y0, int width, int height);
 		void clearStencilBuffer(unsigned char stencil, unsigned char mask, int x0, int y0, int width, int height);
 		void fill(const Color<float> &color, int x0, int y0, int width, int height);