ray 0.1.0.pre1 → 0.1.0

data/test/animation_test.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
+
+class RandomAnimation < Ray::Animation
+  register_for :random_animation
+
+  def setup
+    @setup_called = true
+  end
+
+  def setup_target
+  end
+
+  def update_target
+  end
+
+  def setup_called?; @setup_called; end
+end
+
+context "an animation" do
+  setup do
+    Ray::Animation.new
+  end
+
+  denies :running?
+  asserts(:duration).equals 0
+  asserts(:target).nil
+  asserts(:progression).nil
+
+  context "running for 10 seconds" do
+    hookup do
+      topic.duration = 10
+      topic.start(@target = Object.new)
+    end
+
+    asserts :running?
+    asserts(:duration).equals 10
+    asserts(:target).equals { @target }
+
+    context "paused" do
+      hookup { topic.pause }
+
+      asserts :paused?
+      denies  :running?
+
+      context "resumed" do
+        hookup { topic.resume }
+
+        denies  :paused?
+        asserts :running?
+      end
+    end
+  end
+end
+
+context "a random animation" do
+  setup do
+    obj = Object.new
+    obj.extend Ray::Helper
+    obj.random_animation
+  end
+
+  asserts :setup_called?
+
+  context "started" do
+    hookup do
+      stub(topic).setup_target
+      topic.start @target = Object.new
+    end
+
+    asserts_topic.received :setup_target
+
+    context "updated" do
+      hookup do
+        stub(topic).update_target
+        topic.update
+      end
+
+      asserts_topic.received :update_target
+    end
+  end
+end
+
+run_tests if __FILE__ == $0

data/test/audio_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 
-context "Ray::Audio" do
+context Ray::Audio do
   setup { Ray::Audio }
 
   asserts(:volume).equals(100)
@@ -24,45 +24,100 @@ context "Ray::Audio" do
   end
 end
 
-[Ray::Sound, Ray::Music].each do |klass|
-  context klass do
-    setup { klass }
+context Ray::SoundBuffer do
+  setup { Ray::SoundBuffer }
 
-    denies("created from a file") {
-      topic.new path_of("pop.wav")
-    }.raises(RuntimeError)
+  denies(:new, path_of("pop.wav")).raises_kind_of Exception
 
-    asserts("created from a non-existing file") {
-      topic.new path_of("doesnt_exist.wav")
-    }.raises(RuntimeError)
+  denies("new from IO") {
+    open(path_of("pop.wav")) { |io| topic.new(io) }
+  }.raises_kind_of Exception
+  denies(:new, File.open(path_of("pop.wav"))).raises_kind_of Exception
 
-    denies("created from an IO") {
-      open(path_of("pop.wav")) { |io| topic.new(io) }
-    }.raises(RuntimeError)
+  asserts(:new, path_of("doesnt_exist.wav")).raises_kind_of Exception
+  asserts(:new, path_of("sprite.png")).raises_kind_of Exception
+  asserts("new from invalid IO") {
+    open(path_of("aqua.png")) { |io| new(io) }
+  }.raises_kind_of Exception
+end
+
+context "an audio source" do
+  setup { Ray::Sound.new path_of("pop.wav") }
+
+  asserts(:pos).equals Ray::Vector3[0, 0, 0]
+  asserts(:pitch).equals 1
+  denies(:relative?)
+  asserts(:min_distance).equals 1
+  asserts(:attenuation).equals 1
+  asserts(:volume).equals 100
+
+  context "after changing position" do
+    hookup { topic.pos = [10, 20, 30] }
+    asserts(:pos).equals Ray::Vector3[10, 20, 30]
+  end
+
+  context "after changing pitch" do
+    hookup { topic.pitch = 30 }
+    asserts(:pitch).equals 30
+  end
+
+  context "after changing relativity" do
+    hookup { topic.relative = true }
+    asserts(:relative?)
+  end
+
+  context "after changing minimal distance" do
+    hookup { topic.min_distance = 0.5 }
+    asserts(:min_distance).equals 0.5
+  end
+
+  context "after changing attenuation" do
+    hookup { topic.attenuation = 15 }
+    asserts(:attenuation).equals 15
+  end
 
-    asserts("created from an invalid IO") {
-      open(path_of("aqua.png")) { |io| topic.new(io) }
-    }.raises(RuntimeError)
+  context "after changing volume" do
+    hookup { topic.volume = 40 }
+    asserts(:volume).almost_equals 40, 1e-6
   end
 end
 
-{
-  "a sound" => Ray::Sound.new(path_of("pop.wav")),
-  "a music" => Ray::Music.new(path_of("pop.wav"))
-}.each do |name, object|
-  context name do
-    setup { object }
-
-    asserts(:volume).equals(100)
-    asserts(:pitch).equals(1)
-    asserts(:pos).equals(Ray::Vector3[0, 0, 0])
-    denies(:relative?)
-    asserts(:min_distance).equals(1)
-    asserts(:attenuation).equals(1)
-    asserts(:status).equals(:stopped)
-
-    asserts(:current_time).equals(0)
-    denies(:loop?)
+context "a sound" do
+  setup do
+    sound = Ray::Sound.new path_of("pop.wav")
+    sound.volume = 0
+    sound
+  end
+
+  asserts(:buffer).equals Ray::SoundBuffer[path_of("pop.wav")]
+  asserts(:duration).equals { topic.buffer.duration }
+
+  asserts(:time).equals 0
+
+  denies(:looping?)
+
+  context "after enabling looping" do
+    hookup { topic.looping = true }
+    asserts(:looping?)
+  end
+end
+
+context "a music" do
+  setup do
+    sound = Ray::Music.new path_of("pop.wav")
+    sound.volume = 0
+    sound
+  end
+
+  asserts(:duration).equals Ray::SoundBuffer[path_of("pop.wav")].duration
+
+  asserts(:time).equals 0
+
+  denies(:looping?)
+
+  context "after enabling looping" do
+    hookup { topic.looping = true }
+    asserts(:looping?)
   end
 end
 

data/test/buffer_renderer_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+class MagicDrawable < Ray::Drawable
+  VertexType = Ray::GL::Vertex.make [[:foo, "bar", :float]]
+
+  def initialize
+    super VertexType
+    self.vertex_count = 3
+  end
+end
+
+context "a buffer renderer" do
+  setup { Ray::BufferRenderer.new :static, Ray::Vertex }
+
+  asserts("copies its drawable array") do
+    !(topic.drawables.equal? topic.drawables)
+  end
+
+  asserts(:drawables).empty
+
+  context "after adding drawables" do
+    obj = Ray::Polygon.circle([100,100], 50)
+    hookup { topic << obj }
+
+    asserts(:drawables).equals [obj]
+
+    context "and clearing it" do
+      hookup { topic.clear }
+      asserts(:drawables).empty
+    end
+  end
+
+  asserts("adding a drawable that uses another vertex type") {
+    topic << MagicDrawable.new
+  }.raises_kind_of Exception
+end
+
+run_tests if __FILE__ == $0

data/test/color_test.rb

@@ -1,23 +1,22 @@
 require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 
-context "a color" do
-  setup { Ray::Color.new(10, 10, 10, 10) }
+context Ray::Color do
+  setup { Ray::Color }
 
-  asserts("#* RGBA(255, 0, 0, 255)") {
-    topic * Ray::Color.red
-  }.equals Ray::Color.new(10, 0, 0, 10)
+  asserts(:from_hsv, 0, 1, 1).equals Ray::Color.red
+  asserts(:from_hsv, 240, 1, 1).equals Ray::Color.blue
+  asserts(:from_hsv, 300, 1, 1).equals Ray::Color.fuschia
+  asserts(:from_hsv, 30, 1, 1).equals Ray::Color.new(255, 127, 0)
+end
 
-  asserts("#+ RGBA(20, 10, 4, 255)") {
-    topic + Ray::Color.new(20, 10, 4, 255)
-  }.equals Ray::Color.new(30, 20, 14, 255)
+context "a color" do
+  setup { Ray::Color.new(10, 10, 10, 10) }
 
-  asserts "is equal to a color with the same components" do
-    topic == Ray::Color.new(10, 10, 10, 10)
-  end
+  asserts(:*, Ray::Color.red).equals Ray::Color.new(10, 0, 0, 10)
+  asserts(:+, Ray::Color.new(20, 10, 4, 3)).equals Ray::Color.new(30, 20, 14, 13)
 
-  denies "is equal to a color with different components" do
-    topic == Ray::Color.new(20, 10, 10, 10)
-  end
+  asserts_topic.equals Ray::Color.new(10, 10, 10, 10)
+  denies_topic.equals Ray::Color.new(20, 10, 10, 10)
 
   [:red, :green, :blue, :alpha].each do |comp|
     context "after having changed #{comp} to 30" do
@@ -36,19 +35,29 @@ context "a color" do
   context "created with 3 integers" do
     setup { Ray::Color.new(10, 20, 30) }
 
-    asserts "has the components given at creation" do
-      topic.r == 10 && topic.g == 20 && topic.b == 30
-    end
-
-    asserts(:a).equals(255)
+    asserts(:r).equals 10
+    asserts(:g).equals 20
+    asserts(:b).equals 30
+    asserts(:a).equals 255
   end
 
   context "created with 4 integers" do
     setup { Ray::Color.new(10, 20, 30, 127) }
 
-    asserts "has the components given at creation" do
-      topic.r == 10 && topic.g == 20 && topic.b == 30 && topic.a == 127
-    end
+    asserts(:r).equals 10
+    asserts(:g).equals 20
+    asserts(:b).equals 30
+    asserts(:a).equals 127
+  end
+
+  context "with a component set to more than 255" do
+    hookup { topic.r = 300 }
+    asserts(:r).equals 255
+  end
+
+  context "with a component set to less than 0" do
+    hookup { topic.r = -100 }
+    asserts(:r).equals 0
   end
 
   context "copied from another color" do

data/test/drawable_test.rb

@@ -1,18 +1,218 @@
 require File.expand_path(File.dirname(__FILE__)) + '/helpers.rb'
 
 context "a drawable" do
-  setup do
-    @block = Proc.new {}
-    Ray::Drawable.new(&@block)
+  setup { Ray::Drawable.new }
+
+  asserts(:origin).equals Ray::Vector2[0, 0]
+  asserts(:scale).equals Ray::Vector2[1, 1]
+  asserts(:pos).equals Ray::Vector2[0, 0]
+  asserts(:z).equals 0
+  asserts(:angle).equals 0
+  asserts(:shader).nil
+
+  context "after changing origin" do
+    hookup { topic.origin = Ray::Vector2[10, 20] }
+
+    asserts(:origin).equals Ray::Vector2[10, 20]
+    asserts(:scale).equals Ray::Vector2[1, 1]
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:z).equals 0
+    asserts(:angle).equals 0
+  end
+
+  context "after changing the scale" do
+    hookup { topic.scale = Ray::Vector2[3, 0.5] }
+
+    asserts(:origin).equals Ray::Vector2[0, 0]
+    asserts(:scale).equals Ray::Vector2[3, 0.5]
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:z).equals 0
+    asserts(:angle).equals 0
+  end
+
+  context "after changing pos" do
+    hookup { topic.pos = Ray::Vector2[10, 20] }
+
+    asserts(:origin).equals Ray::Vector2[0, 0]
+    asserts(:scale).equals Ray::Vector2[1, 1]
+    asserts(:pos).equals Ray::Vector2[10, 20]
+    asserts(:z).equals 0
+    asserts(:angle).equals 0
   end
 
-  context "after drawing" do
+  context "after changing z" do
+    hookup { topic.z = -0.5 }
+
+    asserts(:origin).equals Ray::Vector2[0, 0]
+    asserts(:scale).equals Ray::Vector2[1, 1]
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:z).equals(-0.5)
+    asserts(:angle).equals 0
+  end
+
+  context "after changing angle" do
+    hookup { topic.angle = 60 }
+
+    asserts(:origin).equals Ray::Vector2[0, 0]
+    asserts(:scale).equals Ray::Vector2[1, 1]
+    asserts(:pos).equals Ray::Vector2[0, 0]
+    asserts(:z).equals 0
+    asserts(:angle).equals 60
+  end
+
+  context "with several transformations" do
     hookup do
-      stub(@block).call
-      (@img = Ray::Image.new(:w => 10, :h => 10)).draw_drawable topic
+      topic.origin = [30, 40]
+      topic.pos    = [10, 20]
+      topic.angle  = 90
+      topic.scale  = [2, 0.5]
+      topic.z      = 9
     end
 
-    asserts("the block") { @block }.received(:call) { @img }
+    # (10, 30)   => (-20, -10) (origin)
+    # (-20, -10) => (-40, -5)  (scale)
+    # (-40, -5)  => (5, -40)   (rotate)
+    # (5, -40)   => (15, -20)  (translate)
+
+    asserts(:transform, [10, 30]).almost_equals(Ray::Vector3[15, -20, 9], 1e-6)
+
+    asserts("matrix.transform (10, 30)") {
+      topic.matrix.transform [10, 30]
+    }.almost_equals(Ray::Vector3[15, -20, 9], 1e-6)
+
+    context "created from a copy" do
+      setup { topic.dup }
+
+      asserts(:origin).equals Ray::Vector2[30, 40]
+      asserts(:pos).equals Ray::Vector2[10, 20]
+      asserts(:angle).equals 90
+      asserts(:scale).equals Ray::Vector2[2, 0.5]
+      asserts(:z).equals 9
+    end
+
+    context "and a custom matrix" do
+      hookup do
+        topic.matrix = Ray::Matrix.new
+      end
+
+      asserts(:matrix).equals Ray::Matrix.new
+      asserts(:transform, [10, 30]).equals Ray::Vector3[10, 30, 0]
+
+      context "that has been disabled" do
+        hookup do
+          topic.matrix = nil
+        end
+
+        asserts(:transform, [10, 30]).almost_equals(Ray::Vector3[15, -20, 9],
+                                                    1e-6)
+      end
+    end
+  end
+
+  context "after changing shader" do
+    hookup do
+      topic.shader = @shader = Ray::Shader.new
+    end
+
+    asserts(:shader).equals { @shader }
+  end
+end
+
+class CustomDrawable < Ray::Drawable
+  include Ray::GL
+
+  Vertex = Ray::GL::Vertex.make [
+    [:pos, "pos", :vector2]
+  ]
+
+  def initialize
+    super Vertex
+    self.vertex_count = 3
+  end
+
+  def fill_vertices
+     [Vertex.new([0,  0]),
+      Vertex.new([50, 0]),
+      Vertex.new([50, 50])]
+  end
+
+  def fill_indices(from)
+    Ray::GL::IntArray.new(from + 0, from + 1, from + 2)
+  end
+
+  def render(vertex, index)
+    draw_arrays :triangles, vertex, 3
+  end
+end
+
+context "a custom drawable" do
+  setup { CustomDrawable.new }
+
+  asserts(:vertex_count).equals 3
+  asserts :changed?
+  denies  :textured?
+
+  target = Ray::Window.new
+  target.open "test", [100, 100]
+
+  context "drawn" do
+    hookup do
+      proxy(topic).fill_vertices
+      proxy(topic).fill_indices
+      proxy(topic).render
+      target.draw topic
+    end
+
+    asserts_topic.received :fill_vertices
+    denies_topic.received :fill_indices, anything
+    asserts_topic.received :render, is_a(Integer), 0
+
+    denies :changed?
+
+    context "twice" do
+      hookup do
+        target.draw topic
+      end
+
+      denies_topic.received :fill_vertices => 2
+      asserts_topic.received({:render => 2}, is_a(Integer), 0)
+
+      denies :changed?
+    end
+
+    context "and changed" do
+      hookup { topic.changed! }
+      asserts :changed?
+
+      context "and drawn again" do
+        hookup { target.draw topic }
+        denies :changed?
+
+        asserts_topic.received :fill_vertices => 2
+        asserts_topic.received({:render => 2}, is_a(Integer), 0)
+      end
+    end
+  end
+
+  context "with indices" do
+    hookup do
+      proxy(topic).fill_indices
+      topic.index_count = 3
+
+      target.draw topic
+    end
+
+    asserts_topic.received :fill_indices, is_a(Integer)
+  end
+
+  context "with more indices than it gives" do
+    hookup { topic.index_count = 5 }
+    asserts("drawing it") { target.draw topic }.raises_kind_of RuntimeError
+  end
+
+  context "after enabling texturing" do
+    hookup { topic.textured = true }
+    asserts :textured?
   end
 end