ashton 0.0.1alpha

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2012 Bil Bas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+Ashton
+======
+
+Description
+-----------
+
+Add extra visual effects to the Gosu game-development library, utilising OpenGL shaders (using shader model 1.0, for maximum compatibility) and frame-buffers.
+
+"Ashton" is named after [Clark Ashton Smith](http://en.wikipedia.org/wiki/Clark_Ashton_Smith), an fantasy/horror author
+with a particularly colourful imagination.
+
+- Author: Bil Bas (Spooner)
+- License: MIT
+
+Usage
+-----
+
+    gem install ashton --pre
+
+Features
+--------
+
+- Gosu::Font
+  * [TODO] #draw - Added :shader hash option to choose optional shader to use.
+  * [TODO] #draw_rel - Added :shader hash option to choose optional shader to use.
+
+- Gosu::Image
+  * #draw - Added :shader hash option to choose optional shader to use.
+  * #draw_rot - Added :shader hash option to choose optional shader to use.
+  * [TODO] #flip!, #flip, #mirror!, #mirror, #scale!, #scale, etc.
+  * [TODO] #resize (Well, create another image which is smaller/larger).
+  * [TODO] #to_framebuffer
+
+- Gosu::Window
+  * #post_process {} - Draws contents of block into a back-buffer, then applies a shader as it draws that onto the screen.
+  * [TODO] #to_framebuffer - Copy the contents of the window as a {Ashton::Framebuffer}.
+  * [TODO] #to_image - Create Gosu::Image from window contents.
+  * [TODO] #draw_line - Added :shader hash option
+  * [TODO] #draw_quad - Added :shader hash option
+  * [TODO] #draw_triangle - Added :shader hash option
+
+- {Ashton::Shader}
+  * #use {} - Inside the block, all draw operations are affected by the shader.
+  * Supports vertex and fragment shaders.
+
+- {Ashton::PostProcess}
+  * A specific type of shader to perform full-screen post-processing.
+  * #process - Used to post-process the entire Gosu::Window at once, after some, or all, drawing is complete.
+  * Supports fragment shaders.
+  * [TODO] Includes a small library of example shaders (:blur, :simplex, etc).
+
+- {Ashton::Framebuffer}
+  * #use {} - Inside the block, draw operations go into the framebuffer, rather than onto the window.
+  * #to_image - Convert to Gosu::Image. 
+  * #draw - Draw directly onto a Gosu::Window.
+  * [TODO] #flip!, #flip - Invert framebuffer's vertical orientation.
+  
+Similar Libraries
+-----------------
+
+- [TexPlay](https://github.com/banister/texplay) - Deals with Gosu::Image manipulation, such as per-pixel editing and drawing. It is compatible with, and complementary to, this gem.
+
+Credits
+-------
+
+- simplex.glsl - simplex noise implementation - Copyright (C) 2011 Ashima Arts - MIT license.
+  
+

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/clean'
+require 'rspec/core/rake_task'
+require 'yard'
+require 'redcloth'
+require 'launchy'
+require 'rubygems/package_task'
+
+
+spec = Gem::Specification.load Dir['*.gemspec'].first
+
+Gem::PackageTask.new spec do
+end
+
+YARD::Rake::YardocTask.new
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |t|
+end
+
+desc "Open yard docs in browser"
+task :browse_yard => :yard do
+  Launchy.open "doc/index.html" rescue nil
+end

data/examples/framebuffer_example.rb

@@ -0,0 +1,50 @@
+# Use of GLSL shader in Gosu.
+
+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 GameWindow < Gosu::Window
+  def initialize
+    super 800, 600, false
+    self.caption = "Ashton::Framebuffer example - composing an image inside a buffer - hold <LMB> to draw - <delete> to clear"
+
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+    @star = Gosu::Image.new(self, media_path("LargeStar.png"), true)
+    @framebuffer = Ashton::Framebuffer.new width, height
+  end
+
+  def update
+    if button_down? Gosu::MsLeft
+      # Draw into the framebuffer, rather than onto the screen.
+      @framebuffer.use do
+        @star.draw_rot mouse_x, mouse_y, 0, 0, 0.5, 0.5
+      end
+    end
+  end
+
+  def draw
+    @framebuffer.draw 0, 0 # Draws immediately.
+    @star.draw_rot mouse_x, mouse_y, 0, 0, 0.5, 0.5
+
+    @font.draw "FPS: #{Gosu::fps}", 0, 0, 0
+  end
+
+  def button_down(id)
+    case id
+      when Gosu::KbDelete
+        @framebuffer.clear
+      when Gosu::KbEscape
+        close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show

data/examples/output/README.txt

@@ -0,0 +1 @@
+Output from the examples will be saved here, to prove that some functionality works.

data/examples/pixelate_example.rb

@@ -0,0 +1,50 @@
+# 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
+
+TestWindow.new.show

data/examples/radial_blur_example.rb

@@ -0,0 +1,63 @@
+# 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
+
+class TestWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+    self.caption = "Post-processing with 'radial_blur' - hold space to disable; 1..9 sets blurriness"
+
+    @blur = Ashton::PostProcess.new shader('radial_blur.frag')
+    @blur['in_BrightFactor'] = 1.5
+    @blur['in_BlurFactor'] = @blur_factor = 2.0
+    @blur['in_Passes'] = 20 # Quite a lot of work, but just proves how fast shader are!
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+
+    update # Ensure the values are initially set.
+  end
+
+  def update
+    # Wiggle the blur about a bit each frame!
+    @blur['in_OriginX'] = mouse_x
+    @blur['in_OriginY'] = mouse_y
+  end
+
+  def button_down(id)
+    if (Gosu::Kb1..Gosu::Kb9).include? id
+      @blur_factor = (id - Gosu::Kb1 + 1).to_f
+      @blur['in_BlurFactor'] = @blur_factor
+    elsif id == Gosu::KbEscape
+      close
+    end
+  end
+
+  def draw_scene
+    @font.draw_rel "Hello world!", 100, 100, 0, 0, 0.5, 0.5
+    @font.draw_rel "Goodbye world!", 400, 280, 0, 0.5, 0.5
+
+    @font.draw_rel "X", mouse_x, mouse_y, 0, 0.5, 0.5
+  end
+
+  def draw
+    if button_down? Gosu::KbSpace
+      draw_scene
+    else
+      post_process @blur do
+        draw_scene
+      end
+    end
+
+    # Drawing after the effect isn't processed, which is useful for GUI elements.
+    @font.draw "Blur Factor: #{@blur_factor}", 0, 0, 0
+  end
+end
+
+TestWindow.new.show

data/examples/shader_image_example.rb

@@ -0,0 +1,42 @@
+# Use of GLSL shader in Gosu.
+
+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
+def output_path(file); File.expand_path "output/#{file}", File.dirname(__FILE__) end
+
+class GameWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+    self.caption = "Gosu & OpenGL Integration Demo (SHADERS)"
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 20
+    @image = Gosu::Image.new self, media_path("Earth.png"), true
+    @shader = Ashton::Shader.new # Just use default shader for now.
+  end
+
+  def draw
+    # draw, with and without colour.
+    @image.draw 10, 10, 0, :shader => @shader
+    @image.draw 10, @image.height + 20, 0, 1, 1, Gosu::Color::RED, :shader => @shader
+
+    # draw#rot, with and without colour.
+    @image.draw_rot 280, 0, 0, 10, 0, 0, :shader => @shader
+    @image.draw_rot 280, @image.height + 10, 0, 10, 0, 0, 1, 1, Gosu::Color::RED, :shader => @shader
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show

data/examples/shockwave2_example.rb

@@ -0,0 +1,76 @@
+# 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 Shockwave
+  def age; Gosu::milliseconds - @start_time; end
+
+  def process
+    @shader.process
+  end
+
+  def initialize(x, y)
+    @shader = Ashton::PostProcess.new shader('shockwave2.frag')
+    @shader['in_ShockParams'] = [10.0, 0.8, 0.1]
+    @shader['in_Center'] = [x, $window.height - y]
+    @start_time = Gosu::milliseconds
+  end
+
+  def update
+    @shader['in_Time'] = age / 1000.0
+  end
+end
+
+class TestWindow < Gosu::Window
+  def initialize
+    super 640, 480, false
+    self.caption = "Post-processing with 'shockwave2.frag' - Click on window to create a splash"
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+    @background = Gosu::Image.new(self, media_path("Earth.png"), true)
+    @waves = []
+  end
+
+  def update
+    @waves.each {|w| w.update }
+    @waves.delete_if {|w| w.age > 3000 }
+  end
+
+  def needs_cursor?
+    true
+  end
+
+  def button_down(id)
+    case id
+      when Gosu::MsLeft
+        @waves << Shockwave.new(mouse_x, mouse_y)
+      when Gosu::KbEscape
+        close
+    end
+  end
+
+  def draw
+    @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
+    @font.draw_rel "Goodbye world!", 400, 350, 0, 0.5, 0.5
+
+    # Since we want to process multiple post-processing effects...
+    @waves.each do |wave|
+      wave.process
+    end
+
+    # Drawing after the effect isn't processed, which is useful for GUI elements.
+    @font.draw "FPS: #{Gosu::fps} Waves: #{@waves.size}", 0, 0, 0
+  end
+end
+
+TestWindow.new.show

data/examples/tv_screen_and_noise_example.rb

@@ -0,0 +1,60 @@
+# 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 both 'tv_screen.frag' and 'noise.frag'"
+
+    @screen = Ashton::PostProcess.new shader('tv_screen.frag')
+    @screen['in_ColumnWidth'] = 1.0
+
+    @noise = Ashton::PostProcess.new shader('noise.frag')
+
+
+    @font = Gosu::Font.new self, Gosu::default_font_name, 40
+    @star = Gosu::Image.new(self, media_path("LargeStar.png"), true)
+    @background = Gosu::Image.new(self, media_path("Earth.png"), true)
+
+    update # Ensure the values are initially set.
+  end
+
+  def update
+    @noise['in_T'] = Math::sin(Gosu::milliseconds / 500.0) * 1000
+    @noise['in_Intensity'] = Math::sin(Gosu::milliseconds / 2345.0) + 1.5
+  end
+
+  def draw
+    @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
+
+    @star.draw 0, 0, 0
+    @star.draw 200, 100, 0
+
+    @noise.process
+    @screen.process
+
+    # 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/lib/ashton/base_shader.rb

@@ -0,0 +1,172 @@
+module Ashton
+  # @abstract
+  class BaseShader
+    INVALID_LOCATION = -1
+    MIN_OPENGL_VERSION = 2.0
+
+    attr_reader :fragment_source, :vertex_source
+
+    # Todo: Pass in a filename (String) or name of built-in pp shader (Symbol)
+    #
+    # @option options [String] :vertex Source code for vertex shader.
+    # @option options [String] :vert equivalent to :vertex
+    # @option options [String] :fragment Source code for fragment shader.
+    # @option options [String] :frag equivalent to :fragment
+    def initialize(vertex_source, fragment_source)
+      raise "Can't instantiate abstract class" if self.class == BaseShader
+
+      unless GL.version_supported? MIN_OPENGL_VERSION
+        raise NotSupportedError, "Ashton requires OpenGL #{MIN_OPENGL_VERSION} support to utilise shaders"
+      end
+
+      @uniform_locations = {}
+      @attribute_locations = {}
+      @program = nil
+
+      @vertex_source = vertex_source
+      @fragment_source = fragment_source
+
+      @vertex = compile GL_VERTEX_SHADER, vertex_source
+      @fragment = compile GL_FRAGMENT_SHADER, fragment_source
+
+      link
+
+      glBindFragDataLocationEXT @program, 0, "out_FragColor"
+    end
+
+
+    # Creates a copy of the shader program, recompiling the source,
+    # but not preserving the uniform values.
+    def dup
+      self.class.new :vertex => @vertex_source, :fragment => @fragment_source
+    end
+
+    # Make this the current shader program.
+    def use
+      previous_program = glGetIntegerv GL_CURRENT_PROGRAM
+      glUseProgram @program
+
+      if block_given?
+        result = yield self
+        $window.flush # TODO: need to work out how to make shader affect delayed draws.
+        glUseProgram previous_program
+      end
+
+      result
+    end
+
+    # Disable the shader program (not needed in block version of #use).
+    def disable
+      glUseProgram 0 # Disable the shader!
+    end
+
+    # Is this the current shader program?
+    def current?
+      glGetIntegerv(GL_CURRENT_PROGRAM) == @program
+    end
+
+    # Set the value of a uniform.
+    def []=(name, value)
+      use do
+        case value
+          when true, GL_TRUE
+            glUniform1i uniform(name), 1
+
+          when false, GL_FALSE
+            glUniform1i uniform(name), 0
+
+          when Float
+            glUniform1f uniform(name), value
+
+          when Integer
+            glUniform1i uniform(name), value
+
+          when Array
+            size = value.size
+
+            raise ArgumentError, "Empty array not supported for uniform data" if size.zero?
+            raise ArgumentError, "Only support uniforms up to 4 elements" if size > 4
+
+            case value[0]
+              when Float
+                GL.send "glUniform#{size}f", uniform(name), *value
+
+              when Integer
+                GL.send "glUniform#{size}i", uniform(name), *value
+
+              else
+                raise ArgumentError, "Uniform data type not supported for element of type: #{value[0].class}"
+            end
+
+          else
+            raise ArgumentError, "Uniform data type not supported for type: #{value.class}"
+        end
+      end
+    end
+
+
+
+    def uniform(name)
+      location = @uniform_locations[name]
+      if location
+        location
+      else
+        location = glGetUniformLocation @program, name.to_s
+        raise ShaderUniformError, "No #{name} uniform specified in program" if location == INVALID_LOCATION
+        @uniform_locations[name] = location
+      end
+    end
+
+    protected
+    def attribute(name)
+      location = @attribute_locations[name]
+      if location
+        location
+      else
+        location = glGetAttribLocation @program, name.to_s
+        raise ShaderAttributeError, "No #{name} attribute specified in program" if location == INVALID_LOCATION
+        @attribute_locations[name] = location
+      end
+    end
+
+    protected
+    def compile(type, source)
+      shader = glCreateShader type
+      glShaderSource shader, source
+      glCompileShader shader
+
+      unless glGetShaderiv shader, GL_COMPILE_STATUS
+        error = glGetShaderInfoLog shader
+        error_lines = error.scan(/0\((\d+)\)+/m).map {|num| num.first.to_i }.uniq
+
+        if type == GL_VERTEX_SHADER
+          type_name =  "Vertex"
+          source = @vertex_source
+        else
+          type_name = "Fragment"
+          source = @fragment_source
+        end
+
+        source_lines = source.split("\n")
+        lines = error_lines.map {|i| "#{i.to_s.rjust 3}: #{source_lines[i - 1].rstrip}" }.join "\n"
+        raise ShaderCompileError, "#{type_name} shader error: #{glGetShaderInfoLog(shader)}\n#{lines}"
+      end
+
+      shader
+    end
+
+    protected
+    def link
+      @program = glCreateProgram
+      glAttachShader @program, @vertex
+      glAttachShader @program, @fragment
+      glLinkProgram @program
+
+      unless glGetProgramiv @program, GL_LINK_STATUS
+        raise ShaderLinkError, "Shader link error: #{glGetProgramInfoLog(@program)}"
+      end
+
+      nil
+    end
+  end
+end