ray 0.0.1 → 0.1.0.pre1

data/lib/ray/image.rb

@@ -4,7 +4,6 @@ module Ray
       "#<#{self.class} w=#{w} h=#{h}>"
     end
 
-    alias :bits_per_pixel :bpp
     alias :w :width
     alias :h :height
 
@@ -14,13 +13,151 @@ module Ray
     extend Ray::ResourceSet
     add_set(/^(.*)$/) { |filename| new(filename) }
 
+    # @return [Ray::Vector2] Size of the image
+    def size
+      Ray::Vector2[w, h]
+    end
+
+    # Draws a point.
+    #
+    # @param [Ray::Vector2, #to_vector2] point The point which should be drawn.
+    # @param [Ray::Color] color Its new color.
+    def draw_pixel(point, color)
+      point = point.to_vector2
+      draw_filled_rect(Ray::Rect.new(point.x, point.y, 1, 1), color)
+    end
+
+    # Draws a line.
+    #
+    # @param [Ray::Vector2, #to_vector2] p1 First point of the line.
+    # @param [Ray::Vector2, #to_vector2] p2 Second point of the line.
+    # @param [Ray::Color] color Color of the line.
+    # @param [Integer] size Thickness of the line.
+    def draw_line(p1, p2, color, size = 1)
+      draw_shape Ray::Shape.line(p1, p2, size, color)
+    end
+
+    # Draws a rect.
+    #
+    # @param [Ray::Rect, Array<Integer>] rect Rect to draw.
+    # @param [Ray::Color] color Color of the rect.
+    def draw_rect(rect, color)
+      shape = Ray::Shape.rectangle(rect, Ray::Color.none, 1, color)
+      shape.filled = false
+
+      draw_shape shape
+    end
+
+    # Draws a filled rect.
+    #
+    # @param [Ray::Rect, Array<Integer>] rect Rect to draw.
+    # @param [Ray::Color] color color of the rect.
+    def draw_filled_rect(rect, color)
+      draw_shape Ray::Shape.rectangle(rect, color)
+    end
+
+    # Draws a circle.
+    #
+    # @param [Ray::Vector2, #to_vector2] center Center of the circle.
+    # @param [Integer] radius Radius of the circle.
+    # @param [Ray::Color] color Color of the circle.
+    def draw_circle(center, radius, color)
+      shape = Ray::Shape.circle(center, radius, Ray::Color.none, 1, color)
+      shape.filled = false
+
+      draw_shape shape
+    end
+
+    # Draws a filled circle.
+    #
+    # @param [Ray::Vector2, #to_vector2] center Center of the circle.
+    # @param [Integer] radius Radius of the circle.
+    # @param [Ray::Color] color Color of the circle.
+    def draw_filled_circle(center, radius, color)
+      draw_shape Ray::Shape.circle(center, radius, color)
+    end
+
+    # Draws an ellipse.
+    #
+    # @param [Ray::Vector2, #to_vector2] center Center of the ellipse
+    # @param [Float] rx x radius (half of the width)
+    # @param [Float] ry y radius (half of the height)
+    # @param [Ray::Color] color Color in which the ellipse should be drawn.
+    def draw_ellipse(center, rx, ry, color)
+      ellipse = Ray::Shape.ellipse(center, rx, ry, Ray::Color.none, 1, color)
+      ellipse.filled = false
+
+      draw_shape ellipse
+    end
+
+    # Draws a filled ellipse.
+    #
+    # @param [Ray::Vector2, #to_vector2] center Center of the ellipse
+    # @param [Float] rx x radius (half of the width)
+    # @param [Float] ry y radius (half of the height)
+    # @param [Ray::Color] color Color in which the ellipse should be drawn.
+    def draw_filled_ellipse(center, rx, ry, color)
+      draw_shape Ray::Shape.ellipse(center, rx, ry, color)
+    end
+
+    # Draws a triangle.
+    def draw_triangle(p1, p2, p3, color)
+      shape = Ray::Shape.new
+
+      shape.add_point(p1, Ray::Color.none, color)
+      shape.add_point(p2, Ray::Color.none, color)
+      shape.add_point(p3, Ray::Color.none, color)
+
+      shape.filled = false
+      shape.outline_width = 1.0
+
+      draw_shape shape
+    end
+
+    # Draws a filled triangle.
+    def draw_filled_triangle(p1, p2, p3, color)
+      shape = Ray::Shape.new
+
+      shape.add_point(p1, color)
+      shape.add_point(p2, color)
+      shape.add_point(p3, color)
+
+      draw_shape shape
+    end
+
+    # Draws a polygon.
+    #
+    # @param [Array<Ray::Vector2, #to_vector2>] points Points which should be joined
+    #                                                  to draw the polygon.
+    # @param [Ray::Color] color The color in which the polygon should be drawn.
+    def draw_polygon(points, color)
+      shape = Ray::Shape.new
+      points.each { |p| shape.add_point(p, Ray::Color.none, color) }
+
+      shape.filled = false
+      shape.outline_width = 1.0
+
+      draw_shape shape
+    end
+
+    # Draws a filled polygon.
+    #
+    # @param [Array<Ray::Vector2, #to_vector2>] points Points which should be joined
+    #                                                  to draw the polygon.
+    # @param [Ray::Color] color The color in which the polygon should be drawn.
+    def draw_filled_polygon(points, color)
+      shape = Ray::Shape.new
+      points.each { |p| shape.add_point(p, color) }
+      draw_shape shape
+    end
+
     # @yield [pixel]
     # @yieldparam [Ray::Color] pixel Color of a point
     def each
       return Enumerator.new(self, :each) unless block_given?
 
-      (0...w).each do |x|
-        (0...h).each do |y|
+      (0...h).each do |y|
+        (0...w).each do |x|
           yield self[x, y]
         end
       end
@@ -29,13 +166,13 @@ module Ray
     end
 
     # Same as each, but also yields the position of each point.
-    # @yield [x, y, pixel]
+    # @yield [pixel, x, y]
     def each_with_pos
       return Enumerator.new(self, :each_with_pos) unless block_given?
 
-      (0...w).each do |x|
-        (0...h).each do |y|
-          yield x, y, self[x, y]
+      (0...h).each do |y|
+        (0...w).each do |x|
+          yield self[x, y], x, y
         end
       end
 
@@ -47,8 +184,8 @@ module Ray
       return Enumerator.new(self, :map!) unless block_given?
 
       lock do
-        (0...w).each do |x|
-          (0...h).each do |y|
+        (0...h).each do |y|
+          (0...w).each do |x|
             self[x, y] = yield self[x, y]
           end
         end
@@ -57,14 +194,14 @@ module Ray
       self
     end
 
-    # @yield [x, y, pixel] Block returning the new color of this pixel
+    # @yield [pixel, x, y] Block returning the new color of this pixel
     def map_with_pos!
       return Enumerator.new(self, :map_with_pos!) unless block_given?
 
       lock do
-        (0...w).each do |x|
-          (0...h).each do |y|
-            self[x, y] = yield x, y, self[x, y]
+        (0...h).each do |y|
+          (0...w).each do |x|
+            self[x, y] = yield self[x, y], x, y
           end
         end
       end
@@ -82,17 +219,6 @@ module Ray
       dup.map_with_pos!(&block)
     end
 
-    def to_image
-      self
-    end
-
     include Enumerable
   end
 end
-
-class String
-  # Converts the string to an image using Ray::ImageSet.[]
-  def to_image
-    Ray::ImageSet[self]
-  end
-end

data/lib/ray/image_set.rb

@@ -19,9 +19,11 @@ module Ray
   # @param [Regexp] regex Regular expression used to match file
   # @yield [*args] Block returning the image
   # @yieldparam args Regex captures
-  def self.image_set(regex, &block)
+  def image_set(regex, &block)
     Ray::ImageSet.add_set(regex, &block)
   end
+
+  module_function :image_set
 end
 
 begin

data/lib/ray/input.rb

@@ -0,0 +1,10 @@
+module Ray
+  module Input
+    module_function
+
+    # @return [Ray::Vector2] Position of the mouse
+    def mouse_pos
+      Ray::Vector2[mouse_x, mouse_y]
+    end
+  end
+end

data/lib/ray/music_set.rb

@@ -1,10 +1,10 @@
 module Ray
   module MusicSet
     extend Ray::ResourceSet
-    
+
     class << self
       def missing_pattern(string)
-        Ray::Music[string, size]
+        Ray::Music[string]
       end
 
       def select!(&block)
@@ -20,9 +20,11 @@ module Ray
   # @yield [*args] Block returning the music
   #
   # @yieldparam args Regex captures
-  def self.music_set(regex, &block)
+  def music_set(regex, &block)
     Ray::MusicSet.add_set(regex, &block)
   end
+
+  module_function :music_set
 end
 
 begin

data/lib/ray/ray.rb

@@ -1,22 +1,33 @@
 require 'enumerator'
+require 'iconv'
 
-# 'ray_ext' doesn't exist on the PSP.
-# We assume that Ray isn't defined in other cases.
-require 'ray_ext' unless defined? Ray
+require 'ray_ext'
+
+module Ray
+  BIG_ENDIAN = ([1].pack("I") == [1].pack("N"))
+  INTERNAL_ENCODING = BIG_ENDIAN ? "UTF-32BE" : "UTF-32LE"
+end
 
 require 'ray/resource_set'
 
 require 'ray/color'
 require 'ray/rect'
+require 'ray/vector'
 require 'ray/image'
-require 'ray/joystick'
-require 'ray/font' if Ray.has_font_support?
-require 'ray/audio' if Ray.has_audio_support?
+require 'ray/shape'
+require 'ray/drawable'
+require 'ray/text_helper'
+require 'ray/font'
+require 'ray/text'
+require 'ray/audio'
+require 'ray/input'
 
 require 'ray/image_set'
-require 'ray/font_set'  if Ray.has_font_support?
-require 'ray/sound_set' if Ray.has_audio_support?
-require 'ray/music_set' if Ray.has_audio_support?
+require 'ray/font_set'
+require 'ray/sound_set'
+require 'ray/music_set'
+
+require 'ray/turtle'
 
 require 'ray/dsl'
 require 'ray/helper'
@@ -24,4 +35,5 @@ require 'ray/helper'
 require 'ray/sprite'
 
 require 'ray/scene'
+require 'ray/scene_list'
 require 'ray/game'

data/lib/ray/rect.rb

@@ -7,6 +7,7 @@ module Ray
     # @return [true, false] True if the receiver is inside the rect.
     #                       (false if they just collide)
     def inside?(rect)
+      rect = rect.to_rect
       (x >= rect.x) && (y >= rect.y) &&
         (x + w) <= (rect.x + rect.w) &&
         (y + h) <= (rect.y + rect.h)
@@ -14,10 +15,11 @@ module Ray
 
     # @return [true, false] True if the receiver is outside the rect.
     def outside?(rect)
-      !rect.contain?(x, y) &&
-        !rect.contain?(x, y + h) &&
-        !rect.contain?(x + w, y) &&
-        !rect.contain?(x + w, y + h)
+      rect = rect.to_rect
+      !rect.contain?(top_left) &&
+        !rect.contain?(bottom_left) &&
+        !rect.contain?(top_right) &&
+        !rect.contain?(bottom_right)
     end
 
     # @return [true, false] True if the receiver collides with the rect.
@@ -26,9 +28,30 @@ module Ray
     end
 
     # @return [true, false] True if the receiver contians this point
-    def contain?(p_x, p_y)
-      (p_x >= x) && (p_y >= y) &&
-        (p_x < x + w) && (p_y < y + h)
+    def contain?(p)
+      p = p.to_vector2
+      (p.x >= x) && (p.y >= y) &&
+        (p.x < x + w) && (p.y < y + h)
+    end
+
+    # @return [Ray::Vector2] top left corner
+    def top_left
+      Ray::Vector2[x, y]
+    end
+
+    # @return [Ray::Vector2] top right corner
+    def top_right
+      Ray::Vector2[x + w, y]
+    end
+
+    # @return [Ray::Vector2] bottom left corner
+    def bottom_left
+      Ray::Vector2[x, y + h]
+    end
+
+    # @return [Ray::Vector2] bottom right corner
+    def bottom_right
+      Ray::Vector2[x + w, y + h]
     end
 
     # @return [true, false] True if the two rects are equal
@@ -37,10 +60,28 @@ module Ray
       x == rect.x && y == rect.y && w == rect.w && h == rect.h
     end
 
+    def eql?(obj)
+      self.class == obj.class && self == obj
+    end
+
+    def hash
+      [x, y, w, h].hash
+    end
+
     def to_rect
       self
     end
 
+    # @return [Ray::Vector2] The position of the rect
+    def pos
+      Vector2[x, y]
+    end
+
+    # @return [Ray::Vector2] The size of the rect
+    def size
+      Vector2[w, h]
+    end
+
     alias :w :width
     alias :h :height
 

data/lib/ray/rmagick.rb

@@ -0,0 +1,41 @@
+require 'rmagick'
+
+module Ray
+  class Color
+    # @return [Ray::Color] A color created from an Magick::Pixel
+    def self.from_rmagick(pix)
+      max = Magick::QuantumRange.to_f
+      new((pix.red * 255) / max, (pix.green * 255) / max, (pix.blue * 255) / max,
+          ((max - pix.opacity) * 255) / max)
+    end
+
+    # @return [Magick::Pixel] An equivalent color for RMagick
+    def to_rmagick
+      max = Magick::QuantumRange.to_f
+      Magick::Pixel.new((r * max) / 255, (g * max) / 255, (b * max) / 255,
+                        ((255 - a) * max) / 255)
+    end
+  end
+
+  class Image
+    # @return [Ray::Image] An image created from a Magic::Image
+    def self.from_rmagick(input)
+      img = new(:w => input.columns, :h => input.rows)
+
+      img.map_with_pos! do |col, x, y|
+        Color.from_rmagick(input.pixel_color(x, y))
+      end
+    end
+
+    # @return [Magick::Image] An equivalant image for RMagick
+    def to_rmagick
+      img = Magick::Image.new(width, height)
+
+      each_with_pos do |col, x, y|
+        img.pixel_color(x, y, col.to_rmagick)
+      end
+
+      img
+    end
+  end
+end