gosling 2.3.0 → 2.3.2

data/spec/rect_spec.rb

@@ -1,87 +1,87 @@
-describe Gosling::Rect do
-  before(:all) do
-    @window = Gosu::Window.new(640, 480, false)
-    @rect = Gosling::Rect.new(@window)
-  end
-
-  it 'starts with width and height 1' do
-    expect(@rect.width).to be == 1
-    expect(@rect.height).to be == 1
-  end
-
-  describe '#width' do
-    it 'returns our width' do
-      expect(@rect.width).to be_kind_of(Numeric)
-    end
-  end
-
-  describe '#set_width' do
-    it 'alters our width, updating our vertices' do
-      rect = Gosling::Rect.new(@window)
-      rect.width = 10
-      expect(rect.width).to be == 10
-    end
-
-    it 'cannot be less than one' do
-      rect = Gosling::Rect.new(@window)
-      expect { rect.width = 0 }.to raise_error(ArgumentError)
-      expect { rect.width = -100 }.to raise_error(ArgumentError)
-    end
-
-    it 'updates our vertices' do
-      expected_vertices = [
-        Snow::Vec3[ 0, 0, 0],
-        Snow::Vec3[11, 0, 0],
-        Snow::Vec3[11, 1, 0],
-        Snow::Vec3[ 0, 1, 0]
-      ]
-
-      rect = Gosling::Rect.new(@window)
-      rect.width = 11
-      expect(rect.get_vertices).to be == expected_vertices
-    end
-  end
-
-  describe '#height' do
-    it 'returns our height' do
-      expect(@rect.height).to be_kind_of(Numeric)
-    end
-  end
-
-  describe '#set_height' do
-    it 'alters our height, updating our vertices' do
-      rect = Gosling::Rect.new(@window)
-      rect.height = 15
-      expect(rect.height).to be == 15
-    end
-
-    it 'cannot be less than one' do
-      rect = Gosling::Rect.new(@window)
-      expect { rect.height = 0 }.to raise_error(ArgumentError)
-      expect { rect.height = -200 }.to raise_error(ArgumentError)
-    end
-
-    it 'updates our vertices' do
-      expected_vertices = [
-        Snow::Vec3[0,  0, 0],
-        Snow::Vec3[1,  0, 0],
-        Snow::Vec3[1, 40, 0],
-        Snow::Vec3[0, 40, 0]
-      ]
-
-      rect = Gosling::Rect.new(@window)
-      rect.height = 40
-      expect(rect.get_vertices).to be == expected_vertices
-    end
-  end
-
-  it 'does not allow set_vertices to be called directly' do
-    vertices = [
-      Snow::Vec3[0,  0, 0],
-      Snow::Vec3[1, 10, 0],
-      Snow::Vec3[2, 20, 0],
-      Snow::Vec3[3, 40, 0]
-    ]
-    expect { @rect.set_vertices(vertices) }.to raise_error(NoMethodError)
-  end
+describe Gosling::Rect do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @rect = Gosling::Rect.new(@window)
+  end
+
+  it 'starts with width and height 1' do
+    expect(@rect.width).to be == 1
+    expect(@rect.height).to be == 1
+  end
+
+  describe '#width' do
+    it 'returns our width' do
+      expect(@rect.width).to be_kind_of(Numeric)
+    end
+  end
+
+  describe '#set_width' do
+    it 'alters our width, updating our vertices' do
+      rect = Gosling::Rect.new(@window)
+      rect.width = 10
+      expect(rect.width).to be == 10
+    end
+
+    it 'cannot be less than one' do
+      rect = Gosling::Rect.new(@window)
+      expect { rect.width = 0 }.to raise_error(ArgumentError)
+      expect { rect.width = -100 }.to raise_error(ArgumentError)
+    end
+
+    it 'updates our vertices' do
+      expected_vertices = [
+        Snow::Vec3[ 0, 0, 0],
+        Snow::Vec3[11, 0, 0],
+        Snow::Vec3[11, 1, 0],
+        Snow::Vec3[ 0, 1, 0]
+      ]
+
+      rect = Gosling::Rect.new(@window)
+      rect.width = 11
+      expect(rect.get_vertices).to be == expected_vertices
+    end
+  end
+
+  describe '#height' do
+    it 'returns our height' do
+      expect(@rect.height).to be_kind_of(Numeric)
+    end
+  end
+
+  describe '#set_height' do
+    it 'alters our height, updating our vertices' do
+      rect = Gosling::Rect.new(@window)
+      rect.height = 15
+      expect(rect.height).to be == 15
+    end
+
+    it 'cannot be less than one' do
+      rect = Gosling::Rect.new(@window)
+      expect { rect.height = 0 }.to raise_error(ArgumentError)
+      expect { rect.height = -200 }.to raise_error(ArgumentError)
+    end
+
+    it 'updates our vertices' do
+      expected_vertices = [
+        Snow::Vec3[0,  0, 0],
+        Snow::Vec3[1,  0, 0],
+        Snow::Vec3[1, 40, 0],
+        Snow::Vec3[0, 40, 0]
+      ]
+
+      rect = Gosling::Rect.new(@window)
+      rect.height = 40
+      expect(rect.get_vertices).to be == expected_vertices
+    end
+  end
+
+  it 'does not allow set_vertices to be called directly' do
+    vertices = [
+      Snow::Vec3[0,  0, 0],
+      Snow::Vec3[1, 10, 0],
+      Snow::Vec3[2, 20, 0],
+      Snow::Vec3[3, 40, 0]
+    ]
+    expect { @rect.set_vertices(vertices) }.to raise_error(NoMethodError)
+  end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,3 @@
-require_relative '../lib/gosling.rb'
-
-RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+require_relative '../lib/gosling.rb'
+
+RSpec::Expectations.configuration.on_potential_false_positives = :nothing

data/spec/sprite_spec.rb

@@ -1,45 +1,45 @@
-describe Gosling::Sprite do
-  before(:all) do
-    @window = Gosu::Window.new(640, 480, false)
-    @local_path = File.dirname(__FILE__)
-    @image = Gosling::ImageLibrary.get(File.join(@local_path, 'images/key.png'))
-
-    @sprite = Gosling::Sprite.new(@window)
-  end
-
-  describe '#get_image' do
-    it 'returns our image' do
-      get_sprite = Gosling::Sprite.new(@window)
-      expect(get_sprite.get_image).to be == nil
-      get_sprite.set_image(@image)
-      expect(get_sprite.get_image).to be_instance_of(Gosu::Image)
-    end
-  end
-
-  describe '#set_image' do
-    before(:each) do
-      @image_sprite = Gosling::Sprite.new(@window)
-      @image_sprite.set_image(@image)
-    end
-
-    it 'complains if given something other than an image' do
-      expect { Gosling::Sprite.new(@window).set_image(:foo) }.to raise_error(ArgumentError)
-    end
-
-    it 'sets our image' do
-      expect(@image_sprite.get_image).to be == @image
-    end
-
-    it 'automatically updates our width and height' do
-      expect(@image_sprite.width).to be == @image.width
-      expect(@image_sprite.height).to be == @image.height
-      expect(@image_sprite.width).to be_kind_of(Numeric)
-      expect(@image_sprite.height).to be_kind_of(Numeric)
-    end
-  end
-
-  it 'does not allow set_width or set_height to be called directly' do
-    expect { @sprite.set_width(10) }.to raise_error(NoMethodError)
-    expect { @sprite.set_height(20) }.to raise_error(NoMethodError)
-  end
-end
+describe Gosling::Sprite do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @local_path = File.dirname(__FILE__)
+    @image = Gosling::ImageLibrary.get(File.join(@local_path, 'images/key.png'))
+
+    @sprite = Gosling::Sprite.new(@window)
+  end
+
+  describe '#get_image' do
+    it 'returns our image' do
+      get_sprite = Gosling::Sprite.new(@window)
+      expect(get_sprite.get_image).to be == nil
+      get_sprite.set_image(@image)
+      expect(get_sprite.get_image).to be_instance_of(Gosu::Image)
+    end
+  end
+
+  describe '#set_image' do
+    before(:each) do
+      @image_sprite = Gosling::Sprite.new(@window)
+      @image_sprite.set_image(@image)
+    end
+
+    it 'complains if given something other than an image' do
+      expect { Gosling::Sprite.new(@window).set_image(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets our image' do
+      expect(@image_sprite.get_image).to be == @image
+    end
+
+    it 'automatically updates our width and height' do
+      expect(@image_sprite.width).to be == @image.width
+      expect(@image_sprite.height).to be == @image.height
+      expect(@image_sprite.width).to be_kind_of(Numeric)
+      expect(@image_sprite.height).to be_kind_of(Numeric)
+    end
+  end
+
+  it 'does not allow set_width or set_height to be called directly' do
+    expect { @sprite.set_width(10) }.to raise_error(NoMethodError)
+    expect { @sprite.set_height(20) }.to raise_error(NoMethodError)
+  end
+end

data/spec/transformable_spec.rb

@@ -1,479 +1,479 @@
-class TransformableThing
-  include Gosling::Transformable
-
-  attr_reader :is_dirty
-  attr_reader :translation, :translate_is_dirty
-  attr_reader :center, :center_is_dirty
-  attr_reader :scale, :scale_is_dirty
-end
-
-describe Gosling::Transformable do
-  before(:all) do
-    @read_only_tf = TransformableThing.new
-  end
-
-  it 'has a center' do
-    expect(@read_only_tf.center).to be_instance_of(Snow::Vec3)
-  end
-
-  it 'has a scale' do
-    expect(@read_only_tf.scale).to be_instance_of(Snow::Vec2)
-  end
-
-  it 'has a rotation' do
-    expect(@read_only_tf.rotation).to be_kind_of(Numeric)
-  end
-
-  it 'has a translation' do
-    expect(@read_only_tf.translation).to be_instance_of(Snow::Vec3)
-  end
-
-  it 'has methods for getting its x/y position' do
-    expect(@read_only_tf.x).to be_kind_of(Numeric)
-    expect(@read_only_tf.y).to be_kind_of(Numeric)
-  end
-
-  it 'has methods for setting its x/y position' do
-    @read_only_tf.x = 13
-    @read_only_tf.y = -7
-    expect(@read_only_tf.x).to be == 13
-    expect(@read_only_tf.y).to be == -7
-  end
-
-  it 'has methods for getting its x/y centerpoint' do
-    expect(@read_only_tf.center_x).to be_kind_of(Numeric)
-    expect(@read_only_tf.center_y).to be_kind_of(Numeric)
-  end
-
-  it 'has methods for setting its x/y centerpoint' do
-    @read_only_tf.center_x = 5
-    @read_only_tf.center_y = 15
-    expect(@read_only_tf.center_x).to be == 5
-    expect(@read_only_tf.center_y).to be == 15
-  end
-
-  it 'has methods for getting its x/y scaling' do
-    expect(@read_only_tf.scale_x).to be_kind_of(Numeric)
-    expect(@read_only_tf.scale_y).to be_kind_of(Numeric)
-  end
-
-  it 'has methods for setting its x/y scaling' do
-    @read_only_tf.scale_x = 2
-    @read_only_tf.scale_y = 3
-    expect(@read_only_tf.scale_x).to be == 2
-    expect(@read_only_tf.scale_y).to be == 3
-  end
-
-  it 'has a method for getting its rotation' do
-    expect(@read_only_tf.rotation).to be_kind_of(Numeric)
-  end
-
-  it 'has a method for setting its rotation' do
-    @read_only_tf.rotation = Math::PI
-    expect(@read_only_tf.rotation).to be == Math::PI
-  end
-
-  describe '#center=' do
-    it 'accepts a size 3 vector' do
-      tf = TransformableThing.new
-      expect { tf.center = Snow::Vec3[0, 0, 0] }.not_to raise_error
-      expect { tf.center = [0, 0, 0] }.not_to raise_error
-      expect { tf.center = :foo }.to raise_error(ArgumentError)
-    end
-
-    it 'sets the center transform' do
-      v = Snow::Vec3[10.to_r, 20.to_r, 1.to_r]
-      tf = TransformableThing.new
-      tf.center = v
-      expect(tf.center).to be == v
-    end
-
-    it 'does not alter the z value, which should always be 1' do
-      tf = TransformableThing.new
-      [
-        Snow::Vec3[1, 1, 1],
-        Snow::Vec3[1, 1, 13],
-        Snow::Vec3[1, 1, 7],
-        Snow::Vec3[1, 1, 29373],
-        Snow::Vec3[1, 1, -1],
-        Snow::Vec3[1, 1, 0],
-        Snow::Vec3[1, 1, -328.7],
-      ].each do |v|
-        tf.center = v
-        expect(tf.center[2]).to be == 1
-      end
-    end
-
-    context 'when given a block' do
-      it 'yields the center vector directly to the block' do
-        tf = TransformableThing.new
-        tf.center = [3, -7]
-
-        center_ref = nil
-        area = nil
-        tf.set_center do |c|
-          center_ref = c
-          area = c.x * c.y
-        end
-        expect(center_ref).to be_equal(tf.center)
-        expect(area).to eq(-21)
-      end
-
-      it 'marks the transformation as dirty' do
-        tf = TransformableThing.new
-        tf.set_center { |t| area = t.x * t.y }
-        expect(tf.center_is_dirty).to be true
-        expect(tf.is_dirty).to be true
-      end
-    end
-  end
-
-  describe '#set_scale' do
-    it 'accepts a size 2 vector, an equivalent, or a single numeric value' do
-      tf = TransformableThing.new
-      expect { tf.scale = Snow::Vec2[1, 1] }.not_to raise_error
-      expect { tf.scale = [1, 1] }.not_to raise_error
-      expect { tf.scale = 1 }.not_to raise_error
-      expect { tf.set_scale([1, 1]) }.not_to raise_error
-      expect { tf.set_scale(1, 1) }.not_to raise_error
-      expect { tf.set_scale(1) }.not_to raise_error
-      expect { tf.scale = :foo }.to raise_error(ArgumentError)
-    end
-
-    it 'sets the scale transform' do
-      v = Snow::Vec2[2.to_r, 0.5.to_r]
-      tf = TransformableThing.new
-      tf.scale = v
-      expect(tf.scale).to be == v
-    end
-
-    context 'when given a single value' do
-      it 'sets the x and y scaling' do
-        tf = TransformableThing.new
-        tf.scale = 2.7
-        expect(tf.scale.x).to eq(2.7)
-        expect(tf.scale.y).to eq(2.7)
-      end
-    end
-
-    context 'when given a block' do
-      it 'yields the scaling vector directly to the block' do
-        tf = TransformableThing.new
-        tf.scale = [3, 2]
-
-        scale_ref = nil
-        area = nil
-        tf.set_scale do |s|
-          scale_ref = s
-          area = s.x * s.y
-        end
-        expect(scale_ref).to be_equal(tf.scale)
-        expect(area).to eq(6)
-      end
-
-      it 'marks the transformation as dirty' do
-        tf = TransformableThing.new
-        tf.set_scale { |s| area = s.x * s.y }
-        expect(tf.scale_is_dirty).to be true
-        expect(tf.is_dirty).to be true
-      end
-    end
-  end
-
-  describe '#set_rotation' do
-    it 'sets the rotation transform' do
-      r = Math::PI / 2
-      tf = TransformableThing.new
-      tf.rotation = r
-      expect(tf.rotation).to be == r
-    end
-
-    it 'does not allow non-finite floats' do
-      tf = TransformableThing.new
-      expect { tf.rotation = Float::NAN }.to raise_error(ArgumentError)
-      expect { tf.rotation = Float::INFINITY }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#set_translation' do
-    it 'accepts a size 3 vector' do
-      tf = TransformableThing.new
-      expect { tf.translation = Snow::Vec3[0, 0, 0] }.not_to raise_error
-      expect { tf.translation = :foo }.to raise_error(ArgumentError)
-    end
-
-    it 'sets the translation transform' do
-      v = Snow::Vec3[1024.to_r, 768.to_r, 1.to_r]
-      tf = TransformableThing.new
-      tf.translation = v
-      expect(tf.translation).to be == v
-    end
-
-    it 'does not alter the z value, which should always be 1' do
-      tf = TransformableThing.new
-      [
-        Snow::Vec3[1, 1, 1],
-        Snow::Vec3[1, 1, 13],
-        Snow::Vec3[1, 1, 7],
-        Snow::Vec3[1, 1, 29373],
-        Snow::Vec3[1, 1, -1],
-        Snow::Vec3[1, 1, 0],
-        Snow::Vec3[1, 1, -328.7],
-      ].each do |v|
-        tf.translation = v
-        expect(tf.translation[2]).to be == 1
-      end
-    end
-
-    context 'when given a block' do
-      it 'yields the transform vector directly to the block' do
-        tf = TransformableThing.new
-        tf.translation = [7, 11]
-
-        translation_ref = nil
-        area = nil
-        tf.set_translation do |t|
-          translation_ref = t
-          area = t.x * t.y
-        end
-        expect(translation_ref).to be_equal(tf.translation)
-        expect(area).to eq(77)
-      end
-
-      it 'marks the transformation as dirty' do
-        tf = TransformableThing.new
-        tf.set_translation { |t| area = t.x * t.y }
-        expect(tf.translate_is_dirty).to be true
-        expect(tf.is_dirty).to be true
-      end
-    end
-  end
-
-  describe '#to_matrix' do
-    it 'returns a matrix' do
-      expect(@read_only_tf.to_matrix).to be_instance_of(Snow::Mat3)
-    end
-  end
-
-  it 'centers correctly' do
-    tf = TransformableThing.new
-    tf.center = Snow::Vec3[10.to_r, 20.to_r, 0.to_r]
-    expected_matrix = Snow::Mat3[
-                        1, 0, -10,
-                        0, 1, -20,
-                        0, 0,   1
-                      ]
-    expect(tf.to_matrix).to be == expected_matrix
-  end
-
-  it 'scales correctly' do
-    tf = TransformableThing.new
-    tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
-    expected_matrix = Snow::Mat3[
-                        2,   0, 0,
-                        0, 0.5, 0,
-                        0,   0, 1
-                      ]
-    expect(tf.to_matrix).to be == expected_matrix
-  end
-
-  it 'rotates correctly' do
-    tf = TransformableThing.new
-    tf.rotation = Math::PI / 2
-    expected_matrix = Snow::Mat3[
-                         0, 1, 0,
-                        -1, 0, 0,
-                         0, 0, 1
-                      ]
-    expect(tf.to_matrix).to be == expected_matrix
-  end
-
-  it 'translates correctly' do
-    tf = TransformableThing.new
-    tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
-    expected_matrix = Snow::Mat3[
-                        1, 0, 1024,
-                        0, 1,  768,
-                        0, 0,    1
-                      ]
-    expect(tf.to_matrix).to be == expected_matrix
-  end
-
-  it 'applies all transforms in the correct order' do
-    tf = TransformableThing.new
-    tf.center = Snow::Vec3[10.to_r, 20.to_r, 0.to_r]
-    tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
-    tf.rotation = Math::PI / 2
-    tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
-
-    expected_matrix = Snow::Mat3[
-                        0.0, 0.5, 1014.0,
-                        -2.0, 0.0, 788.0,
-                        0.0, 0.0, 1.0
-                      ]
-    expect(tf.to_matrix).to be == expected_matrix
-
-    v = Snow::Vec3[0.to_r, -50.to_r, 1.to_r]
-    v_transformed = Snow::Vec3[989.to_r, 788.to_r, 1.to_r]
-    expect(tf.to_matrix * v).to be == v_transformed
-
-    v = Snow::Vec3[100.to_r, -50.to_r, 1.to_r]
-    v_transformed = Snow::Vec3[989.to_r, 588.to_r, 1.to_r]
-    expect(tf.to_matrix * v).to be == v_transformed
-
-    v = Snow::Vec3[100.to_r, 50.to_r, 1.to_r]
-    v_transformed = Snow::Vec3[1039.to_r, 588.to_r, 1.to_r]
-    expect(tf.to_matrix * v).to be == v_transformed
-
-    v = Snow::Vec3[0.to_r, 50.to_r, 1.to_r]
-    v_transformed = Snow::Vec3[1039.to_r, 788.to_r, 1.to_r]
-    expect(tf.to_matrix * v).to be == v_transformed
-  end
-
-  describe '#transform_point' do
-    it 'expects a length 3 vector' do
-      out = Snow::Vec3.new
-      expect { @read_only_tf.transform_point(Snow::Vec3[1, 0, 1], out) }.not_to raise_error
-      expect { @read_only_tf.transform_point(:foo, out) }.to raise_error
-      expect { @read_only_tf.transform_point(nil, out) }.to raise_error
-    end
-
-    it 'returns a length 3 vector' do
-      out = Snow::Vec3.new
-      result = @read_only_tf.transform_point(Snow::Vec3[1, 0, 1], out)
-      expect(result).to be_instance_of(Snow::Vec3)
-      expect(result).to equal(out)
-    end
-
-    it 'always returns a z value of 0' do
-      out = Snow::Vec3.new
-      [
-        Snow::Vec3[1, 1, 1],
-        Snow::Vec3[-1, -1, -1],
-        Snow::Vec3[-22, -22, 0],
-        Snow::Vec3[-11, 13, 34],
-        Snow::Vec3[37, -4, -15],
-        Snow::Vec3[34, 39, -16],
-        Snow::Vec3[-48, 23, -32],
-        Snow::Vec3[24, -39, 42],
-        Snow::Vec3[49, 44, -15],
-        Snow::Vec3[27, 23, 42],
-        Snow::Vec3[33, -25, -20],
-        Snow::Vec3[-46, -18, 48],
-      ].each do |v|
-        expect(@read_only_tf.transform_point(v, out)[2]).to be == 0
-        expect(out.z).to eq(0)
-      end
-    end
-
-    it 'transforms the point correctly' do
-      tf = TransformableThing.new
-      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
-      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
-      tf.rotation = Math::PI / 2
-      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
-
-      out = Snow::Vec3.new
-      [
-        [0, 0],
-        [10, -20],
-        [-1024, -768],
-        [-5, 999],
-        [5, 20]
-      ].each do |pt|
-        x, y = pt
-        expected = Snow::Vec3[(y - 20) * 0.5 + 1024, (x - 5) * -2 + 768, 0]
-        expect(tf.transform_point(Snow::Vec3[x, y, 0], out)).to be == expected
-        expect(out).to be == expected
-      end
-    end
-  end
-
-  describe '#untransform_point' do
-    it 'expects a length 3 vector' do
-      out = Snow::Vec3.new
-      expect { @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1], out) }.not_to raise_error
-      expect { @read_only_tf.untransform_point(:foo, out) }.to raise_error
-      expect { @read_only_tf.untransform_point(nil, out) }.to raise_error
-    end
-
-    it 'returns a length 3 vector' do
-      out = Snow::Vec3.new
-      result = @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1], out)
-      expect(result).to be_instance_of(Snow::Vec3)
-      expect(out).to equal(result)
-    end
-
-    it 'always returns a z value of 0' do
-      out = Snow::Vec3.new
-      [
-        Snow::Vec3[1, 1, 1],
-        Snow::Vec3[-1, -1, -1],
-        Snow::Vec3[-22, -22, 0],
-        Snow::Vec3[-11, 13, 34],
-        Snow::Vec3[37, -4, -15],
-        Snow::Vec3[34, 39, -16],
-        Snow::Vec3[-48, 23, -32],
-        Snow::Vec3[24, -39, 42],
-        Snow::Vec3[49, 44, -15],
-        Snow::Vec3[27, 23, 42],
-        Snow::Vec3[33, -25, -20],
-        Snow::Vec3[-46, -18, 48],
-      ].each do |v|
-        expect(@read_only_tf.untransform_point(v, out)[2]).to be == 0
-        expect(out.z).to be == 0
-      end
-    end
-
-    it 'untransforms the point correctly' do
-      tf = TransformableThing.new
-      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
-      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
-      tf.rotation = Math::PI / 2
-      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
-
-      out = Snow::Vec3.new
-      [
-        [1014, 778],
-        [1004, 758],
-        [630, 2826],
-        [788, 3027],
-        [768, 1024]
-      ].each do |pt|
-        x, y = pt
-        expected = Snow::Vec3[(y - 768) * -0.5 + 5, (x - 1024) * 2 + 20, 0]
-        expect(tf.untransform_point(Snow::Vec3[x, y, 0], out)).to be == expected
-        expect(out).to be == expected
-      end
-    end
-
-    it 'undoes the results of transform_point' do
-      tf = TransformableThing.new
-      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
-      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
-      tf.rotation = Math::PI / 2
-      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
-
-      out = Snow::Vec3.new
-      [
-        Snow::Vec3[1, 1, 0],
-        Snow::Vec3[-1, -1, 0],
-        Snow::Vec3[-22, -22, 0],
-        Snow::Vec3[-11, 13, 0],
-        Snow::Vec3[37, -4, 0],
-        Snow::Vec3[34, 39, 0],
-        Snow::Vec3[-48, 23, 0],
-        Snow::Vec3[24, -39, 0],
-        Snow::Vec3[49, 44, 0],
-        Snow::Vec3[27, 23, 0],
-        Snow::Vec3[33, -25, 0],
-        Snow::Vec3[-46, -18, 0],
-      ].each do |v|
-        expect(tf.untransform_point(tf.transform_point(v, out), out)).to be == v
-        expect(out).to be == v
-        expect(tf.transform_point(tf.untransform_point(v, out), out)).to be == v
-        expect(out).to be == v
-      end
-    end
-  end
-end
+class TransformableThing
+  include Gosling::Transformable
+
+  attr_reader :is_dirty
+  attr_reader :translation, :translate_is_dirty
+  attr_reader :center, :center_is_dirty
+  attr_reader :scale, :scale_is_dirty
+end
+
+describe Gosling::Transformable do
+  before(:all) do
+    @read_only_tf = TransformableThing.new
+  end
+
+  it 'has a center' do
+    expect(@read_only_tf.center).to be_instance_of(Snow::Vec3)
+  end
+
+  it 'has a scale' do
+    expect(@read_only_tf.scale).to be_instance_of(Snow::Vec2)
+  end
+
+  it 'has a rotation' do
+    expect(@read_only_tf.rotation).to be_kind_of(Numeric)
+  end
+
+  it 'has a translation' do
+    expect(@read_only_tf.translation).to be_instance_of(Snow::Vec3)
+  end
+
+  it 'has methods for getting its x/y position' do
+    expect(@read_only_tf.x).to be_kind_of(Numeric)
+    expect(@read_only_tf.y).to be_kind_of(Numeric)
+  end
+
+  it 'has methods for setting its x/y position' do
+    @read_only_tf.x = 13
+    @read_only_tf.y = -7
+    expect(@read_only_tf.x).to be == 13
+    expect(@read_only_tf.y).to be == -7
+  end
+
+  it 'has methods for getting its x/y centerpoint' do
+    expect(@read_only_tf.center_x).to be_kind_of(Numeric)
+    expect(@read_only_tf.center_y).to be_kind_of(Numeric)
+  end
+
+  it 'has methods for setting its x/y centerpoint' do
+    @read_only_tf.center_x = 5
+    @read_only_tf.center_y = 15
+    expect(@read_only_tf.center_x).to be == 5
+    expect(@read_only_tf.center_y).to be == 15
+  end
+
+  it 'has methods for getting its x/y scaling' do
+    expect(@read_only_tf.scale_x).to be_kind_of(Numeric)
+    expect(@read_only_tf.scale_y).to be_kind_of(Numeric)
+  end
+
+  it 'has methods for setting its x/y scaling' do
+    @read_only_tf.scale_x = 2
+    @read_only_tf.scale_y = 3
+    expect(@read_only_tf.scale_x).to be == 2
+    expect(@read_only_tf.scale_y).to be == 3
+  end
+
+  it 'has a method for getting its rotation' do
+    expect(@read_only_tf.rotation).to be_kind_of(Numeric)
+  end
+
+  it 'has a method for setting its rotation' do
+    @read_only_tf.rotation = Math::PI
+    expect(@read_only_tf.rotation).to be == Math::PI
+  end
+
+  describe '#center=' do
+    it 'accepts a size 3 vector' do
+      tf = TransformableThing.new
+      expect { tf.center = Snow::Vec3[0, 0, 0] }.not_to raise_error
+      expect { tf.center = [0, 0, 0] }.not_to raise_error
+      expect { tf.center = :foo }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the center transform' do
+      v = Snow::Vec3[10.to_r, 20.to_r, 1.to_r]
+      tf = TransformableThing.new
+      tf.center = v
+      expect(tf.center).to be == v
+    end
+
+    it 'does not alter the z value, which should always be 1' do
+      tf = TransformableThing.new
+      [
+        Snow::Vec3[1, 1, 1],
+        Snow::Vec3[1, 1, 13],
+        Snow::Vec3[1, 1, 7],
+        Snow::Vec3[1, 1, 29373],
+        Snow::Vec3[1, 1, -1],
+        Snow::Vec3[1, 1, 0],
+        Snow::Vec3[1, 1, -328.7],
+      ].each do |v|
+        tf.center = v
+        expect(tf.center[2]).to be == 1
+      end
+    end
+
+    context 'when given a block' do
+      it 'yields the center vector directly to the block' do
+        tf = TransformableThing.new
+        tf.center = [3, -7]
+
+        center_ref = nil
+        area = nil
+        tf.set_center do |c|
+          center_ref = c
+          area = c.x * c.y
+        end
+        expect(center_ref).to be_equal(tf.center)
+        expect(area).to eq(-21)
+      end
+
+      it 'marks the transformation as dirty' do
+        tf = TransformableThing.new
+        tf.set_center { |t| area = t.x * t.y }
+        expect(tf.center_is_dirty).to be true
+        expect(tf.is_dirty).to be true
+      end
+    end
+  end
+
+  describe '#set_scale' do
+    it 'accepts a size 2 vector, an equivalent, or a single numeric value' do
+      tf = TransformableThing.new
+      expect { tf.scale = Snow::Vec2[1, 1] }.not_to raise_error
+      expect { tf.scale = [1, 1] }.not_to raise_error
+      expect { tf.scale = 1 }.not_to raise_error
+      expect { tf.set_scale([1, 1]) }.not_to raise_error
+      expect { tf.set_scale(1, 1) }.not_to raise_error
+      expect { tf.set_scale(1) }.not_to raise_error
+      expect { tf.scale = :foo }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the scale transform' do
+      v = Snow::Vec2[2.to_r, 0.5.to_r]
+      tf = TransformableThing.new
+      tf.scale = v
+      expect(tf.scale).to be == v
+    end
+
+    context 'when given a single value' do
+      it 'sets the x and y scaling' do
+        tf = TransformableThing.new
+        tf.scale = 2.7
+        expect(tf.scale.x).to eq(2.7)
+        expect(tf.scale.y).to eq(2.7)
+      end
+    end
+
+    context 'when given a block' do
+      it 'yields the scaling vector directly to the block' do
+        tf = TransformableThing.new
+        tf.scale = [3, 2]
+
+        scale_ref = nil
+        area = nil
+        tf.set_scale do |s|
+          scale_ref = s
+          area = s.x * s.y
+        end
+        expect(scale_ref).to be_equal(tf.scale)
+        expect(area).to eq(6)
+      end
+
+      it 'marks the transformation as dirty' do
+        tf = TransformableThing.new
+        tf.set_scale { |s| area = s.x * s.y }
+        expect(tf.scale_is_dirty).to be true
+        expect(tf.is_dirty).to be true
+      end
+    end
+  end
+
+  describe '#set_rotation' do
+    it 'sets the rotation transform' do
+      r = Math::PI / 2
+      tf = TransformableThing.new
+      tf.rotation = r
+      expect(tf.rotation).to be == r
+    end
+
+    it 'does not allow non-finite floats' do
+      tf = TransformableThing.new
+      expect { tf.rotation = Float::NAN }.to raise_error(ArgumentError)
+      expect { tf.rotation = Float::INFINITY }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#set_translation' do
+    it 'accepts a size 3 vector' do
+      tf = TransformableThing.new
+      expect { tf.translation = Snow::Vec3[0, 0, 0] }.not_to raise_error
+      expect { tf.translation = :foo }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the translation transform' do
+      v = Snow::Vec3[1024.to_r, 768.to_r, 1.to_r]
+      tf = TransformableThing.new
+      tf.translation = v
+      expect(tf.translation).to be == v
+    end
+
+    it 'does not alter the z value, which should always be 1' do
+      tf = TransformableThing.new
+      [
+        Snow::Vec3[1, 1, 1],
+        Snow::Vec3[1, 1, 13],
+        Snow::Vec3[1, 1, 7],
+        Snow::Vec3[1, 1, 29373],
+        Snow::Vec3[1, 1, -1],
+        Snow::Vec3[1, 1, 0],
+        Snow::Vec3[1, 1, -328.7],
+      ].each do |v|
+        tf.translation = v
+        expect(tf.translation[2]).to be == 1
+      end
+    end
+
+    context 'when given a block' do
+      it 'yields the transform vector directly to the block' do
+        tf = TransformableThing.new
+        tf.translation = [7, 11]
+
+        translation_ref = nil
+        area = nil
+        tf.set_translation do |t|
+          translation_ref = t
+          area = t.x * t.y
+        end
+        expect(translation_ref).to be_equal(tf.translation)
+        expect(area).to eq(77)
+      end
+
+      it 'marks the transformation as dirty' do
+        tf = TransformableThing.new
+        tf.set_translation { |t| area = t.x * t.y }
+        expect(tf.translate_is_dirty).to be true
+        expect(tf.is_dirty).to be true
+      end
+    end
+  end
+
+  describe '#to_matrix' do
+    it 'returns a matrix' do
+      expect(@read_only_tf.to_matrix).to be_instance_of(Snow::Mat3)
+    end
+  end
+
+  it 'centers correctly' do
+    tf = TransformableThing.new
+    tf.center = Snow::Vec3[10.to_r, 20.to_r, 0.to_r]
+    expected_matrix = Snow::Mat3[
+                        1, 0, -10,
+                        0, 1, -20,
+                        0, 0,   1
+                      ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'scales correctly' do
+    tf = TransformableThing.new
+    tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
+    expected_matrix = Snow::Mat3[
+                        2,   0, 0,
+                        0, 0.5, 0,
+                        0,   0, 1
+                      ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'rotates correctly' do
+    tf = TransformableThing.new
+    tf.rotation = Math::PI / 2
+    expected_matrix = Snow::Mat3[
+                         0, 1, 0,
+                        -1, 0, 0,
+                         0, 0, 1
+                      ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'translates correctly' do
+    tf = TransformableThing.new
+    tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
+    expected_matrix = Snow::Mat3[
+                        1, 0, 1024,
+                        0, 1,  768,
+                        0, 0,    1
+                      ]
+    expect(tf.to_matrix).to be == expected_matrix
+  end
+
+  it 'applies all transforms in the correct order' do
+    tf = TransformableThing.new
+    tf.center = Snow::Vec3[10.to_r, 20.to_r, 0.to_r]
+    tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
+    tf.rotation = Math::PI / 2
+    tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
+
+    expected_matrix = Snow::Mat3[
+                        0.0, 0.5, 1014.0,
+                        -2.0, 0.0, 788.0,
+                        0.0, 0.0, 1.0
+                      ]
+    expect(tf.to_matrix).to be == expected_matrix
+
+    v = Snow::Vec3[0.to_r, -50.to_r, 1.to_r]
+    v_transformed = Snow::Vec3[989.to_r, 788.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Snow::Vec3[100.to_r, -50.to_r, 1.to_r]
+    v_transformed = Snow::Vec3[989.to_r, 588.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Snow::Vec3[100.to_r, 50.to_r, 1.to_r]
+    v_transformed = Snow::Vec3[1039.to_r, 588.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+
+    v = Snow::Vec3[0.to_r, 50.to_r, 1.to_r]
+    v_transformed = Snow::Vec3[1039.to_r, 788.to_r, 1.to_r]
+    expect(tf.to_matrix * v).to be == v_transformed
+  end
+
+  describe '#transform_point' do
+    it 'expects a length 3 vector' do
+      out = Snow::Vec3.new
+      expect { @read_only_tf.transform_point(Snow::Vec3[1, 0, 1], out) }.not_to raise_error
+      expect { @read_only_tf.transform_point(:foo, out) }.to raise_error
+      expect { @read_only_tf.transform_point(nil, out) }.to raise_error
+    end
+
+    it 'returns a length 3 vector' do
+      out = Snow::Vec3.new
+      result = @read_only_tf.transform_point(Snow::Vec3[1, 0, 1], out)
+      expect(result).to be_instance_of(Snow::Vec3)
+      expect(result).to equal(out)
+    end
+
+    it 'always returns a z value of 0' do
+      out = Snow::Vec3.new
+      [
+        Snow::Vec3[1, 1, 1],
+        Snow::Vec3[-1, -1, -1],
+        Snow::Vec3[-22, -22, 0],
+        Snow::Vec3[-11, 13, 34],
+        Snow::Vec3[37, -4, -15],
+        Snow::Vec3[34, 39, -16],
+        Snow::Vec3[-48, 23, -32],
+        Snow::Vec3[24, -39, 42],
+        Snow::Vec3[49, 44, -15],
+        Snow::Vec3[27, 23, 42],
+        Snow::Vec3[33, -25, -20],
+        Snow::Vec3[-46, -18, 48],
+      ].each do |v|
+        expect(@read_only_tf.transform_point(v, out)[2]).to be == 0
+        expect(out.z).to eq(0)
+      end
+    end
+
+    it 'transforms the point correctly' do
+      tf = TransformableThing.new
+      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
+      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
+      tf.rotation = Math::PI / 2
+      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
+
+      out = Snow::Vec3.new
+      [
+        [0, 0],
+        [10, -20],
+        [-1024, -768],
+        [-5, 999],
+        [5, 20]
+      ].each do |pt|
+        x, y = pt
+        expected = Snow::Vec3[(y - 20) * 0.5 + 1024, (x - 5) * -2 + 768, 0]
+        expect(tf.transform_point(Snow::Vec3[x, y, 0], out)).to be == expected
+        expect(out).to be == expected
+      end
+    end
+  end
+
+  describe '#untransform_point' do
+    it 'expects a length 3 vector' do
+      out = Snow::Vec3.new
+      expect { @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1], out) }.not_to raise_error
+      expect { @read_only_tf.untransform_point(:foo, out) }.to raise_error
+      expect { @read_only_tf.untransform_point(nil, out) }.to raise_error
+    end
+
+    it 'returns a length 3 vector' do
+      out = Snow::Vec3.new
+      result = @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1], out)
+      expect(result).to be_instance_of(Snow::Vec3)
+      expect(out).to equal(result)
+    end
+
+    it 'always returns a z value of 0' do
+      out = Snow::Vec3.new
+      [
+        Snow::Vec3[1, 1, 1],
+        Snow::Vec3[-1, -1, -1],
+        Snow::Vec3[-22, -22, 0],
+        Snow::Vec3[-11, 13, 34],
+        Snow::Vec3[37, -4, -15],
+        Snow::Vec3[34, 39, -16],
+        Snow::Vec3[-48, 23, -32],
+        Snow::Vec3[24, -39, 42],
+        Snow::Vec3[49, 44, -15],
+        Snow::Vec3[27, 23, 42],
+        Snow::Vec3[33, -25, -20],
+        Snow::Vec3[-46, -18, 48],
+      ].each do |v|
+        expect(@read_only_tf.untransform_point(v, out)[2]).to be == 0
+        expect(out.z).to be == 0
+      end
+    end
+
+    it 'untransforms the point correctly' do
+      tf = TransformableThing.new
+      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
+      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
+      tf.rotation = Math::PI / 2
+      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
+
+      out = Snow::Vec3.new
+      [
+        [1014, 778],
+        [1004, 758],
+        [630, 2826],
+        [788, 3027],
+        [768, 1024]
+      ].each do |pt|
+        x, y = pt
+        expected = Snow::Vec3[(y - 768) * -0.5 + 5, (x - 1024) * 2 + 20, 0]
+        expect(tf.untransform_point(Snow::Vec3[x, y, 0], out)).to be == expected
+        expect(out).to be == expected
+      end
+    end
+
+    it 'undoes the results of transform_point' do
+      tf = TransformableThing.new
+      tf.center = Snow::Vec3[5.to_r, 20.to_r, 0.to_r]
+      tf.scale = Snow::Vec2[2.to_r, 0.5.to_r]
+      tf.rotation = Math::PI / 2
+      tf.translation = Snow::Vec3[1024.to_r, 768.to_r, 0.to_r]
+
+      out = Snow::Vec3.new
+      [
+        Snow::Vec3[1, 1, 0],
+        Snow::Vec3[-1, -1, 0],
+        Snow::Vec3[-22, -22, 0],
+        Snow::Vec3[-11, 13, 0],
+        Snow::Vec3[37, -4, 0],
+        Snow::Vec3[34, 39, 0],
+        Snow::Vec3[-48, 23, 0],
+        Snow::Vec3[24, -39, 0],
+        Snow::Vec3[49, 44, 0],
+        Snow::Vec3[27, 23, 0],
+        Snow::Vec3[33, -25, 0],
+        Snow::Vec3[-46, -18, 0],
+      ].each do |v|
+        expect(tf.untransform_point(tf.transform_point(v, out), out)).to be == v
+        expect(out).to be == v
+        expect(tf.transform_point(tf.untransform_point(v, out), out)).to be == v
+        expect(out).to be == v
+      end
+    end
+  end
+end