ashton 0.0.1alpha

data/lib/ashton/framebuffer.rb

@@ -0,0 +1,183 @@
+module Ashton
+  class Framebuffer
+    TEXTURE_COORDINATES = [
+        [0, 1], # TL
+        [0, 0], # BL
+        [1, 0], # TR
+        [1, 1], # BR
+    ]
+
+    TEXTURE_COORDINATES_FLIPPED = [
+        [0, 0], # BL
+        [0, 1], # TL
+        [1, 1], # BR
+        [1, 0], # TR
+    ]
+
+    attr_reader :width, :height, :texture
+
+    def initialize(width, height)
+      @width, @height = width.to_i, height.to_i
+      @fbo, @texture = init_framebuffer
+
+      status = glCheckFramebufferStatusEXT GL_FRAMEBUFFER_EXT
+      raise unless status == GL_FRAMEBUFFER_COMPLETE_EXT
+
+      clear
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+      glBindRenderbufferEXT GL_RENDERBUFFER_EXT, 0
+    end
+
+    # Clears the buffer to transparent.
+    def clear(options = {})
+      options = {
+          color: [0.0, 0.0, 0.0, 0.0],
+      }.merge! options
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, @fbo
+
+      glClearColor *options[:color]
+      glClear GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+    end
+
+    # Enable the framebuffer to use (e.g. to draw or convert it).
+    # BUG: This will force all draws performed in, AND BEFORE, the block!
+    def use
+      raise ArgumentError, "block required" unless block_given?
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, @fbo
+      result = yield self
+
+      $window.flush
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+
+      result
+    end
+
+    # Draw the image, _immediately_ (no z-ordering by Gosu).
+    #
+    # This is not as versatile as converting the Framebuffer into a Gosu::Image and then
+    # drawing it, but it is many times faster, so use it when you are updating the buffer
+    # every frame, rather than just composing an image.
+    #
+    # Drawing in Gosu orientation will be flipped in standard OpenGL and visa versa.
+    #
+    # @param x [Number]
+    # @param y [Number]
+    # @option options :orientation [:gosu, :opengl] (:gosu)
+    def draw x, y, options = {}
+      options = {
+          :orientation => :gosu,
+      }.merge! options
+
+      glEnable GL_TEXTURE_2D
+      glBindTexture GL_TEXTURE_2D, @texture
+
+      coords = case options[:orientation]
+                 when :gosu   then TEXTURE_COORDINATES_FLIPPED
+                 when :opengl then TEXTURE_COORDINATES
+                 else raise ArgumentError, ":orientation option expected to be either :opengl or :gosu"
+               end
+
+      glBegin GL_QUADS do
+        glTexCoord2d *coords[0]
+        glVertex2d x, y + @height # BL
+
+        glTexCoord2d *coords[1]
+        glVertex2d x, y # TL
+
+        glTexCoord2d *coords[2]
+        glVertex2d x + @width, y # TR
+
+        glTexCoord2d *coords[3]
+        glVertex2d x + @width, y + @height # BR
+      end
+
+      glBindTexture GL_TEXTURE_2D, 0
+    end
+
+    # Convert the current contents of the buffer into a Gosu::Image
+    #
+    # @option options [Boolean] :caching (true) TexPlay behaviour.
+    # @option options [Boolean] :tileable (false) Standard Gosu behaviour.
+    # @option options [Array<Integer>] :rect ([0, 0, width, height]) Rectangular area of buffer to use to create the image [x, y, w, h]
+    def to_image(options = {})
+      options = {
+        rect: [0, 0, @width, @height],
+        tileable: false,
+      }.merge! options
+
+      rect = options[:rect]
+
+      # Draw onto the clean flip buffer, in order to flip before saving.
+      @fbo_flip, @fbo_flip_texture = init_framebuffer unless defined? @fbo_flip
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, @fbo_flip
+      glClearColor 0, 0, 0, 0
+      glClear GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+      draw 0, 0
+
+      # Read the data in the flip-buffer.
+      glBindTexture GL_TEXTURE_2D, @fbo_flip_texture
+      blob = glReadPixels *rect, GL_RGBA, GL_UNSIGNED_BYTE
+
+      # Clean up.
+      glBindTexture GL_TEXTURE_2D, 0
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+
+      # Create a new Image from the flipped pixel data.
+      stub = ImageStub.new blob, rect[2], rect[3]
+      if defined? TexPlay
+        Gosu::Image.new $window, stub, options[:tileable], options
+      else
+        Gosu::Image.new $window, stub, options[:tileable]
+      end
+
+    end
+
+    # Create an fbo and its texture
+    def init_framebuffer
+      fbo = glGenFramebuffersEXT(1)[0]
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, fbo
+
+      texture = init_framebuffer_texture
+
+      glFramebufferTexture2DEXT GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texture, 0
+
+      [fbo, texture]
+    end
+
+    protected
+    # Called by init_framebuffer.
+    def init_framebuffer_texture
+      texture = glGenTextures(1)[0]
+      glBindTexture GL_TEXTURE_2D, texture
+
+      glTexParameterf GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE
+      glTexParameterf GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE
+      glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST
+      glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST
+
+      glTexImage2D GL_TEXTURE_2D, 0, GL_RGBA8, @width, @height,
+                   0, GL_RGBA, GL_UNSIGNED_BYTE, nil
+
+      glBindTexture GL_TEXTURE_2D, 0 # Unbind the texture
+
+      texture
+    end
+
+    protected
+    def delete
+      glDeleteFramebuffersEXT @fbo
+      glDeleteTextures @texture
+
+      glDeleteFramebuffersEXT @fbo_flip if defined? @fbo_flip
+      glDeleteTextures @fbo_flip_texture if defined? @fbo_flip_texture
+
+      glBindFramebufferEXT GL_FRAMEBUFFER_EXT, 0
+    end
+  end
+end

data/lib/ashton/gosu_ext/color.rb

@@ -0,0 +1,12 @@
+module Gosu
+  class Color
+    def self.from_opengl(array)
+      rgba *array.map {|c| (c * 255).to_i }
+    end
+
+    # Convert to length 4 array of floats in range 0.0 to 1.0
+    def to_opengl
+      [red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0]
+    end
+  end
+end

data/lib/ashton/gosu_ext/image.rb

@@ -0,0 +1,32 @@
+module Gosu
+  class Image
+    alias_method :draw_without_hash, :draw
+
+    def draw(*args)
+      if args.last.is_a? Hash
+        shader = args.last[:shader]
+        shader.use do
+          shader.image = self
+          shader.color = args[5].is_a?(Color) ? args[5] : [1, 1, 1, 1]
+          draw_without_hash *args[0...-1]
+        end
+      else
+        draw_without_hash *args
+      end
+    end
+
+    alias_method :draw_rot_without_hash, :draw_rot
+    def draw_rot(*args)
+      if args.last.is_a? Hash
+        shader = args.last[:shader]
+        shader.use do
+          shader.image = self
+          shader.color = args[8].is_a?(Color) ? args[8] : [1, 1, 1, 1]
+          draw_rot_without_hash *args[0...-1]
+        end
+      else
+        draw_rot_without_hash *args
+      end
+    end
+  end
+end

data/lib/ashton/gosu_ext/window.rb

@@ -0,0 +1,36 @@
+# Set the window global, in case it hasn't been set (e.g. by Chingu)
+module Gosu
+  class Window
+    class << self
+      # Used for post-processing effects.
+      attr_accessor :back_buffer
+    end
+
+    alias_method :ashton_initialize, :initialize
+    def initialize(*args, &block)
+      $window = self
+      ashton_initialize *args, &block
+    end
+
+    # TODO: accept multiple shaders.
+    def post_process(shader)
+      raise ArgumentError, "Block required" unless block_given?
+
+      Window.back_buffer ||= Ashton::Framebuffer.new width, height
+
+      buffer = Window.back_buffer
+      buffer.clear
+
+      # allow drawing into the back-buffer.
+      buffer.use do
+        yield
+      end
+
+      # Draw the back-buffer onto the window, utilising the shader.
+      shader.use do
+        shader["in_Texture"] = 0
+        buffer.draw 0, 0
+      end
+    end
+  end
+end

data/lib/ashton/image_stub.rb

@@ -0,0 +1,37 @@
+module Ashton
+  # Used internally to create images from raw binary (blob) data.
+  #
+  # This object duck-types an RMagick image (#rows, #columns, #to_blob), so that Gosu will import it.
+  class ImageStub
+
+    # @return [Integer]
+    attr_reader :rows, :columns
+
+    # The first pixel in the blob will be at the top left hand corner of the created image, since that is the orientation
+    # of Gosu images.
+    #
+    # @param [String] blob_data Raw data string to import. Must be RGBA ordered, (4 * width * height) bytes in length.
+    # @param [Integer] width Number of pixels wide.
+    # @param [Integer] height Number of pixels high.
+    def initialize(blob_data, width, height)
+      @data, @columns, @rows = blob_data, width, height
+    end
+
+    # @return [String]
+    def to_blob
+      @data
+    end
+  end
+
+  # Used internally to create blank images (red/blue/green/alpha all 0).
+  #
+  # Credit to philomory for this class.
+  class EmptyImageStub < ImageStub
+    # @param width (see ImageStub#initialize)
+    # @param height (see ImageStub#initialize)
+    def initialize(width, height)
+      #raise ArgumentError if (width > TexPlay::TP_MAX_QUAD_SIZE || height > TexPlay::TP_MAX_QUAD_SIZE)
+      super('\0' * (width * height * 4), width, height)
+    end
+  end
+end

data/lib/ashton/include/simplex.glsl

@@ -0,0 +1,63 @@
+// -----------------------------------
+//
+// Description : Array and textureless GLSL 2D simplex noise function.
+//      Author : Ian McEwan, Ashima Arts.
+//  Maintainer : ijm
+//     Lastmod : 20110410 (stegu)
+//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
+//               Distributed under the MIT License. See LICENSE file.
+//
+
+vec3 permute(vec3 x)
+{
+  return mod(((x*34.0)+1.0)*x, 289.0);
+}
+
+float snoise(vec2 v)
+{
+  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
+                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
+                     -0.577350269189626,  // -1.0 + 2.0 * C.x
+                      0.024390243902439); // 1.0 / 41.0
+  // First corner
+  vec2 i  = floor(v + dot(v, C.yy) );
+  vec2 x0 = v -   i + dot(i, C.xx);
+
+  // Other corners
+  vec2 i1;
+  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+  //i1.y = 1.0 - i1.x;
+  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  // x0 = x0 - 0.0 + 0.0 * C.xx ;
+  // x1 = x0 - i1 + 1.0 * C.xx ;
+  // x2 = x0 - 1.0 + 2.0 * C.xx ;
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+
+  // Permutations
+  i = mod(i, 289.0); // Avoid truncation effects in permutation
+  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+		+ i.x + vec3(0.0, i1.x, 1.0 ));
+
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m*m ;
+  m = m*m ;
+
+  // Gradients: 41 points uniformly over a line, mapped onto a diamond.
+  // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+
+  // Normalise gradients implicitly by scaling m
+  // Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
+
+  // Compute final noise value at P
+  vec3 g;
+  g.x  = a0.x  * x0.x  + h.x  * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}

data/lib/ashton/post_process/contrast.frag

@@ -0,0 +1,16 @@
+#version 110
+
+uniform sampler2D in_Texture;
+uniform float in_contrast;
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+  vec4 color = texture2D(in_Texture, var_TexCoord);
+  
+  color = (color - 0.5) * contrast + 0.5;
+  
+  gl_FragColor.rgb = color.rgb;
+  gl_FragColor.a = 1.0;
+}

data/lib/ashton/post_process/default.vert

@@ -0,0 +1,9 @@
+#version 110
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+  gl_Position = ftransform();
+  var_TexCoord = gl_MultiTexCoord0.xy;
+}

data/lib/ashton/post_process/fade.frag

@@ -0,0 +1,11 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+uniform float fade; # 1.0 => normal 0.0 => invisible.
+
+varying vec2 var_TexCoord;
+
+void main() {
+    gl_FragColor = texture2D(in_Texture, var_TexCoord) * fade;
+}

data/lib/ashton/post_process/mezzotint.frag

@@ -0,0 +1,24 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+uniform int t;
+
+varying vec2 var_TexCoord;
+
+float rand(vec2 co) {
+	return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+void main() {
+	vec4 color;
+
+    color = texture2D(in_Texture, var_TexCoord);
+
+	vec3 mezzo = vec3(0.0);
+	if(rand(var_TexCoord + float(t)/640.0) <= color.r) { mezzo.r = 1.0; }
+	if(rand(var_TexCoord + float(t)/640.0) <= color.g) { mezzo.g = 1.0; }
+	if(rand(var_TexCoord + float(t)/640.0) <= color.b) { mezzo.b = 1.0; }
+		
+    gl_FragColor.rgb = mezzo;
+}

data/lib/ashton/post_process/noise.frag

@@ -0,0 +1,27 @@
+#version 110
+
+// 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;
+
+float rand(vec2 co) {
+	return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}
+
+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/post_process/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/post_process/radial_blur.frag

@@ -0,0 +1,31 @@
+#version 110
+
+uniform sampler2D in_Texture; // Texture to manipulate.
+uniform int in_WindowWidth;
+uniform int in_WindowHeight;
+
+uniform float in_BlurFactor;
+uniform float in_BrightFactor;
+uniform float in_OriginX;
+uniform float in_OriginY;
+uniform int in_Passes; // Number of passes to make (more is slower)
+
+varying vec2 var_TexCoord; // Coordinate coming from the default vertex shader.
+
+void main()
+{
+	vec2 Origin = vec2(in_OriginX, 1.0 - in_OriginY);
+
+	vec2 TexCoord = vec2(var_TexCoord);
+
+	vec4 SumColor = vec4(0.0, 0.0, 0.0, 0.0);
+	TexCoord += vec2(1.0 / float(in_WindowWidth), 1.0 / float(in_WindowHeight)) * 0.5 - Origin;
+
+	for (int i = 0; i < in_Passes; i++)
+	{
+		float Scale = 1.0 - in_BlurFactor * (float(i) / float(in_Passes - 1));
+		SumColor += texture2D(in_Texture, TexCoord * Scale + Origin);
+	}
+
+	gl_FragColor = SumColor / float(in_Passes) * in_BrightFactor;
+}

data/lib/ashton/post_process/sepia.frag

@@ -0,0 +1,19 @@
+#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));
+ 
+  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/shockwave.frag

@@ -0,0 +1,40 @@
+#version 110
+
+uniform sampler2D in_Texture;
+
+varying vec2 var_TexCoord;
+
+uniform float in_Center;
+uniform float in_WaveWidth;
+uniform float in_Time;
+uniform float in_Ratio;
+uniform float in_Refraction;
+
+uniform int in_WindowWidth;
+uniform int in_WindowHeight;
+
+const float PI = 3.14159;
+
+void main()
+{
+    vec2 source_coords = var_TexCoord;
+    vec3 color = texture2D(in_Texture, source_coords).rgb;
+
+    float x = in_X / float(in_WindowHeight);
+    float y = 1.0 - in_Y / float(in_WindowHeight);
+    vec2 rel = source_coords - vec2(x, y);
+    rel.x *= in_Ratio;
+
+    float dist = sqrt(rel.x * rel.x + rel.y * rel.y);
+
+    if(dist >= in_Min && dist <= in_Max)
+    {
+        float inner = (dist - in_Min) / (in_Max - in_Min);
+        float depth = 0.5 + 0.5 * cos((inner + 0.5) * 2.0 * PI);
+
+        source_coords -= depth * rel / dist * in_Refraction;
+        color = texture2D(in_Texture, source_coords).rgb;
+    }
+    
+    gl_FragColor.rgb = color;
+}

data/lib/ashton/post_process/shockwave2.frag

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

data/lib/ashton/post_process/tv_screen.frag

@@ -0,0 +1,32 @@
+#version 110
+#extension GL_EXT_gpu_shader4 : enable
+
+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;
+
+	switch(int(column_index) % 3)
+    {
+      case 0:
+        gl_FragColor.r = color.r;
+        break;
+      case 1:
+        gl_FragColor.g = color.g;
+        break;
+      case 2:
+        gl_FragColor.b = color.b;
+        break;
+    }
+}