rays 0.1.47 → 0.1.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27dc838757afd56a521719cf178e3fc21accf98d1e5041c3afa8df730e998c3
-  data.tar.gz: 2745744e4dc2b11d5771c1deb94fa949c7d2d27a5903c2b0acca2887678330f2
+  metadata.gz: 0da22dbb538f841d5c21371e0b0749479467b1c0746bbd459118b649c66678e0
+  data.tar.gz: f55580763f45ce98198c59f6fe9ed86ac21f64aba8d16cf8b002923650c9b703
 SHA512:
-  metadata.gz: 400f74e76fd7c1db1edfee49d6a68fb7d721fec8dc8e247bc99bdee65b27688b7c6e96962f8a9c95aaa2a87ed045ab2fd0419478cb1aaf118098bf5fefbf7298
-  data.tar.gz: 367ed1df9b709b7c5ac7091ea1d38bbe14da8ab72d2dd049bb1c4a9acf994a45971bcef3b599525f25bdccb420ee032d8036ca58656bbc1401a2becc383a7e7a
+  metadata.gz: d74814adfebbb7b9f0449abeebab017a475c76ae48a61c4f2f066e12a376fe52279db08cb6a27c3a3cadd26ae9179ce7fb204c59eff8440f9569121711d3a26e
+  data.tar.gz: 74e423c7faa9747f34e7e37737882fffce493e127fb5870a7e6a2fb0d4cc6f122a3cac43d9afa96373a6ce69f147198007db9d958a93d478cd4d5f1a9441053b

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

@@ -66,6 +66,257 @@ VALUE color_space(VALUE self)
 	return value(THIS->color_space());
 }
 
+static void
+set_pixels (Rays::Bitmap* bmp, Value pixels)
+{
+	int w = bmp->width(), h = bmp->height();
+	const auto& cs = bmp->color_space();
+	if (pixels.size() != (w * h * (cs.is_float() ? cs.Bpp() / cs.Bpc() : 1)))
+	{
+		argument_error(
+			__FILE__, __LINE__,
+			"The size of the pixel array does not match the size of the bitmap");
+	}
+
+	const Value* array = pixels.as_array();
+
+	switch (cs.type())
+	{
+		case Rays::GRAY_8:
+		case Rays::ALPHA_8:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint8_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_16:
+		case Rays::ALPHA_16:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint16_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint16_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_32:
+		case Rays::ALPHA_32:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint32_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint32_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_float:
+		case Rays::ALPHA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<float>(*pa);
+			}
+			break;
+
+		case Rays::RGB_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 3)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 16 & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 0  & 0xff);
+				}
+			}
+			break;
+
+		case Rays::RGBA_8888:
+		case Rays::RGBX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 16 & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 0  & 0xff);
+					pb[3] = (uint8_t) (argb >> 24 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::ARGB_8888:
+		case Rays::XRGB_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 24 & 0xff);
+					pb[1] = (uint8_t) (argb >> 16 & 0xff);
+					pb[2] = (uint8_t) (argb >> 8  & 0xff);
+					pb[3] = (uint8_t) (argb >> 0  & 0xff);
+				}
+			}
+			break;
+
+		case Rays::BGR_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 3)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 0  & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 16 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::BGRA_8888:
+		case Rays::BGRX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 0  & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 16 & 0xff);
+					pb[3] = (uint8_t) (argb >> 24 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::ABGR_8888:
+		case Rays::XBGR_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 24 & 0xff);
+					pb[1] = (uint8_t) (argb >> 0  & 0xff);
+					pb[2] = (uint8_t) (argb >> 8  & 0xff);
+					pb[3] = (uint8_t) (argb >> 16 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::RGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[3 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 3, pb += 3)
+				{
+					pb[0] = to<float>(pa[0]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[2]);
+				}
+			}
+			break;
+
+		case Rays::RGBA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[0]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[2]);
+					pb[3] = to<float>(pa[3]);
+				}
+			}
+			break;
+
+		case Rays::ARGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[3]);
+					pb[1] = to<float>(pa[0]);
+					pb[2] = to<float>(pa[1]);
+					pb[3] = to<float>(pa[2]);
+				}
+			}
+			break;
+
+		case Rays::BGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[3 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 3, pb += 3)
+				{
+					pb[0] = to<float>(pa[2]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[0]);
+				}
+			}
+			break;
+
+		case Rays::BGRA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[2]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[0]);
+					pb[3] = to<float>(pa[3]);
+				}
+			}
+			break;
+
+		case Rays::ABGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[3]);
+					pb[1] = to<float>(pa[2]);
+					pb[2] = to<float>(pa[1]);
+					pb[3] = to<float>(pa[0]);
+				}
+			}
+			break;
+
+		default:
+			argument_error(__FILE__, __LINE__);
+	}
+}
+
 static inline Value
 to_rgb_value (uint8_t r, uint8_t g, uint8_t b)
 {
@@ -76,7 +327,7 @@ to_rgb_value (uint8_t r, uint8_t g, uint8_t b)
 }
 
 static inline Value
-to_rgba_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+to_argb_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
 {
 	return value(
 		((uint) a) << 24 |
@@ -89,8 +340,8 @@ 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));
 
@@ -146,38 +397,22 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 			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]));
+					pixels->push_back(to_argb_value(p[0], p[1], p[2], p[3]));
 			}
 			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]));
+					pixels->push_back(to_argb_value(p[1], p[2], p[3], p[0]));
 			}
 			break;
 
@@ -191,45 +426,29 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 			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]));
+					pixels->push_back(to_argb_value(p[2], p[1], p[0], p[3]));
 			}
 			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]));
+					pixels->push_back(to_argb_value(p[3], p[2], p[1], p[0]));
 			}
 			break;
 
 		case Rays::RGB_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 3)
 				{
 					pixels->push_back(value(p[0]));
@@ -242,7 +461,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::RGBA_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[0]));
@@ -256,7 +475,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::ARGB_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[1]));
@@ -270,7 +489,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::BGR_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 3)
 				{
 					pixels->push_back(value(p[2]));
@@ -283,7 +502,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::BGRA_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[2]));
@@ -297,7 +516,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::ABGR_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[3]));
@@ -314,10 +533,31 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 }
 
 static
-VALUE pixels(VALUE self)
+VALUE set_pixels(VALUE self, VALUE pixels)
 {
 	CHECK;
 
+	if (sizeof(VALUE) <= 4)
+	{
+		not_implemented_error(
+			__FILE__, __LINE__, "Bitmap#pixels=() does not support 32-bit platforms");
+	}
+
+	set_pixels(THIS, pixels);
+	return pixels;
+}
+
+static
+VALUE get_pixels(VALUE self)
+{
+	CHECK;
+
+	if (sizeof(VALUE) <= 4)
+	{
+		not_implemented_error(
+			__FILE__, __LINE__, "Bitmap#pixels() does not support 32-bit platforms");
+	}
+
 	std::vector<VALUE> pixels;
 	get_pixels(&pixels, *THIS);
 	return value(pixels.size(), (const Value*) &pixels[0]);
@@ -362,7 +602,8 @@ 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);
+	rb_define_method(cBitmap, "pixels=", RUBY_METHOD_FUNC(set_pixels), 1);
+	rb_define_method(cBitmap, "pixels", RUBY_METHOD_FUNC(get_pixels), 0);
 	cBitmap.define_method("[]=", set_at);
 	cBitmap.define_method("[]",  get_at);
 }

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

@@ -125,8 +125,8 @@ VALUE device_names(VALUE self)
 	auto names = Rays::get_camera_device_names();
 
 	std::vector<Value> v;
-	for (auto it = names.begin(), end = names.end(); it != end; ++it)
-		v.emplace_back(value(it->c_str()));
+	for (const auto& name : names)
+		v.emplace_back(name.c_str());
 	return value(v.size(), &v[0]);
 }
 

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

@@ -1,16 +1,14 @@
 #include "defs.h"
 
 
-#include <assert.h>
 #include "rays/ruby/bounds.h"
+#include "rays/ruby/color.h"
 #include "rays/ruby/point.h"
 
 
 void
-get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
+get_points (std::vector<Rays::Point>* points, int argc, const Value* argv)
 {
-	assert(points && argv);
-
 	points->clear();
 
 	if (argc <= 0)
@@ -37,6 +35,36 @@ get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
 	}
 }
 
+void
+get_colors (std::vector<Rays::Color>* colors, int argc, const Value* argv)
+{
+	colors->clear();
+
+	if (argc <= 0)
+		return;
+
+	if (argv[0].is_num())
+	{
+		if (argc % 3 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		colors->reserve(argc / 3);
+		for (int i = 0; i < argc; i += 3)
+		{
+			colors->emplace_back(
+				to<float>(argv[i + 0]),
+				to<float>(argv[i + 1]),
+				to<float>(argv[i + 2]));
+		}
+	}
+	else
+	{
+		colors->reserve(argc);
+		for (int i = 0; i < argc; ++i)
+			colors->emplace_back(to<Rays::Color>(argv[i]));
+	}
+}
+
 static uint
 get_nsegment (Value nsegment)
 {
@@ -53,8 +81,6 @@ void get_rect_args (
 	Value round, Value lefttop, Value righttop, Value leftbottom, Value rightbottom,
 	Value nsegment)
 {
-	assert(x && y && w && h && lt && rt && lb && rb && nseg && argv);
-
 	if (argc <= 0)
 		argument_error(__FILE__, __LINE__);
 
@@ -124,8 +150,6 @@ void get_ellipse_args (
 	Value center, Value radius, Value hole, Value angle_from, Value angle_to,
 	Value nsegment)
 {
-	assert(x && y && w && h && hole_size && from && to_ && nseg && argv);
-
 	if (argc <= 0)
 	{
 		*x = *y = *w = *h = 0;

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

@@ -28,6 +28,15 @@ VALUE initialize(VALUE self)
 	return self;
 }
 
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	RUCY_CHECK_OBJ(Rays::Font, self);
+
+	*THIS = to<Rays::Font&>(obj).dup();
+	return self;
+}
+
 static
 VALUE name(VALUE self)
 {
@@ -35,6 +44,14 @@ VALUE name(VALUE self)
 	return value(THIS->name().c_str());
 }
 
+static
+VALUE set_size(VALUE self, VALUE size)
+{
+	CHECK;
+	THIS->set_size(to<coord>(size));
+	return size;
+}
+
 static
 VALUE size(VALUE self)
 {
@@ -83,6 +100,33 @@ VALUE leading(VALUE self)
 	return value(leading);
 }
 
+static
+VALUE families(VALUE self)
+{
+	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;
+}
+
+static
+VALUE load(VALUE self)
+{
+	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));
+}
+
 
 static Class cFont;
 
@@ -94,13 +138,17 @@ Init_rays_font ()
 	cFont = rb_define_class_under(mRays, "Font", rb_cObject);
 	rb_define_alloc_func(cFont, alloc);
 	rb_define_private_method(cFont, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cFont, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cFont, "name", RUBY_METHOD_FUNC(name), 0);
+	rb_define_method(cFont, "size=", RUBY_METHOD_FUNC(set_size), 1);
 	rb_define_method(cFont, "size", RUBY_METHOD_FUNC(size), 0);
 	rb_define_method(cFont, "width", RUBY_METHOD_FUNC(width), 1);
 	rb_define_method(cFont, "height", RUBY_METHOD_FUNC(height), 0);
 	rb_define_method(cFont, "ascent", RUBY_METHOD_FUNC(ascent), 0);
 	rb_define_method(cFont, "descent", RUBY_METHOD_FUNC(descent), 0);
 	rb_define_method(cFont, "leading", RUBY_METHOD_FUNC(leading), 0);
+	rb_define_module_function(cFont, "families", RUBY_METHOD_FUNC(families), 0);
+	rb_define_module_function(cFont, "load", RUBY_METHOD_FUNC(load), -1);
 }
 
 
@@ -122,9 +170,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/.doc/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
 }