rays 0.1.46 → 0.1.47

data/ext/rays/bitmap.cpp

@@ -72,6 +72,264 @@ RUCY_DEF0(color_space)
 }
 RUCY_END
 
+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
+RUCY_DEF0(pixels)
+{
+	CHECK;
+
+	std::vector<VALUE> pixels;
+	get_pixels(&pixels, *THIS);
+	return value(pixels.size(), (const Value*) &pixels[0]);
+}
+RUCY_END
+
 static
 RUCY_DEF3(set_at, x, y, color)
 {
@@ -113,6 +371,7 @@ Init_rays_bitmap ()
 	cBitmap.define_method("width",  width);
 	cBitmap.define_method("height", height);
 	cBitmap.define_method("color_space", color_space);
+	cBitmap.define_method("pixels", pixels);
 	cBitmap.define_method("[]=", set_at);
 	cBitmap.define_method("[]",  get_at);
 }

data/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/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
@@ -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)
 {
@@ -698,12 +733,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);

data/ext/rays/polygon.cpp

@@ -194,6 +194,34 @@ RUCY_DEF1(op_xor, obj)
 }
 RUCY_END
 
+static
+RUCY_DEF1(create_points, 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()));
+}
+RUCY_END
+
+static
+RUCY_DEF1(create_lines, 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()));
+}
+RUCY_END
+
+static
+RUCY_DEF2(create_line_strip, args, 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));
+}
+RUCY_END
+
 static
 RUCY_DEF7(create_rect,
 	args, round, lefttop, righttop, leftbottom, rightbottom, nsegment)
@@ -226,6 +254,55 @@ RUCY_DEF7(create_ellipse,
 }
 RUCY_END
 
+static
+RUCY_DEF2(create_triangles, args, 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));
+}
+RUCY_END
+
+static
+RUCY_DEF1(create_triangle_strip, 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()));
+}
+RUCY_END
+
+static
+RUCY_DEF1(create_triangle_fan, 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()));
+}
+RUCY_END
+
+static
+RUCY_DEF2(create_quads, args, 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));
+}
+RUCY_END
+
+static
+RUCY_DEF1(create_quad_strip, 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()));
+}
+RUCY_END
+
 static
 RUCY_DEF2(create_curve, args, loop)
 {
@@ -268,10 +345,18 @@ Init_rays_polygon ()
 	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("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/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({
@@ -72,13 +72,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);
 }
 
 
@@ -102,7 +102,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);
@@ -133,7 +133,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);
@@ -164,18 +164,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/include/rays/defs.h

@@ -23,6 +23,32 @@ namespace Rays
 	typedef float coord;
 
 
+	enum DrawMode
+	{
+
+		DRAW_POINTS = 0,
+
+		DRAW_LINES,
+
+		DRAW_LINE_STRIP,
+
+		DRAW_TRIANGLES,
+
+		DRAW_TRIANGLE_STRIP,
+
+		DRAW_TRIANGLE_FAN,
+
+		DRAW_QUADS,
+
+		DRAW_QUAD_STRIP,
+
+		DRAW_POLYGON,
+
+		DRAW_MAX,
+
+	};// DrawMode
+
+
 	enum CapType
 	{
 

data/include/rays/matrix.h

@@ -43,6 +43,8 @@ namespace Rays
 
 		Matrix (const coord* elements, size_t size);
 
+		Matrix (void* null);
+
 		This dup () const;
 
 		This& reset (coord value = 1);

data/include/rays/painter.h

@@ -65,7 +65,17 @@ namespace Rays
 
 			void clear ();
 
-			void polygon (const Polygon& polygon);
+			void polygon (
+				const Polygon& polygon, coord x = 0, coord y = 0);
+
+			void polygon (
+				const Polygon& polygon, const Point& position);
+
+			void polygon (
+				const Polygon& polygon, coord x, coord y, coord width, coord height);
+
+			void polygon (
+				const Polygon& polygon, const Bounds& bounds);
 
 			void line (coord x1, coord y1, coord x2, coord y2);
 
@@ -205,6 +215,10 @@ namespace Rays
 
 			coord    stroke_width () const;
 
+			void set_stroke_outset (float outset);
+
+			float    stroke_outset () const;
+
 			void set_stroke_cap (CapType cap);
 
 			CapType  stroke_cap () const;

data/include/rays/polygon.h

@@ -54,7 +54,12 @@ namespace Rays
 
 			Polygon ();
 
-			Polygon (const Point* points, size_t size, bool loop = true);
+			Polygon (
+				const Point* points, size_t size, bool loop = true);
+
+			Polygon (
+				DrawMode mode,
+				const Point* points, size_t size, bool loop = true);
 
 			Polygon (const Polyline& polyline);
 

data/include/rays/polyline.h

@@ -31,6 +31,8 @@ namespace Rays
 
 			Polyline (const Point* points, size_t size, bool loop = false);
 
+			Polyline (const Point* points, size_t size, bool loop, bool fill);
+
 			~Polyline ();
 
 			bool expand (
@@ -44,6 +46,8 @@ namespace Rays
 
 			bool loop () const;
 
+			bool fill () const;
+
 			size_t size () const;
 
 			bool empty () const;

data/lib/rays/painter.rb

@@ -119,7 +119,7 @@ module Rays
     }
 
     universal_accessor :background, :fill, :stroke, :color,
-      :stroke_width, :stroke_cap, :stroke_join, :miter_limit,
+      :stroke_width, :stroke_outset, :stroke_cap, :stroke_join, :miter_limit,
       :nsegment, :blend_mode, :shader, :clip, :font
 
     private