gosling 2.1.0 → 2.3.0

data/spec/matrix_cache_spec.rb

@@ -0,0 +1,25 @@
+describe MatrixCache do
+  describe '.get' do
+    context 'when there are no Mat3 objects available' do
+      before do
+        MatrixCache.instance.clear
+      end
+
+      it 'creates a new Mat3 and returns it' do
+        new_matrix = Snow::Vec3.new
+        expect(Snow::Mat3).to receive(:new).and_return(new_matrix)
+        m = MatrixCache.instance.get
+        expect(m).to equal(new_matrix)
+      end
+    end
+  end
+
+  describe '.recycle' do
+    it 'resets the Mat3' do
+      m = Snow::Mat3[1, 2, 3, 4, 5, 6, 7, 8, 9]
+      MatrixCache.instance.recycle(m)
+      [0, 4, 8].each { |i| expect(m[i]).to eq(1) }
+      [1, 2, 3, 5, 6, 7].each { |i| expect(m[i]).to eq(0) }
+    end
+  end
+end

data/spec/object_cache_spec.rb

@@ -0,0 +1,22 @@
+describe Object do
+  before(:all) do
+    @test_object = []
+  end
+
+  describe '.unfreeze' do
+    it 'allows the object to be edited after being frozen' do
+      @test_object.freeze
+      expect { @test_object << 'a' }.to raise_error(RuntimeError)
+      @test_object.unfreeze
+      expect { @test_object << 'a' }.not_to raise_error
+    end
+
+    it 'works even after multiple freeze/unfreeze cycles' do
+      3.times do
+        @test_object.freeze
+        @test_object.unfreeze
+      end
+      expect { @test_object << 'a' }.not_to raise_error
+    end
+  end
+end

data/spec/polygon_spec.rb

@@ -111,6 +111,33 @@ describe Gosling::Polygon do
     end
   end
 
+  describe '#set_vertices_rect' do
+    it 'accepts two positive integers, width and height' do
+      polygon = Gosling::Polygon.new(@window)
+
+      expect { polygon.set_vertices_rect(1, 1) }.not_to raise_error
+      expect { polygon.set_vertices_rect(2, 3) }.not_to raise_error
+      expect { polygon.set_vertices_rect(5, 8) }.not_to raise_error
+      expect { polygon.set_vertices_rect(100000, 100000) }.not_to raise_error
+
+      expect { polygon.set_vertices_rect('two', 2) }.to raise_error(ArgumentError)
+      expect { polygon.set_vertices_rect(3, :three) }.to raise_error(ArgumentError)
+      expect { polygon.set_vertices_rect(-1, 1) }.to raise_error(ArgumentError)
+      expect { polygon.set_vertices_rect(1, 0) }.to raise_error(ArgumentError)
+    end
+
+    it 'sets the vertices to form a square with the given width and height' do
+      polygon = Gosling::Polygon.new(@window)
+      polygon.set_vertices_rect(13, 21)
+      expect(polygon.get_vertices).to match_array([
+        Snow::Vec3[0, 0, 0],
+        Snow::Vec3[13, 0, 0],
+        Snow::Vec3[13, 21, 0],
+        Snow::Vec3[0, 21, 0]
+      ])
+    end
+  end
+
   describe '#get_global_vertices' do
     before(:all) do
       @global_polygon = Gosling::Polygon.new(@window)

data/spec/spec_helper.rb

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

data/spec/transformable_spec.rb

@@ -1,5 +1,10 @@
 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
@@ -98,12 +103,40 @@ describe Gosling::Transformable do
         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' 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
 
@@ -113,6 +146,38 @@ describe Gosling::Transformable do
       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
@@ -159,6 +224,29 @@ describe Gosling::Transformable do
         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
@@ -244,17 +332,21 @@ describe Gosling::Transformable do
 
   describe '#transform_point' do
     it 'expects a length 3 vector' do
-      expect { @read_only_tf.transform_point(Snow::Vec3[1, 0, 1]) }.not_to raise_error
-      expect { @read_only_tf.transform_point(:foo) }.to raise_error(ArgumentError)
-      expect { @read_only_tf.transform_point(nil) }.to raise_error(ArgumentError)
+      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
-      result = @read_only_tf.transform_point(Snow::Vec3[1, 0, 1])
+      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],
@@ -269,7 +361,8 @@ describe Gosling::Transformable do
         Snow::Vec3[33, -25, -20],
         Snow::Vec3[-46, -18, 48],
       ].each do |v|
-        expect(@read_only_tf.transform_point(v)[2]).to be == 0
+        expect(@read_only_tf.transform_point(v, out)[2]).to be == 0
+        expect(out.z).to eq(0)
       end
     end
 
@@ -280,6 +373,7 @@ describe Gosling::Transformable do
       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],
@@ -288,24 +382,30 @@ describe Gosling::Transformable do
         [5, 20]
       ].each do |pt|
         x, y = pt
-        expect(tf.transform_point(Snow::Vec3[x, y, 0])).to be == Snow::Vec3[(y - 20) * 0.5 + 1024, (x - 5) * -2 + 768, 0]
+        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
-      expect { @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1]) }.not_to raise_error
-      expect { @read_only_tf.untransform_point(:foo) }.to raise_error(ArgumentError)
-      expect { @read_only_tf.untransform_point(nil) }.to raise_error(ArgumentError)
+      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
-      result = @read_only_tf.untransform_point(Snow::Vec3[1, 0, 1])
+      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],
@@ -320,7 +420,8 @@ describe Gosling::Transformable do
         Snow::Vec3[33, -25, -20],
         Snow::Vec3[-46, -18, 48],
       ].each do |v|
-        expect(@read_only_tf.untransform_point(v)[2]).to be == 0
+        expect(@read_only_tf.untransform_point(v, out)[2]).to be == 0
+        expect(out.z).to be == 0
       end
     end
 
@@ -331,6 +432,7 @@ describe Gosling::Transformable do
       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],
@@ -339,7 +441,9 @@ describe Gosling::Transformable do
         [768, 1024]
       ].each do |pt|
         x, y = pt
-        expect(tf.untransform_point(Snow::Vec3[x, y, 0])).to be == Snow::Vec3[(y - 768) * -0.5 + 5, (x - 1024) * 2 + 20, 0]
+        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
 
@@ -350,6 +454,7 @@ describe Gosling::Transformable do
       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],
@@ -364,8 +469,10 @@ describe Gosling::Transformable do
         Snow::Vec3[33, -25, 0],
         Snow::Vec3[-46, -18, 0],
       ].each do |v|
-        expect(tf.untransform_point(tf.transform_point(v))).to be == v
-        expect(tf.transform_point(tf.untransform_point(v))).to be == 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

data/spec/vector_cache_spec.rb

@@ -0,0 +1,80 @@
+class VectorCache
+  def cache
+    @cache
+  end
+end
+
+describe VectorCache do
+  describe '.get' do
+    context 'when there are no Vec3 objects available' do
+      before do
+        VectorCache.instance.clear
+      end
+
+      it 'creates a new Vec3 and returns it' do
+        new_vector = Snow::Vec3.new
+        expect(Snow::Vec3).to receive(:new).and_return(new_vector)
+        v = VectorCache.instance.get
+        expect(v).to equal(new_vector)
+      end
+    end
+
+    context 'when there are Vec3 objects available' do
+      before do
+        VectorCache.instance.clear
+        @recycled_vector = Snow::Vec3.new
+        VectorCache.instance.recycle(@recycled_vector)
+      end
+
+      it 'does not create a new Vec3' do
+        expect(Snow::Vec3).not_to receive(:new)
+        VectorCache.instance.get
+      end
+
+      it 'returns one of the cached Vec3' do
+        expect(VectorCache.instance.get).to eq(@recycled_vector)
+      end
+    end
+  end
+
+  describe '.recycle' do
+    it 'expects a Vec3' do
+      expect{ VectorCache.instance.recycle(Snow::Vec3.new) }.not_to raise_error
+      expect{ VectorCache.instance.recycle(:foo) }.to raise_error(ArgumentError)
+    end
+
+    it 'adds the Vec3 to the cache' do
+      v = Snow::Vec3.new
+      VectorCache.instance.recycle(v)
+      expect(VectorCache.instance.cache.values).to include(v)
+    end
+
+    it 'zeros out the Vec3' do
+      v = Snow::Vec3[1, 2, 3]
+      VectorCache.instance.recycle(v)
+      expect(v.x).to eq(0)
+      expect(v.y).to eq(0)
+      expect(v.z).to eq(0)
+    end
+  end
+
+  describe '.clear' do
+    it 'removes all Vec3 from the cache' do
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      VectorCache.instance.clear
+      expect(VectorCache.instance.size).to eq(0)
+    end
+  end
+
+  describe '.size' do
+    it 'returns the number of Vec3 in the cache' do
+      VectorCache.instance.clear
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      VectorCache.instance.recycle(Snow::Vec3.new)
+      expect(VectorCache.instance.size).to eq(3)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosling
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Ben Amos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-18 00:00:00.000000000 Z
+date: 2019-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gosu
@@ -52,7 +52,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
-description: A lightweight library for creating 2D apps in Ruby.
+description: |2
+      A 2D app creation library. Includes basic collision testing, actor inheritance,
+      and easy-to-use, intuitive animation transforms. Powered by Gosu and SnowMath.
 email:
 - flashguardian13@gmail.com
 executables: []
@@ -65,12 +67,15 @@ files:
 - "./lib/gosling/collision.rb"
 - "./lib/gosling/image_library.rb"
 - "./lib/gosling/inheritance_error.rb"
+- "./lib/gosling/matrix_cache.rb"
+- "./lib/gosling/object_cache.rb"
 - "./lib/gosling/patches.rb"
 - "./lib/gosling/polygon.rb"
 - "./lib/gosling/rect.rb"
 - "./lib/gosling/sprite.rb"
 - "./lib/gosling/transformable.rb"
 - "./lib/gosling/utils.rb"
+- "./lib/gosling/vector_cache.rb"
 - "./lib/gosling/version.rb"
 - "./spec/actor_spec.rb"
 - "./spec/circle_spec.rb"
@@ -82,11 +87,14 @@ files:
 - "./spec/images/full_icons_07_18.png"
 - "./spec/images/key.png"
 - "./spec/images/nil.png"
+- "./spec/matrix_cache_spec.rb"
+- "./spec/object_cache_spec.rb"
 - "./spec/polygon_spec.rb"
 - "./spec/rect_spec.rb"
 - "./spec/spec_helper.rb"
 - "./spec/sprite_spec.rb"
 - "./spec/transformable_spec.rb"
+- "./spec/vector_cache_spec.rb"
 homepage: https://github.com/flashguardian13/gosling
 licenses:
 - CC-BY-4.0
@@ -110,5 +118,5 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: Ruby 2D app creation
+summary: A library for creating 2D apps
 test_files: []