rays 0.1.46 → 0.1.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4232c9c8e77b4d6e9d3a60a283934c268baade87875d0bf7ce2f6ee7f4e53aa8
-  data.tar.gz: d8931fbc4a860a97425e56f716ac995ff5c51e5b7c2cc4bca160eda184007706
+  metadata.gz: d27dc838757afd56a521719cf178e3fc21accf98d1e5041c3afa8df730e998c3
+  data.tar.gz: 2745744e4dc2b11d5771c1deb94fa949c7d2d27a5903c2b0acca2887678330f2
 SHA512:
-  metadata.gz: 735f49b98489b5a3da4bacb0e501b28410aa67954875185eef2515eaa90112573bee44762bbfd9d1489eaeae06f8543fb02a945d177e901eb5f33c5c90811d35
-  data.tar.gz: ba69b4be7967c303fb8cf0cee65f804be444e7ce426c3d2ea0e337fd8a86837ac95e6011d847c238f8a6c520a81a924c8783b1476040c311080e6ac4f4b72ba8
+  metadata.gz: 400f74e76fd7c1db1edfee49d6a68fb7d721fec8dc8e247bc99bdee65b27688b7c6e96962f8a9c95aaa2a87ed045ab2fd0419478cb1aaf118098bf5fefbf7298
+  data.tar.gz: 367ed1df9b709b7c5ac7091ea1d38bbe14da8ab72d2dd049bb1c4a9acf994a45971bcef3b599525f25bdccb420ee032d8036ca58656bbc1401a2becc383a7e7a

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

@@ -66,6 +66,263 @@ VALUE color_space(VALUE self)
 	return value(THIS->color_space());
 }
 
+static inline Value
+to_rgb_value (uint8_t r, uint8_t g, uint8_t b)
+{
+	return value(
+		((uint) r) << 16 |
+		((uint) g) << 8  |
+		((uint) b));
+}
+
+static inline Value
+to_rgba_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+{
+	return value(
+		((uint) a) << 24 |
+		((uint) r) << 16 |
+		((uint) g) << 8  |
+		((uint) b));
+}
+
+static void
+get_pixels (auto* pixels, const Rays::Bitmap& bmp)
+{
+	int w = bmp.width(), h = bmp.height();
+
+	const auto& cs = bmp.color_space();
+	pixels->clear();
+	pixels->reserve(w * h * (cs.is_float() ? cs.Bpp() / cs.Bpc() : 1));
+
+	switch (cs.type())
+	{
+		case Rays::GRAY_8:
+		case Rays::ALPHA_8:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_16:
+		case Rays::ALPHA_16:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint16_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_32:
+		case Rays::ALPHA_32:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint32_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_float:
+		case Rays::ALPHA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::RGB_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+					pixels->push_back(to_rgb_value(p[0], p[1], p[2]));
+			}
+			break;
+
+		case Rays::RGBA_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgba_value(p[0], p[1], p[2], p[3]));
+			}
+			break;
+
+		case Rays::RGBX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgb_value(p[0], p[1], p[2]));
+			}
+			break;
+
+		case Rays::ARGB_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgba_value(p[1], p[2], p[3], p[0]));
+			}
+			break;
+
+		case Rays::XRGB_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgb_value(p[1], p[2], p[3]));
+			}
+			break;
+
+		case Rays::BGR_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+					pixels->push_back(to_rgb_value(p[2], p[1], p[0]));
+			}
+			break;
+
+		case Rays::BGRA_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgba_value(p[2], p[1], p[0], p[3]));
+			}
+			break;
+
+		case Rays::BGRX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgb_value(p[2], p[1], p[0]));
+			}
+			break;
+
+		case Rays::ABGR_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgba_value(p[3], p[2], p[1], p[0]));
+			}
+			break;
+
+		case Rays::XBGR_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+					pixels->push_back(to_rgb_value(p[3], p[2], p[1]));
+			}
+			break;
+
+		case Rays::RGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+				{
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+				}
+			}
+			break;
+
+		case Rays::RGBA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[3]));
+				}
+			}
+			break;
+
+		case Rays::ARGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[3]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		case Rays::BGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+				{
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		case Rays::BGRA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[3]));
+				}
+			}
+			break;
+
+		case Rays::ABGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[3]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		default:
+			argument_error(__FILE__, __LINE__);
+	}
+}
+
+static
+VALUE pixels(VALUE self)
+{
+	CHECK;
+
+	std::vector<VALUE> pixels;
+	get_pixels(&pixels, *THIS);
+	return value(pixels.size(), (const Value*) &pixels[0]);
+}
+
 static
 VALUE set_at(VALUE self, VALUE x, VALUE y, VALUE color)
 {
@@ -105,6 +362,7 @@ Init_rays_bitmap ()
 	rb_define_method(cBitmap, "width", RUBY_METHOD_FUNC(width), 0);
 	rb_define_method(cBitmap, "height", RUBY_METHOD_FUNC(height), 0);
 	rb_define_method(cBitmap, "color_space", RUBY_METHOD_FUNC(color_space), 0);
+	rb_define_method(cBitmap, "pixels", RUBY_METHOD_FUNC(pixels), 0);
 	cBitmap.define_method("[]=", set_at);
 	cBitmap.define_method("[]",  get_at);
 }

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

@@ -24,9 +24,9 @@ get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
 		points->reserve(argc / 2);
 		for (int i = 0; i < argc; i += 2)
 		{
-			coord x = to<coord>(argv[i + 0]);
-			coord y = to<coord>(argv[i + 1]);
-			points->emplace_back(Rays::Point(x, y));
+			points->emplace_back(
+				to<coord>(argv[i + 0]),
+				to<coord>(argv[i + 1]));
 		}
 	}
 	else

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;
 }
 
@@ -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)
 {
@@ -624,7 +657,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 +678,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);

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

@@ -182,6 +182,31 @@ VALUE op_xor(VALUE self, VALUE obj)
 		return value(*THIS ^ to<Rays::Polygon&>(obj));
 }
 
+static
+VALUE create_points(VALUE self, VALUE args)
+{
+	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()));
+}
+
+static
+VALUE create_lines(VALUE self, VALUE args)
+{
+	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()));
+}
+
+static
+VALUE create_line_strip(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_LINE_STRIP, &points[0], points.size(), loop));
+}
+
 static
 VALUE create_rect(VALUE self, VALUE
 	args, VALUE round, VALUE lefttop, VALUE righttop, VALUE leftbottom, VALUE rightbottom, VALUE nsegment)
@@ -212,6 +237,50 @@ VALUE create_ellipse(VALUE self, VALUE
 	return value(Rays::create_ellipse(x, y, w, h, hole_size, from, to_, nseg));
 }
 
+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)
+{
+	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()));
+}
+
+static
+VALUE create_triangle_fan(VALUE self, VALUE args)
+{
+	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)
 {
@@ -252,10 +321,18 @@ Init_rays_polygon ()
 	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("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("quads!",          create_quads);
+	cPolygon.define_singleton_method("quad_strip!",     create_quad_strip);
+	cPolygon.define_singleton_method("curve!",          create_curve);
+	cPolygon.define_singleton_method("bezier!",         create_bezier);
 }
 
 

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

@@ -16,7 +16,7 @@ struct EnumType
 {
 	const char* name;
 	const char* short_name;
-	T type;
+	T value;
 };
 
 static std::vector<EnumType<Rays::CapType>> CAP_TYPES({
@@ -70,13 +70,13 @@ Init_rays ()
 	mRays.define_singleton_method("fin!", fin);
 
 	for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
 
 	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
 
 	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
 }
 
 
@@ -100,7 +100,7 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid cap type -- %s", str);
@@ -131,7 +131,7 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid join type -- %s", str);
@@ -162,18 +162,18 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid blend mode -- %s", str);
 			}
 		}
 
-		int type = value_to<int>(*argv, convert);
-		if (type < 0 || Rays::BLEND_MAX <= type)
-			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", type);
+		int mode = value_to<int>(*argv, convert);
+		if (mode < 0 || Rays::BLEND_MAX <= mode)
+			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", mode);
 
-		return (Rays::BlendMode) type;
+		return (Rays::BlendMode) mode;
 	}
 
 

data/.github/workflows/test.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches: [master]
   pull_request:
-    branches: [master]
 
 jobs:
   test:

data/ChangeLog.md

@@ -1,6 +1,21 @@
 # rays ChangeLog
 
 
+## [v0.1.47] - 2023-12-09
+
+- Add Polygon's singleton methods: points(), lines(), triangles(), triangle_strip(), triangle_fan(), quads(), quad_strip()
+- Add create_polygon(DrawMode, ...)
+- Add Painter#stroke_outset
+- Add Bitmap#pixels
+- Use earcut.hpp for polygon triangulation and delete poly2tri
+- Painter#polygon() can take x, y, width, and height
+- Polygon#bounds() caches bounds
+- Polygon.line() -> Polygon.line_strip()
+- Rays::Polygon.new() can take DrawMode
+- Matrix(nullptr) avoids initialization
+- Trigger github actions on all pull_request
+
+
 ## [v0.1.46] - 2023-11-09
 
 - Use Gemfile to install gems for development instead of add_development_dependency in gemspec

data/Rakefile

@@ -25,10 +25,10 @@ use_external_library 'https://github.com/skyrpex/clipper',
   srcdirs:  'cpp',
   excludes: 'clipper/cpp/cpp_'
 
-use_external_library 'https://github.com/greenm01/poly2tri',
-  commit:  '88de49021b6d9bef6faa1bc94ceb3fbd85c3c204',
-  incdirs: 'poly2tri',
-  srcdirs: 'poly2tri'
+use_external_library 'https://github.com/mapbox/earcut.hpp',
+  tag:     'v2.2.4',
+  incdirs: 'include/mapbox',
+  srcdirs: 'NOSRC'
 
 use_external_library 'https://github.com/andrewwillmott/splines-lib',
   commit:   '11e7240d57b0d22871aec3308186a5fcf915ba77',

data/VERSION

@@ -1 +1 @@
-0.1.46
+0.1.47