ray 0.1.0.pre1 → 0.1.0

data/test/image_target_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "an image target" do
+  img = Ray::Image.new [50, 50]
+  setup { Ray::ImageTarget.new img }
+
+  asserts(:size).equals Ray::Vector2[50, 50]
+
+  context "after draw & update" do
+    hookup do
+      topic.clear Ray::Color.red
+      topic.update
+    end
+
+    asserts("color of image") { img[0, 0] }.equals Ray::Color.red
+  end
+end if Ray::ImageTarget.available?
+
+run_tests if __FILE__ == $0

data/test/image_test.rb

@@ -3,80 +3,100 @@ require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 context Ray::Image do
   setup { Ray::Image }
 
-  context "created with a hash" do
-    setup { topic.new(:w => 50, :h => 70) }
+  asserts(:new, path_of("pop.wav")).raises_kind_of RuntimeError
+  asserts(:new, path_of("thing.png")).raises_kind_of RuntimeError
 
-    asserts(:w).equals(50)
-    asserts(:h).equals(70)
-  end
-
-  denies("creating from a file") {
-    topic.new(path_of("aqua.bmp"))
-  }.raises(RuntimeError)
+  asserts(:new, [0, 0]).raises_kind_of Exception
 
-  asserts("creating from a non-existing file") {
-    topic.new(path_of("doesnt_exist.bmp"))
-  }.raises(RuntimeError)
+  asserts(:new, StringIO.new(File.read(path_of("pop.wav")))).
+    raises_kind_of RuntimeError
+end
 
-  denies("creating from an IO object") {
-    open(path_of("aqua.bmp")) { |io| topic.new(io) }
-  }.raises(RuntimeError)
+context "an image loaded from a file" do
+  setup { Ray::Image.new path_of("sprite.png") }
 
-  asserts("creating from an invalid IO object") {
-    open(path_of("VeraMono.ttf")) { |io| topic.new(io) }
-  }.raises(RuntimeError)
+  asserts(:width).equals 128
+  asserts(:height).equals 192
+  asserts(:size).equals Ray::Vector2[128, 192]
 
-  denies "two different images are equal, despite their content" do
-    a = topic.new(:w => 10, :h => 10).fill(Ray::Color.red).update
-    b = topic.new(:w => 10, :h => 10).fill(Ray::Color.red).update
+  asserts(:[], 128, 100).nil
+  asserts(:[], 100, 192).nil
 
-    a == b
-  end
+  asserts(:[]=, 128, 100, Ray::Color.green).raises_kind_of RangeError
+  asserts(:[]=, 100, 192, Ray::Color.green).raises_kind_of RangeError
 
-  asserts "two images representing the same one are equal" do
-    Ray.screen == Ray.screen
+  context "after changing a pixel" do
+    hookup { topic[0, 10] = Ray::Color.green }
+    asserts(:[], 0, 10).equals Ray::Color.green
+    denies(:[], 1, 10).equals Ray::Color.green
   end
 end
 
-context "an image" do
-  setup { Ray::Image.new(:w => 10, :h => 10).fill(Ray::Color.green).update }
+context "an image loaded from an IO" do
+  setup { open(path_of("sprite.png"), "rb") { |io| Ray::Image.new(io) } }
 
-  asserts(:size).equals Ray::Vector2[10, 10]
-
-  asserts("#dup returns a copy of the receiver") { topic.dup != topic }
+  asserts(:width).equals 128
+  asserts(:height).equals 192
+  asserts(:size).equals Ray::Vector2[128, 192]
+end
 
-  asserts("a pixel outside the image") { topic[10, 10] }.nil
-  asserts("a pixel inside the image is a Ray::Color") { topic[5, 5].is_a? Ray::Color }
+context "an image created from a size" do
+  setup { Ray::Image.new [64, 128] }
 
-  asserts("setting a pixel outside the image") {
-    topic.lock { topic[10, 10] = Ray::Color.red }
-  }.raises(ArgumentError)
+  asserts(:width).equals 64
+  asserts(:height).equals 128
+  asserts(:size).equals Ray::Vector2[64, 128]
 
-  denies("setting a pixel outside the image") {
-    topic { topic[5, 5] = Ray::Color.red }
-  }.raises(RuntimeError)
+  asserts(:tex_rect, [0, 0, 64, 128]).equals Ray::Rect[0, 0, 1, 1]
+  asserts(:tex_rect, [0, 0, 32, 128]).equals Ray::Rect[0, 0, 0.5, 1]
+  asserts(:tex_rect, [0, 0, 64, 64]).equals Ray::Rect[0, 0, 1, 0.5]
+  asserts(:tex_rect, [32, 32, 32, 32]).equals Ray::Rect[0.5, 0.25, 0.5, 0.25]
 
-  asserts("setting a pixel in a non-locked image") {
-    topic[5, 5] = Ray::Color.red
-  }.raises(RuntimeError)
+  denies :smooth?
 
-  context "after having changed a pixel" do
-    hookup { topic.lock { topic[3, 2] = Ray::Color.green } }
-    asserts("the changed pixel") { topic[3, 2] }.equals(Ray::Color.green)
+  context "after enabling smoothing" do
+    hookup { topic.smooth = true }
+    asserts :smooth?
   end
+end
 
-  asserts(:clip).equals(Ray::Rect.new(0, 0, 10, 10))
+context "an image copy" do
+  setup do
+    img = Ray::Image.new [2, 2]
+    img[0, 0] = Ray::Color.red
+    img[0, 1] = Ray::Color.green
+    img[1, 0] = Ray::Color.blue
+    img[1, 1] = Ray::Color.white
 
-  context "after having changed the clipping rect" do
-    hookup { topic.clip([5, 5, 3, 3]) }
-    asserts(:clip).equals(Ray::Rect.new(5, 5, 3, 3))
+    img.dup
   end
 
-  asserts("clip inside a block and otside the block") {
-    res = []
-    topic.clip([5, 5, 3, 3]) { res << topic.clip }
-    res << topic.clip
-  }.equals([Ray::Rect.new(5, 5, 3, 3), Ray::Rect.new(0, 0, 10, 10)])
+  asserts(:size).equals Ray::Vector2[2, 2]
+
+  asserts(:[], 0, 0).equals Ray::Color.red
+  asserts(:[], 0, 1).equals Ray::Color.green
+  asserts(:[], 1, 0).equals Ray::Color.blue
+  asserts(:[], 1, 1).equals Ray::Color.white
+
+  context "saved and loaded again" do
+    path = path_of("test_save.png")
+
+    setup do
+      topic.write path
+      Ray::Image.new path
+    end
+
+    asserts(:size).equals Ray::Vector2[2, 2]
+
+    asserts(:[], 0, 0).equals Ray::Color.red
+    asserts(:[], 0, 1).equals Ray::Color.green
+    asserts(:[], 1, 0).equals Ray::Color.blue
+    asserts(:[], 1, 1).equals Ray::Color.white
+
+    teardown do
+      File.delete path if File.exist? path
+    end
+  end
 end
 
 run_tests if __FILE__ == $0

data/test/int_array_test.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "an int array" do
+  setup { Ray::GL::IntArray.new }
+
+  asserts(:[], 0).nil
+  asserts(:size).equals 0
+
+  context "with new elements" do
+    hookup { topic << 3 << 0 << 1 }
+
+    asserts(:[], 0).equals 3
+    asserts(:[], 1).equals 0
+    asserts(:[], 2).equals 1
+    asserts(:[], 3).nil
+
+    asserts(:size).equals 3
+    asserts(:to_a).equals [3, 0, 1]
+
+    context "one of which was changed" do
+      hookup { topic[1] = 2 }
+
+      asserts(:[], 0).equals 3
+      asserts(:[], 1).equals 2
+      asserts(:[], 2).equals 1
+      asserts(:[], 3).nil
+
+      asserts(:size).equals 3
+      asserts(:to_a).equals [3, 2, 1]
+    end
+
+    context "but cleared" do
+      hookup { topic.clear }
+
+      asserts(:to_a).equals []
+      asserts(:size).equals 0
+    end
+
+    context "copied" do
+      setup { topic.dup }
+
+      asserts(:size).equals 3
+      asserts(:to_a).equals [3, 0, 1]
+    end
+  end
+
+  context "resized with []=" do
+    hookup { topic[1] = 5 }
+
+    asserts(:[], 0).equals 0
+    asserts(:[], 1).equals 5
+    asserts(:[], 2).nil
+
+    asserts(:size).equals 2
+    asserts(:to_a).equals [0, 5]
+  end
+end
+
+context "an int array created with values" do
+  setup { Ray::GL::IntArray.new 0, 5, 4 }
+  asserts(:to_a).equals [0, 5, 4]
+end
+
+run_tests if __FILE__ == $0

data/test/matrix_test.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a matrix" do
+  setup { Ray::Matrix.new }
+
+  asserts(:content).equals {
+    [1, 0, 0, 0,
+     0, 1, 0, 0,
+     0, 0, 1, 0,
+     0, 0, 0, 1]
+  }
+
+  asserts_topic.equals Ray::Matrix.new
+
+  asserts(:[], 4, 0).raises_kind_of RangeError
+  asserts(:[], 0, 5).raises_kind_of RangeError
+
+  asserts(:[]=, 4, 0, 1).raises_kind_of RangeError
+  asserts(:[]=, 0, 5, 1).raises_kind_of RangeError
+
+  context "after changing a single element" do
+    hookup { topic[2, 2] = 10 }
+
+    asserts(:[], 2, 2).equals 10
+    denies(:[],  2, 3).equals 10
+
+    asserts(:content).equals {
+      [1, 0, 0,  0,
+       0, 1, 0,  0,
+       0, 0, 10, 0,
+       0, 0, 0,  1]
+    }
+  end
+
+  context "after changing its whole content" do
+    new_content = (1..16).to_a
+
+    hookup { topic.content = new_content }
+
+    asserts(:content).equals new_content
+    asserts_topic.equals Ray::Matrix.new(new_content)
+
+    asserts(:hash).equals Ray::Matrix.new(new_content).hash
+    asserts(:eql?, Ray::Matrix.new(new_content))
+
+    asserts(:dup).equals { topic }
+
+    context "after reset" do
+      hookup { topic.reset }
+
+      asserts(:content).equals {
+        [1, 0, 0, 0,
+         0, 1, 0, 0,
+         0, 0, 1, 0,
+         0, 0, 0, 1]
+      }
+    end
+
+    context "multiplied by another matrix" do
+      hookup do
+        other = [2, 0, 0, 0,
+                 0, 2, 0, 0,
+                 0, 0, 2, 0,
+                 0, 0, 0, 2]
+
+        topic.multiply_by! Ray::Matrix.new(other)
+      end
+
+      asserts(:content).equals((1..16).map { |n| n * 2 })
+    end
+  end
+
+  asserts(:content=, (1..17).to_a).raises_kind_of ArgumentError
+  asserts(:content=, (1..15).to_a).raises_kind_of ArgumentError
+end
+
+context "a matrix created with Matrix.[]" do
+  setup { Ray::Matrix[*(1..16)] }
+  asserts(:content).equals((1..16).to_a)
+end
+
+context "a translation matrix" do
+  vector = Ray::Vector3[1, 2, 3]
+
+  setup { Ray::Matrix.translation(vector) }
+  asserts(:transform, -vector).equals Ray::Vector3[0, 0, 0]
+end
+
+context "a rotation matrix" do
+  setup { Ray::Matrix.rotation(90, [0, 0, 1]) }
+
+  asserts(:transform, [0, 0, 0]).almost_equals Ray::Vector3[0, 0, 0]
+  asserts(:transform, [10, 0, 0]).almost_equals(Ray::Vector3[0, 10, 0], 1e-6)
+end
+
+context "a scaling matrix" do
+  setup { Ray::Matrix.scale [10, 5, 1] }
+
+  asserts(:transform, [0, 0, 0]).equals Ray::Vector3[0, 0, 0]
+  asserts(:transform, [10, 10, 0]).equals Ray::Vector3[100, 50, 0]
+end
+
+context "an orthogonal projection" do
+  setup { Ray::Matrix.orthogonal(0, 100, 100, 0, 1, -1) }
+
+  asserts(:transform, [0, 0, 0]).equals Ray::Vector3[-1, 1, 0]
+  asserts(:transform, [100, 100, 0.5]).
+    almost_equals Ray::Vector3[1, -1, 0.5], 1e-6
+end
+
+context "a rotation then a translation" do
+  setup { Ray::Matrix.rotation(-90, [0, 0, 1]).translate([10, 10, 0]) }
+  asserts(:transform, [0, 0, 0]).equals Ray::Vector3[10, -10, 0]
+end
+
+context "a translation then a rotation" do
+  setup { Ray::Matrix.translation([10, 10, 0]).rotate(-90, [0, 0, 1]) }
+  asserts(:transform, [0, 0, 0]).equals Ray::Vector3[10, 10, 0]
+end
+
+context "any transformation" do
+  setup { Ray::Matrix.rotation(90, [0, 0, 1]).scale([2, 3, 4]) }
+
+  asserts "inverse matrix reverts transformations" do
+    point = topic.transform [10, 20, 30]
+    (topic.inverse.transform(point) - [10, 20, 30]).to_a.all? do |n|
+      n.abs < 1e-5
+    end
+  end
+
+  asserts(:untransform, [1, 2, 3]).equals { topic.inverse.transform [1, 2, 3] }
+end
+
+run_tests if __FILE__ == $0

data/test/polygon_test.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+context "a polygon" do
+  setup { Ray::Polygon.new }
+
+  asserts(:size).equals 0
+  asserts(:outline_width).equals 1
+
+  asserts :filled?
+  denies :outlined?
+
+  asserts(:pos_of, 0).nil
+  asserts(:color_of, 0).nil
+  asserts(:outline_of, 0).nil
+
+  asserts(:set_pos_of, 0, [0, 0]).raises_kind_of ArgumentError
+  asserts(:set_color_of, 0, Ray::Color.white).raises_kind_of ArgumentError
+  asserts(:set_outline_of, 0, Ray::Color.none).raises_kind_of ArgumentError
+
+  context "after adding a point" do
+    hookup { topic.add_point [1, 2], Ray::Color.green, Ray::Color.red }
+    asserts(:size).equals 1
+
+    asserts(:pos_of, 0).equals Ray::Vector2[1, 2]
+    asserts(:color_of, 0).equals Ray::Color.green
+    asserts(:outline_of, 0).equals Ray::Color.red
+  end
+
+  context "after resize" do
+    hookup { topic.resize 10 }
+    asserts(:size).equals 10
+
+    context "after changing a point" do
+      id = 3
+
+      hookup do
+        topic.set_pos_of(id, [3, 4])
+        topic.set_color_of(id, Ray::Color.yellow)
+        topic.set_outline_of(id, Ray::Color.cyan)
+      end
+
+      asserts(:pos_of, id).equals Ray::Vector2[3, 4]
+      asserts(:color_of, id).equals Ray::Color.yellow
+      asserts(:outline_of, id).equals Ray::Color.cyan
+    end
+
+    context "after changing all the colors" do
+      hookup do
+        topic.color   = Ray::Color.cyan
+        topic.outline = Ray::Color.yellow
+      end
+
+      0.upto(9) do |n|
+        asserts(:color_of, n).equals Ray::Color.cyan
+        asserts(:outline_of, n).equals Ray::Color.yellow
+      end
+    end
+  end
+
+  context "after changing the outline width" do
+    hookup { topic.outline_width = 3 }
+    asserts(:outline_width).equals 3
+  end
+
+  context "after disabling filling" do
+    hookup { topic.filled = false }
+    denies :filled?
+  end
+
+  context "after enabling outline" do
+    hookup { topic.outlined = true }
+    asserts :outlined?
+  end
+
+  context "copied after several changes" do
+    setup do
+      topic.filled   = false
+      topic.outlined = true
+
+      topic.resize 10
+      topic.set_color_of(3, Ray::Color.green)
+
+      topic.pos = [1, 3]
+      topic.angle = 45
+
+      topic.dup
+    end
+
+    denies :filled?
+    asserts :outlined?
+
+    asserts(:size).equals 10
+
+    asserts(:color_of, 3).equals Ray::Color.green
+
+    asserts(:pos).equals Ray::Vector2[1, 3]
+    asserts(:angle).equals 45
+  end
+end
+
+context "a polygon point" do
+  setup do
+    poly = Ray::Polygon.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
+
+    poly[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") {
+    poly = topic.polygon
+    [poly.pos_of(0), poly.color_of(0), poly.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