ray 0.0.1 → 0.1.0.pre1

data/lib/ray/scene.rb

@@ -26,12 +26,6 @@ module Ray
   #     # Do drawing here
   #   end
   #
-  # Notice win is not filled with an empty color when render is called, i.e.
-  # it still contains the frame which appears to the user.
-  #
-  # Also, scenes are rendered lazily: only once when the scene is created,
-  # and then every time need_render! is called.
-  #
   # Once your scene is loaded, you'll probably want to clean it up (set some
   # instance variables to nil so they can be garbaged collected for instance).
   # You can do that by passing a block to clean_up:
@@ -69,6 +63,13 @@ module Ray
   # == Limiting the loop rate
   # You can prevent a scene from always running by using #loops_per_second=:
   #   self.loops_per_second = 30 # will sleep some time after each loop
+  # This defaults to 60.
+  #
+  # == Lazy rendering
+  # By default, the scene is always rendered. You can enable lazy rendering:
+  #   self.lazy_rendering = true
+  # In this case, the scene will render in its own Image when requested (using
+  # #need_render!), and that image will be drawn in every loop.
   #
   # @see Ray::DSL::EventTranslator
   class Scene
@@ -94,22 +95,20 @@ module Ray
     # Creates a new scene. block will be instance evaluated when
     # this scene becomes the current one.
     def initialize(&block)
-      @scene_register_block = block
-    end
+      @scene_register_block   = block
+      @scene_always_block     = nil
+      @scene_render_block     = nil
+      @scene_clean_block      = nil
 
-    def register_events
-      @scene_held_keys = []
+      @scene_need_render      = true
+      @scene_loops_per_second = 60
 
-      on :key_press do |key, mod|
-        @scene_held_keys << key
-      end
-
-      on :key_release do |key, mod|
-        @scene_held_keys.reject! { |i| i == key }
-      end
+      @scene_shader           = nil
+    end
 
+    def register_events
       if @scene_register_block
-        instance_eval(&@scene_register_block)
+        instance_exec(@scene_arguments,  &@scene_register_block)
       else
         register
       end
@@ -126,21 +125,6 @@ module Ray
     def register
     end
 
-    # @param [Symbol, Integer] val A symbol to find the key (its name)
-    #                              or an integer (Ray::Event::KEY_*)
-    #
-    # @return [true, false] True if the user is holding key.
-    def holding?(val)
-      if val.is_a? Symbol
-        val = key(val)
-        @scene_held_keys.any? { |o| val === o }
-      elsif val.is_a? DSL::Matcher
-        @scene_held_keys.any? { |o| val === o }
-      else
-        @scene_held_keys.include? val
-      end
-    end
-
     # Runs until you exit the scene.
     # This will also raise events if the mouse moves, ... allowing you
     # to directly listen to a such event.
@@ -148,21 +132,43 @@ module Ray
       until @scene_exit
         loop_start = Time.now
 
-        DSL::EventTranslator.translate_event(Ray::Event.new).each do |args|
-          raise_event(*args)
+        ev = Ray::Event.new
+        until ev.type == Ray::Event::TYPE_NOEVENT
+          DSL::EventTranslator.translate_event(ev).each do |args|
+            raise_event(*args)
+          end
+
+          ev.poll!
         end
 
         @scene_always_block.call if @scene_always_block
 
         listener_runner.run
 
-        if @scene_need_render
-          @scene_need_render = false
+        @scene_window.fill(Ray::Color.none)
 
-          render(@scene_window)
-          @scene_window.flip
+        if lazy_rendering?
+          unless @scene_lazy_cache
+            @scene_lazy_cache = Ray::Image.new(:w => @scene_window.w,
+                                               :h => @scene_window.h)
+          end
+
+          if @scene_need_render
+            @scene_lazy_cache.fill Ray::Color.none
+
+            render @scene_lazy_cache
+            @scene_lazy_cache.update
+
+            @scene_need_render = false
+          end
+
+          @scene_lazy_cache.draw(:on => @scene_window, :shader => @scene_shader)
+        else
+          render @scene_window
         end
 
+        @scene_window.update
+
         if @scene_loops_per_second
           ellapsed_time = Time.now - loop_start
           time_per_loop = 1.0 / @scene_loops_per_second
@@ -174,6 +180,28 @@ module Ray
       clean_up
     end
 
+    # Runs another scene over the current one.
+    # This method will return when the scene is done running.
+    def run_scene(name, *args)
+      scene_list = SceneList.new(game)
+      scene_list.push(name, *args)
+
+      event_runner = DSL::EventRunner.new
+
+      old_event_runner = game.event_runner
+      old_scene_list   = game.scenes
+
+      game.event_runner = event_runner
+      game.scenes = scene_list
+
+      begin
+        game.run
+      ensure
+        game.event_runner = old_event_runner
+        game.scenes       = old_scene_list
+      end
+    end
+
     # Exits the scene, but does not pop the scene.
     #
     # You may want to call this if you pushed a new scene, to switch to
@@ -201,9 +229,8 @@ module Ray
 
     # Registers the block to draw the scene.
     #
-    # Does nothing if no block is given, this method being called if you
-    # didn't register any render block. You can thus override it in subclasses
-    # instead of providing a block to it.
+    # If no block is given, renders the scen on the image passed as
+    # an argument.
     #
     # @yield [window] Block to render this scene.
     # @yieldparam [Ray::Image] window The window you should draw on
@@ -220,7 +247,7 @@ module Ray
       game.push_scene(scene, *args)
       exit
     end
-     
+
     # @see Ray::Game#resize_window
     def resize_window(w, h)
       game.resize_window(w, h)
@@ -265,7 +292,36 @@ module Ray
       @scene_loops_per_second = val
     end
 
+    alias :frames_per_second :loops_per_second
+    alias :frames_per_second= :loops_per_second=
+
+    def lazy_rendering
+      @scene_lazy_rendering ||= false
+    end
+
+    alias :lazy_rendering? :lazy_rendering
+
+    def lazy_rendering=(val)
+      @scene_lazy_rendering = val
+
+      unless lazy_rendering?
+        @scene_lazy_cache = nil
+      end
+    end
+
     # The arguments passed to the scene with push_scene
     attr_accessor :scene_arguments
+
+    # @return [Ray::Shader] The shader used for this scene.
+    #   It will be used when drawing the scene on the window.
+    #   This won't do anything unless lazy_rendering is enabled.
+    def shader
+      @scene_shader
+    end
+
+    # Sets the shader used for this scene
+    def shader=(value)
+      @scene_shader = value
+    end
   end
 end

data/lib/ray/scene_list.rb

@@ -0,0 +1,67 @@
+module Ray
+  # @api private
+  class SceneList
+    include Enumerable
+
+    def initialize(game)
+      @game  = game
+      @scenes     = []
+      @scene_args = []
+    end
+
+    def empty?
+      @scenes.empty?
+    end
+
+    def current
+      @scenes.last
+    end
+
+    def run_current
+      scene = @scenes.last
+
+      scene.scene_arguments = @scene_args.last
+
+      scene.setup(*@scene_args.last)
+      scene.register_events
+      scene.need_render!
+      scene.run
+    end
+
+    def exit_current
+      return if empty?
+      current.exit
+    end
+
+    def pop
+      @scenes.pop
+      @scene_args.pop
+    end
+
+    def clear
+      @scenes.clear
+      @scene_args.clear
+    end
+
+    # @param [Symbol] scene Name of the scene
+    def push(scene, *args)
+      scene = @game.registred_scene(scene)
+      raise ArgumentError, "Unknown scene #{scene_name}" unless scene
+
+      @scenes     << scene
+      @scene_args << args
+
+      self
+    end
+
+    alias :<< :push
+
+    def each(&block)
+      @scenes.each(&block)
+    end
+
+    def inspect
+      @scenes.inspect
+    end
+  end
+end

data/lib/ray/shape.rb

@@ -0,0 +1,132 @@
+module Ray
+  class Shape
+    include Enumerable
+
+    # One of the points contained in a shape.
+    class Point
+      def initialize(shape, id)
+        @shape, @id = shape, id
+      end
+
+      # @return [Ray::Vector2] Position of the point.
+      def pos
+        @shape.position_of(@id)
+      end
+
+      # @return [Color] Color of the point
+      def color
+        @shape.color_of(@id)
+      end
+
+      # @return [Color] Outline color of the point
+      def outline
+        @shape.outline_of(@id)
+      end
+
+      # Sets the position of the point
+      def pos=(pos)
+        @shape.set_position_of(@id, pos)
+      end
+
+      # Sets the color of the point
+      def color=(color)
+        @shape.set_color_of(@id, color)
+      end
+
+      # Sets the outline color of the point
+      def outline=(outline)
+        @shape.set_outline_of(@id, outline)
+      end
+
+      def inspect
+        "#<#{self.class} shape=#{shape} id=#{id} pos=#{pos} color=#{color} outline=#{outline}>"
+      end
+
+      attr_reader :shape, :id
+    end
+
+    # Creates an ellipse.
+    #
+    # @param [Ray::Vector2, #to_vector2] center Center of the ellipse
+    # @param [Float] rx x radius
+    # @param [Float] ry y radius
+    # @param [Ray::Color] color Color of the ellipse
+    # @param [Float] outline_width Width of the ouline
+    # @param [Ray::Color] outline_color Color of the outline
+    def self.ellipse(center, rx, ry, color, outline_width = 0.0,
+                     outline_color = Ray::Color.none)
+      rx, ry = rx.to_f, ry.to_f
+      min_radius = x_factor = y_factor = 1
+
+      min_radius = rx
+
+      if rx <= ry
+        min_radius = rx
+        y_factor   = ry / rx
+      else
+        min_radius = ry
+        x_factor   = rx / ry
+      end
+
+      shape = circle([0, 0], min_radius, color, outline_width, outline_color)
+      shape.scale = [x_factor, y_factor]
+      shape.pos = center
+
+      shape
+    end
+
+    alias :size :point_count
+
+    # @param [Integer, nil] size Size of the shape. If non nil, size points will
+    #   be added to the shape and then yielded.
+    # @example
+    #   shape = Ray::Shape.new
+    #
+    #   other_shape = Ray::Shape.new(10) do |point|
+    #     point.pos   = [point.id, point.id]
+    #     point.color = Ray::Color.new(point.id * 10, 0, 0)
+    #   end
+    def initialize(size = nil)
+      if size
+        0.upto(size - 1) do |n|
+          add_point [0, 0]
+          yield self[n]
+        end
+      end
+    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
+
+    # @yieldparam [Ray::Shape::Point] point Each point of the shape
+    def each
+      0.upto(size - 1) { |n| yield self[n] }
+    end
+
+    # @return [Ray::Shape::Point] idth point of the shape (id should be less than size)
+    def [](id)
+      Point.new(self, id)
+    end
+
+    # Draws the shape on an image, optionally using a shader and a color
+    # to multiply each pixel.
+    def draw_on(image, shader = nil, color = Ray::Color.white)
+      image.draw_shape(self, shader, color)
+    end
+
+    # Draws the shape
+    #
+    # @option opts [Ray::Image] :on (Ray.screen) The object to draw the shape.
+    #   on.
+    # @option opts [Ray::Shader] :shader (nil) The shader to use to draw the shape.
+    # @option opts [Ray::Color] :color (Ray::Color.white) Color multiplying each
+    #   pixel of the shape.
+    def draw(opts = {})
+      draw_on(opts[:on] || Ray.screen, opts[:shader],
+              opts[:color] || Ray::Color.white)
+    end
+  end
+end

data/lib/ray/sound_set.rb

@@ -1,7 +1,7 @@
 module Ray
   module SoundSet
     extend Ray::ResourceSet
-    
+
     class << self
       def missing_pattern(string)
         Ray::Sound[string]
@@ -20,9 +20,11 @@ module Ray
   # @yield [*args] Block returning the sound
   #
   # @yieldparam args Regex captures
-  def self.sound_set(regex, &block)
+  def sound_set(regex, &block)
     Ray::SoundSet.add_set(regex, &block)
   end
+
+  module_function :sound_set
 end
 
 begin

data/lib/ray/sprite.rb

@@ -1,103 +1,57 @@
 module Ray
   class Sprite
-    # Creates a sprite.
-    #
-    # @param [String, Ray::Image] The image this object will wrap;
-    # @option opts [Ray::Rect, Array<Integer>] :at Position of the sprite
-    #                                              (defaults to 0,0)
-    # @option opts [Ray::Rect, Array<Integer>] :rect Rect of the image which will
-    #                                                be drawn (defaults to the
-    #                                                whole image)
-    # @option opts [Float] :angle The angle which will be used to draw the image
-    #                              in degrees. Defaults to 0.
-    # @option opts [Float] :zoom The zoom level which will be used to draw the image.
-    #                              Defaults to 1.
-    def initialize(image, opts = {})
-      opts = {
-        :rect  => Ray::Rect.new(0, 0, 0, 0),
-        :at    => [0, 0],
-        :angle => 0.0,
-        :zoom  => 1
-      }.merge(opts)
-
-      @from_rect = opts[:rect].to_rect
-
-      rect = opts[:at].to_rect
-      @x, @y = rect.x, rect.y
-
-      self.angle = opts[:angle]
-      self.zoom  = opts[:zoom]
-
-      @image = image.to_image
-    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)
-      w, h = ary
-      
       @uses_sprite_sheet = true
-      
-      @sprite_sheet_w = w
-      @sprite_sheet_h = h
-      
+      @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=(ary)
-      x, y = ary
-      
-      self.from_rect = Ray::Rect.new(x * sprite_width, y * sprite_height,
+    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_x = x
-      @sheet_pos_y = y
-    end
-    
-    # Returns the position of the cell which is being used.
-    def sheet_pos
-      [@sheet_pos_x, @sheet_pos_y]
+
+      @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_w
+        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_h
+        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_w = nil
-      @sprite_sheet_h = nil
-      
+      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 an image.
-    # @param [Ray::Image] screen The image on which the sprite will be drawn
-    def draw_on(screen)
-      @image.blit(:rect => @from_rect, :on => screen, :at => [@x, @y],
-                  :angle => @angle, :zoom => @zoom)
-    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.
@@ -107,29 +61,29 @@ module Ray
 
     # @return [true, false] True if the sprite is located at (x, y)
     def is_at?(x, y)
-      @x == x && @y == y
+      pos == [x, y]
     end
 
     # @return [Ray::Rect] The rect where this sprite will be drawn.
     def rect
-      Ray::Rect.new(@x, @y, @from_rect.w == 0 ? @image.w : @from_rect.w,
-                    @from_rect.h == 0 ? @image.h : @from_rect.h)
+      pos = self.pos
+      from_rect = self.from_rect
+      zoom = self.zoom
+
+      Ray::Rect.new(pos.x, pos.y, from_rect.w * zoom.w, from_rect.h * zoom.h)
     end
 
-    # @param [Ray::Rect, #rect] An object with which the receiver may collide
-    # @return [true, false]
+    # @param [Ray::Rect, #to_rect] An object with which the receiver may collide
     def collide?(obj)
       rect.collide?(obj.to_rect)
     end
 
-    # @param [Ray::Rect, #rect] (See #collide?)
-    # @return [true, false]
+    # @param [Ray::Rect, #to_rect] (See #collide?)
     def inside?(obj)
       rect.inside?(obj.to_rect)
     end
 
-    # @param [Ray::Rect, #rect] (See #collide?)
-    # @return [true, false]
+    # @param [Ray::Rect, #to_rect] (See #collide?)
     def outside?(obj)
       rect.outside?(obj.to_rect)
     end
@@ -138,47 +92,31 @@ module Ray
       rect
     end
 
-    # @return [Ray::Image]
-    attr_reader :image
-
-    # @return [Integer] position of the sprite
-    attr_accessor :x, :y
-
-    # @return [Ray::Rect] the part of the image which will be drawn. An empty
-    #                     rect means the whole image.
-    attr_accessor :from_rect
-    
-    # @return [Ray::Rect] the position of the sprite
-    def pos
-      [x, y]
-    end
-    
-    # Sets the position of the sprite
-    def pos=(ary)
-      rect = ary.to_rect
-      
-      self.x = rect.x
-      self.y = rect.y
+    # @return [Integer] x position of the sprite
+    def x
+      pos.x
     end
 
-    # @return [Float] The angle used when the image is drawn.
-    def angle
-      @angle ? @angle : 0
+    # @return [Integer] y position of the sprite
+    def y
+      pos.y
     end
 
-    # Sets the angle.
-    def angle=(val)
-      @angle = (val % 360).zero? ? nil : val
+    def x=(value)
+      self.pos = [value, y]
     end
 
-    # @return [Float] the zoom applied to the image when it is drawn.
-    def zoom
-      @zoom ? @zoom : 1
+    def y=(value)
+      self.pos = [x, value]
     end
 
-    # Sets the zoom level.
-    def zoom=(val)
-      @zoom = val == 1 ? nil : val
-    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