rays 0.1.47 → 0.1.49

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,19 @@ 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, VALUE nsegment)
 {
-	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());
+	uint nseg = nsegment ? 0 : to<uint>(nsegment);
+	return value(Rays::create_curve(params.ppoints(), params.size(), loop, nseg));
 }
 
 static
-VALUE create_triangle_fan(VALUE self, VALUE args)
+VALUE create_bezier(VALUE self, VALUE points, VALUE loop, VALUE nsegment)
 {
-	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());
+	uint nseg = nsegment ? 0 : to<uint>(nsegment);
+	return value(Rays::create_bezier(params.ppoints(), params.size(), loop, nseg));
 }
 
 
@@ -309,28 +344,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 +378,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());
 			}
 		}

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

@@ -9,6 +9,8 @@
 RUCY_DEFINE_CONVERT_TO(Rays::CapType)
 RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
 RUCY_DEFINE_CONVERT_TO(Rays::BlendMode)
+RUCY_DEFINE_CONVERT_TO(Rays::TexCoordMode)
+RUCY_DEFINE_CONVERT_TO(Rays::TexCoordWrap)
 
 
 template <typename T>
@@ -43,6 +45,16 @@ static std::vector<EnumType<Rays::BlendMode>> BLEND_MODES({
 	{"BLEND_REPLACE",   "REPLACE",   Rays::BLEND_REPLACE},
 });
 
+static std::vector<EnumType<Rays::TexCoordMode>> TEXCOORD_MODES({
+	{"TEXCOORD_IMAGE",  "IMAGE",  Rays::TEXCOORD_IMAGE},
+	{"TEXCOORD_NORMAL", "NORMAL", Rays::TEXCOORD_NORMAL},
+});
+
+static std::vector<EnumType<Rays::TexCoordWrap>> TEXCOORD_WRAPS({
+	{"TEXCOORD_CLAMP",  "CLAMP",  Rays::TEXCOORD_CLAMP},
+	{"TEXCOORD_REPEAT", "REPEAT", Rays::TEXCOORD_REPEAT},
+});
+
 
 static
 VALUE init(VALUE self)
@@ -77,6 +89,12 @@ Init_rays ()
 
 	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
 		mRays.define_const(it->name, it->value);
+
+	for (auto it = TEXCOORD_MODES.begin(); it != TEXCOORD_MODES.end(); ++it)
+		mRays.define_const(it->name, it->value);
+
+	for (auto it = TEXCOORD_WRAPS.begin(); it != TEXCOORD_WRAPS.end(); ++it)
+		mRays.define_const(it->name, it->value);
 }
 
 
@@ -177,6 +195,68 @@ namespace Rucy
 	}
 
 
+	template <> Rays::TexCoordMode
+	value_to<Rays::TexCoordMode> (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 (auto it = TEXCOORD_MODES.begin(); it != TEXCOORD_MODES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->value;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid texcoord mode -- %s", str);
+			}
+		}
+
+		int mode = value_to<int>(*argv, convert);
+		if (mode < 0 || Rays::TEXCOORD_MODE_MAX <= mode)
+			argument_error(__FILE__, __LINE__, "invalid texcoord mode -- %d", mode);
+
+		return (Rays::TexCoordMode) mode;
+	}
+
+
+	template <> Rays::TexCoordWrap
+	value_to<Rays::TexCoordWrap> (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 (auto it = TEXCOORD_WRAPS.begin(); it != TEXCOORD_WRAPS.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->value;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid texcoord wrap -- %s", str);
+			}
+		}
+
+		int wrap = value_to<int>(*argv, convert);
+		if (wrap < 0 || Rays::TEXCOORD_WRAP_MAX <= wrap)
+			argument_error(__FILE__, __LINE__, "invalid texcoord wrap -- %d", wrap);
+
+		return (Rays::TexCoordWrap) wrap;
+	}
+
+
 }// Rucy
 
 

data/.doc/ext/rays/{noise.cpp → util.cpp}

@@ -1,4 +1,4 @@
-#include "rays/noise.h"
+#include "rays/util.h"
 #include "rays/ruby/point.h"
 #include "defs.h"
 
@@ -45,7 +45,7 @@ VALUE simplex(VALUE self)
 
 
 void
-Init_rays_noise ()
+Init_rays_util ()
 {
 	Module mRays = rb_define_module("Rays");
 	rb_define_singleton_method(mRays, "perlin", RUBY_METHOD_FUNC(perlin), -1);

data/ChangeLog.md

@@ -1,6 +1,52 @@
 # rays ChangeLog
 
 
+## [v0.1.49] - 2024-02-07
+
+- Add point(), line_height(), and line_height!() to Painter
+- Add translate!(), scale!(), rotate!(), transpose(), and transpose!() to Rays::Matrix class
+- Add ortho(), perspective(), and look_at() to Rays::Matrix
+- Add Color#to_hsv
+- Add get_hsv()
+- hsb as an alias for hsv
+
+- Font::get_width() handles multiple lines if there is a newline character
+- Painter::curve() and Painter::bezier() use nsegment state
+- Polygon.curve() and Polygon.bezier() can take 'nsegment' parameter
+- When updating a texture with a bitmap, the texture is reused, not created anew
+- If the texture is bound to the frame buffer, replacing it with a new texture will cause the drawing target to shift
+- Set the modified flag on the texture in the framebuffer at the beginning of painting
+- Set modified flag for bitmap if needed
+- Throw error on conflict between bitmap and texture
+
+- Fix a bug that dust was drawn on the right edge when drawing text
+- Fix that Painter#point ignores stroke_cap
+- Fix Matrix::to_a order
+
+
+## [v0.1.48] - 2024-01-08
+
+- Add Bitmap#pixels=
+- Add Font#dup, Font#size=, Font.families, and Font.load
+- Add Polyline#with
+- Add Painter#texture, Painter#texcoord_mode,  and Painter#texcoord_wrap
+
+- Delete Polygon::Line because it was merged into Polyline
+
+- Polygon and Polyline can take colors and texcoords for each vertex
+- Polyline.new can take 'hole' parameter
+- 'polygonA + polygonB' means Polygon.new(*polygonA.to_a, *polygonB.to_a)
+- Polygon with only holes raises an ArgumentError
+- Image delegates 'pixels' accessors to Bitmap
+- Use GL_CLAMP_TO_EDGE for texturing
+- Refine Point#inspect(), Color#inspect(), and Font#inspect()
+- default_font() -> get_default_font()
+- rays/include/noise.h -> rays/include/util.h
+
+- Fix Polygon.bezier() returns broken object
+- Fix get_pixels() does not work with float colors
+
+
 ## [v0.1.47] - 2023-12-09
 
 - Add Polygon's singleton methods: points(), lines(), triangles(), triangle_strip(), triangle_fan(), quads(), quad_strip()

data/VERSION

@@ -1 +1 @@
-0.1.47
+0.1.49