danabr75-ashton 0.1.5

data/lib/ashton/lighting/manager.rb

@@ -0,0 +1,98 @@
+require 'set'
+
+module Ashton
+module Lighting
+  # 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/
+  class Manager
+    include Enumerable
+
+    attr_accessor :camera_x, :camera_y, :z
+
+    def each(&block); @lights.each(&block) end
+    def size; @lights.size end
+    def empty?; @lights.empty? end
+    def width; @shadows.width end
+    def height; @shadows.height end
+
+    def initialize(options = {})
+      options = {
+          width: $window.width,
+          height: $window.height,
+          camera_x: 0,
+          camera_y: 0,
+          z: 0,
+      }.merge! options
+
+      @camera_x, @camera_y = options[:camera_x], options[:camera_y]
+      @z = options[:z]
+
+      @lights = Set.new
+      @shadows = Ashton::Texture.new options[:width], options[:height]
+    end
+
+    # @param light [Ashton::LightSource]
+    # @return [Ashton::LightSource]
+    def add(light)
+      raise TypeError unless light.is_a? LightSource
+
+      @lights << light
+      light
+    end
+    alias_method :<<, :add
+
+    def remove(light)
+      @lights -= [light]
+      light
+    end
+
+    # @see Ashton::LightSource#new
+    #
+    # @return [Ashton::LightSource]
+    def create_light(*args)
+      add LightSource.new(*args)
+    end
+
+    def draw(options = {})
+      options = {
+          mode: :multiply,
+      }.merge! options
+
+      @shadows.draw @camera_x, @camera_y, @z, options
+    end
+
+    def update_shadow_casters(&block)
+      raise ArgumentError, "Requires block" unless block_given?
+
+      unless empty?
+        # TODO: Need to only render to lights that are on-screen.
+        @lights.each do |light|
+          light.send :render_shadow_casters, &block
+        end
+
+        # Use each shader on every light, to save setting and un-setting shaders (a bit faster, depending on number of light sources).
+        LightSource.distort_shader.enable do
+          @lights.each {|light| light.send :distort }
+        end
+
+        LightSource.draw_shadows_shader.enable do
+          @lights.each {|light| light.send :draw_shadows }
+        end
+
+        LightSource.blur_shader.enable do
+          @lights.each {|light| light.send :blur }
+        end
+      end
+
+      @shadows.render do |buffer|
+        buffer.clear
+        $window.translate(-@camera_x, -@camera_y) do
+          @lights.each {|light| light.draw } unless empty?
+        end
+      end
+
+      nil
+    end
+  end
+end
+end

data/lib/ashton/mixins/version_checking.rb

@@ -0,0 +1,23 @@
+module Ashton
+  module Mixins
+    module VersionChecking
+      # Check if a specific OpenGL version is supported on this machine.
+      #
+      # @raise NotSupportedError
+      def check_opengl_version(version)
+        unless GL.version_supported? version
+          raise NotSupportedError, "OpenGL #{version} required to utilise #{self.class}"
+        end
+      end
+
+      # Check if a specific OpenGL extension is supported on this machine.
+      #
+      # @raise NotSupportedError
+      def check_opengl_extension(extension)
+        unless GL.extension_supported? extension
+          raise NotSupportedError, "OpenGL extension #{extension} required to utilise #{self.class}"
+        end
+      end
+    end
+  end
+end

data/lib/ashton/particle_emitter.rb

@@ -0,0 +1,87 @@
+module Ashton
+  class ParticleEmitter
+    def empty?; count == 0 end
+
+    DEFAULT_MAX_PARTICLES = 1000
+    DEFAULT_COLOR = Gosu::Color::WHITE
+    RANGED_ATTRIBUTES = [
+        :angular_velocity, :center_x, :center_y,
+        :fade, :friction, :interval,
+        :offset, :scale, :speed, :time_to_live, :zoom
+    ]
+
+    def initialize(x, y, z, options = {})
+      # I'm MUCH too lazy to implement a huge options hash manager in C, especially on a constructor.
+      max_particles = options[:max_particles] || DEFAULT_MAX_PARTICLES
+      initialize_ x, y, z, max_particles
+
+      self.shader = options[:shader]
+      self.image = options[:image] || $window.pixel
+
+      self.gravity = options[:gravity] || 0.0
+      self.color = options[:color] || DEFAULT_COLOR
+
+      self.angular_velocity = options[:angular_velocity] || 0.0
+      self.center_x = options[:center_x] || 0.5
+      self.center_y = options[:center_y] || 0.5
+      self.fade = options[:fade] || 0.0
+      self.friction = options[:friction] || 0.0
+      self.interval = options[:interval] || Float::INFINITY
+      self.offset = options[:offset] || 0.0
+      self.scale = options[:scale] || 1.0
+      self.speed = options[:speed] || 0.0
+      self.time_to_live = options[:time_to_live] || Float::INFINITY
+      self.zoom = options[:zoom] || 0.0
+    end
+
+    # Gosu::Color
+    def color
+      Gosu::Color.new color_argb
+    end
+
+    # [Gosu::Color, Integer, Array<Float>]
+    def color=(value)
+      case value
+        when Integer
+          self.color_argb = value
+        when Gosu::Color
+          self.color_argb = value.to_i
+        when Array
+          self.color_argb = Gosu::Color.from_opengl value
+        else
+          raise TypeError, "Expected argb integer, rgba opengl float array or Gosu::Color"
+      end
+
+      value
+    end
+
+    RANGED_ATTRIBUTES.each do |attr|
+      # Returns a Range.
+      define_method attr do
+        send("#{attr}_min")..send("#{attr}_max")
+      end
+
+      # Can be set as a Range or as a single number.
+      define_method "#{attr}=" do |value|
+        min, max = case value
+                     when Numeric
+                       [value, value]
+                     when Range
+                       [value.min, value.max]
+                     else
+                       raise TypeError, "Expecting Numeric or Range, not #{value.class}"
+                   end
+
+        send "#{attr}_min=", min
+        send "#{attr}_max=", max
+
+        value
+      end
+    end
+
+    # @!method draw()
+
+    # @!method update(delta)
+    #   @param delta (Float) number of seconds to run the simulation for.
+  end
+end

data/lib/ashton/pixel_cache.rb

@@ -0,0 +1,24 @@
+module Ashton
+  class PixelCache
+    # Docs here.
+
+    public
+    # Convert the current contents of the cache into a Gosu::Image
+    #
+    # @option options :caching [Boolean] (true) TexPlay behaviour.
+    # @option options :tileable [Boolean] (false) Standard Gosu behaviour.
+    def to_image(options = {})
+      options = {
+          tileable: false,
+      }.merge! options
+
+      # Create a new Image from the flipped pixel data.
+      stub = ImageStub.new to_blob, width, height
+      if defined? TexPlay
+        Gosu::Image.new $window, stub, options[:tileable], options
+      else
+        Gosu::Image.new $window, stub, options[:tileable]
+      end
+    end
+  end
+end

data/lib/ashton/shader.rb

@@ -0,0 +1,386 @@
+module Ashton
+  class Shader
+    include Mixins::VersionChecking
+
+    INVALID_LOCATION = -1
+    MIN_OPENGL_VERSION = 2.0 # For GLSL 1.10
+
+    INCLUDE_PATH = File.expand_path "../shaders/include", __FILE__
+    BUILT_IN_SHADER_PATH = File.expand_path "../shaders", __FILE__
+    FRAGMENT_EXTENSION = ".frag"
+    VERTEX_EXTENSION = ".vert"
+
+    # List of built-in functions.
+    BUILT_IN_FUNCTIONS = Dir[File.join(INCLUDE_PATH, "*.glsl")].map do |filename|
+      filename =~ /(\w+)\.glsl/
+      $1.to_sym
+    end
+
+    attr_reader :vertex_source, :fragment_source
+
+    # Is the shader currently in use?
+    def enabled?; !!@previous_program end
+
+    # Is this the currently activated shader program?
+    def current?; Gl.glGetIntegerv(Gl::GL_CURRENT_PROGRAM) == @program end
+
+    # Instead of passing in source code, a file-name will be loaded or use a symbol to choose a built-in shader.
+    #
+    # `#include` will be recursively replaced in the source.
+    #
+    # * `#include <noise>` will load the built-in shader function, shaders/include/noise.glsl
+    # * `#include "/home/spooner/noise.glsl"` will include that file, relative to the current working directory, NOT the source file.
+    #
+    # @option options :vertex [String, Symbol] (:default) Source code for vertex shader.
+    # @option options :vert [String, Symbol] (:default) Equivalent to :vertex
+    # @option options :fragment [String, Symbol] (:default) Source code for fragment shader.
+    # @option options :frag [String, Symbol] (:default) Equivalent to :fragment
+    # @option options :uniforms [Hash] Sets uniforms, as though calling shader[key] = value for each entry (but faster).
+    def initialize(options = {})
+      check_opengl_version MIN_OPENGL_VERSION
+
+      vertex = options[:vertex] || options[:vert] || :default
+      fragment = options[:fragment] || options[:frag] || :default
+
+      @vertex_source = process_source vertex, VERTEX_EXTENSION
+      @fragment_source = process_source fragment, FRAGMENT_EXTENSION
+
+      @uniform_locations = {}
+      @attribute_locations = {}
+      @program = nil
+      @previous_program = nil
+      @image = nil
+      @color = [1, 1, 1, 1]
+
+      # Actually compile and link.
+
+      @vertex = compile Gl::GL_VERTEX_SHADER, @vertex_source
+      @fragment = compile Gl::GL_FRAGMENT_SHADER, @fragment_source
+      link
+
+      # In case we are using '#version 130' or higher, set out own color output.
+      begin
+        Gl.glBindFragDataLocationEXT @program, 0, "out_FragColor"
+      rescue NotImplementedError
+        # Might fail on an old system, but they will be fine just running GLSL 1.10 or 1.20
+      end
+
+      enable do
+        # GL_TEXTURE0 will be activated later. This is the main image texture.
+        set_uniform uniform_location("in_Texture", required: false), 0
+
+        # For multi-textured shaders, we use in_Texture<NUM> instead.
+        set_uniform uniform_location("in_Texture0", required: false), 0
+        set_uniform uniform_location("in_Texture1", required: false), 1
+
+        # These are optional, and can be used to check pixel size.
+        set_uniform uniform_location("in_WindowWidth", required: false), $window.width
+        set_uniform uniform_location("in_WindowHeight", required: false), $window.height
+
+        # Set uniform values with :uniforms hash.
+        if options.has_key? :uniforms
+          options[:uniforms].each_pair do |uniform, value|
+            self[uniform] = value
+          end
+        end
+      end
+    end
+
+    protected
+    # Converts :frog_head to "in_FrogHead"
+    def uniform_name_from_symbol(uniform)
+      "in_#{uniform.to_s.split("_").map(&:capitalize).join}"
+    end
+
+    public
+    # 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
+
+    public
+    # Make this the current shader program. Use with a block or, alternatively, use #enable and #disable separately.
+    def enable(z = nil)
+      $window.gl z do
+        raise ShaderError, "This shader already enabled." if enabled?
+        current_shader = Gl.glGetIntegerv GL::GL_CURRENT_PROGRAM
+        raise ShaderError, "Another shader already enabled." if current_shader > 0
+
+        @previous_program = current_shader
+        Gl.glUseProgram @program
+      end
+
+      result = nil
+
+      if block_given?
+        begin
+          result = yield self
+        ensure
+          disable z
+        end
+      end
+
+      result
+    end
+
+    # Disable the shader program. Only required if using #enable without a block.
+    def disable(z = nil)
+      $window.gl z do
+        raise ShaderError, "Shader not enabled." unless enabled?
+        Gl.glUseProgram @previous_program # Disable the shader!
+        @previous_program = nil
+      end
+
+      nil
+    end
+
+    public
+    # Allow
+    #   `shader.blob_frequency = 5`
+    # to map to
+    #   `shader["in_BlobFrequency"] = 5`
+    # TODO: define specific methods at compile time, based on parsing the source?
+    def method_missing(meth, *args, &block)
+      if args.size == 1 and meth =~ /^(.+)=$/
+        self[$1.to_sym] = args[0]
+      else
+        super meth, *args, &block
+      end
+    end
+
+    public
+    # Set the value of a uniform.
+    #
+    # @param uniform [String, Symbol] If a Symbol, :frog_paste is looked up as "in_FrogPaste", otherwise the Sting is used directly.
+    # @param value [Any] Value to set the uniform to
+    #
+    # @raise ShaderUniformError unless requested uniform is defined in vertex or fragment shaders.
+    def []=(uniform, value)
+      uniform = uniform_name_from_symbol(uniform) if uniform.is_a? Symbol
+
+      # Ensure that the program is current before setting values.
+      needs_use = !current?
+      enable if needs_use
+      set_uniform uniform_location(uniform), value
+      disable if needs_use
+
+      value
+    end
+
+    protected
+    # Set uniform without trying to force use of the program.
+    def set_uniform(location, value)
+      raise ShaderUniformError, "Shader uniform #{location.inspect} could not be set, since shader is not current" unless current?
+
+      return if location == INVALID_LOCATION # Not for end-users :)
+
+      case value
+        when true, Gl::GL_TRUE
+          Gl.glUniform1i location, 1
+
+        when false, Gl::GL_FALSE
+          Gl.glUniform1i location, 0
+
+        when Float
+          begin
+            Gl.glUniform1f location, value
+          rescue
+            Gl.glUniform1i location, value.to_i
+          end
+
+        when Integer
+          begin
+            Gl.glUniform1i location, value
+          rescue
+            Gl.glUniform1f location, value.to_f
+          end
+
+        when Gosu::Color
+          Gl.glUniform4f location, *value.to_opengl
+
+        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
+              begin
+                Gl.send "glUniform#{size}f", location, *value.map(&:to_f)
+              rescue
+                Gl.send "glUniform#{size}i", location, *value.map(&:to_i)
+              end
+
+            when Integer
+              begin
+                Gl.send "glUniform#{size}i", location, *value.map(&:to_i)
+              rescue
+                Gl.send "glUniform#{size}f", location, *value.map(&:to_f)
+              end
+
+            when Gosu::Color
+              GL.send "glUniform4fv", location, value.map(&:to_opengl).flatten
+
+            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
+
+      value
+    end
+
+    protected
+    def uniform_location(name, options = {})
+      options = {
+          required: true
+      }.merge! options
+
+      location = @uniform_locations[name]
+      if location
+        location
+      else
+        location = Gl.glGetUniformLocation @program, name.to_s
+        if options[:required] && location == INVALID_LOCATION
+          raise ShaderUniformError, "No #{name.inspect} uniform specified in program"
+        end
+        @uniform_locations[name] = location
+      end
+    end
+
+    public
+    def image=(image)
+      raise ShaderError, "Can't set image unless using shader" unless current?
+
+      if image
+        info = image.gl_tex_info
+
+        Gl.glActiveTexture Gl::GL_TEXTURE0
+        Gl.glBindTexture Gl::GL_TEXTURE_2D, info.tex_name
+      end
+
+      set_uniform uniform_location("in_TextureEnabled", required: false), !!image
+
+      @image = image
+    end
+
+    public
+    def color=(color)
+      opengl_color = case color
+                       when Gosu::Color
+                         color.to_opengl
+                       when Integer
+                         Gosu::Color.new(color).to_opengl
+                       when Array
+                         color
+                       else
+                         raise TypeError, "Expected Gosu::Color, Integer or opengl float array for color"
+                     end
+
+      needs_use = !current?
+      enable if needs_use
+      location = Gl.glGetAttribLocation @program, "in_Color"
+      Gl.glVertexAttrib4f location, *opengl_color unless location == INVALID_LOCATION
+      disable if needs_use
+
+      @color = opengl_color
+    end
+
+    protected
+    def attribute(name)
+      location = @attribute_locations[name]
+      if location
+        location
+      else
+        location = Gl.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 = Gl.glCreateShader type
+      Gl.glShaderSource shader, source
+      Gl.glCompileShader shader
+
+      unless Gl.glGetShaderiv shader, Gl::GL_COMPILE_STATUS
+        error = Gl.glGetShaderInfoLog shader
+        error_lines = error.scan(/0\((\d+)\)+/m).map {|num| num.first.to_i }.uniq
+
+        if type == Gl::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 = Gl.glCreateProgram
+      Gl.glAttachShader @program, @vertex
+      Gl.glAttachShader @program, @fragment
+      Gl.glLinkProgram @program
+
+      unless Gl.glGetProgramiv @program, Gl::GL_LINK_STATUS
+        raise ShaderLinkError, "Shader link error: #{glGetProgramInfoLog(@program)}"
+      end
+
+      nil
+    end
+
+    protected
+    # Symbol => load a built-in
+    # Filename => load file
+    # Source => use directly.
+    #
+    # Also recursively replaces #include
+    # TODO: What about line numbers getting messed up by #include?
+    def process_source(shader, extension)
+      source = if shader.is_a? Symbol
+                 file = File.expand_path "#{shader}#{extension}", BUILT_IN_SHADER_PATH
+                 unless File.exist? file
+                   raise ShaderLoadError, "Failed to load built-in shader: #{shader.inspect}"
+                 end
+                 File.read file
+
+               elsif File.exist? shader
+                 File.read shader
+               else
+                 shader
+               end
+
+      replace_include source
+    end
+
+    protected
+    # Recursively replace #include.
+    #
+    # * Replace '#include <rand>' with the contents of include/rand.glsl
+    # * Replace '#include "/home/spooner/my_shader_functions/frog.glsl"' with the contents of that file.
+    #
+    # @return [String] Source code that has been expanded.
+    def replace_include(source)
+      source.gsub!(/^#include\s+<([^>]*)>/) do
+        replace_include File.read(File.expand_path("#{$1}.glsl", INCLUDE_PATH))
+      end
+
+      source.gsub(/^#include\s+"([^"]*)"/) do
+        replace_include File.read($1)
+      end
+    end
+  end
+end