ashton 0.0.1alpha → 0.0.2alpha

data/lib/ashton/image_stub.rb

@@ -1,37 +1,33 @@
-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
+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
+    # @return [Integer]
+    attr_reader :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)
+      raise ArgumentError, "Width must be >= 1 pixel" unless width > 0
+      raise ArgumentError, "Height must be >= 1 pixel" unless height > 0
+
+      expected_size = width * height * 4
+      raise ArgumentError, "Expected blob to be #{expected_size} bytes" unless blob_data.size == expected_size
+
+      @data, @columns, @rows = blob_data, width, height
+    end
+
+    # @return [String]
+    def to_blob
+      @data
+    end
+  end
 end

data/lib/ashton/lighting/light_source.rb

@@ -0,0 +1,146 @@
+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 LightSource
+    include Mixins::VersionChecking
+
+    # PIXEL_BUFFER_EXTENSION = "GL_EXT_pixel_buffer_object"
+
+    class << self
+      attr_accessor :distort_shader, :draw_shadows_shader, :blur_shader
+    end
+
+    attr_reader :radius
+    attr_accessor :x, :y, :z, :color
+
+    def width; @radius * 2 end
+    def height; @radius * 2 end
+
+    def initialize(x, y, z, radius, options = {})
+      #check_opengl_extension PIXEL_BUFFER_EXTENSION
+
+      @x, @y, @z, @radius = x, y, z, radius.to_i
+      @color = options[:color] || Gosu::Color::WHITE
+
+      @shadow_casters = Ashton::Texture.new width, height
+      @shadow_map = Ashton::Texture.new 2, height
+      @shadows = Ashton::Texture.new width, height
+      @blurred = Ashton::Texture.new width, height
+
+      load_shaders
+    end
+
+    public
+    # Only need to render shadows again if anything has actually changed!
+    def render_shadows(&block)
+      raise "block required" unless block_given?
+
+      render_shadow_casters &block
+
+      # Distort the shadow casters and reduce into a a 2-pixel wide shadow-map of the blockages.
+      LightSource.distort_shader.enable { distort }
+
+      # Render the shadows themselves, before blurring.
+      LightLightSource.draw_shadows_shader.enable { draw_shadows }
+
+      # Finally blur it up and apply the radial lighting.
+      LightSource.blur_shader.enable { blur }
+
+      nil
+    end
+
+    protected
+    def render_shadow_casters
+      raise "block required" unless block_given?
+      # Get a copy of the shadow-casting objects in out light-zone.
+      @shadow_casters.render do |buffer|
+        buffer.clear
+        $window.translate @radius - @x, @radius - @y do
+          yield
+        end
+      end
+    end
+
+    protected
+    def distort
+      LightSource.distort_shader.texture_width = width
+      @shadow_map.render do
+        $window.scale 1.0 / radius, 1 do
+          @shadow_casters.draw 0, 0, 0
+        end
+      end
+    end
+
+    protected
+    def draw_shadows
+      LightSource.draw_shadows_shader.texture_width = width
+      @shadows.render do
+        # Not actually drawing anything from the shadow map buffer.
+        # It is just a data input to what will be drawn.
+        $window.scale radius, 1 do
+          @shadow_map.draw 0, 0, 0
+        end
+      end
+    end
+
+    protected
+    def blur
+      LightSource.blur_shader.texture_width = width
+      @blurred.render do
+        @shadows.draw 0, 0, 0
+      end
+    end
+
+    public
+    def draw(options = {})
+      options = {
+          mode: :add,
+          color: @color,
+      }.merge! options
+
+      @blurred.draw @x - @radius, @y - @radius, @z, options
+      @shadow_casters.draw @x - @radius, @y - @radius, @z, options
+      nil
+    end
+
+    public
+    # Draw some quadrant lines (for debugging).
+    def draw_debug
+      color = @color.dup
+      color.alpha = 75
+
+      $window.translate -@radius, -@radius do
+        $window.draw_line x, y, color, x + width, y, color, z
+        $window.draw_line x + width, y, color, x + width, y + height, color, z
+        $window.draw_line x + width, y + height, color, x, y + height, color, z
+        $window.draw_line x, y + height, color, x, y, color, z
+
+        $window.draw_line x, y, color, x + width, y + height, color, z
+        $window.draw_line x, y + height, color, x + width, y, color, z
+      end
+    end
+
+    protected
+    def load_shaders
+      LightSource.distort_shader ||= Ashton::Shader.new fragment: :"lighting/distort"
+
+      LightSource.draw_shadows_shader ||= Ashton::Shader.new fragment: :"lighting/draw_shadows"
+
+      LightSource.blur_shader ||= Ashton::Shader.new fragment: :"lighting/shadow_blur"
+
+      nil
+    end
+
+    protected
+    # Used for debugging purposes only.
+    def save_buffers
+      # Only save once. for purposes of this example only.
+      @shadow_casters.to_image.save "output/shadow_casters_#{x}_#{y}.png"
+      @shadow_map.to_image.save "output/shadow_map_#{x}_#{y}.png"
+      @shadows.to_image.save "output/shadows_#{x}_#{y}.png"
+      @blurred.to_image.save "output/blurred_#{x}_#{y}.png"
+    end
+  end
+end
+end

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