danabr75-ashton 0.1.5

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/shaders/pixelate.frag

@@ -0,0 +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;
+}

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/shaders/shockwave.frag

@@ -0,0 +1,38 @@
+#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);
+}

data/lib/ashton/shaders/static.frag

@@ -0,0 +1,25 @@
+#version 110
+
+#include <rand>
+
+// Rather poor quality noise generation, but better than nothing and sort of looks like TV static a bit.
+
+uniform sampler2D in_Texture;
+
+uniform int in_WindowWidth; // Not used.
+uniform int in_WindowHeight; // Not used.
+
+uniform float in_Intensity;
+uniform float in_T;
+
+varying vec2 var_TexCoord;
+
+void main() {
+	vec4 color = texture2D(in_Texture, var_TexCoord);
+	
+	vec4 influence = min(color, 1.0 - color);
+	
+	float noise = 1.0 - 2.0 * rand(var_TexCoord + float(in_T));
+	
+    gl_FragColor = color + in_Intensity * influence * noise;
+}

data/lib/ashton/shaders/stencil.frag

@@ -0,0 +1,27 @@
+#version 110
+
+// Use a stencil texture to selectively draw. Drawing of the image will occur
+// where the stencil is transparent (or only where the stencil is opaque if
+// inverted).
+//
+// Partial transparency in the stencil will allow the image to be drawn
+// partially too.
+
+varying vec4 var_Color;
+varying vec2 var_TexCoord0; // The texture/image to draw.
+varying vec2 var_TexCoord1; // The stencil (multitexture).
+
+uniform sampler2D in_Texture0; // The texture/image to draw.
+uniform sampler2D in_Texture1; // The stencil (multitexture).
+uniform bool in_Inverted; // true to draw in opaque areas / false to draw in transparent areas.
+ 
+void main()
+{
+  vec4 texColor = texture2D(in_Texture0, var_TexCoord0);
+  vec4 maskColor = texture2D(in_Texture1, var_TexCoord1);
+
+  // Only draw the texture where the stencil is transparent (unless inverted).
+  float mask_alpha = in_Inverted ? (1.0 - maskColor.a) : maskColor.a;
+
+  gl_FragColor = vec4(texColor.r, texColor.g, texColor.b, texColor.a - mask_alpha);
+}

data/lib/ashton/shaders/tv_screen.frag

@@ -0,0 +1,23 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+uniform float in_ColumnWidth; // In pixels.
+uniform int in_WindowWidth;
+uniform int in_WindowHeight; // Not used in this shader.
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+    vec3 color = texture2D(in_Texture, var_TexCoord).rgb;
+
+    gl_FragColor = vec4(color * 0.25, 1.0);
+
+    float column_index = var_TexCoord.x * float(in_WindowWidth) / in_ColumnWidth;
+
+    int c = int(mod(column_index, 3.0));
+    if(c == 0) { gl_FragColor.r = color.r; }
+    else if(c == 1) { gl_FragColor.g = color.g; }
+    else if(c == 2) { gl_FragColor.b = color.b; }
+}

data/lib/ashton/signed_distance_field.rb

@@ -0,0 +1,151 @@
+module Ashton
+  class SignedDistanceField
+    ZERO_DISTANCE = 128 # color channel containing 0 => -128, 128 => 0, 129 => +1, 255 => +128
+
+    attr_reader :width, :height
+
+    # Creates a Signed Distance Field based on a given image.
+    # When drawing into the SDF, drawing should ONLY have alpha of 0 (clear) or 255 (solid)
+    #
+    # @param width [Integer]
+    # @param height [Integer]
+    # @param max_distance [Integer] Maximum distance to measure.
+    # @option options :step_size [Integer] (1) pixels to step out.
+    # @option options :scale [Integer] (1) Scale relative to the image.
+    def initialize(width, height, max_distance, options = {}, &block)
+      options = {
+         scale: 1,
+         step_size: 1,
+      }.merge! options
+
+      @width, @height = width, height
+      @scale = options[:scale].to_f
+
+      @shader = Shader.new fragment: :signed_distance_field, uniforms: {
+          max_distance: max_distance.ceil,
+          step_size: options[:step_size].floor, # One pixel.
+          texture_size: [width, height].map(&:to_f),
+      }
+
+      @field = Texture.new (width / @scale).ceil, (height / @scale).ceil
+      @mask = Texture.new @field.width, @field.height
+
+      if block_given?
+        render_field(&block)
+      else
+        @field.clear color: Gosu::Color.rgb(*([ZERO_DISTANCE + max_distance] * 3))
+      end
+    end
+
+    # Is the position clear for a given radius around it.
+    def position_clear?(x, y, radius)
+      sample_distance(x, y) >= radius
+    end
+
+    # If positive, distance, in pixels, to the nearest opaque pixel.
+    # If negative, distance in pixels to the nearest transparent pixel.
+    def sample_distance(x, y)
+      x = [[x, width - 1].min, 0].max
+      y = [[y, height - 1].min, 0].max
+      # Could be checking any of red/blue/green.
+      @field.red((x / @scale).round, (y / @scale).round) - ZERO_DISTANCE
+    end
+
+    # Gets the gradient of the field at a given point.
+    # @return [Float, Float] gradient_x, gradient_y
+    def sample_gradient(x, y)
+      d0 = sample_distance x, y - 1
+      d1 = sample_distance x - 1, y
+      d2 = sample_distance x + 1, y
+      d3 = sample_distance x, y + 1
+
+      [(d2 - d1) / @scale, (d3 - d0) / @scale]
+    end
+
+    # Get the normal at a given point.
+    # @return [Float, Float] normal_x, normal_y
+    def sample_normal(x, y)
+      gradient_x, gradient_y = sample_gradient x, y
+      length = Gosu::distance 0, 0, gradient_x, gradient_y
+      if length == 0
+        [0, 0] # This could be NaN in edge cases.
+      else
+        [gradient_x / length, gradient_y / length]
+      end
+    end
+
+    # Does the point x1, x2 have line of sight to x2, y2 (that is, no solid in the way).
+    def line_of_sight?(x1, y1, x2, y2)
+      !line_of_sight_blocked_at(x1, y1, x2, y2)
+    end
+
+    # Returns blocking position, else nil if line of sight isn't blocked.
+    def line_of_sight_blocked_at(x1, y1, x2, y2)
+      distance_to_travel = Gosu::distance x1, y1, x2, y2
+      distance_x, distance_y = x2 - x1, y2 - y1
+      distance_travelled = 0
+      x, y = x1, y1
+
+      loop do
+        distance = sample_distance x, y
+
+        # Blocked?
+        return [x, y] if distance <= 0
+
+        distance_travelled += distance
+
+        # Got to destination in the clear.
+        return nil if distance_travelled >= distance_to_travel
+
+        lerp = distance_travelled.fdiv distance_to_travel
+        x = x1 + distance_x * lerp
+        y = y1 + distance_y * lerp
+      end
+    end
+
+    # Update the SDF should the image have changed.
+    # Draw the mask in the passed block.
+    def render_field
+      raise ArgumentError, "Block required" unless block_given?
+
+      @mask.render do
+        @mask.clear
+        $window.scale 1.0 / @scale do
+          yield self
+        end
+      end
+
+      @shader.enable do
+        @field.render do
+          @mask.draw 0, 0, 0
+        end
+      end
+
+      nil
+    end
+
+    # Draw the field, usually for debugging purposes.
+    # @see Ashton::Texture#draw
+    def draw(x, y, z, options = {})
+      options = {
+          mode: :add,
+      }.merge! options
+
+      $window.scale @scale do
+        @field.draw x, y, z, options
+      end
+
+      nil
+    end
+
+    # Convert into a nested array of sample values.
+    # @return [Array<Array<Integer>>]
+    def to_a
+      width.times.map do |x|
+        height.times.map do |y|
+          sample_distance x, y
+        end
+      end
+    end
+  end
+end