rays 0.1.47 → 0.1.48

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

@@ -153,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;
@@ -211,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;
@@ -226,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;
@@ -513,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)
 {
@@ -695,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;
 		});
@@ -183,28 +223,51 @@ VALUE op_xor(VALUE self, VALUE obj)
 }
 
 static
-VALUE create_points(VALUE self, VALUE args)
+VALUE create_points(VALUE self, VALUE points)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_POINTS, &points[0], points.size()));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_points(params.ppoints(), params.size()));
 }
 
 static
-VALUE create_lines(VALUE self, VALUE args)
+VALUE create_line(VALUE self, VALUE points, VALUE loop)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_LINES, &points[0], points.size()));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_line(params.ppoints(), params.size(), loop));
 }
 
 static
-VALUE create_line_strip(VALUE self, VALUE args, VALUE loop)
+VALUE create_lines(VALUE self, VALUE points)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_LINE_STRIP, &points[0], points.size(), loop));
+	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
@@ -221,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)
@@ -238,65 +319,17 @@ VALUE create_ellipse(VALUE self, VALUE
 }
 
 static
-VALUE create_triangles(VALUE self, VALUE args, VALUE loop)
-{
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_TRIANGLES, &points[0], points.size(), loop));
-}
-
-static
-VALUE create_triangle_strip(VALUE self, VALUE args)
+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::Polygon(Rays::DRAW_TRIANGLE_STRIP, &points[0], points.size()));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_curve(params.ppoints(), params.size(), loop));
 }
 
 static
-VALUE create_triangle_fan(VALUE self, VALUE args)
+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::Polygon(Rays::DRAW_TRIANGLE_FAN, &points[0], points.size()));
-}
-
-static
-VALUE create_quads(VALUE self, VALUE args, VALUE loop)
-{
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_QUADS, &points[0], points.size(), loop));
-}
-
-static
-VALUE create_quad_strip(VALUE self, VALUE args)
-{
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_QUAD_STRIP, &points[0], points.size()));
-}
-
-static
-VALUE create_curve(VALUE self, VALUE args, 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));
-}
-
-static
-VALUE create_bezier(VALUE self, VALUE args, 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));
 }
 
 
@@ -309,28 +342,28 @@ 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);
 	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("line_strip!",     create_line_strip);
-	cPolygon.define_singleton_method("rect!",           create_rect);
-	cPolygon.define_singleton_method("ellipse!",        create_ellipse);
 	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);
 }
@@ -343,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());
 			}
 		}