diff --git a/Bizware/BizHawk.Bizware.BizwareGL.OpenTK/IGL_TK.cs b/Bizware/BizHawk.Bizware.BizwareGL.OpenTK/IGL_TK.cs
index 277ee54604..ba0741eee8 100644
--- a/Bizware/BizHawk.Bizware.BizwareGL.OpenTK/IGL_TK.cs
+++ b/Bizware/BizHawk.Bizware.BizwareGL.OpenTK/IGL_TK.cs
@@ -55,7 +55,6 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 
 			//misc initialization
 			CreateRenderStates();
-			GL.Enable(EnableCap.Texture2D);
 			PurgeStateCache();
 		}
 
@@ -279,6 +278,11 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 			GL.UseProgram(pipeline.Id.ToInt32());
 		}
 
+		public void SetPipelineUniform(PipelineUniform uniform, bool value)
+		{
+			GL.Uniform1(uniform.Id.ToInt32(), value ? 1 : 0); 
+		}
+
 		public unsafe void SetPipelineUniformMatrix(PipelineUniform uniform, Matrix4 mat, bool transpose)
 		{
 			GL.UniformMatrix4(uniform.Id.ToInt32(), 1, transpose, (float*)&mat);
@@ -305,6 +309,12 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 			GL.Uniform1(uniform.Id.ToInt32(), value);
 		}
 
+		public unsafe void SetPipelineUniform(PipelineUniform uniform, Vector4[] values)
+		{
+			fixed (Vector4* pValues = &values[0])
+				GL.Uniform4(uniform.Id.ToInt32(), values.Length, (float*)pValues);
+		}
+
 		public void SetPipelineUniformSampler(PipelineUniform uniform, IntPtr texHandle)
 		{
 			//set the sampler index into the uniform first
@@ -511,12 +521,16 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 			bool success = true;
 			ErrorCode errcode;
 
+			errcode = GL.GetError();
+			if (errcode != ErrorCode.NoError) 
+				throw new InvalidOperationException("Error compiling shader (from previous operation) " + errcode);
+
 			GL.ShaderSource(sid, source);
 			
 			errcode = GL.GetError();
 			if (errcode != ErrorCode.NoError)
 				if (required)
-					throw new InvalidOperationException("Error compiling shader (ShaderSource)" + errcode);
+					throw new InvalidOperationException("Error compiling shader (ShaderSource) " + errcode);
 				else success = false;
 
 			GL.CompileShader(sid);
@@ -526,7 +540,7 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 
 			if (errcode != ErrorCode.NoError)
 				if (required)
-					throw new InvalidOperationException("Error compiling shader (CompileShader)" + errcode + "\r\n\r\n" + resultLog);
+					throw new InvalidOperationException("Error compiling shader (CompileShader) " + errcode + "\r\n\r\n" + resultLog);
 				else success = false;
 
 			int n;
@@ -534,7 +548,7 @@ namespace BizHawk.Bizware.BizwareGL.Drivers.OpenTK
 
 			if (n == 0)
 				if (required)
-					throw new InvalidOperationException("Error compiling shader (CompileShader)" + "\r\n\r\n" + resultLog);
+					throw new InvalidOperationException("Error compiling shader (CompileShader )" + "\r\n\r\n" + resultLog);
 				else success = false;
 
 			return success;
diff --git a/Bizware/BizHawk.Bizware.BizwareGL/GuiRenderer.cs b/Bizware/BizHawk.Bizware.BizwareGL/GuiRenderer.cs
index 607df40c4f..09edb20797 100644
--- a/Bizware/BizHawk.Bizware.BizwareGL/GuiRenderer.cs
+++ b/Bizware/BizHawk.Bizware.BizwareGL/GuiRenderer.cs
@@ -1,6 +1,8 @@
 //http://stackoverflow.com/questions/6893302/decode-rgb-value-to-single-float-without-bit-shift-in-glsl
 
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using sd=System.Drawing;
 
 using OpenTK;
@@ -21,8 +23,9 @@ namespace BizHawk.Bizware.BizwareGL
 			Owner = owner;
 
 			VertexLayout = owner.CreateVertexLayout();
-			VertexLayout.DefineVertexAttribute("aPosition", 0, 2, VertexAttribPointerType.Float, false, 16, 0);
-			VertexLayout.DefineVertexAttribute("aTexcoord", 1, 2, VertexAttribPointerType.Float, false, 16, 8);
+			VertexLayout.DefineVertexAttribute("aPosition", 0, 2, VertexAttribPointerType.Float, false, 32, 0);
+			VertexLayout.DefineVertexAttribute("aTexcoord", 1, 2, VertexAttribPointerType.Float, false, 32, 8);
+			VertexLayout.DefineVertexAttribute("aColor", 2, 4, VertexAttribPointerType.Float, false, 32, 16);
 			VertexLayout.Close();
 
 			_Projection = new MatrixStack();
@@ -33,6 +36,30 @@ namespace BizHawk.Bizware.BizwareGL
 			CurrPipeline = DefaultPipeline = Owner.CreatePipeline(VertexLayout, vs, ps, true);
 		}
 
+		OpenTK.Graphics.Color4[] CornerColors = new OpenTK.Graphics.Color4[4] {
+			new OpenTK.Graphics.Color4(1.0f,1.0f,1.0f,1.0f),new OpenTK.Graphics.Color4(1.0f,1.0f,1.0f,1.0f),new OpenTK.Graphics.Color4(1.0f,1.0f,1.0f,1.0f),new OpenTK.Graphics.Color4(1.0f,1.0f,1.0f,1.0f)
+		};
+
+		/// <summary>
+		/// Sets the specified corner color (for the gradient effect)
+		/// </summary>
+		public void SetCornerColor(int which, OpenTK.Graphics.Color4 color)
+		{
+			Flush(); //dont really need to flush with current implementation. we might as well roll modulate color into it too.
+			CornerColors[which] = color;
+		}
+
+		/// <summary>
+		/// Sets all four corner colors at once
+		/// </summary>
+		public void SetCornerColors(OpenTK.Graphics.Color4[] colors)
+		{
+			Flush(); //dont really need to flush with current implementation. we might as well roll modulate color into it too.
+			if (colors.Length != 4) throw new ArgumentException("array must be size 4", "colors");
+			for (int i = 0; i < 4; i++)
+				CornerColors[i] = colors[i];
+		}
+
 		public void Dispose()
 		{
 			VertexLayout.Dispose();
@@ -52,6 +79,10 @@ namespace BizHawk.Bizware.BizwareGL
 
 			Flush();
 			CurrPipeline = pipeline;
+
+			//clobber state cache
+			sTexture = null;
+			//save the modulate color? user beware, I guess, for now.
 		}
 
 		/// <summary>
@@ -135,6 +166,7 @@ namespace BizHawk.Bizware.BizwareGL
 
 			//clear state cache
 			sTexture = null;
+			CurrPipeline["uSamplerEnable"].Set(false);
 			Modelview.Clear();
 			Projection.Clear();
 			SetModulateColorWhite();
@@ -159,6 +191,12 @@ namespace BizHawk.Bizware.BizwareGL
 			IsActive = false;
 		}
 
+		public void RectFill(float x, float y, float w, float h)
+		{
+			PrepDrawSubrectInternal(null);
+			EmitRectangleInternal(x, y, w, h, 0, 0, 0, 0);
+		}
+
 		/// <summary>
 		/// Draws a subrectangle from the provided texture. For advanced users only
 		/// </summary>
@@ -221,27 +259,16 @@ namespace BizHawk.Bizware.BizwareGL
 			if(fy) { v0 = art.v1; v1 = art.v0; }
 			else { v0 = art.v0; v1 = art.v1; }
 
-			float[] data = new float[16] {
-			  x,y, u0,v0, 
-			  x+art.Width,y, u1,v0,
-			  x,y+art.Height, u0,v1,
-			  x+art.Width,y+art.Height, u1,v1
+			float[] data = new float[32] {
+			  x,y, u0,v0, CornerColors[0].R, CornerColors[0].G, CornerColors[0].B, CornerColors[0].A,
+			  x+art.Width,y, u1,v0, CornerColors[1].R, CornerColors[1].G, CornerColors[1].B, CornerColors[1].A,
+			  x,y+art.Height, u0,v1, CornerColors[2].R, CornerColors[2].G, CornerColors[2].B, CornerColors[2].A,
+			  x+art.Width,y+art.Height, u1,v1,  CornerColors[3].R, CornerColors[3].G, CornerColors[3].B, CornerColors[3].A,
 			};
 
 			Texture2d tex = art.BaseTexture;
-			if(sTexture != tex)
-				CurrPipeline["uSampler0"].Set(sTexture = tex);
-
-			if (_Projection.IsDirty)
-			{
-				CurrPipeline["um44Projection"].Set(ref _Projection.Top);
-				_Projection.IsDirty = false;
-			}
-			if (_Modelview.IsDirty)
-			{
-				CurrPipeline["um44Modelview"].Set(ref _Modelview.Top);
-				_Modelview.IsDirty = false;
-			}
+			
+			PrepDrawSubrectInternal(tex);
 
 			fixed (float* pData = &data[0])
 			{
@@ -250,34 +277,21 @@ namespace BizHawk.Bizware.BizwareGL
 			}
 		}
 
-		unsafe void DrawSubrectInternal(Texture2d tex, float x, float y, float w, float h, float u0, float v0, float u1, float v1)
+		unsafe void PrepDrawSubrectInternal(Texture2d tex)
 		{
-			//float[] data = new float[16] {
-			//  x,y, u0,v0, 
-			//  x+w,y, u1,v0,
-			//  x,y+h, u0,v1,
-			//  x+w,y+h, u1,v1
-			//};
-			float* pData = stackalloc float[16];
-			pData[0] = x;
-			pData[1] = y;
-			pData[2] = u0;
-			pData[3] = v0;
-			pData[4] = x + w;
-			pData[5] = y;
-			pData[6] = u1;
-			pData[7] = v0;
-			pData[8] = x;
-			pData[9] = y + h;
-			pData[10] = u0;
-			pData[11] = v1;
-			pData[12] = x + w;
-			pData[13] = y + h;
-			pData[14] = u1;
-			pData[15] = v1;
-
 			if (sTexture != tex)
-				CurrPipeline["uSampler0"].Set(sTexture = tex);
+			{
+				sTexture = tex;
+				CurrPipeline["uSampler0"].Set(tex);
+				if (sTexture == null)
+				{
+					CurrPipeline["uSamplerEnable"].Set(false);
+				}
+				else
+				{
+					CurrPipeline["uSamplerEnable"].Set(true);
+				}
+			}
 
 			if (_Projection.IsDirty)
 			{
@@ -289,10 +303,53 @@ namespace BizHawk.Bizware.BizwareGL
 				CurrPipeline["um44Modelview"].Set(ref _Modelview.Top);
 				_Modelview.IsDirty = false;
 			}
+		}
+
+		unsafe void EmitRectangleInternal(float x, float y, float w, float h, float u0, float v0, float u1, float v1)
+		{
+			float* pData = stackalloc float[32];
+			pData[0] = x;
+			pData[1] = y;
+			pData[2] = u0;
+			pData[3] = v0;
+			pData[4] = CornerColors[0].R;
+			pData[5] = CornerColors[0].G;
+			pData[6] = CornerColors[0].B;
+			pData[7] = CornerColors[0].A;
+			pData[8] = x + w;
+			pData[9] = y;
+			pData[10] = u1;
+			pData[11] = v0;
+			pData[12] = CornerColors[1].R;
+			pData[13] = CornerColors[1].G;
+			pData[14] = CornerColors[1].B;
+			pData[15] = CornerColors[1].A;
+			pData[16] = x;
+			pData[17] = y + h;
+			pData[18] = u0;
+			pData[19] = v1;
+			pData[20] = CornerColors[2].R;
+			pData[21] = CornerColors[2].G;
+			pData[22] = CornerColors[2].B;
+			pData[23] = CornerColors[2].A;
+			pData[24] = x + w;
+			pData[25] = y + h;
+			pData[26] = u1;
+			pData[27] = v1;
+			pData[28] = CornerColors[3].R;
+			pData[29] = CornerColors[3].G;
+			pData[30] = CornerColors[3].B;
+			pData[31] = CornerColors[3].A;
 
 			Owner.BindArrayData(pData);
 			Owner.DrawArrays(PrimitiveType.TriangleStrip, 0, 4);
 		}
+
+		unsafe void DrawSubrectInternal(Texture2d tex, float x, float y, float w, float h, float u0, float v0, float u1, float v1)
+		{
+			PrepDrawSubrectInternal(tex);
+			EmitRectangleInternal(x, y, w, h, u0, v0, u1, v1);
+		}
 		
 		public bool IsActive { get; private set; }
 		public IGL Owner { get; private set; }
@@ -306,30 +363,35 @@ namespace BizHawk.Bizware.BizwareGL
 		public readonly string DefaultVertexShader = @"
 #version 110 //opengl 2.0 ~ 2004
 uniform mat4 um44Modelview, um44Projection;
+uniform vec4 uModulateColor;
 
 attribute vec2 aPosition;
 attribute vec2 aTexcoord;
+attribute vec4 aColor;
 
 varying vec2 vTexcoord0;
+varying vec4 vCornerColor;
 
 void main()
 {
-    vec4 temp = vec4(aPosition,0,1);
-		gl_Position = um44Projection * (um44Modelview * temp);
-    vTexcoord0 = aTexcoord;
+	vec4 temp = vec4(aPosition,0,1);
+	gl_Position = um44Projection * (um44Modelview * temp);
+	vTexcoord0 = aTexcoord;
+	vCornerColor = aColor * uModulateColor;
 }";
 
 		public readonly string DefaultPixelShader = @"
 #version 110 //opengl 2.0 ~ 2004
+uniform bool uSamplerEnable;
 uniform sampler2D uSampler0;
-uniform vec4 uModulateColor;
 
 varying vec2 vTexcoord0;
+varying vec4 vCornerColor;
 
 void main()
 {
-	vec4 temp = texture2D(uSampler0,vTexcoord0);
-	temp *= uModulateColor;
+	vec4 temp = vCornerColor;
+	if(uSamplerEnable) temp *= texture2D(uSampler0,vTexcoord0);
 	gl_FragColor = temp;
 }";
 
diff --git a/Bizware/BizHawk.Bizware.BizwareGL/IGL.cs b/Bizware/BizHawk.Bizware.BizwareGL/IGL.cs
index f091b55ff6..b4946be35b 100644
--- a/Bizware/BizHawk.Bizware.BizwareGL/IGL.cs
+++ b/Bizware/BizHawk.Bizware.BizwareGL/IGL.cs
@@ -96,6 +96,16 @@ namespace BizHawk.Bizware.BizwareGL
 		/// </summary>
 		void SetPipelineUniform(PipelineUniform uniform, float value);
 
+		/// <summary>
+		/// sets uniform values
+		/// </summary>
+		void SetPipelineUniform(PipelineUniform uniform, Vector4[] values);
+
+		/// <summary>
+		/// sets a uniform value
+		/// </summary>
+		void SetPipelineUniform(PipelineUniform uniform, bool value);
+
 		/// <summary>
 		/// Binds array data for use with the currently-bound VertexLayout
 		/// </summary>
diff --git a/Bizware/BizHawk.Bizware.BizwareGL/PipelineUniform.cs b/Bizware/BizHawk.Bizware.BizwareGL/PipelineUniform.cs
index 4c392591d2..4a2f57584c 100644
--- a/Bizware/BizHawk.Bizware.BizwareGL/PipelineUniform.cs
+++ b/Bizware/BizHawk.Bizware.BizwareGL/PipelineUniform.cs
@@ -38,14 +38,28 @@ namespace BizHawk.Bizware.BizwareGL
 			Owner.Owner.SetPipelineUniform(this, f);
 		}
 
+		public void Set(Vector4[] vecs)
+		{
+			Owner.Owner.SetPipelineUniform(this, vecs);
+		}
+
 		public void Set(ref Matrix4 mat, bool transpose = false)
 		{
 			Owner.Owner.SetPipelineUniformMatrix(this, ref mat, transpose);
 		}
 
+		public void Set(bool value)
+		{
+			Owner.Owner.SetPipelineUniform(this, value);
+		}
+
 		public void Set(Texture2d tex)
 		{
-			Owner.Owner.SetPipelineUniformSampler(this, tex.Id);
+			IntPtr handle;
+			if (tex == null)
+				handle = Owner.Owner.GetEmptyHandle();
+			else handle = tex.Id;
+			Owner.Owner.SetPipelineUniformSampler(this, handle);
 		}
 	}
 }
\ No newline at end of file
diff --git a/Bizware/BizHawk.Bizware.Test/BizHawk.Bizware.Test.csproj b/Bizware/BizHawk.Bizware.Test/BizHawk.Bizware.Test.csproj
index 42b71c21ab..4252cdd5ea 100644
--- a/Bizware/BizHawk.Bizware.Test/BizHawk.Bizware.Test.csproj
+++ b/Bizware/BizHawk.Bizware.Test/BizHawk.Bizware.Test.csproj
@@ -89,6 +89,10 @@
   <ItemGroup>
     <EmbeddedResource Include="TestImages\smile.png" />
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="TestImages\4xSoft.cg" />
+    <EmbeddedResource Include="TestImages\4xSoft.glsl" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Bizware/BizHawk.Bizware.Test/Program.cs b/Bizware/BizHawk.Bizware.Test/Program.cs
index c21457293e..4e62cb4718 100644
--- a/Bizware/BizHawk.Bizware.Test/Program.cs
+++ b/Bizware/BizHawk.Bizware.Test/Program.cs
@@ -64,7 +64,9 @@ namespace BizHawk.Bizware.Test
 			rt2.Bind();
 			igl.SetClearColor(Color.CornflowerBlue);
 			igl.Clear(ClearBufferMask.ColorBufferBit);
-			RetroShader shader = new RetroShader(igl, System.IO.File.ReadAllText(@"B:\svn\bizhawk8\trunk\Bizware\4xSoft.glsl"));
+			RetroShader shader;
+			using (var stream = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.4xSoft.glsl"))
+				shader = new RetroShader(igl, new System.IO.StreamReader(stream).ReadToEnd());
 			igl.SetBlendState(igl.BlendNone);
 			shader.Run(rt.Texture2d, new Size(60, 60), new Size(240, 240), true);
 
@@ -95,13 +97,18 @@ namespace BizHawk.Bizware.Test
 
 					gr.Begin(c.ClientSize.Width, c.ClientSize.Height);
 
+					gr.SetModulateColor(Color.Green);
+					gr.RectFill(250, 0, 16, 16);
+
 					gr.SetBlendState(igl.BlendNone);
 					gr.Draw(rt.Texture2d, 0, 20);
 					gr.SetBlendState(igl.BlendNormal);
 
 					sr.RenderString(gr, 0, 0, "?? fps");
 					gr.SetModulateColor(Color.FromArgb(255, 255, 255, 255));
+					gr.SetCornerColor(0, OpenTK.Graphics.Color4.Red);
 					gr.Draw(rt2.Texture2d, 0, 0);
+					gr.SetCornerColor(0, OpenTK.Graphics.Color4.White);
 					gr.SetModulateColorWhite();
 					gr.Modelview.Translate((float)Math.Sin(wobble / 360.0f) * 50, 0);
 					gr.Modelview.Translate(100, 100);
@@ -115,6 +122,7 @@ namespace BizHawk.Bizware.Test
 					gr.Modelview.Pop();
 					gr.SetBlendState(igl.BlendNormal);
 					gr.Draw(smile);
+
 					gr.End();
 
 
diff --git a/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.cg b/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.cg
new file mode 100644
index 0000000000..d55b3c6423
--- /dev/null
+++ b/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.cg
@@ -0,0 +1,105 @@
+/*
+
+   Copyright (C) 2007 guest(r) - guest.r@gmail.com
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; either version 2
+   of the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+ */
+
+struct tex_coords
+{
+   float4 t1;
+   float4 t2;
+   float4 t3;
+   float4 t4;
+   float4 t5;
+   float4 t6;
+};
+
+struct input
+{
+   float2 video_size;
+   float2 texture_size;
+   float2 output_size;
+};
+
+void main_vertex
+(
+   float4 position	: POSITION,
+   out float4 oPosition : POSITION,
+
+   uniform float4x4 modelViewProj,
+
+   float4 color	: COLOR,
+   out float4 oColor    : COLOR,
+
+   float2 tex : TEXCOORD,
+   out float2 oTex : TEXCOORD,
+
+   uniform input IN,
+   out tex_coords coords
+)
+{
+   oPosition = mul(modelViewProj, position);
+   oColor = color;
+   oTex = tex;
+
+   float2 ps = 0.5 / IN.texture_size;
+   float dx = ps.x;
+   float dy = ps.y;
+   float sx = ps.x * 0.5;
+   float sy = ps.y * 0.5;
+
+   coords = tex_coords (
+      float4(tex, tex) + float4(-dx, -dy, dx, -dy), // outer diag. texels
+      float4(tex, tex) + float4(dx, dy, -dx, dy),
+      float4(tex, tex) + float4(-sx, -sy, sx, -sy), // inner diag. texels
+      float4(tex, tex) + float4(sx, sy, -sx, sy),
+      float4(tex, tex) + float4(-dx, 0, dx, 0), // inner hor/vert texels
+      float4(tex, tex) + float4(0, -dy, 0, dy)
+   );
+}
+
+float4 main_fragment (float2 tex : TEXCOORD, in tex_coords co, uniform input IN, uniform sampler2D s0 : TEXUNIT0) : COLOR
+{
+   float3 dt = float3(1.0, 1.0, 1.0);
+
+   float3 c11 = tex2D(s0, tex).xyz;
+   float3 c00 = tex2D(s0, co.t1.xy).xyz;
+   float3 c20 = tex2D(s0, co.t1.zw).xyz;
+   float3 c22 = tex2D(s0, co.t2.xy).xyz;
+   float3 c02 = tex2D(s0, co.t2.zw).xyz;
+   float3 s00 = tex2D(s0, co.t3.xy).xyz;
+   float3 s20 = tex2D(s0, co.t3.zw).xyz;
+   float3 s22 = tex2D(s0, co.t4.xy).xyz;
+   float3 s02 = tex2D(s0, co.t4.zw).xyz;
+   float3 c01 = tex2D(s0, co.t5.xy).xyz;
+   float3 c21 = tex2D(s0, co.t5.zw).xyz;
+   float3 c10 = tex2D(s0, co.t6.xy).xyz;
+   float3 c12 = tex2D(s0, co.t6.zw).xyz;
+
+   float d1 = dot(abs(c00 - c22), dt) + 0.0001;
+   float d2 = dot(abs(c20 - c02), dt) + 0.0001;
+   float hl = dot(abs(c01 - c21), dt) + 0.0001;
+   float vl = dot(abs(c10 - c12), dt) + 0.0001;
+   float m1 = dot(abs(c00 - c22), dt) + 0.001;
+   float m2 = dot(abs(c02 - c20), dt) + 0.001;
+
+   float3 t1 =(hl * (c10 + c12) + vl * (c01 + c21) + (hl + vl) * c11) / (3.0 * (hl + vl));
+   float3 t2 =(d1 * (c20 + c02) + d2 * (c00 + c22) + (d1 + d2) * c11) / (3.0 * (d1 + d2));
+
+   return float4(0.25 * (t1 + t2 + (m2 * (s00 + s22) + m1 * (s02 + s20)) / (m1 + m2)), 1.0);
+}
+
diff --git a/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.glsl b/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.glsl
new file mode 100644
index 0000000000..e65d73c95d
--- /dev/null
+++ b/Bizware/BizHawk.Bizware.Test/TestImages/4xSoft.glsl
@@ -0,0 +1,424 @@
+// GLSL shader autogenerated by cg2glsl.py.
+#if defined(VERTEX)
+
+#if __VERSION__ >= 130
+#define COMPAT_VARYING out
+#define COMPAT_ATTRIBUTE in
+#define COMPAT_TEXTURE texture
+#else
+#define COMPAT_VARYING varying 
+#define COMPAT_ATTRIBUTE attribute 
+#define COMPAT_TEXTURE texture2D
+#endif
+
+#ifdef GL_ES
+#define COMPAT_PRECISION mediump
+#else
+#define COMPAT_PRECISION
+#endif
+COMPAT_VARYING     vec4 VARt6;
+
+COMPAT_VARYING     vec4 VARt5;
+
+COMPAT_VARYING     vec4 VARt4;
+
+COMPAT_VARYING     vec4 VARt3;
+
+COMPAT_VARYING     vec4 VARt2;
+
+COMPAT_VARYING     vec4 VARt1;
+
+
+
+
+
+struct tex_coords {
+
+    vec4 VARt1;
+
+    vec4 VARt2;
+
+    vec4 VARt3;
+
+    vec4 VARt4;
+
+    vec4 VARt5;
+
+    vec4 VARt6;
+
+};
+
+
+
+struct input_dummy {
+
+    vec2 _video_size;
+
+    vec2 _texture_size;
+
+    vec2 _output_dummy_size;
+
+};
+
+
+
+vec4 _oPosition1;
+
+tex_coords _coords1;
+
+
+
+input_dummy _IN1;
+
+vec4 _r0019;
+
+COMPAT_ATTRIBUTE vec4 VertexCoord;
+
+COMPAT_ATTRIBUTE vec4 COLOR;
+
+COMPAT_VARYING vec4 COL0;
+
+COMPAT_ATTRIBUTE vec4 TexCoord;
+
+COMPAT_VARYING vec4 TEX0;
+
+
+
+ 
+uniform mat4 MVPMatrix;
+uniform int FrameDirection;
+uniform int FrameCount;
+uniform COMPAT_PRECISION vec2 OutputSize;
+uniform COMPAT_PRECISION vec2 TextureSize;
+uniform COMPAT_PRECISION vec2 InputSize;
+void main()
+
+{
+
+
+
+    vec4 _oColor;
+
+    vec2 _oTex;
+
+    vec2 _ps;
+
+    float _sx;
+
+    float _sy;
+
+    tex_coords _TMP15;
+
+
+
+    _r0019 = VertexCoord.x*MVPMatrix[0];
+
+    _r0019 = _r0019 + VertexCoord.y*MVPMatrix[1];
+
+    _r0019 = _r0019 + VertexCoord.z*MVPMatrix[2];
+
+    _r0019 = _r0019 + VertexCoord.w*MVPMatrix[3];
+
+    _oPosition1 = _r0019;
+
+    _oColor = COLOR;
+
+    _oTex = TexCoord.xy;
+
+    _ps = 5.00000000E-001/TextureSize;
+
+    _sx = _ps.x*5.00000000E-001;
+
+    _sy = _ps.y*5.00000000E-001;
+
+    _TMP15.VARt1 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(-_ps.x, -_ps.y, _ps.x, -_ps.y);
+
+    _TMP15.VARt2 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(_ps.x, _ps.y, -_ps.x, _ps.y);
+
+    _TMP15.VARt3 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(-_sx, -_sy, _sx, -_sy);
+
+    _TMP15.VARt4 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(_sx, _sy, -_sx, _sy);
+
+    _TMP15.VARt5 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(-_ps.x, 0.00000000E+000, _ps.x, 0.00000000E+000);
+
+    _TMP15.VARt6 = vec4(TexCoord.x, TexCoord.y, TexCoord.x, TexCoord.y) + vec4(0.00000000E+000, -_ps.y, 0.00000000E+000, _ps.y);
+
+    VARt1 = _TMP15.VARt1;
+
+    VARt2 = _TMP15.VARt2;
+
+    VARt3 = _TMP15.VARt3;
+
+    VARt4 = _TMP15.VARt4;
+
+    VARt5 = _TMP15.VARt5;
+
+    VARt6 = _TMP15.VARt6;
+
+    gl_Position = _r0019;
+
+    COL0 = COLOR;
+
+    TEX0.xy = TexCoord.xy;
+
+} 
+#elif defined(FRAGMENT)
+
+#if __VERSION__ >= 130
+#define COMPAT_VARYING in
+#define COMPAT_TEXTURE texture
+out vec4 FragColor;
+#else
+#define COMPAT_VARYING varying
+#define FragColor gl_FragColor
+#define COMPAT_TEXTURE texture2D
+#endif
+
+#ifdef GL_ES
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+#define COMPAT_PRECISION mediump
+#else
+#define COMPAT_PRECISION
+#endif
+COMPAT_VARYING     vec4 VARt6;
+
+COMPAT_VARYING     vec4 VARt5;
+
+COMPAT_VARYING     vec4 VARt4;
+
+COMPAT_VARYING     vec4 VARt3;
+
+COMPAT_VARYING     vec4 VARt2;
+
+COMPAT_VARYING     vec4 VARt1;
+
+
+
+
+
+struct tex_coords {
+
+    vec4 VARt1;
+
+    vec4 VARt2;
+
+    vec4 VARt3;
+
+    vec4 VARt4;
+
+    vec4 VARt5;
+
+    vec4 VARt6;
+
+};
+
+
+
+struct input_dummy {
+
+    vec2 _video_size;
+
+    vec2 _texture_size;
+
+    vec2 _output_dummy_size;
+
+};
+
+
+
+vec4 _ret_0;
+
+float _TMP24;
+
+vec3 _TMP23;
+
+float _TMP22;
+
+vec3 _TMP21;
+
+float _TMP20;
+
+vec3 _TMP19;
+
+float _TMP18;
+
+vec3 _TMP17;
+
+float _TMP16;
+
+vec3 _TMP15;
+
+float _TMP14;
+
+vec3 _TMP13;
+
+vec4 _TMP12;
+
+vec4 _TMP11;
+
+vec4 _TMP10;
+
+vec4 _TMP9;
+
+vec4 _TMP8;
+
+vec4 _TMP7;
+
+vec4 _TMP6;
+
+vec4 _TMP5;
+
+vec4 _TMP4;
+
+vec4 _TMP3;
+
+vec4 _TMP2;
+
+vec4 _TMP1;
+
+vec4 _TMP0;
+
+tex_coords _co1;
+
+uniform sampler2D Texture;
+
+vec3 _a0056;
+
+vec3 _a0060;
+
+vec3 _a0064;
+
+vec3 _a0068;
+
+vec3 _a0072;
+
+vec3 _a0076;
+
+COMPAT_VARYING vec4 TEX0;
+
+
+
+ 
+uniform int FrameDirection;
+uniform int FrameCount;
+uniform COMPAT_PRECISION vec2 OutputSize;
+uniform COMPAT_PRECISION vec2 TextureSize;
+uniform COMPAT_PRECISION vec2 InputSize;
+void main()
+
+{
+
+
+
+    float _d1;
+
+    float _d2;
+
+    float _hl;
+
+    float _vl;
+
+    float _m1;
+
+    float _m2;
+
+    vec3 _t1;
+
+    vec3 _t2;
+
+    vec3 _TMP28;
+
+
+
+    _TMP0 = COMPAT_TEXTURE(Texture, TEX0.xy);
+
+    _TMP1 = COMPAT_TEXTURE(Texture, VARt1.xy);
+
+    _TMP2 = COMPAT_TEXTURE(Texture, VARt1.zw);
+
+    _TMP3 = COMPAT_TEXTURE(Texture, VARt2.xy);
+
+    _TMP4 = COMPAT_TEXTURE(Texture, VARt2.zw);
+
+    _TMP5 = COMPAT_TEXTURE(Texture, VARt3.xy);
+
+    _TMP6 = COMPAT_TEXTURE(Texture, VARt3.zw);
+
+    _TMP7 = COMPAT_TEXTURE(Texture, VARt4.xy);
+
+    _TMP8 = COMPAT_TEXTURE(Texture, VARt4.zw);
+
+    _TMP9 = COMPAT_TEXTURE(Texture, VARt5.xy);
+
+    _TMP10 = COMPAT_TEXTURE(Texture, VARt5.zw);
+
+    _TMP11 = COMPAT_TEXTURE(Texture, VARt6.xy);
+
+    _TMP12 = COMPAT_TEXTURE(Texture, VARt6.zw);
+
+    _a0056 = _TMP1.xyz - _TMP3.xyz;
+
+    _TMP13 = abs(_a0056);
+
+    _TMP14 = dot(_TMP13, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _d1 = _TMP14 + 9.99999975E-005;
+
+    _a0060 = _TMP2.xyz - _TMP4.xyz;
+
+    _TMP15 = abs(_a0060);
+
+    _TMP16 = dot(_TMP15, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _d2 = _TMP16 + 9.99999975E-005;
+
+    _a0064 = _TMP9.xyz - _TMP10.xyz;
+
+    _TMP17 = abs(_a0064);
+
+    _TMP18 = dot(_TMP17, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _hl = _TMP18 + 9.99999975E-005;
+
+    _a0068 = _TMP11.xyz - _TMP12.xyz;
+
+    _TMP19 = abs(_a0068);
+
+    _TMP20 = dot(_TMP19, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _vl = _TMP20 + 9.99999975E-005;
+
+    _a0072 = _TMP1.xyz - _TMP3.xyz;
+
+    _TMP21 = abs(_a0072);
+
+    _TMP22 = dot(_TMP21, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _m1 = _TMP22 + 1.00000005E-003;
+
+    _a0076 = _TMP4.xyz - _TMP2.xyz;
+
+    _TMP23 = abs(_a0076);
+
+    _TMP24 = dot(_TMP23, vec3( 1.00000000E+000, 1.00000000E+000, 1.00000000E+000));
+
+    _m2 = _TMP24 + 1.00000005E-003;
+
+    _t1 = (_hl*(_TMP11.xyz + _TMP12.xyz) + _vl*(_TMP9.xyz + _TMP10.xyz) + (_hl + _vl)*_TMP0.xyz)/(3.00000000E+000*(_hl + _vl));
+
+    _t2 = (_d1*(_TMP2.xyz + _TMP4.xyz) + _d2*(_TMP1.xyz + _TMP3.xyz) + (_d1 + _d2)*_TMP0.xyz)/(3.00000000E+000*(_d1 + _d2));
+
+    _TMP28 = 2.50000000E-001*(_t1 + _t2 + (_m2*(_TMP5.xyz + _TMP7.xyz) + _m1*(_TMP8.xyz + _TMP6.xyz))/(_m1 + _m2));
+
+    _ret_0 = vec4(_TMP28.x, _TMP28.y, _TMP28.z, 1.00000000E+000);
+
+    FragColor = _ret_0;
+
+    return;
+
+} 
+#endif