rays 0.1.46 → 0.1.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4232c9c8e77b4d6e9d3a60a283934c268baade87875d0bf7ce2f6ee7f4e53aa8
-  data.tar.gz: d8931fbc4a860a97425e56f716ac995ff5c51e5b7c2cc4bca160eda184007706
+  metadata.gz: 0da22dbb538f841d5c21371e0b0749479467b1c0746bbd459118b649c66678e0
+  data.tar.gz: f55580763f45ce98198c59f6fe9ed86ac21f64aba8d16cf8b002923650c9b703
 SHA512:
-  metadata.gz: 735f49b98489b5a3da4bacb0e501b28410aa67954875185eef2515eaa90112573bee44762bbfd9d1489eaeae06f8543fb02a945d177e901eb5f33c5c90811d35
-  data.tar.gz: ba69b4be7967c303fb8cf0cee65f804be444e7ce426c3d2ea0e337fd8a86837ac95e6011d847c238f8a6c520a81a924c8783b1476040c311080e6ac4f4b72ba8
+  metadata.gz: d74814adfebbb7b9f0449abeebab017a475c76ae48a61c4f2f066e12a376fe52279db08cb6a27c3a3cadd26ae9179ce7fb204c59eff8440f9569121711d3a26e
+  data.tar.gz: 74e423c7faa9747f34e7e37737882fffce493e127fb5870a7e6a2fb0d4cc6f122a3cac43d9afa96373a6ce69f147198007db9d958a93d478cd4d5f1a9441053b

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

@@ -66,6 +66,503 @@ 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)
+{
+	return value(
+		((uint) r) << 16 |
+		((uint) g) << 8  |
+		((uint) b));
+}
+
+static inline Value
+to_argb_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:
+		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_argb_value(p[0], p[1], p[2], p[3]));
+			}
+			break;
+
+		case Rays::ARGB_8888:
+		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_argb_value(p[1], p[2], p[3], p[0]));
+			}
+			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:
+		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_argb_value(p[2], p[1], p[0], p[3]));
+			}
+			break;
+
+		case Rays::ABGR_8888:
+		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_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<float>(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<float>(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<float>(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<float>(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<float>(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<float>(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 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]);
+}
+
 static
 VALUE set_at(VALUE self, VALUE x, VALUE y, VALUE color)
 {
@@ -105,6 +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(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)
@@ -24,9 +22,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
@@ -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())