ray 0.1.0.pre1 → 0.1.0

data/lib/ray/input.rb

@@ -1,10 +0,0 @@
-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,37 +0,0 @@
-module Ray
-  module MusicSet
-    extend Ray::ResourceSet
-
-    class << self
-      def missing_pattern(string)
-        Ray::Music[string]
-      end
-
-      def select!(&block)
-        super(&block)
-        Ray::Music.select!(&block)
-      end
-    end
-  end
-
-  # Creates a new music set.
-  #
-  # @param [Regexp] regex Regular expression used to match file
-  # @yield [*args] Block returning the music
-  #
-  # @yieldparam args Regex captures
-  def music_set(regex, &block)
-    Ray::MusicSet.add_set(regex, &block)
-  end
-
-  module_function :music_set
-end
-
-begin
-  require 'open-uri'
-
-  Ray.music_set(/^(http|ftp):\/\/(\S+)$/) do |protocol, address|
-    open("#{protocol}://#{address}") { |io| Ray::Music.new(io) }
-  end
-rescue LoadError
-end

data/lib/ray/rmagick.rb

@@ -1,41 +0,0 @@
-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

data/lib/ray/shape.rb

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

data/samples/opengl/binding.rb

@@ -1,38 +0,0 @@
-require 'ffi'
-
-module GL
-  extend FFI::Library
-
-  if RUBY_PLATFORM.include? "darwin"
-    ffi_lib "/System/Library/Frameworks/OpenGL.framework/OpenGL"
-  else
-    ffi_lib "GL"
-  end
-
-  Triangles = 4
-  Quads     = 7
-
-  attach_function :glBegin, [:uint], :void
-  attach_function :glEnd, [], :void
-
-  attach_function :glVertex2f, [:float, :float], :void
-  attach_function :glColor3f,  [:float, :float, :float], :void
-  attach_function :glTexCoord2f, [:float, :float], :void
-
-  attach_function :glScalef, [:float, :float, :float], :void
-
-  class << self
-    def begin(mode)
-      glBegin(mode)
-      yield
-    ensure
-      glEnd
-    end
-
-    alias :vertex :glVertex2f
-    alias :color  :glColor3f
-    alias :tex_coord :glTexCoord2f
-
-    alias :scale :glScalef
-  end
-end

data/test/ray_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
-
-context "a newly created window" do
-  setup { Ray.create_window(:w => 100, :h => 150) }
-
-  asserts "has the size given at creation" do
-    topic.w == 100 && topic.h == 150
-  end
-
-  asserts("equal to Ray.screen") { topic == Ray.screen }
-
-  asserts "can change pixels when locked" do
-    topic.lock do
-      topic[10, 15] = Ray::Color.green
-    end
-
-    topic[10, 15] == Ray::Color.green
-  end
-
-  asserts("changing pixel when not locked") {
-    topic[10, 15] = Ray::Color.blue
-  }.raises(RuntimeError)
-end
-
-run_tests if __FILE__ == $0

data/test/shape_test.rb

@@ -1,101 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
-
-context "a shape" do
-  setup { Ray::Shape.new }
-
-  asserts(:pos).equals(Ray::Vector2[0, 0])
-  asserts(:point_count).equals(0)
-  asserts(:outline_width).equals(0)
-  asserts(:angle).equals(0)
-  asserts(:scale).equals(Ray::Vector2[1.0, 1.0])
-
-  asserts("setting the color of a point outside bounds") {
-    topic.set_color_of(0, Ray::Color.blue)
-  }.raises(ArgumentError)
-
-  asserts("setting the outline of a point outside bounds") {
-    topic.set_outline_of(0, Ray::Color.blue)
-  }.raises(ArgumentError)
-
-  asserts("setting the position of a point outside bounds") {
-    topic.set_position_of(0, [10, 10])
-  }.raises(ArgumentError)
-
-  asserts("color, outline, and position of a point outside bounds") {
-    [topic.color_of(0), topic.outline_of(0), topic.position_of(0)]
-  }.equals([nil, nil, nil])
-
-  context "with a point" do
-    hookup do
-      topic.add_point([5, 3], Ray::Color.red, Ray::Color.black)
-    end
-
-    asserts(:point_count).equals(1)
-
-    asserts("position of the point") { topic.position_of(0) }.equals(Ray::Vector2[5, 3])
-    asserts("color of the point") { topic.color_of(0) }.equals(Ray::Color.red)
-    asserts("outline of the point") { topic.outline_of(0) }.equals(Ray::Color.black)
-
-    context "copied from another shape" do
-      setup do
-        @old_topic = topic
-        topic.dup
-      end
-
-      asserts(:point_count).equals(1)
-
-      asserts("position of the point") { topic.position_of(0) }.equals(Ray::Vector2[5, 3])
-      asserts("color of the point") { topic.color_of(0) }.equals(Ray::Color.red)
-      asserts("outline of the point") { topic.outline_of(0) }.equals(Ray::Color.black)
-
-      denies "is the same object as the original one" do
-        topic.equal? @old_topic
-      end
-    end
-  end
-
-  context "with outline_width = 10" do
-    hookup { topic.outline_width = 10 }
-    asserts(:outline_width).equals(10)
-  end
-
-  context "with angle = 10" do
-    hookup { topic.angle = 10 }
-    asserts(:angle).equals(10)
-  end
-
-  context "with scale = [10, 5.5]" do
-    hookup { topic.scale = [10, 5.5] }
-    asserts(:scale).equals(Ray::Vector2[10, 5.5])
-  end
-
-  context "with position = [3, 4]" do
-    hookup { topic.pos = [3, 4] }
-    asserts(:pos).equals(Ray::Vector2[3, 4])
-  end
-end
-
-context "a shape point" do
-  setup do
-    shape = Ray::Shape.new(1) do |p|
-      p.pos     = [10, 15]
-      p.color   = Ray::Color.new(1, 2, 3)
-      p.outline = Ray::Color.new(4, 5, 6)
-    end
-
-    shape[0]
-  end
-
-  asserts(:pos).equals(Ray::Vector2[10, 15])
-  asserts(:color).equals(Ray::Color.new(1, 2, 3))
-  asserts(:outline).equals(Ray::Color.new(4, 5, 6))
-
-  asserts(:id).equals(0)
-
-  asserts("first position, color, and outline of the shape") {
-    shape = topic.shape
-    [shape.position_of(0), shape.color_of(0), shape.outline_of(0)]
-  }.equals([Ray::Vector2[10, 15], Ray::Color.new(1, 2, 3), Ray::Color.new(4, 5, 6)])
-end
-
-run_tests if __FILE__ == $0

data/yard_ext.rb

@@ -1,63 +0,0 @@
-require 'yard'
-
-class MatcherHandler < YARD::Handlers::Ruby::Base
-  handles method_call(:describe_matcher)
-
-  def process
-    src = statement.parameters.children.first.source[1..-1]
-    MethodObject.new(P("Ray::Matchers"), src) do |o|
-      register(o)
-
-      args = statement.last.first
-      if args
-        o.parameters = [args.source]
-      end
-    end
-  end
-end
-
-class CustomCParser < YARD::Parser::CParser
-  include YARD
-
-  private
-  def find_method_body(object, func_name, content = @content)
-    case content
-    when %r"((?>/\*.*?\*/\s*))(?:(?:static|SWIGINTERN)\s+)?(?:intern\s+)?VALUE\s+#{func_name}
-                \s*(\([^)]*\))([^;]|$)"xm
-      comment, params = $1, $2
-      body_text = $&
-
-      remove_private_comments(comment) if comment
-
-      # see if we can find the whole body
-
-      re = Regexp.escape(body_text.strip) + '[^(]*\{.*?^\}'
-      if /#{re}/m =~ content
-        body_text = $&
-      end
-
-      # The comment block may have been overridden with a 'Document-method'
-      # block. This happens in the interpreter when multiple methods are
-      # vectored through to the same C method but those methods are logically
-      # distinct (for example Kernel.hash and Kernel.object_id share the same
-      # implementation
-
-      # override_comment = find_override_comment(object)
-      # comment = override_comment if override_comment
-
-      object.docstring = parse_comments(object, comment) if comment
-      object.source = body_text
-    when %r{((?>/\*.*?\*/\s*))^\s*\#\s*define\s+#{func_name}\s+(\w+)}m
-      comment = $1
-      find_method_body(object, $2, content)
-    else
-      # No body, but might still have an override comment
-      # comment = find_override_comment(object)
-      comment = nil
-      object.docstring = parse_comments(object, comment) if comment
-    end
-  end
-end
-
-YARD::Parser::SourceParser.register_parser_type(:c, CustomCParser,
-                                                ['c', 'cc', 'cxx', 'cpp'])