From 3ffa44cef9512974c9039c559806383677c549da Mon Sep 17 00:00:00 2001
From: Tim Allen <screwtape@froup.com>
Date: Wed, 29 Sep 2010 10:10:38 +1000
Subject: [PATCH] Add pixel shaders from the external tarball.

byuu has traditionally kept these shaders separately, but I don't see
why they shouldn't be stored alongside the code that uses them.

Unlike previous versions of pixel shaders, these are updated to use the
new file-format introduced in v070r03.
---
 pixelshaders/GLSL/Curvature.shader | 18 ++++++++
 pixelshaders/GLSL/HDR-TV.shader    | 21 +++++++++
 pixelshaders/GLSL/HQ2x.shader      | 73 ++++++++++++++++++++++++++++++
 pixelshaders/GLSL/Pixellate.shader | 44 ++++++++++++++++++
 pixelshaders/GLSL/Scale2x.shader   | 55 ++++++++++++++++++++++
 pixelshaders/HLSL/Sepia.shader     | 30 ++++++++++++
 6 files changed, 241 insertions(+)
 create mode 100755 pixelshaders/GLSL/Curvature.shader
 create mode 100755 pixelshaders/GLSL/HDR-TV.shader
 create mode 100755 pixelshaders/GLSL/HQ2x.shader
 create mode 100755 pixelshaders/GLSL/Pixellate.shader
 create mode 100755 pixelshaders/GLSL/Scale2x.shader
 create mode 100755 pixelshaders/HLSL/Sepia.shader

diff --git a/pixelshaders/GLSL/Curvature.shader b/pixelshaders/GLSL/Curvature.shader
new file mode 100755
index 00000000..49abf527
--- /dev/null
+++ b/pixelshaders/GLSL/Curvature.shader
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <fragment><![CDATA[
+    uniform sampler2D rubyTexture;
+
+    #define distortion 0.2
+
+    vec2 barrelDistortion(vec2 coord) {
+      vec2 cc = coord - 0.5;
+      float dist = dot(cc, cc);
+      return coord + cc * (dist + distortion * dist * dist) * distortion;
+    }
+
+    void main(void) {
+      gl_FragColor = texture2D(rubyTexture, barrelDistortion(gl_TexCoord[0].xy));
+    }
+  ]]></fragment>
+</shader>
diff --git a/pixelshaders/GLSL/HDR-TV.shader b/pixelshaders/GLSL/HDR-TV.shader
new file mode 100755
index 00000000..137bedba
--- /dev/null
+++ b/pixelshaders/GLSL/HDR-TV.shader
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    void main(void) {
+      gl_Position = ftransform();
+      gl_TexCoord[0] = gl_MultiTexCoord0;
+    }
+  ]]></vertex>
+
+  <fragment><![CDATA[
+    uniform sampler2D rubyTexture;
+
+    void main(void) {   
+      vec4 rgb = texture2D(rubyTexture, gl_TexCoord[0].xy);
+      vec4 intens = smoothstep(0.2,0.8,rgb) + normalize(vec4(rgb.xyz, 1.0));
+
+      if(fract(gl_FragCoord.y * 0.5) > 0.5) intens = rgb * 0.8;
+      gl_FragColor = intens;
+    }
+  ]]></fragment>
+</shader>
diff --git a/pixelshaders/GLSL/HQ2x.shader b/pixelshaders/GLSL/HQ2x.shader
new file mode 100755
index 00000000..d4f8c822
--- /dev/null
+++ b/pixelshaders/GLSL/HQ2x.shader
@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      float x = 0.5 * (1.0 / rubyTextureSize.x);
+      float y = 0.5 * (1.0 / rubyTextureSize.y);
+      vec2 dg1 = vec2( x, y);
+      vec2 dg2 = vec2(-x, y);
+      vec2 dx = vec2(x, 0.0);
+      vec2 dy = vec2(0.0, y);
+
+      gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+      gl_TexCoord[0] = gl_MultiTexCoord0;
+      gl_TexCoord[1].xy = gl_TexCoord[0].xy - dg1;
+      gl_TexCoord[1].zw = gl_TexCoord[0].xy - dy;
+      gl_TexCoord[2].xy = gl_TexCoord[0].xy - dg2;
+      gl_TexCoord[2].zw = gl_TexCoord[0].xy + dx;
+      gl_TexCoord[3].xy = gl_TexCoord[0].xy + dg1;
+      gl_TexCoord[3].zw = gl_TexCoord[0].xy + dy;
+      gl_TexCoord[4].xy = gl_TexCoord[0].xy + dg2;
+      gl_TexCoord[4].zw = gl_TexCoord[0].xy - dx;
+    }
+  ]]></vertex>
+
+  <fragment><![CDATA[
+    uniform sampler2D rubyTexture;
+
+    const float mx = 0.325;      // start smoothing wt.
+    const float k = -0.250;      // wt. decrease factor
+    const float max_w = 0.25;    // max filter weigth
+    const float min_w =-0.05;    // min filter weigth
+    const float lum_add = 0.25;  // effects smoothing
+
+    void main() {
+      vec3 c00 = texture2D(rubyTexture, gl_TexCoord[1].xy).xyz; 
+      vec3 c10 = texture2D(rubyTexture, gl_TexCoord[1].zw).xyz; 
+      vec3 c20 = texture2D(rubyTexture, gl_TexCoord[2].xy).xyz; 
+      vec3 c01 = texture2D(rubyTexture, gl_TexCoord[4].zw).xyz; 
+      vec3 c11 = texture2D(rubyTexture, gl_TexCoord[0].xy).xyz; 
+      vec3 c21 = texture2D(rubyTexture, gl_TexCoord[2].zw).xyz; 
+      vec3 c02 = texture2D(rubyTexture, gl_TexCoord[4].xy).xyz; 
+      vec3 c12 = texture2D(rubyTexture, gl_TexCoord[3].zw).xyz; 
+      vec3 c22 = texture2D(rubyTexture, gl_TexCoord[3].xy).xyz; 
+      vec3 dt = vec3(1.0, 1.0, 1.0);
+
+      float md1 = dot(abs(c00 - c22), dt);
+      float md2 = dot(abs(c02 - c20), dt);
+
+      float w1 = dot(abs(c22 - c11), dt) * md2;
+      float w2 = dot(abs(c02 - c11), dt) * md1;
+      float w3 = dot(abs(c00 - c11), dt) * md2;
+      float w4 = dot(abs(c20 - c11), dt) * md1;
+
+      float t1 = w1 + w3;
+      float t2 = w2 + w4;
+      float ww = max(t1, t2) + 0.0001;
+
+      c11 = (w1 * c00 + w2 * c20 + w3 * c22 + w4 * c02 + ww * c11) / (t1 + t2 + ww);
+
+      float lc1 = k / (0.12 * dot(c10 + c12 + c11, dt) + lum_add);
+      float lc2 = k / (0.12 * dot(c01 + c21 + c11, dt) + lum_add);
+
+      w1 = clamp(lc1 * dot(abs(c11 - c10), dt) + mx, min_w, max_w);
+      w2 = clamp(lc2 * dot(abs(c11 - c21), dt) + mx, min_w, max_w);
+      w3 = clamp(lc1 * dot(abs(c11 - c12), dt) + mx, min_w, max_w);
+      w4 = clamp(lc2 * dot(abs(c11 - c01), dt) + mx, min_w, max_w);
+
+      gl_FragColor.xyz = w1 * c10 + w2 * c21 + w3 * c12 + w4 * c01 + (1.0 - w1 - w2 - w3 - w4) * c11;
+    }
+  ]]></fragment>
+</shader>
diff --git a/pixelshaders/GLSL/Pixellate.shader b/pixelshaders/GLSL/Pixellate.shader
new file mode 100755
index 00000000..dc484899
--- /dev/null
+++ b/pixelshaders/GLSL/Pixellate.shader
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    void main() {
+      gl_Position    = ftransform();
+      gl_TexCoord[0] = gl_MultiTexCoord0;
+    }
+  ]]></vertex>
+
+  <fragment><![CDATA[
+    uniform sampler2D rubyTexture;
+    uniform vec2      rubyTextureSize;
+
+    void main() {
+      vec2 texelSize = 1.0 / rubyTextureSize;
+
+      vec2 range;
+      range.x = dFdx(gl_TexCoord[0].x) / 2.0 * 0.99;
+      range.y = dFdy(gl_TexCoord[0].y) / 2.0 * 0.99;
+
+      float left   = gl_TexCoord[0].x - range.x;
+      float top    = gl_TexCoord[0].y + range.y;
+      float right  = gl_TexCoord[0].x + range.x;
+      float bottom = gl_TexCoord[0].y - range.y;
+
+      vec4 topLeftColor     = texture2D(rubyTexture, (floor(vec2(left, top)     / texelSize) + 0.5) * texelSize);
+      vec4 bottomRightColor = texture2D(rubyTexture, (floor(vec2(right, bottom) / texelSize) + 0.5) * texelSize);
+      vec4 bottomLeftColor  = texture2D(rubyTexture, (floor(vec2(left, bottom)  / texelSize) + 0.5) * texelSize);
+      vec4 topRightColor    = texture2D(rubyTexture, (floor(vec2(right, top)    / texelSize) + 0.5) * texelSize);
+
+      vec2 border = clamp(round(gl_TexCoord[0] / texelSize) * texelSize, vec2(left, bottom), vec2(right, top));
+
+      float totalArea = 4.0 * range.x * range.y;
+
+      vec4 averageColor;
+      averageColor  = ((border.x - left)  * (top - border.y)    / totalArea) * topLeftColor;
+      averageColor += ((right - border.x) * (border.y - bottom) / totalArea) * bottomRightColor;
+      averageColor += ((border.x - left)  * (border.y - bottom) / totalArea) * bottomLeftColor;
+      averageColor += ((right - border.x) * (top - border.y)    / totalArea) * topRightColor;
+
+      gl_FragColor = averageColor;
+    }
+  ]]></fragment>
+</shader>
diff --git a/pixelshaders/GLSL/Scale2x.shader b/pixelshaders/GLSL/Scale2x.shader
new file mode 100755
index 00000000..b82cfb4d
--- /dev/null
+++ b/pixelshaders/GLSL/Scale2x.shader
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="GLSL">
+  <vertex><![CDATA[
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      vec4 offsetx;
+      vec4 offsety;
+
+      gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
+
+      offsetx.x = 1.0 / rubyTextureSize.x;
+      offsetx.y = 0.0;
+      offsetx.w = 0.0;
+      offsetx.z = 0.0;
+      offsety.y = 1.0 / rubyTextureSize.y;
+      offsety.x = 0.0;
+      offsety.w = 0.0;
+      offsety.z = 0.0;
+
+      gl_TexCoord[0] = gl_MultiTexCoord0;         //center
+      gl_TexCoord[1] = gl_TexCoord[0] - offsetx;  //left
+      gl_TexCoord[2] = gl_TexCoord[0] + offsetx;  //right
+      gl_TexCoord[3] = gl_TexCoord[0] - offsety;  //top
+      gl_TexCoord[4] = gl_TexCoord[0] + offsety;  //bottom
+    }
+  ]]></vertex>
+
+  <fragment><![CDATA[
+    uniform sampler2D rubyTexture;
+    uniform vec2 rubyTextureSize;
+
+    void main() {
+      vec4 colD, colF, colB, colH, col, tmp;
+      vec2 sel;
+
+      col  = texture2DProj(rubyTexture, gl_TexCoord[0]);  //central (can be E0-E3)
+      colD = texture2DProj(rubyTexture, gl_TexCoord[1]);  //D (left)
+      colF = texture2DProj(rubyTexture, gl_TexCoord[2]);  //F (right)
+      colB = texture2DProj(rubyTexture, gl_TexCoord[3]);  //B (top)
+      colH = texture2DProj(rubyTexture, gl_TexCoord[4]);  //H (bottom)
+
+      sel = fract(gl_TexCoord[0].xy * rubyTextureSize.xy);       //where are we (E0-E3)? 
+                                                                 //E0 is default
+      if(sel.y >= 0.5) { tmp = colB; colB = colH; colH = tmp; }  //E1 (or E3): swap B and H
+      if(sel.x >= 0.5) { tmp = colF; colF = colD; colD = tmp; }  //E2 (or E3): swap D and F 
+
+      if(colB == colD && colB != colF && colD != colH) {  //do the Scale2x rule
+        col = colD;
+      }
+
+      gl_FragColor = col;
+    }
+  ]]></fragment>
+</shader>
diff --git a/pixelshaders/HLSL/Sepia.shader b/pixelshaders/HLSL/Sepia.shader
new file mode 100755
index 00000000..1fa725e2
--- /dev/null
+++ b/pixelshaders/HLSL/Sepia.shader
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shader language="HLSL">
+  <source><![CDATA[
+    texture rubyTexture;
+
+    float4 vec;
+
+    sampler s0 = sampler_state { texture = <rubyTexture>; };
+    float3 LightColor = { 1.0, 0.7, 0.5 };
+    float3 DarkColor = { 0.2, 0.05, 0.0 };
+
+    float4 DiffColorPass(in float2 Tex : TEXCOORD0) : COLOR0
+    {
+      vec.x = 0.5;
+      vec.y = 1.0;
+      float3 scnColor = LightColor * tex2D(s0, Tex).xyz;
+      float3 grayXfer = float3(0.3, 0.59, 0.11);
+      float gray = dot(grayXfer, scnColor);
+      float3 muted = lerp(scnColor, gray.xxx, vec.x);
+      float3 sepia = lerp(DarkColor, LightColor, gray);
+      float3 result = lerp(muted, sepia, vec.y);
+      return float4(result, 1);
+    }
+
+    Technique T0
+    {
+      pass p0 { PixelShader = compile ps_2_0 DiffColorPass(); }
+    }
+  ]]></source>
+</shader>