ray 0.1.0.pre1 → 0.1.0

data/lib/ray/vertex.rb

@@ -0,0 +1,24 @@
+module Ray
+  class Vertex
+    # Important settings
+    @vertex_type_id = 0
+
+    def x; pos.x; end
+    def y; pos.y; end
+
+    def x=(val); self.pos = [val, y]; end
+    def y=(val); self.pos = [x, val]; end
+
+    def tex_x; tex.x; end
+    def tex_y; tex.y; end
+
+    def tex_x=(val); self.tex = [val, tex_y]; end
+    def tex_y=(val); self.tex = [tex_x, val]; end
+
+    alias color  col
+    alias color= col=
+
+    alias position  pos
+    alias position= pos=
+  end
+end

data/lib/ray/view.rb

@@ -0,0 +1,47 @@
+module Ray
+  class View
+    def ==(other)
+      other.is_a?(Ray::View) && self.matrix == other.matrix
+    end
+
+    # Increases zoom (making object appear bigger). The center of the view and
+    # its viewport aren't affected by this.
+    #
+    # @param [Float, Ray::Vector2] value Zoom coefficient
+    # @see unzoom_by
+    def zoom_by(value)
+      self.size /= value
+    end
+
+    # Decreases zoom (making object appear smaller).
+    #
+    # @param [Float, Ray::Vector2] value Zoom coefficient
+    # @see zoom_by
+    def unzoom_by(value)
+      self.size *= value
+    end
+
+    # @return [Ray::Rect] Rect representing the part of the world that can be
+    #   seen through this view.
+    def rect
+      size = self.size
+      pos  = self.center
+
+      Ray::Rect[pos.x - size.x / 2, pos.y - size.y / 2, size.x, size.y]
+    end
+
+    def x; center.x; end
+    def y; center.y; end
+    def w; size.w;   end
+    def h; size.h;   end
+
+    def x=(val); self.center = [val, y]; end
+    def y=(val); self.center = [x, val]; end
+    def w=(val); self.size   = [val, h]; end
+    def h=(val); self.size   = [w, val]; end
+
+    def inspect
+      "#<#{self.class} center=#{center} size=#{size} viewport=#{viewport}>"
+    end
+  end
+end

data/lib/ray/window.rb

@@ -0,0 +1,23 @@
+module Ray
+  class Window
+    # @param title (see #open)
+    # @param size  (see #open)
+    # @param opts  (see #open)
+    def initialize(title = nil, size = [640, 480], opts = {})
+      open(title, size, opts) if title
+    end
+
+    alias size= resize
+
+    # @yieldparam [Ray::Event] event Each event to be processed
+    def each_event
+      return Enumerator.new(self, :each_event) unless block_given?
+
+      ev = Ray::Event.new
+
+      until poll_event(ev).type == Ray::Event::TypeNone
+        yield ev
+      end
+    end
+  end
+end

data/samples/_media/CptnRuby Map.txt

@@ -0,0 +1,25 @@
+#....................................................#
+#....................................................#
+#.............xx......x.x............................#
+#............x..x....................................#
+#x....x...x..x.......#####..xxx....................x.#
+#.x.........................xxx.........##.........x.#
+#...............""..........###...##..........##.....#
+#..##..###..##..##...................................#
+#........................................xx........###
+#.............................###....................#
+##....##.............................................#
+#....................##....##......##....##....##....#
+#.................................................x..#
+#...x....##....##.......x...x.....................x..#
+#.....x...............x...x...x...................x..#
+#......x...##.....##.................................#
+#.......x.........................................#..#
+#...........##........#...#...#..#.......x...........#
+#...#................................................#
+#....."""".................x.......#..#####...###....#
+#x....#......................##......................#
+#"""""#.....#.....x..................#...............#
+##xxxx......#........................................#
+##xxxx...#####............."...""""".................#
+######"""#############################################

data/samples/animation/chain.rb

@@ -0,0 +1,33 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Chained animations" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :animation_chain do
+    @text = text "Hello world!", :at => [100, 100], :size => 30
+
+    @animations = animation_combination
+    @animations << color_variation(:from => Ray::Color.green,
+                                   :to => Ray::Color.blue,
+                                   :duration => 3)
+    @animations << translation(:of => [200, 200], :duration => 3)
+    @animations << scale_variation(:of => [1, 1], :duration => 3)
+    @animations << rotation(:of => 180, :duration => 3)
+
+    @reverse_animations = @animations.start(@text).bounce!
+
+    always do
+      @animations.update
+      @reverse_animations.update
+    end
+
+    render do |win|
+      win.draw @text
+    end
+  end
+
+  scenes << :animation_chain
+end

data/samples/animation/circle.rb

@@ -0,0 +1,38 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Circular motion" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :rotation do
+    @sun = Ray::Polygon.circle([0, 0], 50, Ray::Color.yellow)
+    @sun.pos = window.size / 2
+
+    @earth = Ray::Polygon.circle([0, 0], 20, Ray::Color.blue)
+    @animation = circular_motion(:center => @sun.pos, :angle => 360,
+                                 :duration => 5, :radius => 200).start(@earth)
+
+    @animation.loop!
+
+    on :key_press, key(:p) do
+      if @animation.running?
+        @animation.pause
+      else
+        @animation.resume
+      end
+    end
+
+    always do
+      @animation.update
+    end
+
+    render do |win|
+      win.draw @earth
+      win.draw @sun
+    end
+  end
+
+  scenes << :rotation
+end

data/samples/animation/color.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Hello world!" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :rotation do
+    @text = text "Hello world!", :at => [100, 100], :size => 30
+    animations << color_variation(:from => Ray::Color.red, :to => Ray::Color.blue,
+                                  :duration => 1).start(@text)
+
+    render { |win| win.draw @text }
+  end
+
+  scenes << :rotation
+end

data/samples/animation/rotation.rb

@@ -0,0 +1,17 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Hello world!" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :rotation do
+    @text = text "Hello world!", :at => [100, 100], :size => 30
+    animations << rotation(:of => 360, :duration => 1).start(@text)
+
+    render { |win| win.draw @text }
+  end
+
+  scenes << :rotation
+end

data/samples/animation/sequence.rb

@@ -0,0 +1,33 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray.game "Chained animation sequences" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :animation_seq do
+    @text = text "Hello world!", :at => [100, 100], :size => 30
+
+    seq = animation_sequence
+    seq << color_variation(:from     => Ray::Color.green,
+                           :to       => Ray::Color.blue,
+                           :duration => 1)
+    seq << translation(:of => [200, 200], :duration => 2)
+    seq << scale_variation(:of => [1, 1], :duration => 1)
+    seq << rotation(:of => 180, :duration => 2)
+
+    rev = seq.start(@text).bounce!
+
+    always do
+      seq.update
+      rev.update
+    end
+
+    render do |win|
+      win.draw @text
+    end
+  end
+
+  scenes << :animation_seq
+end

data/samples/animation/shader.rb

@@ -0,0 +1,65 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+Ray::Shader.use_old!
+
+Ray.game "Change color" do
+  register do
+    add_hook :quit, method(:exit!)
+  end
+
+  scene :change do
+    window.shader.compile :frag => StringIO.new(<<-EOF)
+      #version 110
+
+      uniform sampler2D in_Texture;
+      uniform bool in_TextureEnabled;
+
+      uniform float progression;
+
+      varying vec4 var_Color;
+      varying vec2 var_TexCoord;
+
+      void main() {
+        if (in_TextureEnabled)
+          gl_FragColor = texture2D(in_Texture, var_TexCoord) * var_Color;
+        else
+          gl_FragColor = var_Color;
+
+        float stolen_green = gl_FragColor.g * progression;
+        gl_FragColor.g -= stolen_green;
+        gl_FragColor.r += stolen_green;
+      }
+    EOF
+
+    @img = Ray::Image.new [100, 100]
+
+    image_target(@img) do |target|
+      target.clear Ray::Color.green
+
+      target.draw Ray::Polygon.line([0, 0], [100, 100], 2, Ray::Color.blue)
+      target.draw Ray::Polygon.circle([30, 70], 20, Ray::Color.white)
+      target.draw Ray::Polygon.ellipse([70, 20], 30, 10, Ray::Color.new(30, 100, 50))
+
+      target.update
+    end
+
+    @sprite = sprite @img
+
+    @animation = block_animation :duration => 5, :block => proc { |target, progression|
+      target[:progression] = progression
+    }
+
+    @animation.start window.shader
+
+    always do
+      @animation.update
+    end
+
+    render { |win| win.draw @sprite }
+  end
+
+  scenes << :change
+end

data/samples/animation/sprite_motion.rb

@@ -0,0 +1,103 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+def path_of(res)
+  File.expand_path File.join(File.dirname(__FILE__), '../../test/res', res)
+end
+
+class SpriteAnimation < Ray::Animation
+  register_for :sprite_animation
+
+  # @option opts [Ray::Vector2] :from First sprite position
+  # @option opts [Ray::Vector2] :to   Last sprite position
+  # @option opts [true, false]  :loop Whether to reset to the first step at the
+  #   end of the animation.
+  # @option opts [Float] :duration Duration of the animation, in seconds.
+  def setup(opts)
+    self.duration = opts[:duration]
+
+    @initial_value = opts[:from].to_vector2.dup
+
+    delta = opts[:to].to_vector2 - opts[:from].to_vector2
+
+    @x_steps = delta.x.to_i.abs + 1
+    @y_steps = delta.y.to_i.abs + 1
+
+    @negative_x = delta.x < 0
+    @negative_y = delta.y < 0
+
+    @loop = opts[:loop]
+  end
+
+  def update_target
+    progress = progression
+
+    x_prog = ((progress / 100) * @x_steps).floor
+    y_prog = ((progress / 100) * @y_steps).floor
+
+    x_prog = @x_steps - 1 if x_prog == @x_steps
+    y_prog = @y_steps - 1 if y_prog == @y_steps
+
+    target.sheet_pos = @initial_value + variation(x_prog, y_prog)
+  end
+
+  def end_animation
+    target.sheet_pos = @initial_value if @loop
+  end
+
+  def variation(x, y)
+    Ray::Vector2[@negative_x ? -x : x, @negative_y ? -y : y]
+  end
+
+  def -@
+    last_value = @initial_value + variation(@x_steps - 1, @y_steps - 1)
+
+    sprite_animation(:from     => @initial_value,
+                     :to       => last_value,
+                     :loop     => @loop,
+                     :duration => @duration)
+  end
+
+  attr_reader :current_value
+
+  attr_reader :initial_value
+  attr_reader :x_steps, :y_steps
+  attr_reader :negative_x, :negative_y
+end
+
+Ray.game "Sprite motion" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :sprite do
+    @sprite = sprite path_of("sprite.png")
+    @sprite.sheet_size = [4, 4]
+
+    always do
+      if animations.empty?
+        if holding? :down
+          animations << sprite_animation(:from => [0, 0], :to => [4, 0],
+                                         :duration => 0.3).start(@sprite)
+          animations << translation(:of => [0, 32], :duration => 0.3).start(@sprite)
+        elsif holding? :left
+          animations << sprite_animation(:from => [0, 1], :to => [4, 1],
+                                         :duration => 0.3).start(@sprite)
+          animations << translation(:of => [-32, 0], :duration => 0.3).start(@sprite)
+        elsif holding? :right
+          animations << sprite_animation(:from => [0, 2], :to => [4, 2],
+                                         :duration => 0.3).start(@sprite)
+          animations << translation(:of => [32, 0], :duration => 0.3).start(@sprite)
+        elsif holding? :up
+          animations << sprite_animation(:from => [0, 3], :to => [4, 3],
+                                         :duration => 0.3).start(@sprite)
+          animations << translation(:of => [0, -32], :duration => 0.3).start(@sprite)
+        end
+      end
+    end
+
+    render { |win| win.draw @sprite }
+  end
+
+  scenes << :sprite
+end