ashton 0.0.1alpha → 0.0.2alpha

data/examples/noise_example.rb

@@ -0,0 +1,94 @@
+# Use of GLSL shader in Gosu to post-process the entire screen.
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('../lib/', File.dirname(__FILE__))
+require "ashton"
+
+def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
+
+class TestWindow < Gosu::Window
+  NOISE_FRAGMENT =<<-END
+#version 110
+
+// Use 3D Simplex noise, even though the shader operates on a 2D
+// texture, since then we can make the Z-coordinate act as time.
+#include <noise3d>
+
+uniform sampler2D in_Texture;
+
+uniform float in_T;
+uniform vec4 in_BlobColor;
+
+varying vec2 var_TexCoord;
+
+void main()
+{
+  gl_FragColor = texture2D(in_Texture, var_TexCoord);
+
+  // First layer. faster, low intensity, small scale blobbing.
+  // Use [x, y, t] to create a 2D noise that varies over time.
+  vec3 position1 = vec3(var_TexCoord * 25.0, in_T * 1.6);
+
+  // Gives range 0.75..1.25
+  float brightness1 = snoise(position1) / 4.0 + 1.0;
+
+  // Second layer - slow, high intensity, large-scale blobbing
+  // This decides where the first layer will be "seen"
+  // Use [x, y, t] to create a 2D noise that varies over time.
+  vec3 position2 = vec3(var_TexCoord * 3.0, in_T * 0.16);
+
+  // Gives range 0.3..1.3
+  float brightness2 = snoise(position2) / 2.0 + 0.8;
+
+  if(brightness2 > 0.8)
+  {
+    gl_FragColor.rgb += in_BlobColor.rgb;
+    gl_FragColor.rgb *= brightness1 * brightness2;
+  }
+}
+  END
+
+  def initialize
+    super 640, 480, false
+    self.caption = "Post-processing with the simplex noise function - intelligent blob?"
+
+    @noise = Ashton::Shader.new fragment: NOISE_FRAGMENT, uniforms: {
+        blob_color: Gosu::Color.rgb(0, 40, 0),
+    }
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+    @background = Gosu::Image.new(self, media_path("Earth.png"), true)
+    @start_time = Time.now
+
+    update # Ensure the values are initially set.
+  end
+
+  def update
+    $gosu_blocks.clear if defined? $gosu_blocks # Workaround for Gosu bug (0.7.45)
+    @noise.t = Time.now - @start_time
+  end
+
+  def draw
+    post_process @noise do
+      @background.draw 0, 0, 0, width.fdiv(@background.width), height.fdiv(@background.height)
+
+      @font.draw_rel "Hello world!", 350, 50, 0, 0.5, 0.5, 1, 1, Gosu::Color::GREEN
+      @font.draw_rel "Goodbye world!", 400, 350, 0, 0.5, 0.5, 2, 2, Gosu::Color::BLUE
+    end
+
+    # Drawing after the effect isn't processed, which is useful for GUI elements.
+    @font.draw "FPS: #{Gosu::fps}", 0, 0, 0
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+end
+
+TestWindow.new.show

data/examples/outline_example.rb

@@ -0,0 +1,86 @@
+# Use of GLSL shader in Gosu to post-process the entire screen.
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('../lib/', File.dirname(__FILE__))
+require "ashton"
+
+def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
+
+class TestWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+
+    Gosu::enable_undocumented_retrofication
+
+    self.caption = "Image, font and buffer composition drawn with 'outline' shader"
+
+    @outline = Ashton::Shader.new fragment: :outline
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+    @ship = Gosu::Image.new(self, media_path("Starfighter.png"), true)
+    @background = Gosu::Image.new(self, media_path("Earth.png"), true)
+
+    @buffer = Ashton::Texture.new width, height
+
+    render_to_buffer
+  end
+
+  def update
+    $gosu_blocks.clear if defined? $gosu_blocks # Workaround for Gosu bug (0.7.45)
+    render_to_buffer
+  end
+
+  def render_to_buffer
+    # Draw together into a temp buffer, before outlining all together.
+    @buffer.render do |buffer|
+      buffer.clear
+
+      10.downto(1) do |i|
+        scale = i / 2.0
+        angle = i * 15 + Time.now.to_f * 10
+
+        @ship.draw_rot i * 25, 15 + i * 30, 0, angle, 0.5, 0.5, scale, scale
+      end
+    end
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+
+  def draw
+    @background.draw 0, 0, 0, width.fdiv(@background.width), height.fdiv(@background.height)
+
+    @outline.outline_width = 2.0
+    @outline.outline_color = Gosu::Color::YELLOW
+    @buffer.draw 0, 0, 0, shader: @outline
+
+    # Draw individually, each with their own outline.
+    10.downto(1) do |i|
+      scale = i / 2.0
+      angle = i * 15 + Time.now.to_f * 10
+
+      @outline.outline_color = [Gosu::Color::RED, Gosu::Color::WHITE][i % 2]
+
+      # This keeps the outline of constant width on the screen,
+      # compared to the sprite pixels. Wouldn't keep updating this in real usage, of course.
+      @outline.outline_width = 0.9 / scale
+
+      @ship.draw_rot 225 + i * 25, 15 + i * 30, 0, angle, 0.5, 0.5, scale, scale, :shader => @outline
+    end
+
+    # Guitastic!
+    @outline.outline_width = 2.0
+    @outline.outline_color = Gosu::Color::BLACK
+    @font.draw "FPS:", 0, 0, 0, 1, 1, Gosu::Color::BLUE, shader: @outline
+    @font.draw_rel "#{Gosu::fps}", 150, 0, 0, 1, 0, 1, 1, Gosu::Color::GREEN, shader: @outline
+  end
+end
+
+TestWindow.new.show

data/examples/particle_emitter_example.rb

@@ -0,0 +1,114 @@
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('../lib/', File.dirname(__FILE__))
+require "ashton"
+
+def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
+
+class TestWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+    self.caption = "Particle emitters - 4 emitters at static positions and one on mouse"
+
+    @grayscale = Ashton::Shader.new fragment: :grayscale
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 24
+    @star = Gosu::Image.new self, media_path("SmallStar.png"), true
+
+    @image_emitter = Ashton::ParticleEmitter.new 450, 100, 0,
+                                                 image: @star,
+                                                 scale: 0.2,
+                                                 speed: 40,
+                                                 friction: 0.1,
+                                                 max_particles: 30000,
+                                                 interval: 0.00015,
+                                                 fade: 57, # loses 25 alpha/s
+                                                 angular_velocity: -50..50
+
+    @shaded_image_emitter = Ashton::ParticleEmitter.new 450, 350, 0,
+                                                        image: @star,
+                                                        shader: @grayscale,
+                                                        interval: 0.00015,
+                                                        offset: 0..10,
+                                                        max_particles: 30000,
+                                                        angular_velocity: 20..50,
+                                                        center_x: 3..8, center_y: 3..8,
+                                                        zoom: -0.22 # Shrinks, so doesn't need TTL.
+
+    @point_emitter = Ashton::ParticleEmitter.new 100, 100, 1,
+                                                 scale: 10,
+                                                 speed: 200,
+                                                 interval: 0.0002,
+                                                 max_particles: 30000,
+                                                 interval: 0.0001,
+                                                 color: Gosu::Color.rgba(255, 0, 0, 150),
+                                                 fade: 50 # loses 50 alpha/s
+
+    @shaded_point_emitter = Ashton::ParticleEmitter.new 100, 300, 2,
+                                                        scale: 4..10,
+                                                        shader: @grayscale,
+                                                        speed: 60..100,
+                                                        offset: 0..10,
+                                                        time_to_live: 12,
+                                                        interval: 0.0003,
+                                                        max_particles: 30000,
+                                                        color: Gosu::Color.rgba(255, 0, 0, 100),
+                                                        gravity: 60 # pixels/s*s
+
+    @mouse_emitter = Ashton::ParticleEmitter.new 0, 0, 3,
+                                                 scale: 4,
+                                                 speed: 20..50,
+                                                 max_particles: 5000,
+                                                 offset: 0..5,
+                                                 interval: 0.0010,
+                                                 color: Gosu::Color.rgba(0, 255, 255, 100),
+                                                 fade: 25,
+                                                 gravity: 60 # pixels/s*s
+  end
+
+  def needs_cursor?; true end
+
+  def update
+    $gosu_blocks.clear if defined? $gosu_blocks # workaround for Gosu 0.7.45 bug.
+
+    # Calculate delta from milliseconds.
+    @last_update_at ||= Gosu::milliseconds
+    delta = [Gosu::milliseconds - @last_update_at, 100].min * 0.001 # Limit delta to 100ms (10fps), in case of freezing.
+    @last_update_at = Gosu::milliseconds
+
+    @image_emitter.update delta unless button_down? Gosu::Kb1
+    @shaded_image_emitter.update delta unless button_down? Gosu::Kb2
+    @point_emitter.update delta unless button_down? Gosu::Kb3
+    @shaded_point_emitter.update delta unless button_down? Gosu::Kb4
+
+    @mouse_emitter.x, @mouse_emitter.y = mouse_x, mouse_y
+    @mouse_emitter.update delta unless button_down? Gosu::Kb5
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+
+  def draw
+    @point_emitter.draw
+    @shaded_image_emitter.draw
+    @shaded_point_emitter.draw
+    @image_emitter.draw
+    @mouse_emitter.draw
+
+    num_particles = @point_emitter.count + @shaded_point_emitter.count +
+                    @image_emitter.count + @shaded_image_emitter.count +
+                    @mouse_emitter.count
+    @font.draw "FPS: #{Gosu::fps}   Particles: #{num_particles}", 0, 0, Float::INFINITY
+
+    totals = "Pnt: #{@point_emitter.count} ShaPnt: #{@shaded_point_emitter.count} Img: #{@image_emitter.count} ShaImg: #{@shaded_image_emitter.count} Mouse: #{@mouse_emitter.count}"
+    @font.draw_rel totals, 0, height, Float::INFINITY, 0, 1
+  end
+end
+
+TestWindow.new.show

data/examples/pixelate_example.rb

@@ -1,50 +1,52 @@
-# Use of GLSL shader in Gosu to post-process the entire screen.
-
-begin
-  require 'rubygems'
-rescue LoadError
-end
-
-$LOAD_PATH.unshift File.expand_path('../lib/', File.dirname(__FILE__))
-require "ashton"
-
-def shader(file); File.read File.expand_path("../lib/ashton/post_process/#{file}", File.dirname(__FILE__)) end
-def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
-
-class TestWindow < Gosu::Window
-  def initialize
-    super 640, 480, false
-    self.caption = "Post-processing with 'pixelate' - 1..9 affect pixel size"
-
-    @pixelate = Ashton::PostProcess.new shader('pixelate.frag')
-    @pixelate['in_PixelSize'] = @pixel_size = 4
-
-    @font = Gosu::Font.new self, Gosu::default_font_name, 40
-    @star = Gosu::Image.new(self, media_path("LargeStar.png"), true)
-
-    update # Ensure the values are initially set.
-  end
-
-  def button_down(id)
-    if (Gosu::Kb1..Gosu::Kb9).include? id
-      @pixel_size = (id - Gosu::Kb1 + 1) ** 2
-      @pixelate['in_PixelSize'] = @pixel_size
-    elsif id == Gosu::KbEscape
-      close
-    end
-  end
-
-  def draw
-    post_process @pixelate do
-      @font.draw_rel "Hello world!", 350, 50, 0, 0.5, 0.5
-      @font.draw_rel "Goodbye world!", 400, 350, 0, 0.5, 0.5
-      @star.draw 0, 0, 0
-      @star.draw 200, 100, 0
-    end
-
-    # Drawing after the effect isn't processed, which is useful for GUI elements.
-    @font.draw "Pixel ratio: 1:#{@pixel_size}", 0, 0, 0
-  end
-end
-
+# Use of GLSL shader in Gosu to post-process the entire screen.
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('../lib/', File.dirname(__FILE__))
+require "ashton"
+
+def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
+
+class TestWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+    self.caption = "Post-processing with 'pixelate' - 1..9 affect pixel size"
+
+    @pixelate = Ashton::Shader.new fragment: :pixelate, uniforms: {
+        pixel_size: @pixel_size = 4,
+    }
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+    @star = Gosu::Image.new(self, media_path("LargeStar.png"), true)
+  end
+
+  def update
+    $gosu_blocks.clear if defined? $gosu_blocks # Workaround for Gosu bug (0.7.45)
+  end
+
+  def button_down(id)
+    if (Gosu::Kb1..Gosu::Kb9).include? id
+      @pixel_size = (id - Gosu::Kb1 + 1) ** 2
+      @pixelate.pixel_size = @pixel_size
+    elsif id == Gosu::KbEscape
+      close
+    end
+  end
+
+  def draw
+    post_process @pixelate do
+      @font.draw_rel "Hello world!", 350, 50, 0, 0.5, 0.5
+      @font.draw_rel "Goodbye world!", 400, 350, 0, 0.5, 0.5
+      @star.draw 0, 0, 0
+      @star.draw 200, 100, 0
+    end
+
+    # Drawing after the effect isn't processed, which is useful for GUI elements.
+    @font.draw "Pixel ratio: 1:#{@pixel_size}", 0, 0, 0
+  end
+end
+
 TestWindow.new.show

data/examples/pixelated_texture_example.rb

@@ -0,0 +1,69 @@
+# Use of GLSL shader in Gosu.
+
+require_relative '../lib/ashton'
+
+def media_path(file); File.expand_path "media/#{file}", File.dirname(__FILE__) end
+
+class GameWindow < Gosu::Window
+  def initialize
+    super 800, 600, false
+
+    # Enable pixelation for all Gosu Images (must be called before creating any Images).
+    # Comment this line out to see default Gosu behaviour (smoothing).
+    Gosu.enable_undocumented_retrofication
+
+    self.caption = "Ashton::Texture pixelation example (Gosu::enable_undocumented_retrofication HAS "
+    self.caption += "NOT " unless Ashton::Texture.pixelated?
+    self.caption += "been called)"
+
+    @image = Gosu::Image.new self, media_path("Starfighter.bmp"), true
+    @texture = @image.to_texture
+    @font = Gosu::Font.new $window, Gosu::default_font_name, 15
+  end
+
+  def update
+    $gosu_blocks.clear if defined? $gosu_blocks # Workaround for Gosu bug (0.7.45)
+  end
+
+  def draw
+    # Drawing Textures will pixelate by default if Gosu::enable_undocumented_retrofication has ever been called.
+    @font.draw "Gosu::Image", 0, 0, 0
+    @font.draw "Ashton::Texture default", 200, 0, 0
+    @font.draw "Ashton::Texture pixelated: true", 400, 0, 0
+    @font.draw "Ashton::Texture pixelated: false", 600, 0, 0
+
+    # Zoom in a Texture, so smoothing/pixelation occurs based on preference.
+    scale 4 do
+      @image.draw 0, 10, 0
+      @texture.draw 50, 10, 0
+      @texture.draw 100, 10, 0, pixelated: true
+      @texture.draw 150, 10, 0, pixelated: false
+    end
+
+    # Actual size, so all will look the same.
+    @image.draw 0, 300, 0
+    @texture.draw 200, 300, 0
+    @texture.draw 400, 300, 0, pixelated: true
+    @texture.draw 600, 300, 0, pixelated: false
+
+    # Zooming out a Texture will _always_ smooth (with Gosu::Image it will pixelate on zooming out, which looks terrible!)
+    scale 0.5 do
+      @image.draw 0, 900, 0
+      @texture.draw 400, 900, 0
+      @texture.draw 800, 900, 0, pixelated: true
+      @texture.draw 1200, 900, 0, pixelated: false
+    end
+
+    @font.draw "Ashton::Texture is <i>always</i> smoothed when zoomed out, so it doesn't distort", 0, 400, 0
+  end
+
+  def button_down(id)
+    case id
+      when Gosu::KbEscape
+        close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show