ashton 0.0.1alpha → 0.0.2alpha

data/lib/ashton/shaders/lighting/shadow_blur.frag

@@ -0,0 +1,60 @@
+#version 110
+
+// Based on Catalin Zima's shader based dynamic shadows system.
+// http://www.catalinzima.com/2010/07/my-technique-for-the-shader-based-dynamic-2d-shadows/
+
+
+const float minBlur = 0.0;
+const float maxBlur = 5.0; // TODO: Make this a uniform?
+const int blurSamples = 13;
+
+uniform sampler2D in_Texture; // Original texture.
+uniform int in_TextureWidth;
+
+varying vec2 var_TexCoord; // Pixel to process on this pass.
+
+void main()
+{
+    vec2 offsetAndWeight[blurSamples];
+
+    offsetAndWeight[0] = vec2( 0.0, 0.199471);
+    offsetAndWeight[1] = vec2( 1.0, 0.176033);
+    offsetAndWeight[2] = vec2( 2.0, 0.120985);
+    offsetAndWeight[3] = vec2( 3.0, 0.064759);
+    offsetAndWeight[4] = vec2( 4.0, 0.026995);
+    offsetAndWeight[5] = vec2( 5.0, 0.008764);
+    offsetAndWeight[6] = vec2( 6.0, 0.002216);
+
+    vec4 color = texture2D(in_Texture, var_TexCoord);
+    float distance = color.b;
+    float pixel_width = 1.0 / float(in_TextureWidth);
+
+    // Take a reading from the center pixel once,
+    // but multiply since it would be added twice in the loop.
+    float sum = color.r * offsetAndWeight[0].y * 2.0;
+
+    for (int i = 1; i < blurSamples; i++)
+    {
+        float offset = offsetAndWeight[i].x;
+        float weight = offsetAndWeight[i].y;
+
+        offset *= pixel_width * mix(minBlur, maxBlur, distance);
+
+        // Take colour from above, below, left and right at once.
+        float effect = texture2D(in_Texture, var_TexCoord + vec2( offset,     0.0)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(-offset,     0.0)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(    0.0,  offset)).r +
+                       texture2D(in_Texture, var_TexCoord + vec2(    0.0, -offset)).r;
+
+        sum += effect * weight;
+    }
+
+    // Halve the sum, since we have applied horizontal and vertical at once.
+    sum *= 0.5;
+
+    // Light is brighter at the center.
+    float d = 2.0 * length(var_TexCoord - 0.5);
+    float attenuation = clamp(1.0 - d, 0.0, 1.0);
+
+    gl_FragColor = vec4(vec3(sum * attenuation), 1.0);
+}

data/lib/ashton/shaders/mezzotint.frag

@@ -0,0 +1,22 @@
+#version 110
+
+#include <rand>
+
+uniform sampler2D in_Texture;
+uniform int in_WindowWidth;
+
+uniform int in_T;
+
+varying vec2 var_TexCoord;
+
+void main() {
+	vec4 color = texture2D(in_Texture, var_TexCoord);
+	vec3 mezzo = vec3(0.0);
+	float width = float(in_WindowWidth);
+
+	if(rand(var_TexCoord + float(in_T) / width) <= color.r) { mezzo.r = 1.0; }
+	if(rand(var_TexCoord + float(in_T) / width) <= color.g) { mezzo.g = 1.0; }
+	if(rand(var_TexCoord + float(in_T) / width) <= color.b) { mezzo.b = 1.0; }
+		
+    gl_FragColor.rgb = mezzo;
+}

data/lib/ashton/shaders/multitexture2.vert

@@ -0,0 +1,19 @@
+#version 110
+
+attribute vec4 in_Color;
+
+varying vec4 var_Color;
+varying vec2 var_TexCoord0;
+varying vec2 var_TexCoord1;
+
+void main()
+{
+  gl_Position = ftransform();
+  var_Color = in_Color;
+
+  // Set the coordinates for TEXTURE0
+  var_TexCoord0 = gl_MultiTexCoord0.xy;
+
+  // Set the coordinates for TEXTURE1
+  var_TexCoord1 = gl_MultiTexCoord1.xy;
+}

data/lib/ashton/shaders/outline.frag

@@ -0,0 +1,45 @@
+#version 110
+
+const float ALPHA_THRESHOLD = 0.5;
+
+const vec2 TextureSize = vec2(1024.0, 1024.0); // Gosu-specific!
+const vec2 PixelSize = 1.0 / TextureSize;
+
+// Automatically set by Ray (actually passed from the vertex shader).
+uniform sampler2D in_Texture; // Original texture.
+//uniform int in_WindowWidth;
+//uniform int in_WindowHeight;
+
+uniform vec4 in_OutlineColor;
+uniform float in_OutlineWidth; // In pixels.
+
+varying vec2 var_TexCoord; // Pixel to process on this pass
+varying vec4 var_Color;
+
+void main()
+{
+    gl_FragColor = texture2D(in_Texture, var_TexCoord); // * var_Color;
+
+    if(gl_FragColor.a < ALPHA_THRESHOLD)
+    {
+        for(int i = -1; i < 2; i++)
+        {
+            for(int j = -1; j < 2; j++)
+            {
+                if(i != 0 && j != 0)
+                {
+                    // Get the color of the adjacent pixel.
+                    vec2 pos = var_TexCoord + vec2(i, j) * PixelSize * in_OutlineWidth;
+                    if(texture2D(in_Texture, pos).a > ALPHA_THRESHOLD)
+                    {
+                        gl_FragColor = in_OutlineColor;
+
+                        // Simplified return, since GLSL 1.10 hates `return`.
+                        i = 2;
+                        j = 2;
+                    }
+                }
+            }
+        }
+    }
+}

data/lib/ashton/{post_process → shaders}/pixelate.frag

@@ -1,48 +1,48 @@
-#version 110
-
-#define KERNEL_SIZE 9
-
-uniform int in_WindowWidth;
-uniform int in_WindowHeight;
-
-uniform sampler2D in_Texture;
-uniform int in_PixelSize;
-
-varying vec2 var_TexCoord;
-
-vec2 texCoords[KERNEL_SIZE];
-
-void main(void)
-{
-   vec4 avgColor;
-   vec2 texCoordsStep = 1.0 /
-            (vec2(float(in_WindowWidth), float(in_WindowHeight))/float(in_PixelSize));
-   vec2 pixelBin = floor(var_TexCoord / texCoordsStep);
-   vec2 inPixelStep = texCoordsStep / 3.0;
-   vec2 inPixelHalfStep = inPixelStep / 2.0;
-
-
-   texCoords[0] = vec2(inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[1] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[2] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[3] = vec2(inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[4] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[5] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[6] = vec2(inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[7] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
-   texCoords[8] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
-
-   avgColor = texture2D(in_Texture, texCoords[0]) +
-              texture2D(in_Texture, texCoords[1]) +
-              texture2D(in_Texture, texCoords[2]) +
-              texture2D(in_Texture, texCoords[3]) +
-              texture2D(in_Texture, texCoords[4]) +
-              texture2D(in_Texture, texCoords[5]) +
-              texture2D(in_Texture, texCoords[6]) +
-              texture2D(in_Texture, texCoords[7]) +
-              texture2D(in_Texture, texCoords[8]);
-
-   avgColor /= float(KERNEL_SIZE);
-
-   gl_FragColor = avgColor;
-}
+#version 110
+
+#define KERNEL_SIZE 9
+
+uniform int in_WindowWidth;
+uniform int in_WindowHeight;
+
+uniform sampler2D in_Texture;
+uniform int in_PixelSize;
+
+varying vec2 var_TexCoord;
+
+vec2 texCoords[KERNEL_SIZE];
+
+void main(void)
+{
+   vec4 avgColor;
+   vec2 texCoordsStep = 1.0 /
+            (vec2(float(in_WindowWidth), float(in_WindowHeight))/float(in_PixelSize));
+   vec2 pixelBin = floor(var_TexCoord / texCoordsStep);
+   vec2 inPixelStep = texCoordsStep / 3.0;
+   vec2 inPixelHalfStep = inPixelStep / 2.0;
+
+
+   texCoords[0] = vec2(inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[1] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[2] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelStep.y*2.0 + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[3] = vec2(inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[4] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[5] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelStep.y + inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[6] = vec2(inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[7] = vec2(inPixelStep.x + inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
+   texCoords[8] = vec2(inPixelStep.x*2.0 + inPixelHalfStep.x, inPixelHalfStep.y) + pixelBin * texCoordsStep;
+
+   avgColor = texture2D(in_Texture, texCoords[0]) +
+              texture2D(in_Texture, texCoords[1]) +
+              texture2D(in_Texture, texCoords[2]) +
+              texture2D(in_Texture, texCoords[3]) +
+              texture2D(in_Texture, texCoords[4]) +
+              texture2D(in_Texture, texCoords[5]) +
+              texture2D(in_Texture, texCoords[6]) +
+              texture2D(in_Texture, texCoords[7]) +
+              texture2D(in_Texture, texCoords[8]);
+
+   avgColor /= float(KERNEL_SIZE);
+
+   gl_FragColor = avgColor;
+}

data/lib/ashton/shaders/radial_blur.frag

@@ -0,0 +1,63 @@
+#version 110
+
+// http://www.gamerendering.com/2008/12/20/radial-blur-filter/
+
+uniform sampler2D in_Texture; // Texture to manipulate.
+uniform int in_WindowWidth;
+uniform int in_WindowHeight;
+
+uniform float in_Spacing; // good value is 1.0;
+uniform float in_Strength; // good value is 2.2;
+
+varying vec2 var_TexCoord;
+
+void main(void)
+{
+    // some sample positions. GLSL 1.10 is painfully dumb with arrays :)
+    float samples[10];
+    samples[0] = -0.08;
+    samples[1] = -0.05;
+    samples[2] = -0.03;
+    samples[3] = -0.02;
+    samples[4] = -0.01;
+    samples[5] =  0.01;
+    samples[6] =  0.02;
+    samples[7] =  0.03;
+    samples[8] =  0.05;
+    samples[9] =  0.08;
+
+    // 0.5,0.5 is the center of the screen
+    // so substracting uv from it will result in
+    // a vector pointing to the middle of the screen
+    vec2 dir = 0.5 - var_TexCoord;
+
+    // calculate the distance to the center of the screen
+    float dist = sqrt(dir.x * dir.x + dir.y * dir.y);
+
+    // normalize the direction (reuse the distance)
+    dir /= dist;
+
+    // this is the original colour of this fragment
+    // using only this would result in a non-blurred version
+    vec4 color = texture2D(in_Texture, var_TexCoord);
+
+    vec4 sum = color;
+
+    // take 10 additional blur samples in the direction towards
+    // the center of the screen
+    for (int i = 0; i < 10; i++)
+    {
+        sum += texture2D(in_Texture, var_TexCoord + dir * samples[i] * in_Spacing);
+    }
+
+    // we have taken eleven samples
+    sum *= 1.0/11.0;
+
+    // weighten the blur effect with the distance to the
+    // center of the screen ( further out is blurred more)
+    float t = dist * in_Strength;
+    t = clamp(t, 0.0, 1.0); //0 &lt;= t &lt;= 1
+
+    // Blend the original color with the averaged pixels
+    gl_FragColor = mix(color, sum, t);
+}

data/lib/ashton/shaders/sepia.frag

@@ -0,0 +1,26 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+  vec4 Sepia1 = vec4( 0.2, 0.05, 0.0, 1.0 );    
+  vec4 Sepia2 = vec4( 1.0, 0.9, 0.5, 1.0 );
+ 
+  vec4 Color = texture2D(in_Texture, vec2(var_TexCoord));
+
+  if(Color.a == 0.0)
+  {
+    gl_FragColor = Color;
+  }
+  else
+  {
+    float SepiaMix = dot(vec3(0.3, 0.59, 0.11), vec3(Color));
+    Color = mix(Color, vec4(SepiaMix), vec4(0.5));
+    vec4 Sepia = mix(Sepia1, Sepia2, SepiaMix);
+
+    gl_FragColor = mix(Color, Sepia, 1.0);
+  }
+}

data/lib/ashton/{post_process/shockwave2.frag → shaders/shockwave.frag}

@@ -1,35 +1,38 @@
-#version 110
-
-// http://www.geeks3d.com/20091116/shader-library-2d-shockwave-post-processing-filter-glsl/
-
-uniform sampler2D in_Texture; // 0
-uniform vec2 in_Center; // Mouse position
-uniform float in_Time; // effect elapsed time. Multiply this to affect speed.
-
-// Amplitude?, Refraction?, Width?  e.g. 10.0, 0.8, 0.1
-uniform vec3 in_ShockParams;
-
-uniform int in_WindowWidth;
-uniform int in_WindowHeight;
-
-varying vec2 var_TexCoord;
-
-void main()
-{
-  vec2 uv = var_TexCoord;
-  vec2 texCoord = uv;
-  float distance = distance(uv, in_Center / vec2(float(in_WindowWidth), float(in_WindowHeight)));
-
-  if ( (distance <= (in_Time + in_ShockParams.z)) &&
-       (distance >= (in_Time - in_ShockParams.z)) )
-  {
-    float diff = (distance - in_Time);
-    float powDiff = 1.0 - pow(abs(diff * in_ShockParams.x),
-                                in_ShockParams.y);
-    float diffTime = diff  * powDiff;
-    vec2 diffUV = normalize(uv - in_Center);
-    texCoord = uv + (diffUV * diffTime);
-  }
-
-  gl_FragColor = texture2D(in_Texture, texCoord);
-}
+#version 110
+
+// http://empire-defense.crystalin.fr/blog/2d_shock_wave_texture_with_shader
+// http://www.geeks3d.com/20091116/shader-library-2d-shockwave-post-processing-filter-glsl/
+
+uniform sampler2D in_Texture; // 0
+uniform vec2 in_Center; // Mouse position
+uniform float in_Time; // effect elapsed time. Multiply this to affect speed.
+
+// Amplitude?, Refraction?, Width?  e.g. 10.0, 0.8, 0.1
+uniform vec3 in_ShockParams;
+
+uniform int in_WindowWidth;
+uniform int in_WindowHeight;
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+  vec2 uv = var_TexCoord;
+  vec2 texCoord = uv;
+  float x = in_Center.x / float(in_WindowWidth);
+  float y = (float(in_WindowHeight) - in_Center.y) / float(in_WindowHeight);
+  float distance = distance(uv, vec2(x, y));
+
+  if ( (distance <= (in_Time + in_ShockParams.z)) &&
+       (distance >= (in_Time - in_ShockParams.z)) )
+  {
+    float diff = (distance - in_Time);
+    float powDiff = 1.0 - pow(abs(diff * in_ShockParams.x),
+                                in_ShockParams.y);
+    float diffTime = diff  * powDiff;
+    vec2 diffUV = normalize(uv - in_Center);
+    texCoord = uv + (diffUV * diffTime);
+  }
+
+  gl_FragColor = texture2D(in_Texture, texCoord);
+}

data/lib/ashton/shaders/signed_distance_field.frag

@@ -0,0 +1,80 @@
+#version 110
+
+// Calculates a signed distance field, based on how far any pixel is from an opaque pixel.
+// In each pixel, the signed value is actually r/g/b - 128
+//    if r/g/b > 0 => distance from an opaque pixel.
+//    if r/g/b <= 0 => distance from an opaque pixel that is adjacent to a transparent pixel.
+
+uniform sampler2D in_Texture; // Original texture.
+
+uniform vec2 in_TextureSize; // Width and height of the texture, so we know how big pixels are.
+uniform int in_StepSize; // Distance to check each time (larger steps will be faster, but less accurate).
+uniform int in_MaxDistance; // Maximum distance to search out to. Cannot be more than 127!
+
+varying vec2 var_TexCoord; // Pixel to process on this pass.
+
+const float NUM_SPOKES = 36.0; // Number of radiating lines to check in.
+const float ANGULAR_STEP = 360.0 / NUM_SPOKES;
+
+const int ZERO_VALUE = 128; // Color channel containing 0 => -128, 128 => 0, 255 => +127
+
+// Returns true an alpha value is found at this distance (any direction).
+bool find_alpha_at_distance(in vec2 center, in vec2 distance, in float alpha)
+{
+    bool found = false;
+
+    for(float angle = 0.0; angle < 360.0; angle += ANGULAR_STEP)
+    {
+        vec2 position = center + distance * vec2(cos(angle), sin(angle));
+
+        if(texture2D(in_Texture, position).a == alpha)
+        {
+           found = true;
+           angle = 361.0;
+        }
+    }
+
+    return found;
+}
+
+void main()
+{
+    vec2 pixel_size = 1.0 / in_TextureSize;
+
+    int distance;
+
+    if(texture2D(in_Texture, var_TexCoord).a == 0.0)
+    {
+        // Texel is transparent, search for nearest opaque.
+        distance = ZERO_VALUE + 1;
+        for(int i = in_StepSize; i < in_MaxDistance; i += in_StepSize)
+        {
+            if(find_alpha_at_distance(var_TexCoord, float(i) * pixel_size, 1.0))
+            {
+                i = in_MaxDistance + 1; // BREAK!
+            }
+            else
+            {
+                distance = ZERO_VALUE + 1 + i;
+            }
+        }
+    }
+    else
+    {
+        // Texel is opaque, search for nearest transparent.
+        distance = ZERO_VALUE;
+        for(int i = in_StepSize; i <= in_MaxDistance; i += in_StepSize)
+        {
+            if(find_alpha_at_distance(var_TexCoord, float(i) * pixel_size, 0.0))
+            {
+                i = in_MaxDistance + 1; // BREAK!
+            }
+            else
+            {
+                distance = ZERO_VALUE - i;
+            }
+        }
+    }
+
+    gl_FragColor =  vec4(vec3(float(distance) / 255.0), 1.0);
+}