rays 0.1.46 → 0.1.48

data/ext/rays/font.cpp

@@ -30,6 +30,16 @@ RUCY_DEFN(initialize)
 }
 RUCY_END
 
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	RUCY_CHECK_OBJ(Rays::Font, self);
+
+	*THIS = to<Rays::Font&>(obj).dup();
+	return self;
+}
+RUCY_END
+
 static
 RUCY_DEF0(name)
 {
@@ -38,6 +48,15 @@ RUCY_DEF0(name)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_size, size)
+{
+	CHECK;
+	THIS->set_size(to<coord>(size));
+	return size;
+}
+RUCY_END
+
 static
 RUCY_DEF0(size)
 {
@@ -92,6 +111,35 @@ RUCY_DEF0(leading)
 }
 RUCY_END
 
+static
+RUCY_DEF0(families)
+{
+	Hash hash;
+	for (const auto& family : Rays::get_font_families())
+	{
+		std::vector<Value> members;
+		for (const auto& member : family.second)
+			members.emplace_back(member.c_str());
+		hash.set(family.first.c_str(), value(members.size(), &members[0]));
+	}
+	return hash;
+}
+RUCY_END
+
+static
+RUCY_DEFN(load)
+{
+	check_arg_count(__FILE__, __LINE__, "Font.load", argc, 1, 2);
+
+	const char* path = argv[0].c_str();
+
+	if (argc >= 2)
+		return value(Rays::load_font(path, to<Rays::coord>(argv[1])));
+	else
+		return value(Rays::load_font(path));
+}
+RUCY_END
+
 
 static Class cFont;
 
@@ -102,14 +150,18 @@ Init_rays_font ()
 
 	cFont = mRays.define_class("Font");
 	cFont.define_alloc_func(alloc);
-	cFont.define_private_method("initialize", initialize);
+	cFont.define_private_method("initialize",      initialize);
+	cFont.define_private_method("initialize_copy", initialize_copy);
 	cFont.define_method("name", name);
-	cFont.define_method("size", size);
+	cFont.define_method("size=", set_size);
+	cFont.define_method("size",      size);
 	cFont.define_method("width",   width);
 	cFont.define_method("height",  height);
 	cFont.define_method("ascent",  ascent);
 	cFont.define_method("descent", descent);
 	cFont.define_method("leading", leading);
+	cFont.define_module_function("families", families);
+	cFont.define_module_function("load", load);
 }
 
 
@@ -131,9 +183,9 @@ namespace Rucy
 		if (convert)
 		{
 			if (argc == 0)
-				return Rays::default_font();
+				return Rays::get_default_font();
 
-			coord size = argc >= 2 ? to<coord>(argv[1]) : 0;
+			coord size = argc >= 2 ? to<coord>(argv[1]) : Rays::Font::DEFAULT_SIZE;
 			if (argv->is_nil())
 				return Rays::Font(NULL, size);
 			else if (argv->is_s() || argv->is_sym())

data/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/ext/rays/painter.cpp

@@ -129,11 +129,29 @@ RUCY_DEF0(clear)
 RUCY_END
 
 static
-RUCY_DEF1(polygon, poly)
+RUCY_DEFN(polygon)
 {
 	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;
 }
 RUCY_END
@@ -144,7 +162,7 @@ RUCY_DEF2(line, args, 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;
@@ -206,7 +224,7 @@ RUCY_DEF2(curve, args, 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;
@@ -222,7 +240,7 @@ RUCY_DEF2(bezier, args, 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;
@@ -393,6 +411,23 @@ RUCY_DEF0(get_stroke_width)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_stroke_outset, outset)
+{
+	CHECK;
+	THIS->set_stroke_outset(to<float>(outset));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_stroke_outset)
+{
+	CHECK;
+	return value(THIS->stroke_outset());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_stroke_cap, cap)
 {
@@ -523,6 +558,76 @@ RUCY_DEF0(get_font)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_texture, image)
+{
+	CHECK;
+
+	if (!image)
+		THIS->no_texture();
+	else
+		THIS->set_texture(to<Rays::Image&>(image));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_texture)
+{
+	CHECK;
+
+	const Rays::Image& image = THIS->texture();
+	return image ? value(image) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(no_texture)
+{
+	CHECK;
+	THIS->no_texture();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_texcoord_mode, mode)
+{
+	CHECK;
+
+	THIS->set_texcoord_mode(to<Rays::TexCoordMode>(mode));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_texcoord_mode)
+{
+	CHECK;
+
+	return value(THIS->texcoord_mode());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_texcoord_wrap, wrap)
+{
+	CHECK;
+
+	THIS->set_texcoord_wrap(to<Rays::TexCoordWrap>(wrap));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_texcoord_wrap)
+{
+	CHECK;
+
+	return value(THIS->texcoord_wrap());
+}
+RUCY_END
+
 static
 RUCY_DEFN(set_shader)
 {
@@ -698,12 +803,14 @@ Init_rays_painter ()
 	cPainter.define_method(   "stroke=",       set_stroke);
 	cPainter.define_method(   "stroke",        get_stroke);
 	cPainter.define_method("no_stroke",         no_stroke);
-	cPainter.define_method(   "stroke_width=", set_stroke_width);
-	cPainter.define_method(   "stroke_width",  get_stroke_width);
-	cPainter.define_method(   "stroke_cap=",   set_stroke_cap);
-	cPainter.define_method(   "stroke_cap",    get_stroke_cap);
-	cPainter.define_method(   "stroke_join=",  set_stroke_join);
-	cPainter.define_method(   "stroke_join",   get_stroke_join);
+	cPainter.define_method(   "stroke_width=",  set_stroke_width);
+	cPainter.define_method(   "stroke_width",   get_stroke_width);
+	cPainter.define_method(   "stroke_outset=", set_stroke_outset);
+	cPainter.define_method(   "stroke_outset",  get_stroke_outset);
+	cPainter.define_method(   "stroke_cap=",    set_stroke_cap);
+	cPainter.define_method(   "stroke_cap",     get_stroke_cap);
+	cPainter.define_method(   "stroke_join=",   set_stroke_join);
+	cPainter.define_method(   "stroke_join",    get_stroke_join);
 	cPainter.define_method("miter_limit=", set_miter_limit);
 	cPainter.define_method("miter_limit",  get_miter_limit);
 	cPainter.define_method("nsegment=", set_nsegment);
@@ -715,6 +822,13 @@ Init_rays_painter ()
 	cPainter.define_method("no_clip",   no_clip);
 	cPainter.define_method("font=", set_font);
 	cPainter.define_method("font",  get_font);
+	cPainter.define_method(   "texture=", set_texture);
+	cPainter.define_method(   "texture",  get_texture);
+	cPainter.define_method("no_texture",   no_texture);
+	cPainter.define_method("texcoord_mode=", set_texcoord_mode);
+	cPainter.define_method("texcoord_mode",  get_texcoord_mode);
+	cPainter.define_method("texcoord_wrap=", set_texcoord_wrap);
+	cPainter.define_method("texcoord_wrap",  get_texcoord_wrap);
 	cPainter.define_private_method("set_shader", set_shader);
 	cPainter.define_method(            "shader", get_shader);
 	cPainter.define_method(         "no_shader",  no_shader);

data/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"
@@ -24,7 +23,7 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF2(setup, args, loop)
+RUCY_DEF4(setup, args, loop, colors, texcoords)
 {
 	CHECK;
 
@@ -32,9 +31,10 @@ RUCY_DEF2(setup, args, 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());
 	}
 }
 RUCY_END
@@ -102,22 +102,63 @@ RUCY_DEF0(each)
 	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;
 }
 RUCY_END
 
-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
+RUCY_DEF1(op_add, 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()));
+}
+RUCY_END
+
 static
 RUCY_DEF1(op_sub, obj)
 {
@@ -126,7 +167,7 @@ RUCY_DEF1(op_sub, 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;
 		});
@@ -145,7 +186,7 @@ RUCY_DEF1(op_and, 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;
 		});
@@ -164,7 +205,7 @@ RUCY_DEF1(op_or, 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,7 +224,7 @@ RUCY_DEF1(op_xor, 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;
 		});
@@ -194,6 +235,60 @@ RUCY_DEF1(op_xor, obj)
 }
 RUCY_END
 
+static
+RUCY_DEF1(create_points, points)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_points(params.ppoints(), params.size()));
+}
+RUCY_END
+
+static
+RUCY_DEF2(create_line, points, loop)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_line(params.ppoints(), params.size(), loop));
+}
+RUCY_END
+
+static
+RUCY_DEF1(create_lines, points)
+{
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_lines(params.ppoints(), params.size()));
+}
+RUCY_END
+
+static
+RUCY_DEF4(create_triangles, points, loop, colors, texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangles(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
+}
+RUCY_END
+
+static
+RUCY_DEF3(create_triangle_strip, points, colors, texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+RUCY_END
+
+static
+RUCY_DEF3(create_triangle_fan, points, colors, texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_fan(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+RUCY_END
+
 static
 RUCY_DEF7(create_rect,
 	args, round, lefttop, righttop, leftbottom, rightbottom, nsegment)
@@ -209,6 +304,26 @@ RUCY_DEF7(create_rect,
 }
 RUCY_END
 
+static
+RUCY_DEF4(create_quads, points, loop, colors, texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quads(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
+}
+RUCY_END
+
+static
+RUCY_DEF3(create_quad_strip, points, colors, texcoords)
+{
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quad_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
+}
+RUCY_END
+
 static
 RUCY_DEF7(create_ellipse,
 	args, center, radius, hole, angle_from, angle_to, nsegment)
@@ -227,22 +342,18 @@ RUCY_DEF7(create_ellipse,
 RUCY_END
 
 static
-RUCY_DEF2(create_curve, args, loop)
+RUCY_DEF2(create_curve, points, 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));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_bezier, args, loop)
+RUCY_DEF2(create_bezier, points, 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));
 }
 RUCY_END
 
@@ -259,19 +370,27 @@ Init_rays_polygon ()
 	cPolygon.define_private_method("setup", setup);
 	cPolygon.define_method("expand", expand);
 	cPolygon.define_method("bounds", bounds);
-	cPolygon.define_method("size", size);
+	cPolygon.define_method("size",   size);
 	cPolygon.define_method("empty?", is_empty);
 	cPolygon.define_method("[]", get_at);
 	cPolygon.define_method("each", each);
-	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("create_rect",    create_rect);
-	cPolygon.define_singleton_method("create_ellipse", create_ellipse);
-	cPolygon.define_singleton_method("create_curve",   create_curve);
-	cPolygon.define_singleton_method("create_bezier",  create_bezier);
+	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);
 }
 
 
@@ -282,26 +401,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());
 			}
 		}