rays 0.1.14 → 0.1.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b638147e270acdfa9515fa0f8d8407a8f2026aeaa16e2ff724bee70949949732
-  data.tar.gz: bcf27b5481561456ee6bf5519cfa8bdb74618a076b355a8c8a577e6fc7c0d494
+  metadata.gz: c784fe46265f04062957d138081db6de0d9e257600be215741d120563534420c
+  data.tar.gz: d58b4c10a2e9f0591a6465aea2b36f01de4f0720187acd2fbf98608162bb77d0
 SHA512:
-  metadata.gz: ff95edf30be8dcfdf0f03e784ba1d74131635b1619265fd6b5ef3c7ea63e58eeeebf0e0448ef8c0d138999ef87378bd3cd666e266d0db0cf1707fc07c26b5cc7
-  data.tar.gz: cb2088c67197218c3ada99d85c8d98b3ccb0b1ca73aed1944d43c5c4fc002ec158d2200eea1f21dd25b4867c554e13a3d16c20de2f63f28f12d29f5dea326efe
+  metadata.gz: 2a4771e03c225cd3f84c0d723ee3072d3a1403eec5028e38c1cc00ddda5e27dbd6ed4db14bee3fa9c8f412e49928cf4b9fd13f5cc5ae79b80149438dd3f9c96c
+  data.tar.gz: 17567e4b335014d772f80f35c1a44859893605c65912469f00aac2ecc6f6a9a1c024d1303b42a24e78dd59b8797cc41f2af1b47627755250e74f5eac12dbc031

data/.doc/ext/rays/color_space.cpp

@@ -181,6 +181,9 @@ Init_color_space ()
 {
 	Module mRays = rb_define_module("Rays");
 
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+		mRays.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
+
 	cColorSpace = rb_define_class_under(mRays, "ColorSpace", rb_cObject);
 	rb_define_alloc_func(cColorSpace, alloc);
 	rb_define_private_method(cColorSpace, "initialize", RUBY_METHOD_FUNC(initialize), -1);
@@ -195,9 +198,6 @@ Init_color_space ()
 	cColorSpace.define_method("has_skip?",  has_skip);
 	cColorSpace.define_method("premult?", is_premult);
 	rb_define_method(cColorSpace, "to_s", RUBY_METHOD_FUNC(to_s), 0);
-
-	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-		cColorSpace.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
 }
 
 
@@ -218,16 +218,7 @@ namespace Rucy
 
 		if (convert)
 		{
-			if (argv->is_s() || argv->is_sym())
-			{
-				const char* str = argv[0].c_str();
-				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-				{
-					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
-						return Rays::ColorSpace(COLOR_SPACES[i].type);
-				}
-			}
-			else if (argv->is_i())
+			if (argv->is_i() || argv->is_s() || argv->is_sym())
 			{
 				return Rays::ColorSpace(
 					to<Rays::ColorSpaceType>(argv[0]),
@@ -245,7 +236,24 @@ namespace Rucy
 	template <> Rays::ColorSpaceType
 	value_to<Rays::ColorSpaceType> (Value value, bool convert)
 	{
-		return (Rays::ColorSpaceType) value_to<uint>(value, convert);
+		if (convert)
+		{
+			if (value.is_s() || value.is_sym())
+			{
+				const char* str = value.c_str();
+				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+				{
+					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
+						return COLOR_SPACES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(value, convert);
+		if (type >= Rays::COLORSPACE_MAX)
+			argument_error(__FILE__, __LINE__, "invalid color space type -- %d", type);
+
+		return (Rays::ColorSpaceType) type;
 	}
 
 

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

@@ -141,6 +141,36 @@ VALUE ellipse(VALUE self, VALUE args, VALUE center, VALUE radius, VALUE hole, VA
 	return self;
 }
 
+static
+VALUE curve(VALUE self, VALUE args, VALUE loop)
+{
+	CHECK;
+
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
+
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->curve(&points[0], points.size(), loop);
+	return self;
+}
+
+static
+VALUE bezier(VALUE self, VALUE args, VALUE loop)
+{
+	CHECK;
+
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
+
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->bezier(&points[0], points.size(), loop);
+	return self;
+}
+
 static
 VALUE image(VALUE self)
 {
@@ -292,6 +322,61 @@ VALUE get_stroke_width(VALUE self)
 	return value(THIS->stroke_width());
 }
 
+static
+VALUE set_stroke_cap(VALUE self, VALUE cap)
+{
+	CHECK;
+
+	int type = to<int>(cap);
+	if (type < 0 || Rays::CAP_MAX <= type)
+		argument_error(__FILE__, __LINE__, "invalid stroke cap -- %d", type);
+
+	THIS->set_stroke_cap((Rays::CapType) type);
+	return self;
+}
+
+static
+VALUE get_stroke_cap(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_cap());
+}
+
+static
+VALUE set_stroke_join(VALUE self, VALUE join)
+{
+	CHECK;
+
+	int type = to<int>(join);
+	if (type < 0 || Rays::JOIN_MAX <= type)
+		argument_error(__FILE__, __LINE__, "invalid stroke join -- %d", type);
+
+	THIS->set_stroke_join((Rays::JoinType) type);
+	return self;
+}
+
+static
+VALUE get_stroke_join(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_join());
+}
+
+static
+VALUE set_miter_limit(VALUE self, VALUE limit)
+{
+	CHECK;
+	THIS->set_miter_limit(to<coord>(limit));
+	return self;
+}
+
+static
+VALUE get_miter_limit(VALUE self)
+{
+	CHECK;
+	return value(THIS->miter_limit());
+}
+
 static
 VALUE set_nsegment(VALUE self, VALUE nsegment)
 {
@@ -490,6 +575,8 @@ Init_painter ()
 	rb_define_private_method(cPainter, "draw_polyline", RUBY_METHOD_FUNC(polyline), 1);
 	rb_define_private_method(cPainter, "draw_rect", RUBY_METHOD_FUNC(rect), 6);
 	rb_define_private_method(cPainter, "draw_ellipse", RUBY_METHOD_FUNC(ellipse), 6);
+	rb_define_private_method(cPainter, "draw_curve", RUBY_METHOD_FUNC(curve), 2);
+	rb_define_private_method(cPainter, "draw_bezier", RUBY_METHOD_FUNC(bezier), 2);
 	rb_define_method(cPainter, "image", RUBY_METHOD_FUNC(image), -1);
 	rb_define_method(cPainter, "text", RUBY_METHOD_FUNC(text), -1);
 
@@ -504,6 +591,12 @@ Init_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_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);
+	rb_define_method(cPainter, "stroke_join", RUBY_METHOD_FUNC(get_stroke_join), 0);
+	rb_define_method(cPainter, "miter_limit=", RUBY_METHOD_FUNC(set_miter_limit), 1);
+	rb_define_method(cPainter, "miter_limit", RUBY_METHOD_FUNC(get_miter_limit), 0);
 	rb_define_method(cPainter, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
 	rb_define_method(cPainter, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
 	rb_define_method(cPainter, "clip=", RUBY_METHOD_FUNC(set_clip), -1);

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

@@ -26,7 +26,7 @@ VALUE setup(VALUE self, VALUE args, VALUE loop)
 {
 	CHECK;
 
-	if (loop)
+	if (args[0].is_kind_of(Rays::polyline_class()))
 		*THIS = to<Rays::Polygon>(args.size(), args.as_array());
 	else
 	{
@@ -37,12 +37,18 @@ VALUE setup(VALUE self, VALUE args, VALUE loop)
 }
 
 static
-VALUE expand(VALUE self, VALUE width)
+VALUE expand(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Polygon#expand", argc, 1, 2, 3, 4);
+
+	coord width         =             to<coord>         (argv[0]);
+	Rays::CapType cap   = argc >= 2 ? to<Rays::CapType> (argv[1]) : Rays::CAP_DEFAULT;
+	Rays::JoinType join = argc >= 3 ? to<Rays::JoinType>(argv[2]) : Rays::JOIN_DEFAULT;
+	coord ml            = argc >= 4 ? to<coord>         (argv[3]) : Rays::JOIN_DEFAULT_MITER_LIMIT;
 
 	Rays::Polygon polygon;
-	THIS->expand(&polygon, to<coord>(width));
+	THIS->expand(&polygon, width, cap, join, ml);
 	return value(polygon);
 }
 
@@ -205,6 +211,24 @@ VALUE create_ellipse(VALUE self, VALUE
 	return value(Rays::create_ellipse(x, y, w, h, hole_size, from, to_, nseg));
 }
 
+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));
+}
+
 
 static Class cPolygon;
 
@@ -216,7 +240,7 @@ Init_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_method(cPolygon, "expand", RUBY_METHOD_FUNC(expand), 1);
+	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?", empty);
@@ -229,6 +253,8 @@ Init_polygon ()
 	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);
 }
 
 

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

@@ -32,12 +32,18 @@ VALUE setup(VALUE self, VALUE points, VALUE loop)
 }
 
 static
-VALUE expand(VALUE self, VALUE width)
+VALUE expand(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Polyline#expand", argc, 1, 2, 3, 4);
+
+	coord width         =             to<coord>         (argv[0]);
+	Rays::CapType cap   = argc >= 2 ? to<Rays::CapType> (argv[1]) : Rays::CAP_DEFAULT;
+	Rays::JoinType join = argc >= 3 ? to<Rays::JoinType>(argv[2]) : Rays::JOIN_DEFAULT;
+	coord ml            = argc >= 4 ? to<coord>         (argv[3]) : Rays::JOIN_DEFAULT_MITER_LIMIT;
 
 	Rays::Polygon polygon;
-	THIS->expand(&polygon, to<coord>(width));
+	THIS->expand(&polygon, width, cap, join, ml);
 	return value(polygon);
 }
 
@@ -106,7 +112,7 @@ Init_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_method(cPolyline, "expand", RUBY_METHOD_FUNC(expand), 1);
+	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);
 	rb_define_method(cPolyline, "size", RUBY_METHOD_FUNC(size), 0);

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

@@ -1,7 +1,45 @@
-#include "rays/rays.h"
+#include "rays/ruby/rays.h"
+
+
 #include "defs.h"
 
 
+RUCY_DEFINE_VALUE_OR_ARRAY_TO(Rays::CapType)
+RUCY_DEFINE_VALUE_OR_ARRAY_TO(Rays::JoinType)
+
+
+static struct CapTypeEnum
+{
+	const char* name;
+	Rays::CapType type;
+}
+CAP_TYPES[] =
+{
+	{"CAP_BUTT",   Rays::CAP_BUTT},
+	{"CAP_ROUND",  Rays::CAP_ROUND},
+	{"CAP_SQUARE", Rays::CAP_SQUARE},
+};
+
+static const size_t CAP_TYPES_SIZE =
+	sizeof(CAP_TYPES) / sizeof(CAP_TYPES[0]);
+
+
+static struct JoinTypeEnum
+{
+	const char* name;
+	Rays::JoinType type;
+}
+JOIN_TYPES[] =
+{
+	{"JOIN_MITER",  Rays::JOIN_MITER},
+	{"JOIN_ROUND",  Rays::JOIN_ROUND},
+	{"JOIN_SQUARE", Rays::JOIN_SQUARE},
+};
+
+static const size_t JOIN_TYPES_SIZE =
+	sizeof(JOIN_TYPES) / sizeof(JOIN_TYPES[0]);
+
+
 static
 VALUE init(VALUE self)
 {
@@ -23,11 +61,77 @@ void
 Init_rays ()
 {
 	mRays = rb_define_module("Rays");
+
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
+
+	for (size_t i = 0; i < CAP_TYPES_SIZE; ++i)
+		mRays.define_const(CAP_TYPES[i].name, CAP_TYPES[i].type);
+
+	for (size_t i = 0; i < JOIN_TYPES_SIZE; ++i)
+		mRays.define_const(JOIN_TYPES[i].name, JOIN_TYPES[i].type);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::CapType
+	value_to<Rays::CapType> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (size_t i = 0; i < CAP_TYPES_SIZE; ++i)
+				{
+					if (strcasecmp(str, CAP_TYPES[i].name) == 0)
+						return CAP_TYPES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(*argv, convert);
+		if (type >= Rays::CAP_MAX)
+			argument_error(__FILE__, __LINE__, "invalid cap type -- %d", type);
+
+		return (Rays::CapType) type;
+	}
+
+
+	template <> Rays::JoinType
+	value_to<Rays::JoinType> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (size_t i = 0; i < JOIN_TYPES_SIZE; ++i)
+				{
+					if (strcasecmp(str, JOIN_TYPES[i].name) == 0)
+						return JOIN_TYPES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(*argv, convert);
+		if (type >= Rays::JOIN_MAX)
+			argument_error(__FILE__, __LINE__, "invalid join type -- %d", type);
+
+		return (Rays::JoinType) type;
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {
 

data/Rakefile

@@ -29,6 +29,9 @@ use_external_library 'https://github.com/greenm01/poly2tri',
   incdir: 'poly2tri',
   srcdir: 'poly2tri'
 
+use_external_library 'https://github.com/andrewwillmott/splines-lib.git',
+  excludes: 'Test\.cpp'
+
 build_native_library
 build_ruby_extension
 test_ruby_extension

data/VERSION

@@ -1 +1 @@
-0.1.14
+0.1.15

data/ext/rays/color_space.cpp

@@ -194,6 +194,9 @@ Init_color_space ()
 {
 	Module mRays = define_module("Rays");
 
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+		mRays.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
+
 	cColorSpace = mRays.define_class("ColorSpace");
 	cColorSpace.define_alloc_func(alloc);
 	cColorSpace.define_private_method("initialize",      initialize);
@@ -208,9 +211,6 @@ Init_color_space ()
 	cColorSpace.define_method("has_skip?",  has_skip);
 	cColorSpace.define_method("premult?", is_premult);
 	cColorSpace.define_method("to_s", to_s);
-
-	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-		cColorSpace.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
 }
 
 
@@ -231,16 +231,7 @@ namespace Rucy
 
 		if (convert)
 		{
-			if (argv->is_s() || argv->is_sym())
-			{
-				const char* str = argv[0].c_str();
-				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-				{
-					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
-						return Rays::ColorSpace(COLOR_SPACES[i].type);
-				}
-			}
-			else if (argv->is_i())
+			if (argv->is_i() || argv->is_s() || argv->is_sym())
 			{
 				return Rays::ColorSpace(
 					to<Rays::ColorSpaceType>(argv[0]),
@@ -258,7 +249,24 @@ namespace Rucy
 	template <> Rays::ColorSpaceType
 	value_to<Rays::ColorSpaceType> (Value value, bool convert)
 	{
-		return (Rays::ColorSpaceType) value_to<uint>(value, convert);
+		if (convert)
+		{
+			if (value.is_s() || value.is_sym())
+			{
+				const char* str = value.c_str();
+				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+				{
+					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
+						return COLOR_SPACES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(value, convert);
+		if (type >= Rays::COLORSPACE_MAX)
+			argument_error(__FILE__, __LINE__, "invalid color space type -- %d", type);
+
+		return (Rays::ColorSpaceType) type;
 	}