ruby2d 0.3.1 → 0.4.0

data/lib/ruby2d/sprite.rb

@@ -2,16 +2,17 @@
 
 module Ruby2D
   class Sprite
-    
+
     attr_accessor :x, :y, :clip_x, :clip_y, :clip_w, :clip_h, :data
-    
-    def initialize(x, y, path)
-      
+    attr_reader :z
+
+    def initialize(x, y, path, z=0)
+
       # unless File.exists? path
       #   raise Error, "Cannot find image file `#{path}`"
       # end
-      
-      @type_id = 4
+
+      @type_id = 5
       @x, @y, @path = x, y, path
       @clip_x, @clip_y, @clip_w, @clip_h = 0, 0, 0, 0
       @default = nil
@@ -19,22 +20,23 @@ module Ruby2D
       @current_animation = nil
       @current_frame = 0
       @current_frame_time = 0
-      
-      init(path)
+      @z = z
+
+      ext_sprite_init(path)
       if Module.const_defined? :DSL
         Application.add(self)
       end
     end
-    
+
     def start(x, y, w, h)
       @default = [x, y, w, h]
       clip(x, y, w, h)
     end
-    
+
     def add(animations)
       @animations.merge!(animations)
     end
-    
+
     def animate(animation)
       if @current_animation != animation
         @current_frame      = 0
@@ -43,31 +45,31 @@ module Ruby2D
       end
       animate_frames(@animations[animation])
     end
-    
+
     def reset
       clip(@default[0], @default[1], @default[2], @default[3])
       @current_animation = nil
     end
-    
+
     # TODO: Sprite already has an `add` method, have to reconsile
     # def add
     #   if Module.const_defined? :DSL
     #     Application.add(self)
     #   end
     # end
-    
+
     def remove
       if Module.const_defined? :DSL
         Application.remove(self)
       end
     end
-    
+
     private
-    
+
     def clip(x, y, w, h)
       @clip_x, @clip_y, @clip_w, @clip_h = x, y, w, h
     end
-    
+
     def animate_frames(frames)
       if @current_frame_time < frames[@current_frame][4]
         clip_with_current_frame(frames)
@@ -81,11 +83,11 @@ module Ruby2D
         @current_frame_time = 0
       end
     end
-    
+
     def clip_with_current_frame(frames)
       clip(frames[@current_frame][0], frames[@current_frame][1],
            frames[@current_frame][2], frames[@current_frame][3])
     end
-    
+
   end
 end

data/lib/ruby2d/square.rb

@@ -2,22 +2,27 @@
 
 module Ruby2D
   class Square < Rectangle
-    
+
     attr_reader :size
-    
-    def initialize(x=0, y=0, s=100, c='white')
+
+    def initialize(opts = {})
       @type_id = 2
-      @x, @y, @color = x, y, c
-      @width = @height = @size = s
-      update_coords(x, y, s, s)
-      update_color(c)
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @z = opts[:z] || 0
+      @width = @height = @size = opts[:size] || 100
+
+      self.color = opts[:color] || 'white'
+
+      update_coords(@x, @y, @size, @size)
+
       add
     end
-    
+
     def size=(s)
       self.width = self.height = @size = s
     end
-    
+
     private :width=, :height=
   end
 end

data/lib/ruby2d/text.rb

@@ -2,44 +2,48 @@
 
 module Ruby2D
   class Text
-    
+    include Renderable
+
     attr_accessor :x, :y, :data
-    attr_reader :text, :size, :font, :color
-    
-    def initialize(x=0, y=0, text="Hello World!", size=20, font=nil, c="white")
-      
-      # if File.exists? font
-        @font = font
-      # else
-      #   @font = resolve_path(font)
-      # end
-      
-      @type_id = 5
-      @x, @y, @size = x, y, size
-      @text = text
-      @color = Color.new(c)
-      init
+    attr_reader :text, :size, :width, :height, :font, :color
+
+    def initialize(opts = {})
+      @type_id = 6
+
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @z = opts[:z] || 0
+      @text = (opts[:text] || "Hello World!").to_s
+      @size = opts[:size] || 20
+
+      @font = opts[:font]
+
+      unless RUBY_ENGINE == 'opal'
+        unless File.exists? @font
+          raise Error, "Cannot find font file `#{@font}`"
+        end
+      end
+
+      self.color = opts[:color] || 'white'
+      ext_text_init
       add
     end
-    
+
+    def text=(msg)
+      @text = msg.to_s
+      ext_text_set(@text)
+    end
+
     def color=(c)
       @color = Color.new(c)
     end
-    
-    def add
-      if Module.const_defined? :DSL
-        Application.add(self)
-      end
-    end
-    
-    def remove
-      if Module.const_defined? :DSL
-        Application.remove(self)
-      end
+
+    def contains?(x, y)
+      @x < x and @x + @width > x and @y < y and @y + @height > y
     end
-    
+
     private
-    
+
     def resolve_path(font)
       if RUBY_PLATFORM =~ /darwin/
         font_path = "/Library/Fonts/#{font}.ttf"
@@ -47,13 +51,13 @@ module Ruby2D
         # Linux
         font_path = "/usr/share/fonts/truetype/#{font}.ttf"
       end
-      
+
       unless File.exists? font_path
         raise Error, "Cannot find system font"
       else
         font_path
       end
     end
-    
+
   end
 end

data/lib/ruby2d/triangle.rb

@@ -2,64 +2,66 @@
 
 module Ruby2D
   class Triangle
-    
+    include Renderable
+
     attr_accessor :x1, :y1, :c1,
                   :x2, :y2, :c2,
                   :x3, :y3, :c3
     attr_reader :color, :type_id
-    
-    def initialize(x1=50, y1=0, x2=100, y2=100, x3=0, y3=100, c='white')
+
+    def initialize(opts= {})
       @type_id = 1
-      @x1, @y1 = x1, y1
-      @x2, @y2 = x2, y2
-      @x3, @y3 = x3, y3
-      @color = c
-      update_color(c)
+
+      @x1 = opts[:x1] || 50
+      @y1 = opts[:y1] || 0
+      @x2 = opts[:x2] || 100
+      @y2 = opts[:y2] || 100
+      @x3 = opts[:x3] || 0
+      @y3 = opts[:y3] || 100
+      @z = opts[:z] || 0
+
+      self.color = opts[:color] || 'white'
       add
     end
-    
+
     def color=(c)
-      update_color(c)
-      @color = c
-    end
-    
-    def add
-      if Module.const_defined? :DSL
-        Application.add(self)
-      end
+      @color = Color.from(c)
+      update_color(@color)
     end
-    
-    def remove
-      if Module.const_defined? :DSL
-        Application.remove(self)
-      end
+
+    # Point is inside a triangle if
+    # the area of 3 triangles, constructed from triangle sides and that point
+    # is equal to the area of triangle.
+    def contains?(x, y)
+      self_area = triangle_area(@x1, @y1, @x2, @y2, @x3, @y3)
+      questioned_area =
+        triangle_area(@x1, @y1, @x2, @y2, x, y) +
+        triangle_area(@x2, @y2, @x3, @y3, x, y) +
+        triangle_area(@x3, @y3, @x1, @y1, x, y)
+
+      questioned_area <= self_area
     end
-    
+
     private
-    
+
+    def triangle_area(x1, y1, x2, y2, x3, y3)
+      (x1*y2 + x2*y3 + x3*y1 - x3*y2 - x1*y3 - x2*y1).abs / 2
+    end
+
     def update_color(c)
-      
-      # If a valid color, use it for each vertex
-      if Color.is_valid? c
-        @c1 = Color.new(c)
-        @c2 = Color.new(c)
-        @c3 = Color.new(c)
-        
-      elsif c.class == Array && c.length < 3
-        raise Error, "Triangles require 3 colors, one for each vertex. Only " <<
-                     "#{c.length} were given."
-        
-      # If a valid array of colors, assign them to each vertex, respectively
-      elsif c.all? { |el| Color.is_valid? el }
-        @c1 = Color.new(c[0])
-        @c2 = Color.new(c[1])
-        @c3 = Color.new(c[2])
-        
+      if c.is_a? Color::Set
+        if c.length == 3
+          @c1 = c[0]
+          @c2 = c[1]
+          @c3 = c[2]
+        else
+          raise ArgumentError, "Triangles require 3 colors, one for each vertex. #{c.length} were given."
+        end
       else
-        raise Error, "Not a valid color for #{self.class}"
+        @c1 = c
+        @c2 = c
+        @c3 = c
       end
-      
     end
-    
   end
 end

data/lib/ruby2d/version.rb

@@ -1,5 +1,5 @@
 # version.rb
 
 module Ruby2D
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/ruby2d/window.rb

@@ -2,10 +2,15 @@
 
 module Ruby2D
   class Window
-    
+
     attr_reader :objects
     attr_accessor :mouse_x, :mouse_y, :frames, :fps
-    
+
+    MouseEvent      = Struct.new(:type, :button, :direction, :x, :y, :delta_x, :delta_y)
+    KeyEvent        = Struct.new(:type, :key)
+    ControllerEvent = Struct.new(:which, :type, :axis, :value, :button)
+    EventDescriptor = Struct.new(:type, :id)
+
     def initialize(args = {})
       @title      = args[:title]  || "Ruby 2D"
       @background = Color.new([0.0, 0.0, 0.0, 1.0])
@@ -17,18 +22,35 @@ module Ruby2D
       @fullscreen = false
       @highdpi    = false
       @frames     = 0
-      @fps_cap    = args[:fps] || 60
+      @fps_cap    = args[:fps]    || 60
       @fps        = @fps_cap
-      @vsync      = args[:vsync] || true
-      @mouse_x = 0; @mouse_y = 0
+      @vsync      = args[:vsync]  || true
+      @mouse_x, @mouse_y = 0, 0
       @objects    = []
-      @keys_down, @keys, @keys_up, @mouse, @controller = {}, {}, {}, {}, {}
-      @on_key_proc        = Proc.new {}
-      @on_controller_proc = Proc.new {}
-      @update_proc        = Proc.new {}
-      @diagnostics        = false
+      @event_key  = 0
+      @events     = {
+        key: {},
+        key_down: {},
+        key_held: {},
+        key_up: {},
+        mouse: {},
+        mouse_up: {},
+        mouse_down: {},
+        mouse_scroll: {},
+        mouse_move: {},
+        controller: {},
+        controller_axis: {},
+        controller_button_down: {},
+        controller_button_up: {}
+      }
+      @update_proc = Proc.new {}
+      @diagnostics = false
     end
-    
+
+    def new_event_key
+      @event_key = @event_key.next
+    end
+
     def get(sym)
       case sym
       when :window;          self
@@ -49,7 +71,7 @@ module Ruby2D
       when :diagnostics;     @diagnostics
       end
     end
-    
+
     def set(opts)
       # Store new window attributes, or ignore if nil
       @title           = opts[:title]           || @title
@@ -66,7 +88,7 @@ module Ruby2D
       @highdpi         = opts[:highdpi]         || @highdpi
       @diagnostics     = opts[:diagnostics]     || @diagnostics
     end
-    
+
     def add(o)
       case o
       when nil
@@ -77,153 +99,159 @@ module Ruby2D
         add_object(o)
       end
     end
-    
+
     def remove(o)
       if o == nil
         raise Error, "Cannot remove '#{o.class}' from window!"
       end
-      
+
       if i = @objects.index(o)
-        @objects.slice!(i)
+        @objects.delete_at(i)
         true
       else
         false
       end
     end
-    
+
     def clear
       @objects.clear
     end
-    
+
     def update(&proc)
       @update_proc = proc
       true
     end
-    
-    # def on(mouse: nil, key: nil, key_up: nil, key_down: nil, controller: nil, &proc)
-    def on(args = {}, &proc)
-      mouse      = args[:mouse]
-      key        = args[:key]
-      key_up     = args[:key_up]
-      key_down   = args[:key_down]
-      controller = args[:controller]
-      
-      unless mouse.nil?
-        reg_mouse(mouse, &proc)
-      end
-      
-      unless key_down.nil?
-        reg_key_down(key_down, &proc)
-      end
-      
-      unless key.nil?
-        reg_key(key, &proc)
-      end
-      
-      unless key_up.nil?
-        reg_key_up(key_up, &proc)
-      end
-      
-      unless controller.nil?
-        reg_controller(controller, &proc)
-      end
-    end
-    
-    def mouse_callback(btn, x, y)
-      if @mouse.has_key? 'any'
-        @mouse[btn].call(x, y)
+
+    def on(event, &proc)
+      unless @events.has_key? event
+        raise Error, "`#{event}` is not a valid event type"
       end
+      event_id = new_event_key
+      @events[event][event_id] = proc
+      EventDescriptor.new(event, event_id)
     end
-    
-    def on_key(&proc)
-      @on_key_proc = proc
-      true
+
+    def off(event_descriptor)
+      @events[event_descriptor.type].delete(event_descriptor.id)
     end
-    
-    def key_down_callback(key)
+
+    def key_callback(type, key)
+      # puts "===", "type: #{type}", "key: #{key}"
+
       key = key.downcase
-      if @keys_down.has_key? 'any'
-        @keys_down['any'].call
+
+      # All key events
+      @events[:key].each do |id, e|
+        e.call(KeyEvent.new(type, key))
       end
-      if @keys_down.has_key? key
-        @keys_down[key].call
+
+      case type
+      # When key is pressed, fired once
+      when :down
+        @events[:key_down].each do |id, e|
+          e.call(KeyEvent.new(type, key))
+        end
+      # When key is being held down, fired every frame
+      when :held
+        @events[:key_held].each do |id, e|
+          e.call(KeyEvent.new(type, key))
+        end
+      # When key released, fired once
+      when :up
+        @events[:key_up].each do |id, e|
+          e.call(KeyEvent.new(type, key))
+        end
       end
     end
-    
-    def key_callback(key)
-      key = key.downcase
-      @on_key_proc.call(key)
-      if @keys.has_key? 'any'
-        @keys['any'].call
+
+    def mouse_callback(type, button, direction, x, y, delta_x, delta_y)
+      # Convert to symbols (see MRuby bug in native extension)
+      button    = button.to_sym    unless button    == nil
+      direction = direction.to_sym unless direction == nil
+
+      # All mouse events
+      @events[:mouse].each do |id, e|
+        e.call(MouseEvent.new(type, button, direction, x, y, delta_x, delta_y))
       end
-      if @keys.has_key? key
-        @keys[key].call
+
+      case type
+      # When mouse button pressed
+      when :down
+        @events[:mouse_down].each do |id, e|
+          e.call(MouseEvent.new(type, button, nil, x, y, nil, nil))
+        end
+      # When mouse button released
+      when :up
+        @events[:mouse_up].each do |id, e|
+          e.call(MouseEvent.new(type, button, nil, x, y, nil, nil))
+        end
+      # When mouse motion / movement
+      when :scroll
+        @events[:mouse_scroll].each do |id, e|
+          e.call(MouseEvent.new(type, nil, direction, nil, nil, delta_x, delta_y))
+        end
+      # When mouse scrolling, wheel or trackpad
+      when :move
+        @events[:mouse_move].each do |id, e|
+          e.call(MouseEvent.new(type, nil, nil, x, y, delta_x, delta_y))
+        end
       end
     end
-    
-    def key_up_callback(key)
-      key = key.downcase
-      if @keys_up.has_key? 'any'
-        @keys_up['any'].call
+
+    def controller_callback(which, type, axis, value, button)
+      # All controller events
+      @events[:controller].each do |id, e|
+        e.call(ControllerEvent.new(which, type, axis, value, button))
       end
-      if @keys_up.has_key? key
-        @keys_up[key].call
+
+      case type
+      # When controller axis motion, like analog sticks
+      when :axis
+        @events[:controller_axis].each do |id, e|
+          e.call(ControllerEvent.new(which, type, axis, value, nil))
+        end
+      # When controller button is pressed
+      when :button_down
+        @events[:controller_button_down].each do |id, e|
+          e.call(ControllerEvent.new(which, type, nil, nil, button))
+        end
+      # When controller button is released
+      when :button_up
+        @events[:controller_button_up].each do |id, e|
+          e.call(ControllerEvent.new(which, type, nil, nil, button))
+        end
       end
     end
-    
-    def on_controller(&proc)
-      @on_controller_proc = proc
-      true
-    end
-    
-    def controller_callback(which, is_axis, axis, val, is_btn, btn, pressed)
-      @on_controller_proc.call(which, is_axis, axis, val, is_btn, btn, pressed)
-    end
-    
+
     def update_callback
       @update_proc.call
     end
-    
+
+    def show
+      ext_window_show
+    end
+
+    def close
+      ext_window_close
+    end
+
     private
-    
+
     def add_object(o)
       if !@objects.include?(o)
-        @objects.push(o)
+        index = @objects.index do |object|
+          object.z > o.z
+        end
+        if index
+          @objects.insert(index, o)
+        else
+          @objects.push(o)
+        end
         true
       else
         false
       end
     end
-    
-    # Register key string with proc
-    def reg_key_down(key, &proc)
-      @keys_down[key] = proc
-      true
-    end
-    
-    # Register key string with proc
-    def reg_key(key, &proc)
-      @keys[key] = proc
-      true
-    end
-    
-    # Register key string with proc
-    def reg_key_up(key, &proc)
-      @keys_up[key] = proc
-      true
-    end
-    
-    # Register mouse button string with proc
-    def reg_mouse(btn, &proc)
-      @mouse[btn] = proc
-      true
-    end
-    
-    # Register controller string with proc
-    def reg_controller(event, &proc)
-      @controller[event] = proc
-      true
-    end
-    
+
   end
 end