rays 0.1.47 → 0.1.49

data/test/test_point.rb

@@ -179,7 +179,7 @@ class TestPoint < Test::Unit::TestCase
   end
 
   def test_inspect()
-    assert_equal "#<Rays::Point 1.0, 2.0, 3.0>", point(1, 2, 3).inspect
+    assert_equal "#<Rays::Point 1.0 2.0 3.0>", point(1, 2, 3).inspect
   end
 
   def test_dot()

data/test/test_polygon.rb

@@ -13,12 +13,8 @@ class TestPolygon < Test::Unit::TestCase
     Rays::Polygon.new(*args, **kwargs)
   end
 
-  def line(*args)
-    Rays::Polygon::Line.new(*args)
-  end
-
-  def polyline(*args)
-    Rays::Polyline.new(*args)
+  def polyline(*args, **kwargs)
+    Rays::Polyline.new(*args, **kwargs)
   end
 
   def point(*args)
@@ -44,20 +40,23 @@ class TestPolygon < Test::Unit::TestCase
     assert_equal [[[5, 6], [7, 8]]], polygon(  [5, 6],   [7, 8], loop: false).dump
     assert_equal [[[1, 1], [2, 2]]], polygon(     [1],      [2], loop: false).dump
     assert_equal [[[3, 3], [4, 4]]], polygon(point(3), point(4), loop: false).dump
-    assert_nothing_raised       {polygon(                  loop: true)}
-    assert_nothing_raised       {polygon(                  loop: false)}
-    assert_raise(ArgumentError) {polygon(1,                loop: true)}
-    assert_raise(ArgumentError) {polygon(1,                loop: false)}
-    assert_nothing_raised       {polygon(1, 2,             loop: true)}
-    assert_nothing_raised       {polygon(1, 2,             loop: false)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: true)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3,          loop: false)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4,       loop: true)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4,       loop: false)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: true)}
-    assert_raise(ArgumentError) {polygon(1, 2, 3, 4, 5,    loop: false)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: true)}
-    assert_nothing_raised       {polygon(1, 2, 3, 4, 5, 6, loop: false)}
+
+    assert_nothing_raised       {polygon(               loop: true)}
+    assert_nothing_raised       {polygon(               loop: false)}
+    assert_raise(ArgumentError) {polygon(1,             loop: true)}
+    assert_raise(ArgumentError) {polygon(1,             loop: false)}
+    assert_nothing_raised       {polygon(1,2,           loop: true)}
+    assert_nothing_raised       {polygon(1,2,           loop: false)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,        loop: true)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,        loop: false)}
+    assert_nothing_raised       {polygon(1,2, 3,4,      loop: true)}
+    assert_nothing_raised       {polygon(1,2, 3,4,      loop: false)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,4, 5,   loop: true)}
+    assert_raise(ArgumentError) {polygon(1,2, 3,4, 5,   loop: false)}
+    assert_nothing_raised       {polygon(1,2, 3,4, 5,6, loop: true)}
+    assert_nothing_raised       {polygon(1,2, 3,4, 5,6, loop: false)}
+
+    assert_raise(ArgumentError) {polygon(polyline(1,2, 3,4, 5,6, loop: true, hole: true))}
   end
 
   def test_expand()
@@ -71,43 +70,26 @@ class TestPolygon < Test::Unit::TestCase
     }
   end
 
-  def test_transform_with_matrix()
-    m = Rays::Matrix.translate 10, 10
-    assert_equal_polygon rect(20, 20, 50, 50), rect(10, 10, 50, 50).transform(m)
-
-    m = Rays::Matrix.scale 2
-    assert_equal_polygon rect(20, 20, 40, 40), rect(10, 10, 20, 20).transform(m)
-
-    m = Rays::Matrix.rotate 90
-    assert_equal_polygon rect(-10, 0, 10, 10), rect(0, 0, 10, 10).transform(m)
-  end
-
-  def test_transform_block()
+  def test_transform()
     o = rect(0, 0, 100, 100) - rect(10, 10, 50, 50)
     assert_equal 2, o.size
 
-    o.transform {|lines|
-      lines.map {|l| l.transform Rays::Matrix.translate 10, 10}
+    o.transform {|polylines|
+      m = Rays::Matrix.translate 10, 10
+      polylines.map {|pl| pl.with points: pl.points.map {|p| m * p}}
     }.tap {|x|
       assert_equal_polygon (rect(10, 10, 100, 100) - rect(20, 20, 50, 50)), x
     }
 
-    o.transform {|lines|
-      lines.reject {|l| l.to_a.include? point(10, 10)}
+    o.transform {|polylines|
+      polylines.reject {|pl| pl.to_a.include? point(10, 10)}
     }.tap {|x|
       assert_equal 1, x.size
       assert_equal 2, o.size
     }
 
-    o.transform {|lines|
-      lines.reject {|l| l.to_a.include? point(10, 10)}
-    }.tap {|x|
-      assert_equal 1, x.size
-      assert_equal 2, o.size
-    }
-
-    o.transform {|lines|
-      lines + [line(1, 2, 3, 4, 5, 6)]
+    o.transform {|polylines|
+      polylines + [polyline(1, 2, 3, 4, 5, 6)]
     }.tap {|x|
       assert_equal 3, x.size
       assert_equal 2, o.size
@@ -156,6 +138,31 @@ class TestPolygon < Test::Unit::TestCase
     assert_raise(IndexError) {o[-4]}
   end
 
+  def test_add()
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(5, 0, 10, 10).to_a),
+               rect(0, 0, 10, 10)      + rect(5, 0, 10, 10))
+
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(5, 0, 10, 10).to_a, *rect(10, 0, 10, 10).to_a),
+               rect(0, 0, 10, 10)     + [rect(5, 0, 10, 10),       rect(10, 0, 10, 10)])
+
+    o = rect(0, 0, 10, 10)
+    assert_equal_polygon(
+      polygon(*rect(0, 0, 10, 10).to_a, *rect(0, 0, 10, 10).to_a),
+      o + o)
+
+    assert_equal_polygon rect(0, 0, 10, 10), rect(0, 0, 10, 10) + polygon()
+    assert_equal_polygon rect(0, 0, 10, 10), polygon() + rect(0, 0, 10, 10)
+    assert_equal_polygon rect(0, 0, 10, 10), rect(0, 0, 10, 10) + []
+
+    assert_equal(
+      polygon(
+        polyline(0,0, 0,10, 10,10, 10,0, loop: true, fill: true),
+        polyline(1,1, 2,1,   2,2,   1,2, loop: true, fill: true, hole: true)),
+      polygon(0,0, 0,10, 10,10, 10,0) + polyline(1,1, 2,1, 2,2, 1,2, loop: true, hole: true))
+  end
+
   def test_sub()
     rect10 = rect 0, 0, 10, 10
 

data/test/test_polyline.rb

@@ -3,12 +3,6 @@ require_relative 'helper'
 
 class TestPolyline < Test::Unit::TestCase
 
-  class Rays::Polyline
-    def dump()
-      map &:to_a
-    end
-  end
-
   def polyline(*args, **kwargs)
     Rays::Polyline.new(*args, **kwargs)
   end
@@ -21,32 +15,101 @@ class TestPolyline < Test::Unit::TestCase
     Rays::Bounds.new(*args)
   end
 
-  def test_initialize()
-    assert_equal [[1, 2], [3, 4]], polyline(   1, 2,     3, 4 ).dump
-    assert_equal [[1, 2], [3, 4]], polyline(  [1, 2],   [3, 4]).dump
-    assert_equal [[1, 1], [2, 2]], polyline(     [1],      [2]).dump
-    assert_equal [[1, 1], [2, 2]], polyline(point(1), point(2)).dump
-
-    assert_false polyline(1, 2, 3, 4, 5, 6             ).loop?
-    assert_true  polyline(1, 2, 3, 4, 5, 6, loop: true ).loop?
-    assert_false polyline(1, 2, 3, 4, 5, 6, loop: false).loop?
-    assert_true  polyline(                  loop: true ).loop?
-    assert_false polyline(                  loop: false).loop?
-
-    assert_nothing_raised       {polyline(                  loop: true)}
-    assert_nothing_raised       {polyline(                  loop: false)}
-    assert_raise(ArgumentError) {polyline(1,                loop: true)}
-    assert_raise(ArgumentError) {polyline(1,                loop: false)}
-    assert_nothing_raised       {polyline(1, 2,             loop: true)}
-    assert_nothing_raised       {polyline(1, 2,             loop: false)}
-    assert_raise(ArgumentError) {polyline(1, 2, 3,          loop: true)}
-    assert_raise(ArgumentError) {polyline(1, 2, 3,          loop: false)}
-    assert_nothing_raised       {polyline(1, 2, 3, 4,       loop: true)}
-    assert_nothing_raised       {polyline(1, 2, 3, 4,       loop: false)}
-    assert_raise(ArgumentError) {polyline(1, 2, 3, 4, 5,    loop: true)}
-    assert_raise(ArgumentError) {polyline(1, 2, 3, 4, 5,    loop: false)}
-    assert_nothing_raised       {polyline(1, 2, 3, 4, 5, 6, loop: true)}
-    assert_nothing_raised       {polyline(1, 2, 3, 4, 5, 6, loop: false)}
+  def color(*args)
+    Rays::Color.new(*args)
+  end
+
+  def dump(pl, name = :points)
+    pl.send(name).map(&:to_a)
+  end
+
+  def test_initialize_points()
+    assert_equal [[1,2], [3,4]], dump(polyline(      1,2,      3,4 ))
+    assert_equal [[1,2], [3,4]], dump(polyline(     [1,2],    [3,4]))
+    assert_equal [[1,1], [2,2]], dump(polyline(     [1],      [2]))
+    assert_equal [[1,1], [2,2]], dump(polyline(point(1), point(2)))
+  end
+
+  def test_initialize_colors()
+    assert_equal(                          [[1,2,3,1], [4,5,6,1]],
+      dump(polyline(1,2, 3,4, colors:      [ 1,2,3,     4,5,6   ]), :colors))
+    assert_equal(                          [[1,2,3,1], [4,5,6,1]],
+      dump(polyline(1,2, 3,4, colors:      [[1,2,3],   [4,5,6]  ]), :colors))
+    assert_equal(                          [[1,1,1,1], [2,2,2,1]],
+      dump(polyline(1,2, 3,4, colors:      [[1],       [2]      ]), :colors))
+    assert_equal(                          [[1,1,1,1], [2,2,2,1]],
+      dump(polyline(1,2, 3,4, colors: [color(1),  color(2)      ]), :colors))
+
+    assert_raise(ArgumentError) {polyline([1,2, 3,4], colors: [[1,2,3]])}
+  end
+
+  def test_initialize_texcoords()
+    assert_equal(                             [[1,2],      [3,4]],
+      dump(polyline(1,2, 3,4, texcoords:      [ 1,2,        3,4 ]), :texcoords))
+    assert_equal(                             [[1,2],      [3,4]],
+      dump(polyline(1,2, 3,4, texcoords:      [[1,2],      [3,4]]), :texcoords))
+    assert_equal(                             [[1,1],      [2,2]],
+      dump(polyline(1,2, 3,4, texcoords:      [[1],        [2]  ]), :texcoords))
+    assert_equal(                             [[1,2],      [3,4]],
+      dump(polyline(1,2, 3,4, texcoords: [point(1,2), point(3,4)]), :texcoords))
+
+    assert_raise(ArgumentError) {polyline([1,2, 3,4], texcoords: [[1,2]])}
+  end
+
+  def test_initialize_loop_fill()
+    get = -> pl {[pl.loop?, pl.fill?]}
+
+    assert_equal [false, false], get[polyline(1,2, 3,4, 5,6)]
+
+    assert_equal [true,  true],  get[polyline(1,2, 3,4, 5,6, loop: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, 5,6, loop: false)]
+    assert_equal [false, true],  get[polyline(1,2, 3,4, 5,6, fill: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, 5,6, fill: false)]
+
+    assert_equal [true,  true],  get[polyline(1,2, 3,4, 5,6, loop: true,  fill: true)]
+    assert_equal [true,  false], get[polyline(1,2, 3,4, 5,6, loop: true,  fill: false)]
+    assert_equal [false, true],  get[polyline(1,2, 3,4, 5,6, loop: false, fill: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, 5,6, loop: false, fill: false)]
+
+    assert_equal [true,  true],  get[polyline(               loop: true,  fill: true)]
+    assert_equal [true,  false], get[polyline(               loop: true,  fill: false)]
+    assert_equal [false, true],  get[polyline(               loop: false, fill: true)]
+    assert_equal [false, false], get[polyline(               loop: false, fill: false)]
+  end
+
+  def test_initialize_hole()
+    assert_false polyline(1,2, 3,4, 5,6, loop: true).hole?
+
+    assert_true  polyline(1,2, 3,4, 5,6, loop: true, hole: true) .hole?
+    assert_false polyline(1,2, 3,4, 5,6, loop: true, hole: false).hole?
+
+    assert_true  polyline(               loop: true, hole: true) .hole?
+    assert_false polyline(               loop: true, hole: false).hole?
+  end
+
+  def test_initialize_errors()
+    assert_nothing_raised       {polyline(               loop: true,  hole: true)}
+    assert_nothing_raised       {polyline(               loop: true,  hole: false)}
+    assert_raise(ArgumentError) {polyline(               loop: false, hole: true)}
+    assert_nothing_raised       {polyline(               loop: false, hole: false)}
+    assert_raise(ArgumentError) {polyline(1,             loop: true)}
+    assert_raise(ArgumentError) {polyline(1,             loop: false)}
+    assert_nothing_raised       {polyline(1,2,           loop: true,  hole: true)}
+    assert_nothing_raised       {polyline(1,2,           loop: true,  hole: false)}
+    assert_raise(ArgumentError) {polyline(1,2,           loop: false, hole: true)}
+    assert_nothing_raised       {polyline(1,2,           loop: false, hole: false)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,        loop: true)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,        loop: false)}
+    assert_nothing_raised       {polyline(1,2, 3,4,      loop: true,  hole: true)}
+    assert_nothing_raised       {polyline(1,2, 3,4,      loop: true,  hole: false)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,4,      loop: false, hole: true)}
+    assert_nothing_raised       {polyline(1,2, 3,4,      loop: false, hole: false)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,4, 5,   loop: true)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,4, 5,   loop: false)}
+    assert_nothing_raised       {polyline(1,2, 3,4, 5,6, loop: true,  hole: true)}
+    assert_nothing_raised       {polyline(1,2, 3,4, 5,6, loop: true,  hole: false)}
+    assert_raise(ArgumentError) {polyline(1,2, 3,4, 5,6, loop: false, hole: true)}
+    assert_nothing_raised       {polyline(1,2, 3,4, 5,6, loop: false, hole: false)}
   end
 
   def test_expand()
@@ -91,46 +154,74 @@ class TestPolyline < Test::Unit::TestCase
     assert_raise(ArgumentError) {pl[].expand 1, 99}
   end
 
-  def test_transform_with_materix()
-    m = Rays::Matrix.translate 100, 200
-    polyline([10,10], [20,20]).transform(m).tap {|o|
-      assert_equal [[110,210], [120,220]], o.dump
-    }
+  def test_with_points()
+    assert_equal polyline(5,6, 7,8), polyline(1,2, 3,4).with(points: [5,6, 7,8])
+    assert_equal polyline(5,6),      polyline(1,2, 3,4).with(points: [5,6])
 
-    m = Rays::Matrix.scale 2
-    polyline([10,10], [20,20]).transform(m).tap {|o|
-      assert_equal [[20,20],   [40,40]],   o.dump
-    }
+    assert_raise(ArgumentError) do
+      polyline(1,2, 3,4, colors: [[1], [2]]).with(points: [1,2])
+    end
+  end
 
-    m = Rays::Matrix.rotate 90
-    polyline([10,10], [20,20]).transform(m).tap {|o|
-      assert_equal [[-10,10],  [-20,20]],  o.dump
-    }
+  def test_with_loop_fill()
+    assert_equal(
+      polyline(1,2, 3,4, 5,6,     loop: false, fill: false),
+      polyline(1,2, 3,4, 5,6))
+    assert_equal(
+      polyline(1,2, 3,4, 5,6,      loop: true,  fill: false),
+      polyline(1,2, 3,4, 5,6).with(loop: true))
+    assert_equal(
+      polyline(1,2, 3,4, 5,6,      loop: false, fill: true),
+      polyline(1,2, 3,4, 5,6).with(             fill: true))
   end
 
-  def test_transform_with_block()
-    polyline([10,10], [20,20]                      ).transform {|points|
-      points.map {|p| p + [10, 20]}
-    }.tap {|o|
-      assert_equal [[20,30], [30,40]], o.dump
-    }
+  def test_with_colors()
+    assert_equal(
+      polyline(1,2, 3,4,      texcoords: [1,2, 3,4]),
+      polyline(1,2, 3,4).with(texcoords: [1,2, 3,4]))
+    assert_equal(
+      polyline(1,2, 3,4,                             texcoords: [5,6, 7,8]),
+      polyline(1,2, 3,4, texcoords: [1,2, 3,4]).with(texcoords: [5,6, 7,8]))
 
-    polyline([10,10], [20,20], [30,30]             ).transform {|points|
-      points.reject {|p| p == point(20, 20)}
-    }.tap {|o|
-      assert_equal [[10,10], [30,30]], o.dump
-    }
+    assert_raise(ArgumentError) {polyline(1,2, 3,4).with(colors: [[1]])}
+  end
 
-    polyline([10,10], [20,20], [30,30]             ).transform {|points|
-      points + [[40, 40]]
-    }.tap {|o|
-      assert_equal [[10,10], [20,20], [30,30], [40,40]], o.dump
-    }
+  def test_with_texcoords()
+    assert_equal(
+      polyline(1,2, 3,4,      colors: [[1], [2]]),
+      polyline(1,2, 3,4).with(colors: [[1], [2]]))
+    assert_equal(
+      polyline(1,2, 3,4,                          colors: [[3], [4]]),
+      polyline(1,2, 3,4, colors: [[1], [2]]).with(colors: [[3], [4]]))
 
-    polyline([10,10], [20,20], [30,30], loop: false).transform(loop: true).tap {|o|
-      assert_equal [[10,10], [20,20], [30,30]], o.dump
-      assert o.loop?
-    }
+    assert_raise(ArgumentError) {polyline(1,2, 3,4).with(colors: [[1]])}
+  end
+
+  def test_with_hole()
+    assert_equal(
+      polyline(1,2, 3,4, 5,6, loop: true,     hole: false),
+      polyline(1,2, 3,4, 5,6, loop: true))
+    assert_equal(
+      polyline(1,2, 3,4, 5,6, loop: true,      hole: true),
+      polyline(1,2, 3,4, 5,6, loop: true).with(hole: true))
+  end
+
+  def test_equal()
+    assert_false polyline(1,2, 3,4) == polyline(1,2)
+
+    assert_true  polyline(1,2, 3,4) == polyline(1,2, 3,4)
+    assert_false polyline(1,2, 3,4) == polyline(1,2, 3,9)
+
+    assert_true  polyline(1,2, 3,4, loop: true,  fill: true)  == polyline(1,2, 3,4, loop: true,  fill: true)
+    assert_true  polyline(1,2, 3,4, loop: false, fill: false) == polyline(1,2, 3,4, loop: false, fill: false)
+    assert_false polyline(1,2, 3,4, loop: false, fill: false) == polyline(1,2, 3,4, loop: true,  fill: false)
+    assert_false polyline(1,2, 3,4, loop: false, fill: false) == polyline(1,2, 3,4, loop: false, fill: true)
+
+    assert_true  polyline(1,2, 3,4, colors: [[1], [2]]) == polyline(1,2, 3,4, colors: [[1], [2]])
+    assert_false polyline(1,2, 3,4, colors: [[1], [2]]) == polyline(1,2, 3,4, colors: [[1], [9]])
+
+    assert_true  polyline(1,2, 3,4, texcoords: [1,2, 3,4]) == polyline(1,2, 3,4, texcoords: [1,2, 3,4])
+    assert_false polyline(1,2, 3,4, texcoords: [1,2, 3,4]) == polyline(1,2, 3,4, texcoords: [1,2, 3,9])
   end
 
   def test_bounds()
@@ -140,18 +231,34 @@ class TestPolyline < Test::Unit::TestCase
     assert_not polyline()                      .bounds.valid?
   end
 
+  def test_loop_fill()
+    get = -> pl {[pl.loop?, pl.fill?]}
+
+    assert_equal [false, false], get[polyline(1,2, 3,4)]
+    assert_equal [true,  true],  get[polyline(1,2, 3,4, loop: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, loop: false)]
+    assert_equal [false, true],  get[polyline(1,2, 3,4, fill: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, fill: false)]
+    assert_equal [true,  true],  get[polyline(1,2, 3,4, loop: true,  fill: true)]
+    assert_equal [false, false], get[polyline(1,2, 3,4, loop: false, fill: false)]
+    assert_equal [true,  false], get[polyline(1,2, 3,4, loop: true,  fill: false)]
+    assert_equal [false, true],  get[polyline(1,2, 3,4, loop: false, fill: true)]
+  end
+
   def test_size()
-    assert_equal 2, polyline(1, 2, 3, 4,     ).size
-    assert_equal 3, polyline(1, 2, 3, 4, 5, 6).size
+    assert_equal 0, polyline()             .size
+    assert_equal 1, polyline(1,2)          .size
+    assert_equal 2, polyline(1,2, 3,4)     .size
+    assert_equal 3, polyline(1,2, 3,4, 5,6).size
   end
 
   def test_empty?()
-    assert_equal true,  polyline(          ).empty?
-    assert_equal false, polyline(1, 2, 3, 4).empty?
+    assert_equal true,  polyline()        .empty?
+    assert_equal false, polyline(1,2, 3,4).empty?
   end
 
   def test_index()
-    o = polyline 1, 2, 3, 4, 5, 6
+    o = polyline 1,2, 3,4, 5,6
     assert_equal [1, 2], o[ 0].to_a
     assert_equal [3, 4], o[ 1].to_a
     assert_equal [5, 6], o[-1].to_a
@@ -161,8 +268,20 @@ class TestPolyline < Test::Unit::TestCase
 
   def test_inspect()
     assert_equal(
-      "#<Rays::Polyline [1.0, 2.0], [3.0, 4.0], loop: false>",
-      polyline(1, 2, 3, 4).inspect)
+      "#<Rays::Polyline [1.0,2.0, 3.0,4.0] loop:false fill:false hole:false colors:0 texcoords:0>",
+      polyline(1,2, 3,4).inspect)
+    assert_equal(
+      "#<Rays::Polyline [1.0,2.0, 3.0,4.0] loop:true fill:false hole:false colors:0 texcoords:0>",
+      polyline(1,2, 3,4, loop: true, fill: false).inspect)
+    assert_equal(
+      "#<Rays::Polyline [1.0,2.0, 3.0,4.0] loop:false fill:true hole:false colors:0 texcoords:0>",
+      polyline(1,2, 3,4, loop: false, fill: true).inspect)
+    assert_equal(
+      "#<Rays::Polyline [1.0,2.0, 3.0,4.0] loop:false fill:false hole:false colors:2 texcoords:0>",
+      polyline(1,2, 3,4, colors: [[1], [2]]).inspect)
+    assert_equal(
+      "#<Rays::Polyline [1.0,2.0, 3.0,4.0] loop:false fill:false hole:false colors:0 texcoords:2>",
+      polyline(1,2, 3,4, texcoords: [1,2, 3,4]).inspect)
   end
 
 end# TestPolyline

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.1.47
+  version: 0.1.49
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-09 00:00:00.000000000 Z
+date: 2024-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.41
+        version: 0.1.42
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.42
+        version: 0.1.44
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.42
+        version: 0.1.44
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []
@@ -55,14 +55,13 @@ extra_rdoc_files:
 - ".doc/ext/rays/image.cpp"
 - ".doc/ext/rays/matrix.cpp"
 - ".doc/ext/rays/native.cpp"
-- ".doc/ext/rays/noise.cpp"
 - ".doc/ext/rays/painter.cpp"
 - ".doc/ext/rays/point.cpp"
 - ".doc/ext/rays/polygon.cpp"
-- ".doc/ext/rays/polygon_line.cpp"
 - ".doc/ext/rays/polyline.cpp"
 - ".doc/ext/rays/rays.cpp"
 - ".doc/ext/rays/shader.cpp"
+- ".doc/ext/rays/util.cpp"
 files:
 - ".doc/ext/rays/bitmap.cpp"
 - ".doc/ext/rays/bounds.cpp"
@@ -75,14 +74,13 @@ files:
 - ".doc/ext/rays/image.cpp"
 - ".doc/ext/rays/matrix.cpp"
 - ".doc/ext/rays/native.cpp"
-- ".doc/ext/rays/noise.cpp"
 - ".doc/ext/rays/painter.cpp"
 - ".doc/ext/rays/point.cpp"
 - ".doc/ext/rays/polygon.cpp"
-- ".doc/ext/rays/polygon_line.cpp"
 - ".doc/ext/rays/polyline.cpp"
 - ".doc/ext/rays/rays.cpp"
 - ".doc/ext/rays/shader.cpp"
+- ".doc/ext/rays/util.cpp"
 - ".github/workflows/release-gem.yml"
 - ".github/workflows/tag.yml"
 - ".github/workflows/test.yml"
@@ -107,14 +105,13 @@ files:
 - ext/rays/image.cpp
 - ext/rays/matrix.cpp
 - ext/rays/native.cpp
-- ext/rays/noise.cpp
 - ext/rays/painter.cpp
 - ext/rays/point.cpp
 - ext/rays/polygon.cpp
-- ext/rays/polygon_line.cpp
 - ext/rays/polyline.cpp
 - ext/rays/rays.cpp
 - ext/rays/shader.cpp
+- ext/rays/util.cpp
 - include/rays.h
 - include/rays/bitmap.h
 - include/rays/bounds.h
@@ -128,7 +125,6 @@ files:
 - include/rays/font.h
 - include/rays/image.h
 - include/rays/matrix.h
-- include/rays/noise.h
 - include/rays/opengl.h
 - include/rays/painter.h
 - include/rays/point.h
@@ -153,6 +149,7 @@ files:
 - include/rays/ruby/rays.h
 - include/rays/ruby/shader.h
 - include/rays/shader.h
+- include/rays/util.h
 - lib/rays.rb
 - lib/rays/autoinit.rb
 - lib/rays/bitmap.rb
@@ -168,7 +165,6 @@ files:
 - lib/rays/painter.rb
 - lib/rays/point.rb
 - lib/rays/polygon.rb
-- lib/rays/polygon_line.rb
 - lib/rays/polyline.rb
 - lib/rays/shader.rb
 - rays.gemspec
@@ -196,7 +192,6 @@ files:
 - src/ios/rays.mm
 - src/matrix.cpp
 - src/matrix.h
-- src/noise.cpp
 - src/opengl.cpp
 - src/opengl.h
 - src/osx/bitmap.h
@@ -224,6 +219,7 @@ files:
 - src/shader_source.h
 - src/texture.cpp
 - src/texture.h
+- src/util.cpp
 - src/win32/bitmap.cpp
 - src/win32/font.cpp
 - src/win32/font.h
@@ -242,7 +238,6 @@ files:
 - test/test_painter_shape.rb
 - test/test_point.rb
 - test/test_polygon.rb
-- test/test_polygon_line.rb
 - test/test_polyline.rb
 - test/test_rays_init.rb
 - test/test_shader.rb
@@ -265,7 +260,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: A Drawing Engine using OpenGL.
@@ -282,7 +277,6 @@ test_files:
 - test/test_painter_shape.rb
 - test/test_point.rb
 - test/test_polygon.rb
-- test/test_polygon_line.rb
 - test/test_polyline.rb
 - test/test_rays_init.rb
 - test/test_shader.rb