ray 0.1.0.pre1 → 0.1.0

data/test/target_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a target" do
+  setup do
+    win = Ray::Window.new
+    win.open "test", [640, 480]
+  end
+
+  asserts(:view).equals Ray::View.new([320, 240], [640, 480])
+  asserts(:default_view).equals Ray::View.new([320, 240], [640, 480])
+
+  asserts(:shader).equals { topic.shader }
+
+  asserts(:clip).equals Ray::Rect[0, 0, 640, 480]
+
+  asserts(:viewport_for, [0, 0, 640, 480]).equals Ray::Rect[0, 0, 1, 1]
+  asserts(:viewport_for, [320, 0, 320, 480]).equals Ray::Rect[0.5, 0, 0.5, 1]
+
+  context "with a custom view" do
+    hookup do
+      view = topic.view
+      view.viewport = Ray::Rect[0, 0, 0.5, 0.5]
+      topic.view = view
+    end
+
+    asserts(:view).equals Ray::View.new([320, 240], [640, 480],
+                                        [0, 0, 0.5, 0.5])
+    asserts(:clip).equals Ray::Rect[0, 0, 320, 240]
+
+    asserts(:default_view).equals Ray::View.new([320, 240], [640, 480])
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/text_test.rb

@@ -4,54 +4,43 @@ require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 context "a text" do
   setup { Ray::Text.new "Hello world!" }
 
-  asserts(:content).equals "Hello world!"
-
-  asserts(:style).equals Ray::Font::STYLE_NORMAL
-
-  asserts(:pos).equals Ray::Vector2[0, 0]
-  asserts(:scale).equals Ray::Vector2[1, 1]
-  asserts(:angle).equals 0
-
-  asserts(:character_size).equals 12
+  asserts(:string).equals "Hello world!"
 
+  asserts(:style).equals Ray::Text::Normal
+  asserts(:size).equals 12
   asserts(:color).equals Ray::Color.white
 
   context "after changing style" do
     hookup { topic.style = [:bold, :italic] }
-    asserts(:style).equals Ray::Font::STYLE_BOLD | Ray::Font::STYLE_ITALIC
+    asserts(:style).equals Ray::Text::Bold | Ray::Text::Italic
   end
 
   context "after changing string" do
     hookup do
-      topic.encoding = "utf-8" # Would be required in 1.8 (but utf-8 is the default)
-      topic.content  = "héllo"
+      topic.string = "héllo"
     end
 
-    asserts(:encoding).matches /utf-8/i
-    asserts(:content).equals "héllo"
-  end
+    asserts(:encoding).matches(/utf-8/i)
+    asserts(:string).equals "héllo"
 
-  context "after changing position" do
-    hookup { topic.pos = [13, 22] }
-    asserts(:pos).equals Ray::Vector2[13, 22]
-  end
+    context "copied" do
+      setup { topic.dup }
 
-  context "after changing angle" do
-    hookup { topic.angle = 90 }
-    asserts(:angle).equals 90
-  end
+      asserts(:style).equals Ray::Text::Normal
+      asserts(:size).equals 12
+      asserts(:color).equals Ray::Color.white
 
-  context "after changing scale" do
-    hookup { topic.scale = [2, 10] }
-    asserts(:scale).equals Ray::Vector2[2, 10]
+      asserts(:encoding).matches(/utf-8/i)
+      asserts(:string).equals "héllo"
+    end
   end
 
   context "after changing character size" do
-    hookup { topic.character_size = 120 }
-    asserts(:character_size).equals 120
+    hookup { topic.size = 30 }
+    asserts(:size).equals 30
   end
 
-  context "with another position and scale" do
+  context "rect with another position and scale" do
     hookup do
       topic.pos   = [10, 20]
       topic.scale = [2, 10]
@@ -59,10 +48,10 @@ context "a text" do
 
     asserts("position of the rect") { topic.rect.pos }.equals Ray::Vector2[10, 20]
     asserts("size / size without scale") {
-      scaled_size = topic.size
+      scaled_size = topic.rect.size
 
       topic.scale = [1, 1]
-      size = topic.size
+      size = topic.rect.size
       topic.scale = [2, 10]
 
       scaled_size / size

data/test/turtle_test.rb

@@ -2,17 +2,19 @@
 require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 
 context "a turtle" do
-  setup { Ray::Turtle.new(Ray.screen) }
+  image = Ray::Image.new [100, 150]
+  setup { Ray::Turtle.new image }
 
   asserts(:drawing?)
   asserts(:pos).equals(Ray::Vector2[0, 0])
   asserts(:angle_unit).equals(:deg)
   asserts(:angle).equals(0)
   asserts(:pen_width).equals(1)
+  asserts("target's image") { topic.target.image }.equals image
 
   asserts("setting angle unit to something else than :deg or :rad") {
     topic.angle_unit = :foo
-  }.raises ArgumentError
+  }.raises_kind_of ArgumentError
 
   context "moved to [10, 15]" do
     hookup { topic.pos = [10, 15] }
@@ -63,65 +65,78 @@ context "a turtle" do
     context "after having moved forward by 10" do
       hookup { topic.forward 10 }
 
-      asserts(:x).almost_equals(+cos(deg_to_rad(-30)) * 10)
-      asserts(:y).almost_equals(-sin(deg_to_rad(-30)) * 10) # reversed y axis
+      asserts(:x).almost_equals(+cos(deg_to_rad(-30)) * 10, 10e-6)
+      asserts(:y).almost_equals(-sin(deg_to_rad(-30)) * 10, 10e-6) # reversed y axis
     end
   end
 
   context "which was drawing" do
-    hookup { stub(topic.img).draw_line }
+    hookup { stub(topic.target).draw }
 
     context "with pen_width = 3.4" do
       hookup { topic.pen_width = 3.4 }
 
       context "after having moved forward by 10" do
         hookup { topic.forward(10) }
-        asserts(:img).received(:draw_line, [0, 0], [10, 0], is_a(Ray::Color), 3.4)
+        asserts(:target).received(:draw, is_a(Ray::Polygon))
       end
     end
 
     context "after having moved forward by 10" do
       hookup { topic.forward(10) }
-      asserts(:img).received(:draw_line, [0, 0], [10, 0], is_a(Ray::Color), 1)
+      asserts(:target).received(:draw, is_a(Ray::Polygon))
     end
 
     context "and went to (100, 100)" do
-      hookup { topic.go_to(100, 100) }
+      hookup { topic.go_to [100, 100] }
 
-      asserts(:img).received(:draw_line, [0, 0], [100, 100], is_a(Ray::Color), 1)
+      asserts(:target).received(:draw, is_a(Ray::Polygon))
       asserts(:pos).equals(Ray::Vector2[100, 100])
     end
 
-    context "and went to the center of its image" do
+    context "and went to the center of its target" do
       hookup { topic.center }
 
-      asserts(:img).received(:draw_line, [0, 0], [50, 75], is_a(Ray::Color), 1)
+      asserts(:target).received(:draw, is_a(Ray::Polygon))
       asserts(:pos).equals(Ray::Vector2[50, 75])
     end
+
+    context "and went to the center of its target when using a smaller viewport" do
+      hookup do
+        view = topic.target.view
+        view.viewport = [0, 0, 1, 1 / 1.5]
+        topic.target.view = view
+
+        topic.center
+      end
+
+      asserts(:target).received(:draw, is_a(Ray::Polygon))
+      asserts(:pos).equals(Ray::Vector2[50, 50])
+    end
   end
 
   context "which wasn't drawing" do
     hookup do
       topic.pen_up
-      stub(topic.img).draw_line
+      stub(topic.target).draw
     end
 
     context "after having moved forward by 10" do
       hookup { topic.forward(10) }
-      denies(:img).received(:draw_line, anything, anything, anything, anything)
+      denies(:target).received(:draw, anything)
     end
 
     context "and went to (100, 100)" do
-      hookup { topic.go_to(100, 100) }
+      hookup { topic.go_to [100, 100] }
 
-      denies(:img).received(:draw_line, anything, anything, anything, anything)
+      denies(:target).received(:draw, anything)
       asserts(:pos).equals(Ray::Vector2[100, 100])
     end
 
-    context "and went to the center of its image" do
+    context "and went to the center of its target" do
       hookup { topic.center }
 
-      denies(:img).received(:draw_line, anything, anything, anything, anything)
+      denies(:target).received(:draw, anything)
       asserts(:pos).equals(Ray::Vector2[50, 75])
     end
   end
@@ -144,13 +159,13 @@ context "a turtle" do
       topic.pen_width = 3
       topic.pen_up
 
-      stub(topic.img).fill
+      stub(topic.target).clear
     end
 
     context "after #reset" do
       hookup { topic.reset }
 
-      denies(:img).received(:fill, anything)
+      denies(:target).received(:clear, anything)
 
       asserts(:pos).equals(Ray::Vector2[0, 0])
       asserts(:angle).equals(0)
@@ -162,7 +177,7 @@ context "a turtle" do
     context "after #clear" do
       hookup { topic.clear }
 
-      asserts(:img).received(:fill, Ray::Color.none)
+      asserts(:target).received(:clear, Ray::Color.none)
 
       asserts(:pos).equals(Ray::Vector2[0, 0])
       asserts(:angle).equals(0)

data/test/vector_test.rb

@@ -9,33 +9,35 @@ context "a vector2" do
   asserts(:w).equals(5)
   asserts(:h).equals(15)
 
-  asserts("#+ (1, 2)") { topic + [1, 2] }.equals Ray::Vector2[6, 17]
-  asserts("#- (1, 2)") { topic - [1, 2] }.equals Ray::Vector2[4, 13]
+  asserts(:+, [1, 2]).equals Ray::Vector2[6, 17]
+  asserts(:-, [1, 2]).equals Ray::Vector2[4, 13]
 
-  asserts("#* 2") { topic * 2 }.equals Ray::Vector2[10, 30]
-  asserts("#* (2, 1)") { topic * [2, 1] }.equals Ray::Vector2[10, 15]
-  asserts("#/ (2, 1)") { topic / [2, 1] }.equals Ray::Vector2[2.5, 15]
-  asserts("#dot (2, 1)") { topic.dot [2, 1] }.equals 25
+  asserts(:*, 2).equals Ray::Vector2[10, 30]
+  asserts(:*, [2, 1]).equals Ray::Vector2[10, 15]
+  asserts(:/, [2, 1]).equals Ray::Vector2[2.5, 15]
+  asserts(:dot, [2, 1]).equals 25
 
   asserts(:-@).equals Ray::Vector2[-5, -15]
   asserts(:+@).equals Ray::Vector2[+5, +15]
 
-  asserts("#inside?(Ray::Rect.new(0, 0, 20, 20))") do
-    topic.inside? Ray::Rect.new(0, 0, 20, 20)
-  end
-
-  asserts("#outside?(Ray::Rect.new(8, 0, 20, 20))") do
-    topic.outside? Ray::Rect.new(8, 0, 20, 20)
-  end
+  asserts :inside?, Ray::Rect.new(0, 0, 20, 20)
+  asserts :outside?, Ray::Rect.new(8, 0, 20, 20)
 
   asserts(:to_a).equals([5, 15])
 
+  asserts(:length).almost_equals Math.sqrt(5 * 5 + 15 * 15)
+
+  asserts(:dist, [5, 15]).equals 0
+  asserts(:dist, [0, 15]).almost_equals 5
+
   asserts("equals to #to_a") { topic == [5, 15] }
   asserts("equals to the same vector") { topic == Ray::Vector2[5, 15] }
   asserts("equals to #dup") { topic == topic.dup }
   asserts("eql? to the same vector") { topic.eql? Ray::Vector2[5, 15] }
   asserts(:hash).equals { Ray::Vector2[5, 15].hash }
 
+  denies(:==, [5, 15, 20])
+
   context "after changing x" do
     hookup { topic.x = 10 }
 
@@ -55,6 +57,21 @@ context "a vector2" do
     asserts(:w).equals(5)
     asserts(:h).equals(2)
   end
+
+  context "normalized" do
+    hookup do
+      @old_vector = topic.dup
+      topic.normalize!
+    end
+
+    asserts(:length).almost_equals 1, 10e-6
+
+    asserts("is a multiple of the old vector") do
+      (topic.x / @old_vector.x - topic.y / @old_vector.y).abs < 10e-6
+    end
+
+    asserts_topic.equals { @old_vector.normalize }
+  end
 end
 
 context "a vector3" do
@@ -66,23 +83,30 @@ context "a vector3" do
 
   asserts(:to_a).equals([5, 15, 20])
 
-  asserts("#+ (1, 2, 3)") { topic + [1, 2, 3] }.equals Ray::Vector3[6, 17, 23]
-  asserts("#- (1, 2, 3)") { topic - [1, 2, 3] }.equals Ray::Vector3[4, 13, 17]
+  asserts(:+, [1, 2, 3]).equals Ray::Vector3[6, 17, 23]
+  asserts(:-, [1, 2, 3]).equals Ray::Vector3[4, 13, 17]
 
-  asserts("#* 2") { topic * 2 }.equals Ray::Vector3[10, 30, 40]
-  asserts("#* (2, 0, 0.5)") { topic * [2, 0, 0.5] }.equals Ray::Vector3[10, 0, 10]
-  asserts("#/ (2, 1, 0.5)") { topic / [2, 1, 0.5] }.equals Ray::Vector3[2.5, 15, 40]
-  asserts("#dot (2, 0, 0.5)") { topic.dot [2, 0, 0.5] }.equals 20
+  asserts(:*, 2).equals Ray::Vector3[10, 30, 40]
+  asserts(:*, [2, 0, 0.5]).equals Ray::Vector3[10, 0, 10]
+  asserts(:/, [2, 1, 0.5]).equals Ray::Vector3[2.5, 15, 40]
+  asserts(:dot, [2, 0, 0.5]).equals 20
 
   asserts(:-@).equals Ray::Vector3[-5, -15, -20]
   asserts(:+@).equals Ray::Vector3[+5, +15, +20]
 
+  asserts(:length).almost_equals Math.sqrt(5 * 5 + 15 * 15 + 20 * 20)
+
+  asserts(:dist, [5, 15, 20]).equals 0
+  asserts(:dist, [5, 15, 0]).almost_equals 20
+
   asserts("equals to #to_a") { topic == [5, 15, 20] }
   asserts("equals to the same vector") { topic == Ray::Vector3[5, 15, 20] }
   asserts("equals to #dup") { topic == topic.dup }
   asserts("eql? to the same vector") { topic.eql? Ray::Vector3[5, 15, 20] }
   asserts(:hash).equals { Ray::Vector3[5, 15, 20].hash }
 
+  denies(:==, [5, 15, 20, 30])
+
   context "after changing x" do
     hookup { topic.x = 10 }
 
@@ -106,6 +130,24 @@ context "a vector3" do
     asserts(:y).equals(15)
     asserts(:z).equals(3)
   end
+
+  context "normalized" do
+    hookup do
+      @old_vector = topic.dup
+      topic.normalize!
+    end
+
+    asserts(:length).almost_equals 1, 10e-6
+
+    asserts("is a multiple of the old vector") do
+      val = topic.x / @old_vector.x
+
+      (val - topic.y / @old_vector.y).abs < 10e-6 &&
+        (val - topic.z / @old_vector.z).abs < 10e-6
+    end
+
+    asserts_topic.equals { @old_vector.normalize }
+  end
 end
 
 run_tests if __FILE__ == $0

data/test/vertex_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a vertex" do
+  setup { Ray::Vertex.new }
+
+  asserts(:pos).equals Ray::Vector2[0, 0]
+  asserts(:col).equals Ray::Color.white
+  asserts(:tex).equals Ray::Vector2[0, 0]
+
+  context "after changing pos" do
+    hookup { topic.pos = [1, 2] }
+
+    asserts(:pos).equals Ray::Vector2[1, 2]
+    asserts(:col).equals Ray::Color.white
+    asserts(:tex).equals Ray::Vector2[0, 0]
+  end
+
+  context "after changing col" do
+    hookup { topic.col = Ray::Color.red }
+
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:col).equals Ray::Color.red
+    asserts(:tex).equals Ray::Vector2[0, 0]
+  end
+
+  context "after changing tex" do
+    hookup { topic.tex = [3, 4] }
+
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:col).equals Ray::Color.white
+    asserts(:tex).equals Ray::Vector2[3, 4]
+  end
+end
+
+context "a vertex created with settings" do
+  setup { Ray::Vertex.new([1, 2], Ray::Color.green, [3, 4]) }
+
+  asserts(:pos).equals Ray::Vector2[1, 2]
+  asserts(:col).equals Ray::Color.green
+  asserts(:tex).equals Ray::Vector2[3, 4]
+end
+
+run_tests if __FILE__ == $0

data/test/view_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a view" do
+  setup { Ray::View.new [25, 40], [30, 40] }
+
+  asserts(:==, Ray::View.new([25, 40], [30, 40]))
+  asserts(:dup).equals { topic }
+
+  asserts(:center).equals Ray::Vector2[25, 40]
+  asserts(:size).equals   Ray::Vector2[30, 40]
+  asserts(:rect).equals   Ray::Rect[10, 20, 30, 40]
+
+  asserts(:viewport).equals Ray::Rect.new(0, 0, 1, 1)
+
+  asserts(:matrix).equals Ray::Matrix.orthogonal(10, 40, 60, 20, -1, 1)
+
+  context "after changing the size" do
+    hookup { topic.size = [70, 80] }
+
+    asserts(:center).equals Ray::Vector2[25, 40]
+    asserts(:size).equals   Ray::Vector2[70, 80]
+    asserts(:matrix).equals Ray::Matrix.orthogonal(-10, 60, 80, 0, -1, 1)
+  end
+
+  context "after changing the center" do
+    hookup { topic.center = [30, 45] }
+
+    asserts(:center).equals Ray::Vector2[30, 45]
+    asserts(:size).equals   Ray::Vector2[30, 40]
+  end
+
+  context "after unzooming" do
+    hookup { topic.unzoom_by [2, 2] }
+
+    asserts(:center).equals Ray::Vector2[25, 40]
+    asserts(:size).equals   Ray::Vector2[60, 80]
+  end
+
+  context "after zooming" do
+    hookup { topic.zoom_by [2, 2] }
+
+    asserts(:center).equals Ray::Vector2[25, 40]
+    asserts(:size).equals   Ray::Vector2[15, 20]
+  end
+
+  context "after changing the viewport" do
+    hookup { topic.viewport = [0.3, 0.3, 0.5, 0.5] }
+    asserts(:viewport).equals Ray::Rect.new(0.3, 0.3, 0.5, 0.5)
+  end
+
+  context "with a custom matrix" do
+    hookup do
+      topic.matrix = Ray::Matrix.scale([2, 3, 4])
+      topic.zoom_by [2, 3]
+    end
+
+    asserts(:matrix).equals Ray::Matrix.scale([2, 3, 4])
+  end
+end
+
+run_tests if __FILE__ == $0