ray 0.1.0.pre1 → 0.1.0

data/lib/ray/music.rb

@@ -0,0 +1,12 @@
+module Ray
+  class Music
+    def initialize(filename = nil)
+      open(filename) if filename
+    end
+
+    alias time= seek
+
+    alias position  pos
+    alias position= pos=
+  end
+end

data/lib/ray/polygon.rb

@@ -0,0 +1,77 @@
+module Ray
+  class Polygon < Drawable
+    include Enumerable
+
+    # One of the points contained in a polygon.
+    class Point
+      def initialize(polygon, id)
+        @polygon, @id = polygon, id
+      end
+
+      # @return [Ray::Vector2] Position of the point.
+      def pos
+        @polygon.pos_of(@id)
+      end
+
+      # @return [Color] Color of the point
+      def color
+        @polygon.color_of(@id)
+      end
+
+      # @return [Color] Outline color of the point
+      def outline
+        @polygon.outline_of(@id)
+      end
+
+      # Sets the position of the point
+      def pos=(pos)
+        @polygon.set_pos_of(@id, pos)
+      end
+
+      # Sets the color of the point
+      def color=(color)
+        @polygon.set_color_of(@id, color)
+      end
+
+      # Sets the outline color of the point
+      def outline=(outline)
+        @polygon.set_outline_of(@id, outline)
+      end
+
+      def inspect
+        "#<#{self.class} polygon=#{polygon} id=#{id} pos=#{pos} color=#{color} \
+outline=#{outline}>"
+      end
+
+      attr_reader :polygon, :id
+    end
+
+    # @param [Integer, nil] size Size of the polygon. If non nil, size points
+    #   will be added to the polygon and then yielded.
+    #
+    # @example
+    #   polygon = Ray::Polygon.new
+    #
+    #   other_polygon = Ray::Polygon.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, &block)
+      if size
+        resize size
+        each(&block) if block
+      end
+    end
+
+    # @yieldparam [Ray::Polygon::Point] point Each point of the polygon
+    def each
+      0.upto(size - 1) { |n| yield self[n] }
+    end
+
+    # @return [Ray::Polygon::Point] idth point of the polygon (id should be less
+    #   than size)
+    def [](id)
+      Point.new(self, id)
+    end
+  end
+end

data/lib/ray/ray.rb

@@ -1,39 +1,71 @@
 require 'enumerator'
 require 'iconv'
 
+# Change PATH so as to find DLLs on windows.
+if RUBY_PLATFORM =~ /mingw/
+  ext_dir = File.expand_path("../../ext", File.dirname(__FILE__))
+  ENV["PATH"] = ENV["PATH"] + File::PATH_SEPARATOR + ext_dir
+end
+
 require 'ray_ext'
 
 module Ray
-  BIG_ENDIAN = ([1].pack("I") == [1].pack("N"))
-  INTERNAL_ENCODING = BIG_ENDIAN ? "UTF-32BE" : "UTF-32LE"
+  # True for big endian
+  BigEndian = ([1].pack("I") == [1].pack("N"))
+
+  # Encoding used by Ray for text_entered events.
+  InternalEncoding = BigEndian ? "UTF-32BE" : "UTF-32LE"
 end
 
 require 'ray/resource_set'
 
-require 'ray/color'
-require 'ray/rect'
 require 'ray/vector'
+require 'ray/rect'
+require 'ray/matrix'
+require 'ray/view'
+require 'ray/color'
+require 'ray/vertex'
+require 'ray/gl/vertex'
+require 'ray/gl/int_array'
+require 'ray/buffer_renderer'
+require 'ray/shader'
+
 require 'ray/image'
-require 'ray/shape'
-require 'ray/drawable'
 require 'ray/text_helper'
 require 'ray/font'
+
+require 'ray/target'
+require 'ray/window'
+require 'ray/image_target'
+
+require 'ray/event'
+
+require 'ray/drawable'
+require 'ray/polygon'
+require 'ray/sprite'
 require 'ray/text'
+require 'ray/turtle'
+
 require 'ray/audio'
-require 'ray/input'
+require 'ray/sound_buffer'
+require 'ray/sound'
+require 'ray/music'
 
 require 'ray/image_set'
 require 'ray/font_set'
-require 'ray/sound_set'
-require 'ray/music_set'
-
-require 'ray/turtle'
+require 'ray/sound_buffer_set'
 
 require 'ray/dsl'
 require 'ray/helper'
 
-require 'ray/sprite'
+require 'ray/animation'
+require 'ray/animation_list'
 
-require 'ray/scene'
 require 'ray/scene_list'
+require 'ray/scene'
+
 require 'ray/game'
+
+at_exit do # Cleaning Ray
+  Ray.send :_clean_up!
+end

data/lib/ray/rect.rb

@@ -1,9 +1,15 @@
 module Ray
   class Rect
+    class << self
+      alias :[] :new
+    end
+
     def inspect
-      "#<#{self.class} {{#{x}, #{y}}, {#{w}, #{h}}}>"
+      "(#{pos}, #{size})"
     end
 
+    alias :to_s :inspect
+
     # @return [true, false] True if the receiver is inside the rect.
     #                       (false if they just collide)
     def inside?(rect)
@@ -54,6 +60,11 @@ module Ray
       Ray::Vector2[x + w, y + h]
     end
 
+    # @return [Ray::Vector2]
+    def center
+      Ray::Vector2[x + w / 2, y + h / 2]
+    end
+
     # @return [true, false] True if the two rects are equal
     def ==(rect)
       return false unless rect.is_a? Rect
@@ -91,14 +102,14 @@ module Ray
 end
 
 class Array
-  # Converts an Array to a rect
+  # @return [Ray::Rect] Converts an array to a rect.
   def to_rect
     Ray::Rect.new(*self)
   end
 end
 
 class Hash
-  # Converts a Hash to a rect
+  # @return [Ray::Rect] Converts a hash into a rect.
   def to_rect
     Ray::Rect.new(self)
   end

data/lib/ray/resource_set.rb

@@ -18,11 +18,9 @@ module Ray
   module ResourceSet
     # Registers a block for handling some resources.
     def add_set(regexp, &block)
-      set_hash[regexp] = Hash.new do |hash, args|
-        regexp =~ args.first
-
-        block_args = $~.captures + args[1..-1]
-        hash[args] = block.call(*block_args)
+      set_hash[regexp] = Hash.new do |hash, key|
+        key =~ regexp
+        hash[key] = yield(*$~.captures)
       end
     end
 
@@ -30,62 +28,47 @@ module Ray
       (@set_hash ||= {})
     end
 
-    # @return The object corresponding to a given list of parameters.
-    def [](value, *params)
-      if params.size != required_argument_count
-        raise(ArgumentError, "wrong number of arguments (%d for %d)" %
-              [params.size, required_argument_count])
-      end
-
+    # @return The object corresponding to a given string.
+    def [](key)
       set_hash.each do |regexp, hash|
-        return hash[([value] + params)] if regexp =~ value
+        return hash[key] if regexp =~ key
       end
 
-      missing_pattern(value, *params)
+      missing_pattern(key)
     end
 
     # Selects objects matching a condition.
     #
-    # @yield *arguments, object
-    # @yieldparam *arguments All the arguments used to access that object
+    # @yield key, object
+    # @yieldparam key the key used to refer to the resource
     # @yieldparam object the actual resource
-    def select!(&block)
+    def select!
       return Enumerator.new(self, :select!) unless block_given?
 
       set_hash.each do |regexp, hash|
-        hash.delete_if do |key, val|
-          !block.call(*(key + [val]))
-        end
+        hash.delete_if { |key, val| !yield(key, val) }
       end
     end
 
     # Removes all the objects from the array but those for which
     # block returned true.
     #
-    # @yield *arguments, object (See #select!)
-    def reject!(&block)
+    # @yield key, object (See #select!)
+    def reject!
       return Enumerator.new(self, :reject!) unless block_given?
-      select! { |*args| !block.call(*args) }
+      select! { |key, obj| !yield(key, obj) }
     end
 
     alias :delete_if :reject!
 
-    # Sets the required argument count. The number of arguments passed to []
-    # must be equal to this + 1 (the first argument isn't counted and is required)
-    #
-    # Defaulted to 0.
-    def need_argument_count(n)
-      @set_argument_count = n
-    end
-
-    # Returns the required argument count.
-    def required_argument_count
-      @set_argument_count ||= 0
+    # Removes all the items from the resource set
+    def clear
+      set_hash.each { |regexp, hash| hash.clear }
     end
 
     # Method called when a string isn't matched by any pattern.
     # Raises a NoPatternError excpetion by default.
-    def missing_pattern(string, *args)
+    def missing_pattern(string)
       raise NoPatternError, "#{string.inspect} not macthed by any pattern"
     end
   end

data/lib/ray/scene.rb

@@ -23,7 +23,7 @@ module Ray
   #
   # Or you can override render:
   #   def render(win)
-  #     # Do drawing here
+  #     # Do draw ing here
   #   end
   #
   # Once your scene is loaded, you'll probably want to clean it up (set some
@@ -65,12 +65,6 @@ module Ray
   #   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
     include Ray::Helper
@@ -78,15 +72,25 @@ module Ray
     class << self
       # Registers a scene to a game object, used for subclasses.
       def bind(game)
-        game.scene(scene_name, self)
+        game.scene(@scene_name || snake_cased_name, self)
       end
 
       # @overload scene_name
       #   @return [Symbol] the name of the scene
       # @overload scene_name(value)
-      #   Sets the name of the scene
-      def scene_name(val = nil)
-        @scene_name = val || @scene_name
+      #   Sets the name of the scene. Defaulted to the snake cased name of the
+      #   scene.
+      def scene_name(val)
+        @scene_name = val
+      end
+
+      private
+      def snake_cased_name
+        if name
+          last_part = name.split("::").last
+          last_part[0] = last_part[0, 1].downcase
+          last_part.gsub(/[A-Z]/) { |letter| "_#{letter.downcase}" }.to_sym
+        end
       end
     end
 
@@ -100,10 +104,9 @@ module Ray
       @scene_render_block     = nil
       @scene_clean_block      = nil
 
-      @scene_need_render      = true
       @scene_loops_per_second = 60
 
-      @scene_shader           = nil
+      @scene_animations       = Ray::AnimationList.new
     end
 
     def register_events
@@ -132,42 +135,7 @@ module Ray
       until @scene_exit
         loop_start = Time.now
 
-        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
-
-        @scene_window.fill(Ray::Color.none)
-
-        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
+        run_tick
 
         if @scene_loops_per_second
           ellapsed_time = Time.now - loop_start
@@ -180,6 +148,23 @@ module Ray
       clean_up
     end
 
+    # Runs one tick of the scene, checking for events, running the event loop,
+    # and drawing on the window.
+    #
+    # @param [true, false] check_events True to check for events
+    def run_tick(check_events = true)
+      collect_events if check_events
+
+      @scene_always_block.call if @scene_always_block
+      listener_runner.run
+
+      @scene_animations.update
+
+      @scene_window.clear Ray::Color.none
+      render @scene_window
+      @scene_window.update
+    end
+
     # Runs another scene over the current one.
     # This method will return when the scene is done running.
     def run_scene(name, *args)
@@ -222,11 +207,6 @@ module Ray
       @scene_always_block = block
     end
 
-    # Marks the scene should be redrawn.
-    def need_render!
-      @scene_need_render = true
-    end
-
     # Registers the block to draw the scene.
     #
     # If no block is given, renders the scen on the image passed as
@@ -248,11 +228,6 @@ module Ray
       exit
     end
 
-    # @see Ray::Game#resize_window
-    def resize_window(w, h)
-      game.resize_window(w, h)
-    end
-
     # Cleans the scene or registers a block to clean it.
     def clean_up(&block)
       if block_given?
@@ -295,33 +270,20 @@ module Ray
     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
+    # @return [Ray::AnimationList] An animation list automatically updated by
+    #   the scene.
+    def animations
+      @scene_animations
     end
 
-    # Sets the shader used for this scene
-    def shader=(value)
-      @scene_shader = value
+    private
+    def collect_events
+      window.each_event do |ev|
+        raise_event(*DSL::EventTranslator.translate_event(ev))
+      end
     end
   end
 end