rays 0.1.47 → 0.1.48

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.48
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-09 00:00:00.000000000 Z
+date: 2024-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.42
+        version: 0.1.43
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.42
+        version: 0.1.43
 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
@@ -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

data/.doc/ext/rays/polygon_line.cpp

@@ -1,97 +0,0 @@
-#include "rays/ruby/polygon.h"
-
-
-#include <assert.h>
-#include "rays/ruby/polyline.h"
-#include "defs.h"
-
-
-RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
-
-#define THIS  to<Rays::Polygon::Line*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon::Line, self)
-
-
-static
-VALUE alloc(VALUE klass)
-{
-	return new_type<Rays::Polygon::Line>(klass);
-}
-
-static
-VALUE setup(VALUE self, VALUE points, VALUE loop, VALUE hole)
-{
-	CHECK;
-
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polygon::Line(&array[0], array.size(), loop, hole);
-}
-
-static
-VALUE hole(VALUE self)
-{
-	CHECK;
-	return value(THIS->hole());
-}
-
-
-static Class cPolygonLine;
-
-void
-Init_rays_polygon_line ()
-{
-	Module mRays = rb_define_module("Rays");
-	Class cPolygon = rb_define_class_under(mRays, "Polygon", rb_cObject);
-
-	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
-	rb_define_alloc_func(cPolygonLine, alloc);
-	rb_define_private_method(cPolygonLine, "setup", RUBY_METHOD_FUNC(setup), 3);
-	cPolygonLine.define_method("hole?", hole);
-}
-
-
-namespace Rucy
-{
-
-
-	template <> Rays::Polygon::Line
-	value_to<Rays::Polygon::Line> (int argc, const Value* argv, bool convert)
-	{
-		assert(argc == 0 || (argc > 0 && argv));
-
-		if (convert)
-		{
-			if (argc <= 0)
-				return Rays::Polygon::Line();
-			else if (argv->is_num() || argv->is_array())
-			{
-				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
-				return Rays::Polygon::Line(&points[0], points.size());
-			}
-		}
-
-		if (argc != 1)
-			argument_error(__FILE__, __LINE__);
-
-		return value_to<Rays::Polygon::Line&>(*argv, convert);
-	}
-
-
-}// Rucy
-
-
-namespace Rays
-{
-
-
-	Class
-	polygon_line_class ()
-	{
-		return cPolygonLine;
-	}
-
-
-}// Rays

data/ext/rays/polygon_line.cpp

@@ -1,100 +0,0 @@
-#include "rays/ruby/polygon.h"
-
-
-#include <assert.h>
-#include "rays/ruby/polyline.h"
-#include "defs.h"
-
-
-RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
-
-#define THIS  to<Rays::Polygon::Line*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon::Line, self)
-
-
-static
-RUCY_DEF_ALLOC(alloc, klass)
-{
-	return new_type<Rays::Polygon::Line>(klass);
-}
-RUCY_END
-
-static
-RUCY_DEF3(setup, points, loop, hole)
-{
-	CHECK;
-
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polygon::Line(&array[0], array.size(), loop, hole);
-}
-RUCY_END
-
-static
-RUCY_DEF0(hole)
-{
-	CHECK;
-	return value(THIS->hole());
-}
-RUCY_END
-
-
-static Class cPolygonLine;
-
-void
-Init_rays_polygon_line ()
-{
-	Module mRays   = define_module("Rays");
-	Class cPolygon = mRays.define_class("Polygon");
-
-	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
-	cPolygonLine.define_alloc_func(alloc);
-	cPolygonLine.define_private_method("setup", setup);
-	cPolygonLine.define_method("hole?", hole);
-}
-
-
-namespace Rucy
-{
-
-
-	template <> Rays::Polygon::Line
-	value_to<Rays::Polygon::Line> (int argc, const Value* argv, bool convert)
-	{
-		assert(argc == 0 || (argc > 0 && argv));
-
-		if (convert)
-		{
-			if (argc <= 0)
-				return Rays::Polygon::Line();
-			else if (argv->is_num() || argv->is_array())
-			{
-				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
-				return Rays::Polygon::Line(&points[0], points.size());
-			}
-		}
-
-		if (argc != 1)
-			argument_error(__FILE__, __LINE__);
-
-		return value_to<Rays::Polygon::Line&>(*argv, convert);
-	}
-
-
-}// Rucy
-
-
-namespace Rays
-{
-
-
-	Class
-	polygon_line_class ()
-	{
-		return cPolygonLine;
-	}
-
-
-}// Rays

data/lib/rays/polygon_line.rb

@@ -1,33 +0,0 @@
-require 'rays/ext'
-
-
-module Rays
-
-
-  class Polygon
-
-
-    class Line < Polyline
-
-      def initialize(*points, loop: true, hole: false)
-        setup points, loop, hole
-      end
-
-      def transform(matrix = nil, loop: loop?, hole: hole?, &block)
-        points = to_a
-        points = points.map {|point| matrix * point} if matrix
-        points = block.call points if block
-        self.class.new(*points, loop: loop, hole: hole)
-      end
-
-      def inspect()
-        "#<Rays::Polygon::Line #{to_a.join ', '}, loop: #{loop?}, hole: #{hole?}>"
-      end
-
-    end# Line
-
-
-  end# Polygon
-
-
-end# Rays