Overlay the user Shaders/ over the shared one to avoid copying files

Data/Sys/Shaders/16bit.glsl

@@ -0,0 +1,61 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  //Change this number to increase the pixel size.
+  float pixelSize = 3;
+
+  float red   = 0.0;
+  float green = 0.0;
+  float blue  = 0.0;
+  
+  vec2 pos = floor(uv0 * resolution.xy / pixelSize) * pixelSize * resolution.zw;
+  
+  vec4 c0 = texture(samp9, pos);
+
+  if (c0.r < 0.1)
+    red = 0.1;
+  else if (c0.r < 0.20)
+    red = 0.20;
+  else if (c0.r < 0.40)
+    red = 0.40;
+  else if (c0.r < 0.60)
+    red = 0.60;
+  else if (c0.r < 0.80)
+    red = 0.80;
+  else
+    red = 1.0;
+
+  if (c0.b < 0.1)
+    blue = 0.1;
+  else if (c0.b < 0.20)
+    blue = 0.20;
+  else if (c0.b < 0.40)
+    blue = 0.40;
+  else if (c0.b < 0.60)
+    blue = 0.60;
+  else if (c0.b < 0.80)
+    blue = 0.80;
+  else
+    blue = 1.0;
+
+  if (c0.g < 0.1)
+    green = 0.1;
+  else if (c0.g < 0.20)
+    green = 0.20;
+  else if (c0.g < 0.40)
+    green = 0.40;
+  else if (c0.g < 0.60)
+    green = 0.60;
+  else if (c0.g < 0.80)
+    green = 0.80;
+  else
+    green = 1.0;
+  
+  ocol0 = vec4(red, green, blue, c0.a);
+}

Data/Sys/Shaders/32bit.glsl

@@ -0,0 +1,86 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  //Change this number to increase the pixel size.
+  float pixelSize = 2;
+
+  float red   = 0.0;
+  float green = 0.0;
+  float blue  = 0.0;
+  
+  vec2 pos = floor(uv0 * resolution.xy / pixelSize) * pixelSize * resolution.zw;
+  
+  vec4 c0 = texture(samp9, pos);
+  
+  if (c0.r < 0.06)
+    red = 0.06;
+  else if (c0.r < 0.13)
+    red = 0.13;
+  else if (c0.r < 0.26)
+    red = 0.26;
+  else if (c0.r < 0.33)
+    red = 0.33;
+  else if (c0.r < 0.46)
+    red = 0.46;
+  else if (c0.r < 0.60)
+    red = 0.60;
+  else if (c0.r < 0.73)
+    red = 0.73;
+  else if (c0.r < 0.80)
+    red = 0.80;
+  else if (c0.r < 0.93)
+    red = 0.93;
+  else
+    red = 1.0;
+
+  if (c0.b < 0.06)
+    blue = 0.06;
+  else if (c0.b < 0.13)
+    blue = 0.13;
+  else if (c0.b < 0.26)
+    blue = 0.26;
+  else if (c0.b < 0.33)
+    blue = 0.33;
+  else if (c0.b < 0.46)
+    blue = 0.46;
+  else if (c0.b < 0.60)
+    blue = 0.60;
+  else if (c0.b < 0.73)
+    blue = 0.73;
+  else if (c0.b < 0.80)
+    blue = 0.80;
+  else if( c0.b < 0.93)
+    blue = 0.93;
+  else
+    blue = 1.0;
+
+
+  if (c0.g < 0.06)
+    green = 0.06;
+  else if (c0.g < 0.13)
+    green = 0.13;
+  else if (c0.g < 0.26)
+    green = 0.26;
+  else if (c0.g < 0.33)
+    green = 0.33;
+  else if (c0.g < 0.46)
+    green = 0.46;
+  else if (c0.g < 0.60)
+    green = 0.60;
+  else if (c0.g < 0.73)
+    green = 0.73;
+  else if (c0.g < 0.80)
+    green = 0.80;
+  else if( c0.g < 0.93)
+    green = 0.93;
+  else
+    green = 1.0;
+
+  ocol0 = vec4(red, green, blue, c0.a);
+}

Data/Sys/Shaders/README.txt

@@ -0,0 +1,18 @@
+//dummy shader:
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+  ocol0 = texture(samp9, uv0);
+}
+
+/*
+And now that's over with, the contents of this readme file!
+For best results, turn Wordwrap formatting on...
+The shaders shown in the dropdown box in the video plugin configuration window are kept in the directory named User/Data/Shaders. They are linked in to the dolphin source from the repository at <http://dolphin-shaders-database.googlecode.com/svn/trunk/>. See <http://code.google.com/p/dolphin-shaders-database/wiki/Documentation> for more details on the way shaders work.
+
+This file will hopefully hold more content in future...
+*/

Data/Sys/Shaders/acidmetal.glsl

@@ -0,0 +1,21 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float red   = 0.0;
+	float blue  = 0.0;
+
+	if (c0.r > 0.15 && c0.b > 0.15)
+	{
+		blue = 0.5;
+		red = 0.5;
+	}
+
+	float green = max(c0.r + c0.b, c0.g);
+
+	ocol0 = vec4(red, green, blue, 1.0);
+}

Data/Sys/Shaders/acidtrip.glsl

@@ -0,0 +1,11 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  ocol0 = (texture(samp9, uv0+resolution.zw) - texture(samp9, uv0-resolution.zw))*8;
+}

Data/Sys/Shaders/acidtrip2.glsl

@@ -0,0 +1,13 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  vec4 a = texture(samp9, uv0+resolution.zw);
+  vec4 b = texture(samp9, uv0-resolution.zw);
+  ocol0 = ( a*a*1.3 - b )*8;
+}

Data/Sys/Shaders/asciiart.glsl

@@ -0,0 +1,95 @@
+uniform sampler2D samp8; // textures
+uniform sampler2D samp9;
+
+const int char_width = 8;
+const int char_height = 13;
+const int char_count = 95;
+const int char_pixels = char_width*char_height;
+const vec2 char_dim = vec2(char_width, char_height);
+const vec2 font_scale = vec2(1.0/char_width/char_count, 1.0/char_height);
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  vec2 char_pos = floor(uv0*resolution.xy/char_dim);
+  vec2 pixel_offset = floor(uv0*resolution.xy) - char_pos*char_dim;
+
+  float mindiff = char_width*char_height*100; // just a big number
+  float minc = 0.0;
+  vec4 mina = vec4(0.0, 0.0, 0.0, 0.0);
+  vec4 minb = vec4(0.0, 0.0, 0.0, 0.0);
+  
+  for(int i=0; i<char_count; i++) {
+    vec4 ff = vec4(0.0, 0.0, 0.0, 0.0);
+    vec4 f = vec4(0.0, 0.0, 0.0, 0.0);
+    vec4 ft = vec4(0.0, 0.0, 0.0, 0.0);
+    vec4 t = vec4(0.0, 0.0, 0.0, 0.0);
+    vec4 tt = vec4(0.0, 0.0, 0.0, 0.0);
+    
+    for(int x=0; x<char_width; x++) {
+      for(int y=0; y<char_height; y++) {
+      
+	vec2 tex_pos = char_pos*char_dim + vec2(x,y) + 0.5;
+	vec4 tex = texture(samp9, tex_pos * resolution.zw);
+      
+	vec2 font_pos = vec2(x+i*char_width, y) + 0.5;
+	vec4 font = texture(samp8, font_pos * font_scale);
+	
+	// generates sum of texture and font and their squares
+	ff += font*font;
+	f += font;
+	ft += font*tex;
+	t += tex;
+	tt += tex*tex;
+      }
+    }
+    
+    /*
+      The next lines are a bit harder, hf :-)
+      
+      The idea is to find the perfect char with the perfect background color and the perfect font color.
+      As this is an equation with three unknowns, we can't just try all chars and color combinations.
+      
+      As criterion how "perfect" the selection is, we compare the "mean squared error" of the resulted colors of all chars.
+      So, now the big issue: how to calculate the MSE without knowing the two colors ...
+      
+      In the next steps, "a" is the font color, "b" is the background color, "f" is the font value at this pixel, "t" is the texture value
+      
+      So the square error of one pixel is: 
+        e = ( t - a⋅f - b⋅(1-f) ) ^ 2
+        
+      In longer:
+        e = a^2⋅f^2 - 2⋅a⋅b⋅f^2 + 2⋅a⋅b⋅f - 2⋅a⋅f⋅t + b^2⋅f^2 - 2⋅b^2⋅f + b^2 + 2⋅b⋅f⋅t - 2⋅b⋅t + t^2
+        
+      The sum of all errors is: (as shortcut, ff,f,ft,t,tt are now the sums like declared above, sum(1) is the count of pixels)
+        sum(e) = a^2⋅ff - 2⋅a^2⋅ff + 2⋅a⋅b⋅f - 2⋅a⋅ft + b^2⋅ff - 2⋅b^2⋅f + b^2⋅sum(1) + 2⋅b⋅ft - 2⋅b⋅t + tt
+        
+      To find the minimum, we have to derive this by "a" and "b":
+        d/da sum(e) = 2⋅a⋅ff + 2⋅b⋅f - 2⋅b⋅ff - 2⋅ft
+        d/db sum(e) = 2⋅a⋅f - 2⋅a⋅ff - 4⋅b⋅f + 2⋅b⋅ff + 2⋅b⋅sum(1) + 2⋅ft - 2⋅t
+      
+      So, both equations must be zero at minimum and there is only one solution.
+    */
+    vec4 a = (f*ft - ff*t + f*t - ft*char_pixels) / (f*f  - ff*char_pixels);
+    vec4 b = (f*ft - ff*t)                        / (f*f  - ff*char_pixels);
+    
+    vec4 diff = a*a*ff + 2.0*a*b*f - 2.0*a*b*ff - 2.0*a*ft + b*b *(-2.0*f + ff + char_pixels) + 2.0*b*ft - 2.0*b*t + tt;
+    float diff_f = dot(diff, vec4(1.0, 1.0, 1.0, 1.0));
+    
+    if(diff_f < mindiff) {
+      mindiff = diff_f;
+      minc = i;
+      mina = a;
+      minb = b;
+    }
+  }
+  
+  vec2 font_pos_res = vec2(minc*char_width, 0) + pixel_offset + 0.5;
+
+  vec4 col = texture(samp8, font_pos_res * font_scale);
+  ocol0 = mina * col + minb * (vec4(1.0,1.0,1.0,1.0) - col);
+}

Data/Sys/Shaders/auto_toon.glsl

@@ -0,0 +1,22 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  vec4 to_gray = vec4(0.3,0.59,0.11,0);
+  
+  float x1 = dot(to_gray, texture(samp9, uv0+vec2(1,1)*resolution.zw));
+  float x0 = dot(to_gray, texture(samp9, uv0+vec2(-1,-1)*resolution.zw));
+  float x3 = dot(to_gray, texture(samp9, uv0+vec2(1,-1)*resolution.zw));
+  float x2 = dot(to_gray, texture(samp9, uv0+vec2(-1,1)*resolution.zw));
+  
+  float edge = (x1 - x0) * (x1 - x0) + (x3 - x2) * (x3 - x2);
+  
+  float4 color = texture(samp9, uv0).rgba;
+
+  ocol0 = color - vec4(edge, edge, edge, edge) * 12.0;
+}

Data/Sys/Shaders/auto_toon2.glsl

@@ -0,0 +1,92 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+ //Changethis to increase the number of colors.
+  int numColors =8;
+
+  float4 to_gray = float4(0.3,0.59,0.11,0);
+  float x1 = dot(to_gray, texture(samp9, uv0+vec2(1,1)*resolution.zw));
+  float x0 = dot(to_gray, texture(samp9, uv0+vec2(-1,-1)*resolution.zw));
+  float x3 = dot(to_gray, texture(samp9, uv0+vec2(1,-1)*resolution.zw));
+  float x2 = dot(to_gray, texture(samp9, uv0+vec2(-1,1)*resolution.zw));
+  float edge = (x1 - x0) * (x1 - x0) + (x3 - x2) * (x3 - x2);
+  float4 color = texture(samp9, uv0).rgba;
+
+  float4 c0 = color - float4(edge, edge, edge, edge) * 12;
+
+ 
+
+  float red   = 0.0;
+  float green = 0.0;
+  float blue  = 0.0;
+  bool rr = false;
+  bool bb = false;
+  bool gg = false;
+  int count = 1;
+  
+  float colorN = 0.0;
+  float colorB = 0.0;
+
+	 
+	 for(count = 1; count <= numColors ; count++){
+		 colorN = count / numColors;
+		 
+		 if ( c0.r <= colorN && c0.r >= colorB && rr == false ){
+			if (count == 1){
+				if(colorN >= 0.1)
+					red = 0.01;
+				else
+					red = colorN;
+			}
+			else if (count == numColors)
+				red = 0.95;
+			else
+				red = colorN ;
+			
+			 rr = true;
+		}
+
+		 if (c0.b <= colorN && c0.b >= colorB && bb == false){
+			if (count == 1){
+				if(colorN >= 0.1)
+					blue = 0.01;
+				else
+					blue = colorN;
+			}
+			else if (count == numColors)
+				blue = 0.95;
+			else
+				blue = colorN ;
+			
+			 bb = true;
+		}
+
+		 if (c0.g <= colorN && c0.g >= colorB && gg == false){
+			if (count == 1){
+				if(colorN >= 0.1)
+					green = 0.01;
+				else
+					green = colorN;
+			}
+			else if (count == numColors)
+				green = 0.95 ;
+			else
+			green = colorN ;
+			 gg = true;
+		}
+			
+		colorB = count / numColors;
+		if(rr == true && bb == true && gg == true)
+			break;
+	}
+
+
+  
+  ocol0 = float4(red, green, blue, c0.a);
+}

Data/Sys/Shaders/bad_bloom.glsl

@@ -0,0 +1,43 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  float4 c_center = texture(samp9, uv0);
+
+  float4 bloom_sum = float4(0.0, 0.0, 0.0, 0.0);
+  vec2 pos = uv0 + float2(0.3, 0.3) * resolution.zw;
+  float2 radius1 = 1.3 * resolution.zw;
+  bloom_sum += texture(samp9, pos + float2(-1.5, -1.5) * radius1);
+  bloom_sum += texture(samp9, pos + float2(-2.5, 0)  * radius1);
+  bloom_sum += texture(samp9, pos + float2(-1.5, 1.5) * radius1);
+  bloom_sum += texture(samp9, pos + float2(0, 2.5) * radius1);
+  bloom_sum += texture(samp9, pos + float2(1.5, 1.5) * radius1);
+  bloom_sum += texture(samp9, pos + float2(2.5, 0) * radius1);
+  bloom_sum += texture(samp9, pos + float2(1.5, -1.5) * radius1);
+  bloom_sum += texture(samp9, pos + float2(0, -2.5) * radius1);
+
+  float2 radius2 = 4.6 * resolution.zw;
+  bloom_sum += texture(samp9, pos + float2(-1.5, -1.5) * radius2);
+  bloom_sum += texture(samp9, pos + float2(-2.5, 0)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(-1.5, 1.5)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(0, 2.5)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(1.5, 1.5)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(2.5, 0)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(1.5, -1.5)  * radius2);
+  bloom_sum += texture(samp9, pos + float2(0, -2.5)  * radius2);
+
+  bloom_sum *= 0.07;
+  bloom_sum -= float4(0.3, 0.3, 0.3, 0.3);
+  bloom_sum = max(bloom_sum, float4(0,0,0,0));
+
+  float2 vpos = (uv0 - float2(.5, .5)) * 2;
+  float dist = (dot(vpos, vpos));
+  dist = 1 - 0.4*dist;
+
+  ocol0 = (c_center * 0.7 + bloom_sum) * dist;
+}

Data/Sys/Shaders/brighten.glsl

@@ -0,0 +1,9 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	ocol0 = texture(samp9, uv0) * 3;
+}

Data/Sys/Shaders/chrismas.glsl

@@ -0,0 +1,17 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float red   = 0.0;
+	float green = 0.0;
+
+	if (c0.r < 0.35 || c0.b > 0.35)
+		green = c0.g + (c0.b / 2);
+	else
+		red = c0.r + 0.4;
+	ocol0 = vec4(red, green, 0.0, 1.0);
+}

Data/Sys/Shaders/cool1.glsl

@@ -0,0 +1,24 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float red   = 0.0;
+	float green = 0.0;
+	float blue  = 0.0;
+
+	if (c0.r < 0.50 || c0.b > 0.5)
+	{
+		blue = c0.r;
+		red = c0.g;
+	}
+	else
+	{
+		blue = c0.r;
+		green = c0.r;
+	}
+	ocol0 = vec4(red, green, blue, 1.0);
+}

Data/Sys/Shaders/darkerbrighter.glsl

@@ -0,0 +1,41 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  float4 c0 = texture(samp9, uv0);
+  float4 c1 = texture(samp9, uv0 - float2(1, 0)*resolution.zw);
+  float4 c2 = texture(samp9, uv0 - float2(0, 1)*resolution.zw);
+  float4 c3 = texture(samp9, uv0 + float2(1, 0)*resolution.zw);
+  float4 c4 = texture(samp9, uv0 + float2(0, 1)*resolution.zw);
+
+  float red = c0.r;
+  float blue = c0.b;
+  float green = c0.g;
+
+  float red2 = (c1.r + c2.r + c3.r + c4.r) / 4;
+  float blue2 = (c1.b + c2.b + c3.b + c4.b) / 4;
+  float green2 = (c1.g + c2.g + c3.g + c4.g) / 4;
+
+ 	if(red2 > 0.3)
+		red = c0.r + c0.r /  2 ;
+	 else
+		red = c0.r - c0.r /  2 ;
+
+	if(green2 >  0.3)
+		green = c0.g+ c0.g / 2;
+	 else
+		green = c0.g - c0.g / 2;
+	
+		
+	if(blue2  >  0.3)
+		blue = c0.b+ c0.b / 2 ;
+	  else
+		blue = c0.b - c0.b / 2 ;
+	
+  ocol0 = float4(red, green, blue, c0.a);
+}

Data/Sys/Shaders/emboss.glsl

@@ -0,0 +1,24 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  float4 c0 = texture(samp9, uv0).rgba;
+  float4 c1 = texture(samp9, uv0 + float2(5,5)*resolution.zw).rgba;
+  float y = (0.222 * c1.r) + (0.707 * c1.g) + (0.071 * c1.b);
+  float y2 = ((0.222 * c0.r) + (0.707 * c0.g) + (0.071 * c0.b)) / 3;
+  float red   = c0.r;
+  float green = c0.g;
+  float blue  = c0.b;
+  float alpha = c0.a;
+  
+  red   = y2 + (1 - y);
+  green = y2 + (1 - y);
+  blue  = y2 + (1 - y);
+
+  ocol0 = float4(red, green, blue, alpha);
+}

Data/Sys/Shaders/fire.glsl

@@ -0,0 +1,36 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float red   = 0.0;
+	float green = 0.0;
+	float blue  = 0.0;
+
+	red = c0.r;
+
+
+	if (c0.r > 0.0)
+	if (c0.g > c0.r)
+		green = (c0.g - (c0.g - c0.r)) / 3;
+
+	if (c0.b > 0.0 && c0.r < 0.25)
+	{
+		red = c0.b;
+		green = c0.b / 3;
+	}
+
+	if (c0.g > 0.0 && c0.r < 0.25)
+	{
+		red = c0.g;
+		green = c0.g / 3;
+	}
+
+	if (((c0.r + c0.g + c0.b) / 3) > 0.9)
+		green = c0.r / 3;
+
+	ocol0 = vec4(red, green, blue, 1.0);
+}

Data/Sys/Shaders/fire2.glsl

@@ -0,0 +1,18 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float red   = 0.0;
+	float green = 0.0;
+	float blue  = 0.0;
+	float avg = (c0.r + c0.g + c0.b) / 3;
+
+	red = c0.r + (c0.g / 2) + (c0.b / 3);
+	green = c0.r / 3;
+
+	ocol0 = vec4(red, green, blue, 1.0);
+}

Data/Sys/Shaders/firewater.glsl

@@ -0,0 +1,22 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+uniform vec4 resolution;
+
+void main()
+{
+  float4 c0 = texture(samp9, uv0);
+  float4 c1 = texture(samp9, uv0 + float2(1,1)*resolution.zw);
+  float4 c2 = texture(samp9, uv0 + float2(-1,-1)*resolution.zw);
+  float red   = c0.r;
+  float green = c0.g;
+  float blue  = c0.b;
+  float alpha = c0.a;
+  
+  red = c0.r - c1.b;
+  blue = c0.b - c2.r + (c0.g - c0.r);
+
+  ocol0 = float4(red, 0.0, blue, alpha);
+}

Data/Sys/Shaders/grayscale.glsl

@@ -0,0 +1,11 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	float avg = (c0.r + c0.g + c0.b) / 3.0;
+	ocol0 = vec4(avg, avg, avg, c0.a);
+}

Data/Sys/Shaders/grayscale2.glsl

@@ -0,0 +1,12 @@
+uniform sampler2D samp9;
+
+out vec4 ocol0;
+in vec2 uv0;
+
+void main()
+{
+	vec4 c0 = texture(samp9, uv0);
+	// Info: http://www.oreillynet.com/cs/user/view/cs_msg/8691
+	float avg = (0.222 * c0.r) + (0.707 * c0.g) + (0.071 * c0.b);
+	ocol0 = vec4(avg, avg, avg, c0.a);
+}