ray 0.1.0.pre1 → 0.1.0

data/lib/ray/scene_list.rb

@@ -1,22 +1,27 @@
 module Ray
-  # @api private
+  # Class used by games to manage their scene list.
+  # It needs a game object to find a scene from its name.
   class SceneList
     include Enumerable
 
+    # @param [Ray::Game] game The game which will be used to find scenes.
     def initialize(game)
       @game  = game
       @scenes     = []
       @scene_args = []
     end
 
+    # @return [true, false] True if the scene list contains no scene
     def empty?
       @scenes.empty?
     end
 
+    # @return [Ray::Scene, nil] The current scene
     def current
       @scenes.last
     end
 
+    # Rune the current scene
     def run_current
       scene = @scenes.last
 
@@ -24,28 +29,30 @@ module Ray
 
       scene.setup(*@scene_args.last)
       scene.register_events
-      scene.need_render!
       scene.run
     end
 
+    # Exits the current scene
     def exit_current
       return if empty?
       current.exit
     end
 
+    # Pops the last scene
     def pop
       @scenes.pop
       @scene_args.pop
     end
 
+    # Clears the scene list
     def clear
       @scenes.clear
       @scene_args.clear
     end
 
     # @param [Symbol] scene Name of the scene
-    def push(scene, *args)
-      scene = @game.registred_scene(scene)
+    def push(scene_name, *args)
+      scene = @game.registered_scene(scene_name)
       raise ArgumentError, "Unknown scene #{scene_name}" unless scene
 
       @scenes     << scene
@@ -61,7 +68,7 @@ module Ray
     end
 
     def inspect
-      @scenes.inspect
+      "#{self.class}#{@scenes.inspect}"
     end
   end
 end

data/lib/ray/shader.rb

@@ -0,0 +1,82 @@
+module Ray
+  class Shader
+    class NoUniformError < StandardError
+      def initialize(name)
+        super "could not find uniform in shader: #{name}"
+      end
+    end
+
+    # @param opts (see compile)
+    def initialize(opts = nil)
+      @locations = {}
+      @images    = {}
+
+      compile(opts) if opts
+    end
+
+    # @option opts [String, #read] :vertex A vertex shader (filename, or io)
+    # @option opts [String, #read] :frag A fragment shader (filename, or io)
+    # @option opts [String, #read] :geometry A geometry shader (filename, or io)
+    #
+    # Compiles the shader.
+    def compile(opts)
+      [:vertex, :frag, :geometry].each do |type|
+        if opts[type]
+          if opts[type].is_a? String
+            opts[type] = File.read(opts[type])
+          else
+            opts[type] = opts[type].read
+          end
+        end
+      end
+
+      compile_vertex(opts[:vertex]) if opts[:vertex]
+      compile_frag(opts[:frag]) if opts[:frag]
+      compile_geometry(opts[:geometry]) if opts[:geometry]
+
+      link
+
+      @locations.clear
+      @images.clear
+
+      self
+    end
+
+    # @param [String, Symbol] attr Name of the parameter to set
+    # @param
+    def []=(attr, value)
+      attr = attr.to_sym
+      @locations[attr] ||= locate(attr)
+
+      loc = @locations[attr]
+      unless loc
+        raise NoUniformError, attr
+      end
+
+      case value
+      when Vector2
+        set_vector2 loc, value
+      when Vector3
+        set_vector3 loc, value
+      when Color
+        set_color loc, value
+      when Matrix
+        set_matrix loc, value
+      when true, false, nil
+        set_bool loc, value
+      when :current_texture
+        set_current_texture loc
+      when Image
+        set_image loc, val
+      when Array
+        unless value.size.between? 1, 4
+          raise "can't send a #{value.size}-sized vector"
+        end
+
+        set_array loc, value
+      else # numeric-stuff
+        set_numeric loc, value
+      end
+    end
+  end
+end

data/lib/ray/sound.rb

@@ -0,0 +1,18 @@
+module Ray
+  class Sound
+    def initialize(arg = nil)
+      case arg
+      when String      then self.buffer = SoundBufferSet[arg]
+      when SoundBuffer then self.buffer = arg
+      when nil         then return
+      else
+        self.buffer = SoundBuffer.new(arg)
+      end
+    end
+
+    alias time= seek
+
+    alias position  pos
+    alias position= pos=
+  end
+end

data/lib/ray/sound_buffer.rb

@@ -0,0 +1,6 @@
+module Ray
+  class SoundBuffer
+    extend Ray::ResourceSet
+    add_set(/^(.*)$/) { |filename| new(filename) }
+  end
+end

data/lib/ray/sound_buffer_set.rb

@@ -0,0 +1,32 @@
+module Ray
+  module SoundBufferSet
+    extend Ray::ResourceSet
+
+    class << self
+      def missing_pattern(string)
+        Ray::SoundBuffer[string]
+      end
+
+      def select!(&block)
+        super(&block)
+        Ray::SoundBuffer.select!(&block)
+      end
+    end
+  end
+
+  # Creates a new sound buffer set.
+  #
+  # @param [Regexp] regex Regular expression used to match file
+  # @yield [*args] Block returning the sound buffer
+  # @yieldparam args Regex captures
+  def sound_buffer_set(regex, &block)
+    Ray::SoundBufferSet.add_set(regex, &block)
+  end
+
+  module_function :sound_buffer_set
+end
+
+require 'open-uri'
+Ray.sound_buffer_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
+  open("#{protocol}://#{address}") { |io| Ray::SoundBuffer.new(io) }
+end

data/lib/ray/sprite.rb

@@ -1,76 +1,117 @@
 module Ray
-  class Sprite
-    # Sets the size of the sprite sheet. For instance,
-    #   sprite.sheet_size = [3, 4]
-    # would mean there are 4 rows and 3 columns in the sprite (and each cell
-    # has the same size).
-    def sheet_size=(ary)
-      @uses_sprite_sheet = true
-      @sprite_sheet_size = ary.to_vector2
-
-      self.sheet_pos = [0, 0]
-    end
-
-    # Sets which cell of the sprite sheet should be displayed.
-    #   sprite.sheet_pos = [0, 1] # Uses the first cell of the second line.
-    def sheet_pos=(pos)
-      pos = pos.to_vector2
-
-      self.from_rect = Ray::Rect.new(pos.x * sprite_width,
-                                     pos.y * sprite_height,
-                                     sprite_width, sprite_height)
-
-      @sheet_pos = pos
-    end
-
-    # @return [Ray::Vector2] the position of the cell which is being used.
-    attr_reader :sheet_pos
-
-    # @return [Integer, nil] The width of each cell in the sprite sheet
-    def sprite_width
-      if uses_sprite_sheet?
-        image.w / @sprite_sheet_size.w
-      end
-    end
-
-    # @return [Integer, nil] The height of each cell in the sprite sheet
-    def sprite_height
-      if uses_sprite_sheet?
-        image.h / @sprite_sheet_size.h
-      end
-    end
-
-    # Disables the sprite sheet
-    def disable_sprite_sheet
-      self.from_rect = Ray::Rect.new(0, 0, image.w, image.h)
-
-      @sprite_sheet_size = nil
-      @uses_sprite_sheet = false
-    end
-
-    def uses_sprite_sheet?
-      @uses_sprite_sheet
-    end
-
-    # Draws the sprite on the screen or on another image
-    # @option opts [Ray::Image] :on The image we should draw on. Defaults to
-    #                               Ray.screen.
-    def draw(opts = {})
-      draw_on(opts[:on] || Ray.screen)
-    end
-
-    # @return [true, false] True if the sprite is located at (x, y)
-    def is_at?(x, y)
-      pos == [x, y]
-    end
-
-    # @return [Ray::Rect] The rect where this sprite will be drawn.
+  class Sprite < Drawable
+    # Creates a sprite.
+    #
+    # @param [String, Ray::Image] img The image this object will use
+    # @option opts [Ray::Vecor2, #to_Vector2] :at ((0,0)) Position of the sprite
+    # @option opts [Ray::Rect, Array<Integer>] :rect Rect of the image which will
+    #   be drawn.
+    # @option opts [Float] :angle (0) The angle which will be used to draw the image
+    #   in degrees. Defaults to 0.
+    # @option opts [Ray::Vector2] :zoom (1, 1) The zoom level which will be used to draw the image.
+    # @option opts [Ray::Vector2] :scale Alias for :zoom
+    # @option opts [Ray::Color] :color (Ray::Color.white) Color used, multiplying each pixel of the
+    #   sprite.
+    # @option opts [true, false] :flip_x (false) Set to true to flip the sprite
+    #   horizontally.
+    # @option opts [true, false] :flip_y (false) Set to true to flip the sprite
+    #   vertically.
+    # @option opts [Ray::Vector2] :origin ((0, 0)) The origin of transformations
+    # @option opts :shader [Ray::Shader] (nil) Shader
+    def initialize(img = nil, opts = {})
+      self.image = img.is_a?(String) ? Ray::ImageSet[img] : img
+
+      opts = {
+        :at     => Ray::Vector2[0, 0],
+        :angle  => 0,
+        :zoom   => Ray::Vector2[1, 1],
+        :color  => Ray::Color.white,
+        :origin => Ray::Vector2[0, 0]
+      }.merge(opts)
+
+      self.pos      = opts[:at]
+      self.sub_rect = opts[:rect] if opts[:rect]
+      self.angle    = opts[:angle]
+      self.scale    = opts[:scale] || opts[:zoom]
+      self.color    = opts[:color]
+      self.flip_x   = opts[:flip_x]
+      self.flip_y   = opts[:flip_y]
+      self.origin   = opts[:origin]
+      self.shader   = opts[:shader]
+
+      # @uses_sprite_sheet = false
+      # @sprite_sheet_size = Ray::Vector2[1, 1]
+      # @sprite_sheet_pos  = Ray::Vector2[0, 0]
+    end
+
+    # # Sets the size of the sprite sheet. For instance,
+    # #   sprite.sheet_size = [3, 4]
+    # # would mean there are 4 rows and 3 columns in the sprite (and each cell
+    # # has the same size).
+    # def sheet_size=(ary)
+    #   @uses_sprite_sheet = true
+    #   @sprite_sheet_size = ary.to_vector2
+
+    #   self.sheet_pos = [0, 0]
+    # end
+
+    # # Sets which cell of the sprite sheet should be displayed.
+    # #   sprite.sheet_pos = [0, 1] # Uses the first cell of the second line.
+    # #
+    # # pos.x and pos.y are rounded to floor.
+    # # Passing a too high value will make the sprite use the previous cells.
+    # #    sprite.sheet_size = [4, 4]
+    # #    sprite.sheet_size = [5, 5]
+    # #    sprite.sheet_size == [1, 1] # => true
+    # def sheet_pos=(pos)
+    #   pos = pos.to_vector2.dup
+    #   pos.x = pos.x.floor % @sprite_sheet_size.w
+    #   pos.y = pos.y.floor % @sprite_sheet_size.h
+
+    #   self.sub_rect = Ray::Rect.new(pos.x * sprite_width,
+    #                                 pos.y * sprite_height,
+    #                                 sprite_width, sprite_height)
+
+    #   @sheet_pos = pos
+    # end
+
+    # # @return [Ray::Vector2] the position of the cell which is being used.
+    # attr_reader :sheet_pos
+
+    # # @return [Integer, nil] The width of each cell in the sprite sheet
+    # def sprite_width
+    #   if uses_sprite_sheet?
+    #     image.w / @sprite_sheet_size.w
+    #   end
+    # end
+
+    # # @return [Integer, nil] The height of each cell in the sprite sheet
+    # def sprite_height
+    #   if uses_sprite_sheet?
+    #     image.h / @sprite_sheet_size.h
+    #   end
+    # end
+
+    # # Disables the sprite sheet
+    # def disable_sprite_sheet
+    #   self.sub_rect = Ray::Rect.new(0, 0, image.w, image.h) if image
+
+    #   @sprite_sheet_size = nil
+    #   @uses_sprite_sheet = false
+    # end
+
+    # def uses_sprite_sheet?
+    #   @uses_sprite_sheet
+    # end
+
+    # @return [Ray::Rect] The rect where this sprite will be drawn, taking
+    #   position and scale in account.
     def rect
-      pos = self.pos
-      from_rect = self.from_rect
-      zoom = self.zoom
+      pos      = self.pos
+      sub_rect = self.sub_rect
+      scade    = self.scale
 
-      Ray::Rect.new(pos.x, pos.y, from_rect.w * zoom.w, from_rect.h * zoom.h)
+      Ray::Rect.new(pos.x, pos.y, sub_rect.w * scale.w, sub_rect.h * scale.h)
     end
 
     # @param [Ray::Rect, #to_rect] An object with which the receiver may collide
@@ -91,32 +132,5 @@ module Ray
     def to_rect
       rect
     end
-
-    # @return [Integer] x position of the sprite
-    def x
-      pos.x
-    end
-
-    # @return [Integer] y position of the sprite
-    def y
-      pos.y
-    end
-
-    def x=(value)
-      self.pos = [value, y]
-    end
-
-    def y=(value)
-      self.pos = [x, value]
-    end
-
-    def scale_x; scale.x; end
-    def scale_y; scale.y; end
-
-    def scale_x=(val); self.scale = [val, scale_y]; end
-    def scale_y=(val); self.scale = [scale_x, val]; end
-
-    alias :zoom  :scale
-    alias :zoom= :scale=
   end
 end

data/lib/ray/target.rb

@@ -0,0 +1,18 @@
+module Ray
+  class Target
+    # @return [Ray::Shader] Shader used when drawing on this target
+    def shader
+      @shader ||= simple_shader # must always remain the same object
+    end
+
+    # @param [Ray::View] view A new view
+    # @yield a block where the view has been changed
+    def with_view(view)
+      old_view = self.view
+      self.view = view
+      yield self
+    ensure
+      self.view = old_view
+    end
+  end
+end