rays 0.1.46 → 0.1.48

data/.doc/ext/rays/native.cpp

@@ -12,7 +12,6 @@ void Init_rays_matrix ();
 
 void Init_rays_painter ();
 void Init_rays_polyline ();
-void Init_rays_polygon_line ();
 void Init_rays_polygon ();
 void Init_rays_bitmap ();
 void Init_rays_image ();
@@ -20,7 +19,7 @@ void Init_rays_font ();
 void Init_rays_shader ();
 void Init_rays_camera ();
 
-void Init_rays_noise ();
+void Init_rays_util ();
 
 
 extern "C" void
@@ -45,7 +44,6 @@ extern "C" void
 
 	Init_rays_painter();
 	Init_rays_polyline();
-	Init_rays_polygon_line();
 	Init_rays_polygon();
 	Init_rays_bitmap();
 	Init_rays_image();
@@ -53,7 +51,7 @@ extern "C" void
 	Init_rays_shader();
 	Init_rays_camera();
 
-	Init_rays_noise();
+	Init_rays_util();
 
 	RUCY_CATCH
 }

data/.doc/ext/rays/painter.cpp

@@ -121,11 +121,29 @@ VALUE clear(VALUE self)
 }
 
 static
-VALUE polygon(VALUE self, VALUE poly)
+VALUE polygon(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#polygon", argc, 1, 3, 5);
+
+	const Rays::Polygon* polygon = to<Rays::Polygon*>(argv[0]);
+	if (!polygon)
+		argument_error(__FILE__, __LINE__, "%s is not a polygon.", argv[0].inspect().c_str());
+
+	if (argc == 1)
+		THIS->polygon(*polygon);
+	else if (argc == 3)
+	{
+		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
+		THIS->polygon(*polygon, x, y);
+	}
+	else if (argc == 5)
+	{
+		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
+		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
+		THIS->polygon(*polygon, x, y, w, h);
+	}
 
-	THIS->polygon(to<Rays::Polygon&>(poly));
 	return self;
 }
 
@@ -135,7 +153,7 @@ VALUE line(VALUE self, VALUE args, VALUE loop)
 	CHECK;
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->line(&points[0], points.size(), loop);
 	return self;
@@ -193,7 +211,7 @@ VALUE curve(VALUE self, VALUE args, VALUE loop)
 		argument_error(__FILE__, __LINE__);
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->curve(&points[0], points.size(), loop);
 	return self;
@@ -208,7 +226,7 @@ VALUE bezier(VALUE self, VALUE args, VALUE loop)
 		argument_error(__FILE__, __LINE__);
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->bezier(&points[0], points.size(), loop);
 	return self;
@@ -365,6 +383,21 @@ VALUE get_stroke_width(VALUE self)
 	return value(THIS->stroke_width());
 }
 
+static
+VALUE set_stroke_outset(VALUE self, VALUE outset)
+{
+	CHECK;
+	THIS->set_stroke_outset(to<float>(outset));
+	return self;
+}
+
+static
+VALUE get_stroke_outset(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_outset());
+}
+
 static
 VALUE set_stroke_cap(VALUE self, VALUE cap)
 {
@@ -480,6 +513,69 @@ VALUE get_font(VALUE self)
 	return value(THIS->font());
 }
 
+static
+VALUE set_texture(VALUE self, VALUE image)
+{
+	CHECK;
+
+	if (!image)
+		THIS->no_texture();
+	else
+		THIS->set_texture(to<Rays::Image&>(image));
+	return self;
+}
+
+static
+VALUE get_texture(VALUE self)
+{
+	CHECK;
+
+	const Rays::Image& image = THIS->texture();
+	return image ? value(image) : nil();
+}
+
+static
+VALUE no_texture(VALUE self)
+{
+	CHECK;
+	THIS->no_texture();
+	return self;
+}
+
+static
+VALUE set_texcoord_mode(VALUE self, VALUE mode)
+{
+	CHECK;
+
+	THIS->set_texcoord_mode(to<Rays::TexCoordMode>(mode));
+	return self;
+}
+
+static
+VALUE get_texcoord_mode(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->texcoord_mode());
+}
+
+static
+VALUE set_texcoord_wrap(VALUE self, VALUE wrap)
+{
+	CHECK;
+
+	THIS->set_texcoord_wrap(to<Rays::TexCoordWrap>(wrap));
+	return self;
+}
+
+static
+VALUE get_texcoord_wrap(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->texcoord_wrap());
+}
+
 static
 VALUE set_shader(VALUE self)
 {
@@ -624,7 +720,7 @@ Init_rays_painter ()
 	rb_define_private_method(cPainter, "end_paint", RUBY_METHOD_FUNC(end_paint), 0);
 	cPainter.define_method(              "painting?", is_painting);
 	rb_define_method(cPainter, "clear", RUBY_METHOD_FUNC(clear), 0);
-	rb_define_method(cPainter, "polygon", RUBY_METHOD_FUNC(polygon), 1);
+	rb_define_method(cPainter, "polygon", RUBY_METHOD_FUNC(polygon), -1);
 	rb_define_private_method(cPainter, "draw_line", RUBY_METHOD_FUNC(line), 2);
 	rb_define_private_method(cPainter, "draw_polyline", RUBY_METHOD_FUNC(polyline), 1);
 	rb_define_private_method(cPainter, "draw_rect", RUBY_METHOD_FUNC(rect), 6);
@@ -645,6 +741,8 @@ Init_rays_painter ()
 	rb_define_method(cPainter, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
 	rb_define_method(cPainter, "stroke_width=", RUBY_METHOD_FUNC(set_stroke_width), 1);
 	rb_define_method(cPainter, "stroke_width", RUBY_METHOD_FUNC(get_stroke_width), 0);
+	rb_define_method(cPainter, "stroke_outset=", RUBY_METHOD_FUNC(set_stroke_outset), 1);
+	rb_define_method(cPainter, "stroke_outset", RUBY_METHOD_FUNC(get_stroke_outset), 0);
 	rb_define_method(cPainter, "stroke_cap=", RUBY_METHOD_FUNC(set_stroke_cap), 1);
 	rb_define_method(cPainter, "stroke_cap", RUBY_METHOD_FUNC(get_stroke_cap), 0);
 	rb_define_method(cPainter, "stroke_join=", RUBY_METHOD_FUNC(set_stroke_join), 1);
@@ -660,6 +758,13 @@ Init_rays_painter ()
 	rb_define_method(cPainter, "no_clip", RUBY_METHOD_FUNC(no_clip), 0);
 	rb_define_method(cPainter, "font=", RUBY_METHOD_FUNC(set_font), -1);
 	rb_define_method(cPainter, "font", RUBY_METHOD_FUNC(get_font), 0);
+	rb_define_method(cPainter, "texture=", RUBY_METHOD_FUNC(set_texture), 1);
+	rb_define_method(cPainter, "texture", RUBY_METHOD_FUNC(get_texture), 0);
+	rb_define_method(cPainter, "no_texture", RUBY_METHOD_FUNC(no_texture), 0);
+	rb_define_method(cPainter, "texcoord_mode=", RUBY_METHOD_FUNC(set_texcoord_mode), 1);
+	rb_define_method(cPainter, "texcoord_mode", RUBY_METHOD_FUNC(get_texcoord_mode), 0);
+	rb_define_method(cPainter, "texcoord_wrap=", RUBY_METHOD_FUNC(set_texcoord_wrap), 1);
+	rb_define_method(cPainter, "texcoord_wrap", RUBY_METHOD_FUNC(get_texcoord_wrap), 0);
 	rb_define_private_method(cPainter, "set_shader", RUBY_METHOD_FUNC(set_shader), -1);
 	rb_define_method(cPainter, "shader", RUBY_METHOD_FUNC(get_shader), 0);
 	rb_define_method(cPainter, "no_shader", RUBY_METHOD_FUNC(no_shader), 0);

data/.doc/ext/rays/polygon.cpp

@@ -1,7 +1,6 @@
 #include "rays/ruby/polygon.h"
 
 
-#include <assert.h>
 #include <vector>
 #include <functional>
 #include "rays/ruby/bounds.h"
@@ -23,7 +22,7 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE setup(VALUE self, VALUE args, VALUE loop)
+VALUE setup(VALUE self, VALUE args, VALUE loop, VALUE colors, VALUE texcoords)
 {
 	CHECK;
 
@@ -31,9 +30,10 @@ VALUE setup(VALUE self, VALUE args, VALUE loop)
 		*THIS = to<Rays::Polygon>(args.size(), args.as_array());
 	else
 	{
-		std::vector<Rays::Point> points;
-		get_line_args(&points, args.size(), args.as_array());
-		*THIS = Rays::Polygon(&points[0], points.size(), loop);
+		CreateParams params(args, colors, texcoords);
+		*THIS = Rays::Polygon(
+			params.ppoints(), params.size(), loop,
+			params.pcolors(), params.ptexcoords());
 	}
 }
 
@@ -95,19 +95,59 @@ VALUE each(VALUE self)
 	CHECK;
 
 	Value ret = Qnil;
-	for (const auto& line : *THIS)
-		ret = rb_yield(value(line));
+	for (const auto& polyline : *THIS)
+		ret = rb_yield(value(polyline));
 	return ret;
 }
 
-static void
-each_polygon (const Value& value, std::function<void(const Rays::Polygon&)> fun)
+template <typename T>
+static inline void
+each_poly (const Value& value, auto fun)
 {
 	int size           = value.size();
 	const Value* array = value.as_array();
 
 	for (int i = 0; i < size; ++i)
-		fun(to<Rays::Polygon&>(array[i]));
+		fun(to<T&>(array[i]));
+}
+
+static
+VALUE op_add(VALUE self, VALUE obj)
+{
+	CHECK;
+
+	if (obj.is_kind_of(Rays::polyline_class()))
+		return value(*THIS + to<Rays::Polyline&>(obj));
+
+	if (obj.is_kind_of(Rays::polygon_class()))
+		return value(*THIS + to<Rays::Polygon&>(obj));
+
+	if (!obj.is_array())
+		argument_error(__FILE__, __LINE__);
+
+	if (obj.empty()) return self;
+
+	std::vector<Rays::Polyline> polylines;
+	for (const auto& polyline : to<Rays::Polygon&>(self))
+		polylines.emplace_back(polyline);
+
+	if (obj[0].is_kind_of(Rays::polyline_class()))
+	{
+		each_poly<Rays::Polyline>(obj, [&](const auto& polyline)
+		{
+			polylines.emplace_back(polyline);
+		});
+	}
+	else
+	{
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
+		{
+			for (const auto& polyline : polygon)
+				polylines.emplace_back(polyline);
+		});
+	}
+
+	return value(Rays::Polygon(&polylines[0], polylines.size()));
 }
 
 static
@@ -118,7 +158,7 @@ VALUE op_sub(VALUE self, VALUE obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result - polygon;
 		});
@@ -136,7 +176,7 @@ VALUE op_and(VALUE self, VALUE obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result & polygon;
 		});
@@ -154,7 +194,7 @@ VALUE op_or(VALUE self, VALUE obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result | polygon;
 		});
@@ -172,7 +212,7 @@ VALUE op_xor(VALUE self, VALUE obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result ^ polygon;
 		});
@@ -182,6 +222,54 @@ VALUE op_xor(VALUE self, VALUE obj)
 		return value(*THIS ^ to<Rays::Polygon&>(obj));
 }
 
+static
+VALUE create_points(VALUE self, VALUE points)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_points(params.ppoints(), params.size()));
+}
+
+static
+VALUE create_line(VALUE self, VALUE points, VALUE loop)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_line(params.ppoints(), params.size(), loop));
+}
+
+static
+VALUE create_lines(VALUE self, VALUE points)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_lines(params.ppoints(), params.size()));
+}
+
+static
+VALUE create_triangles(VALUE self, VALUE points, VALUE loop, VALUE colors, VALUE texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangles(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
+}
+
+static
+VALUE create_triangle_strip(VALUE self, VALUE points, VALUE colors, VALUE texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+
+static
+VALUE create_triangle_fan(VALUE self, VALUE points, VALUE colors, VALUE texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_fan(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+
 static
 VALUE create_rect(VALUE self, VALUE
 	args, VALUE round, VALUE lefttop, VALUE righttop, VALUE leftbottom, VALUE rightbottom, VALUE nsegment)
@@ -196,6 +284,24 @@ VALUE create_rect(VALUE self, VALUE
 	return value(Rays::create_rect(x, y, w, h, lt, rt, lb, rb, nseg));
 }
 
+static
+VALUE create_quads(VALUE self, VALUE points, VALUE loop, VALUE colors, VALUE texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quads(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
+}
+
+static
+VALUE create_quad_strip(VALUE self, VALUE points, VALUE colors, VALUE texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quad_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+
 static
 VALUE create_ellipse(VALUE self, VALUE
 	args, VALUE center, VALUE radius, VALUE hole, VALUE angle_from, VALUE angle_to, VALUE nsegment)
@@ -213,21 +319,17 @@ VALUE create_ellipse(VALUE self, VALUE
 }
 
 static
-VALUE create_curve(VALUE self, VALUE args, VALUE loop)
+VALUE create_curve(VALUE self, VALUE points, VALUE loop)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-
-	return value(Rays::create_curve(&points[0], points.size(), loop));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_curve(params.ppoints(), params.size(), loop));
 }
 
 static
-VALUE create_bezier(VALUE self, VALUE args, VALUE loop)
+VALUE create_bezier(VALUE self, VALUE points, VALUE loop)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-
-	return value(Rays::create_bezier(&points[0], points.size(), loop));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_bezier(params.ppoints(), params.size(), loop));
 }
 
 
@@ -240,22 +342,30 @@ Init_rays_polygon ()
 
 	cPolygon = rb_define_class_under(mRays, "Polygon", rb_cObject);
 	rb_define_alloc_func(cPolygon, alloc);
-	rb_define_private_method(cPolygon, "setup", RUBY_METHOD_FUNC(setup), 2);
+	rb_define_private_method(cPolygon, "setup", RUBY_METHOD_FUNC(setup), 4);
 	rb_define_method(cPolygon, "expand", RUBY_METHOD_FUNC(expand), -1);
 	rb_define_method(cPolygon, "bounds", RUBY_METHOD_FUNC(bounds), 0);
 	rb_define_method(cPolygon, "size", RUBY_METHOD_FUNC(size), 0);
 	cPolygon.define_method("empty?", is_empty);
 	cPolygon.define_method("[]", get_at);
 	rb_define_method(cPolygon, "each", RUBY_METHOD_FUNC(each), 0);
-	cPolygon.define_method("+", op_or);
+	cPolygon.define_method("+", op_add);
 	cPolygon.define_method("-", op_sub);
 	cPolygon.define_method("&", op_and);
 	cPolygon.define_method("|", op_or);
 	cPolygon.define_method("^", op_xor);
-	rb_define_singleton_method(cPolygon, "create_rect", RUBY_METHOD_FUNC(create_rect), 7);
-	rb_define_singleton_method(cPolygon, "create_ellipse", RUBY_METHOD_FUNC(create_ellipse), 7);
-	rb_define_singleton_method(cPolygon, "create_curve", RUBY_METHOD_FUNC(create_curve), 2);
-	rb_define_singleton_method(cPolygon, "create_bezier", RUBY_METHOD_FUNC(create_bezier), 2);
+	cPolygon.define_singleton_method("points!",         create_points);
+	cPolygon.define_singleton_method("line!",           create_line);
+	cPolygon.define_singleton_method("lines!",          create_lines);
+	cPolygon.define_singleton_method("triangles!",      create_triangles);
+	cPolygon.define_singleton_method("triangle_strip!", create_triangle_strip);
+	cPolygon.define_singleton_method("triangle_fan!",   create_triangle_fan);
+	cPolygon.define_singleton_method("rect!",           create_rect);
+	cPolygon.define_singleton_method("quads!",          create_quads);
+	cPolygon.define_singleton_method("quad_strip!",     create_quad_strip);
+	cPolygon.define_singleton_method("ellipse!",        create_ellipse);
+	cPolygon.define_singleton_method("curve!",          create_curve);
+	cPolygon.define_singleton_method("bezier!",         create_bezier);
 }
 
 
@@ -266,26 +376,27 @@ namespace Rucy
 	template <> Rays::Polygon
 	value_to<Rays::Polygon> (int argc, const Value* argv, bool convert)
 	{
-		assert(argc == 0 || (argc > 0 && argv));
-
 		if (convert)
 		{
 			if (argc <= 0)
 				return Rays::Polygon();
-			else if (argv->is_kind_of(Rays::polygon_line_class()))
+			else if (argv->is_kind_of(Rays::polyline_class()))
 			{
-				std::vector<Rays::Polygon::Line> lines;
-				lines.reserve(argc);
-				for (int i = 0; i < argc; ++i)
-					lines.emplace_back(to<Rays::Polygon::Line&>(argv[i]));
-				return Rays::Polygon(&lines[0], lines.size());
+				if (argc == 1)
+					return Rays::Polygon(to<Rays::Polyline&>(*argv));
+				else
+				{
+					std::vector<Rays::Polyline> polylines;
+					polylines.reserve(argc);
+					for (int i = 0; i < argc; ++i)
+						polylines.emplace_back(to<Rays::Polyline&>(argv[i]));
+					return Rays::Polygon(&polylines[0], polylines.size());
+				}
 			}
-			else if (argv->is_kind_of(Rays::polyline_class()))
-				return Rays::Polygon(to<Rays::Polyline&>(*argv));
 			else if (argv->is_num() || argv->is_array())
 			{
 				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
+				get_points(&points, argc, argv);
 				return Rays::Polygon(&points[0], points.size());
 			}
 		}

data/.doc/ext/rays/polyline.cpp

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 #include <vector>
+#include "rays/ruby/color.h"
 #include "rays/ruby/point.h"
 #include "rays/ruby/bounds.h"
 #include "rays/ruby/polygon.h"
@@ -23,13 +24,15 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE setup(VALUE self, VALUE points, VALUE loop)
+VALUE setup(VALUE self, VALUE points, VALUE loop, VALUE fill, VALUE colors, VALUE texcoords, VALUE hole)
 {
 	CHECK;
 
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polyline(&array[0], array.size(), loop);
+	CreateParams params(points, colors, texcoords);
+	*THIS = Rays::Polyline(
+		params.ppoints(), params.size(), loop, fill,
+		params.pcolors(), params.ptexcoords(),
+		hole);
 }
 
 static
@@ -56,12 +59,26 @@ VALUE bounds(VALUE self)
 }
 
 static
-VALUE loop(VALUE self)
+VALUE is_loop(VALUE self)
 {
 	CHECK;
 	return value(THIS->loop());
 }
 
+static
+VALUE is_fill(VALUE self)
+{
+	CHECK;
+	return value(THIS->fill());
+}
+
+static
+VALUE is_hole(VALUE self)
+{
+	CHECK;
+	return value(THIS->hole());
+}
+
 static
 VALUE size(VALUE self)
 {
@@ -92,7 +109,28 @@ VALUE get_at(VALUE self, VALUE index)
 }
 
 static
-VALUE each(VALUE self)
+VALUE has_points(VALUE self)
+{
+	CHECK;
+	return value(THIS->points() && !THIS->empty());
+}
+
+static
+VALUE has_colors(VALUE self)
+{
+	CHECK;
+	return value(THIS->colors() && !THIS->empty());
+}
+
+static
+VALUE has_texcoords(VALUE self)
+{
+	CHECK;
+	return value(THIS->texcoords() && !THIS->empty());
+}
+
+static
+VALUE each_point(VALUE self)
 {
 	CHECK;
 
@@ -102,6 +140,40 @@ VALUE each(VALUE self)
 	return ret;
 }
 
+static
+VALUE each_color(VALUE self)
+{
+	CHECK;
+
+	const Rays::Color* colors = THIS->colors();
+
+	Value ret = Qnil;
+	if (colors)
+	{
+		size_t size = THIS->size();
+		for (size_t i = 0; i < size; ++i)
+			ret = rb_yield(value(colors[i]));
+	}
+	return ret;
+}
+
+static
+VALUE each_texcoord(VALUE self)
+{
+	CHECK;
+
+	const Rays::Coord3* texcoords = THIS->texcoords();
+
+	Value ret = Qnil;
+	if (texcoords)
+	{
+		size_t size = THIS->size();
+		for (size_t i = 0; i < size; ++i)
+			ret = rb_yield(value(*(Rays::Point*) &texcoords[i]));
+	}
+	return ret;
+}
+
 
 static Class cPolyline;
 
@@ -112,14 +184,21 @@ Init_rays_polyline ()
 
 	cPolyline = rb_define_class_under(mRays, "Polyline", rb_cObject);
 	rb_define_alloc_func(cPolyline, alloc);
-	rb_define_private_method(cPolyline, "setup", RUBY_METHOD_FUNC(setup), 2);
+	rb_define_private_method(cPolyline, "setup", RUBY_METHOD_FUNC(setup), 6);
 	rb_define_method(cPolyline, "expand", RUBY_METHOD_FUNC(expand), -1);
 	rb_define_method(cPolyline, "bounds", RUBY_METHOD_FUNC(bounds), 0);
-	cPolyline.define_method("loop?", loop);
+	cPolyline.define_method("loop?", is_loop);
+	cPolyline.define_method("fill?", is_fill);
+	cPolyline.define_method("hole?", is_hole);
 	rb_define_method(cPolyline, "size", RUBY_METHOD_FUNC(size), 0);
 	cPolyline.define_method("empty?", is_empty);
 	cPolyline.define_method("[]", get_at);
-	rb_define_method(cPolyline, "each", RUBY_METHOD_FUNC(each), 0);
+	cPolyline.define_method("points?",    has_points);
+	cPolyline.define_method("colors?",    has_colors);
+	cPolyline.define_method("texcoords?", has_texcoords);
+	cPolyline.define_private_method("each_point!",    each_point);
+	cPolyline.define_private_method("each_color!",    each_color);
+	cPolyline.define_private_method("each_texcoord!", each_texcoord);
 }
 
 
@@ -139,7 +218,7 @@ namespace Rucy
 			else if (argv->is_num() || argv->is_array())
 			{
 				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
+				get_points(&points, argc, argv);
 				return Rays::Polyline(&points[0], points.size());
 			}
 		}