rays 0.1.3 → 0.1.4

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

@@ -2,6 +2,7 @@
 
 
 #include <rucy.h>
+#include "rays/ruby/font.h"
 #include "defs.h"
 
 
@@ -13,12 +14,13 @@ using Rays::ulong;
 using Rays::coord;
 
 
+static Class cBitmap;
+
+
 namespace Rays
 {
 
 
-	static Class cBitmap;
-
 	Class
 	bitmap_class ()
 	{
@@ -34,41 +36,62 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Bitmap& bitmap)
+	value (const Rays::Bitmap& obj)
+	{
+		return new_type(cBitmap, new Rays::Bitmap(obj));
+	}
+
+	Value
+	value (const Rays::Bitmap* obj)
 	{
-		return new_type<Rays::Bitmap>(
-			Rays::bitmap_class(), new Rays::Bitmap(bitmap));
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Bitmap*>(self)
+#define THIS to<Rays::Bitmap*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Bitmap, Rays::bitmap_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Bitmap, cBitmap)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<Rays::Bitmap>(klass, new Rays::Bitmap);
+	return new_type<Rays::Bitmap>(klass);
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE setup(VALUE self, VALUE width, VALUE height, VALUE colorspace)
 {
-	CHECK_OBJ(self, Rays::Bitmap, Rays::bitmap_class());
-	if (argc != 0 && argc != 2 && argc != 3)
-		arg_count_error("Bitmap#initialize", argc, 0, 2, 3);
+	RUCY_CHECK_OBJ(self, Rays::Bitmap, cBitmap);
+	*THIS = Rays::Bitmap(
+		to<int>(width), to<int>(height),
+		(Rays::ColorSpaceType) to<uint>(colorspace));
+	return self;
+}
 
-	if (argc == 0) return self;
+static
+VALUE draw_string(VALUE self)
+{
+	CHECK;
+	if (argc < 1 || 4 < argc)
+		arg_count_error("Bitmap#draw_string", argc, 1, 2, 3, 4);
 
-	int width  = to<int>(argv[0]);
-	int height = to<int>(argv[1]);
-	uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
+	const char* str        = to<const char*>(argv[0]);
+	coord x                = argc >= 2 ? to<coord>(argv[1]) : 0;
+	coord y                = argc >= 3 ? to<coord>(argv[2]) : 0;
+	const Rays::Font* font = argc >= 4
+		? to<Rays::Font*>(argv[3]) : &Rays::default_font();
+
+	if (!Rays::draw_string(THIS, str, x, y, *font))
+	{
+		rays_error(
+			"Bitmap#draw_string('%s', %f, %f, %s) failed.",
+			str, x, y, font->name().c_str());
+	}
 
-	*this = Rays::Bitmap(width, height, (Rays::ColorSpaceType) colorspace);
 	return self;
 }
 
@@ -77,7 +100,7 @@ VALUE width(VALUE self)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 
 static
@@ -85,7 +108,7 @@ VALUE height(VALUE self)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
 }
 
 static
@@ -93,7 +116,7 @@ VALUE color_space(VALUE self)
 {
 	CHECK;
 
-	return value(this->color_space().type());
+	return value(THIS->color_space().type());
 }
 
 static
@@ -102,14 +125,14 @@ VALUE at(VALUE self, VALUE x, VALUE y)
 	CHECK;
 
 	int xx = x.as_i(), yy = y.as_i();
-	void* pixel = this->at<void*>(xx, yy);
-	if (!pixel) error("Bitmap#at(%d, %d) failed.", xx, yy);
+	void* pixel = THIS->at<void*>(xx, yy);
+	if (!pixel) rays_error("Bitmap#at(%d, %d) failed.", xx, yy);
 
-	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
-	if (this->color_space().is_float())
+	Value array(THIS->color_space().Bpp() / THIS->color_space().Bpc(), NULL);
+	if (THIS->color_space().is_float())
 	{
 		float* p = (float*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			case Rays::GRAY_float:
 				array.push(p[0]);
@@ -133,13 +156,13 @@ VALUE at(VALUE self, VALUE x, VALUE y)
 				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
 				break;
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 	else
 	{
 		uchar* p = (uchar*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			case Rays::GRAY_8:
 				array.push(*(uchar*) pixel);
@@ -181,7 +204,7 @@ VALUE at(VALUE self, VALUE x, VALUE y)
 				array.push(p[3]).push(p[2]).push(p[1]);
 				break;
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 
@@ -194,14 +217,14 @@ VALUE assign_at(VALUE self, VALUE x, VALUE y, VALUE color)
 	CHECK;
 
 	int xx = x.as_i(), yy = y.as_i();
-	void* pixel = this->at<void*>(xx, yy);
-	if (!pixel) error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
+	void* pixel = THIS->at<void*>(xx, yy);
+	if (!pixel) rays_error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
 
-	Value array(this->color_space().Bpp() / this->color_space().Bpc(), NULL);
-	if (this->color_space().is_float())
+	Value array(THIS->color_space().Bpp() / THIS->color_space().Bpc(), NULL);
+	if (THIS->color_space().is_float())
 	{
 		float* p = (float*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			#define C(n) ((float) color[n].as_f())
 			case Rays::GRAY_float:
@@ -227,13 +250,13 @@ VALUE assign_at(VALUE self, VALUE x, VALUE y, VALUE color)
 				break;
 			#undef C
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 	else
 	{
 		uchar* p = (uchar*) pixel;
-		switch (this->color_space().type())
+		switch (THIS->color_space().type())
 		{
 			#define C(n) ((uchar) color[n].as_i())
 			case Rays::GRAY_8:
@@ -277,7 +300,7 @@ VALUE assign_at(VALUE self, VALUE x, VALUE y, VALUE color)
 				break;
 			#undef C
 			default:
-				error("Bitmap#at: unknown color space");
+				rays_error("Bitmap#at: unknown color space");
 		}
 	}
 
@@ -290,7 +313,7 @@ VALUE load(VALUE self, VALUE path)
 {
 	Rays::Bitmap bmp;
 	if (!Rays::load_bitmap(&bmp, path.c_str()))
-		error("Bitmap.load('%s') failed.", path.c_str());
+		rays_error("Bitmap.load('%s') failed.", path.c_str());
 
 	return value(bmp);
 }
@@ -299,20 +322,20 @@ VALUE load(VALUE self, VALUE path)
 void
 Init_bitmap ()
 {
-	Module m = rb_define_module("Rays");
-
-	m.define_const("RGB", Rays::RGB);
-	m.define_const("RGBA", Rays::RGBA);
-
-	Class c = rb_define_class_under(m, "Bitmap", rb_cObject);
-	Rays::cBitmap = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
-	rb_define_method(c, "width", RUBY_METHOD_FUNC(width), 0);
-	rb_define_method(c, "height", RUBY_METHOD_FUNC(height), 0);
-	rb_define_method(c, "color_space", RUBY_METHOD_FUNC(color_space), 0);
-	c.define_method("[]", at);
-	c.define_method("[]=", assign_at);
-	rb_define_function(c, "load", RUBY_METHOD_FUNC(load), 1);
+	Module mRays = rb_define_module("Rays");
+
+	mRays.define_const("GRAY", Rays::GRAY);
+	mRays.define_const("RGB",  Rays::RGB);
+	mRays.define_const("RGBA", Rays::RGBA);
+
+	cBitmap = rb_define_class_under(mRays, "Bitmap", rb_cObject);
+	rb_define_alloc_func(cBitmap, alloc);
+	rb_define_private_method(cBitmap, "setup", RUBY_METHOD_FUNC(setup), 3);
+	rb_define_method(cBitmap, "draw_string", RUBY_METHOD_FUNC(draw_string), -1);
+	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);
+	cBitmap.define_method("[]", at);
+	cBitmap.define_method("[]=", assign_at);
+	rb_define_function(cBitmap, "load", RUBY_METHOD_FUNC(load), 1);
 }

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

@@ -10,12 +10,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cFont;
+
+
 namespace Rays
 {
 
 
-	static Class cFont;
-
 	Class
 	font_class ()
 	{
@@ -31,37 +32,42 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Font& font)
+	value (const Rays::Font& obj)
 	{
-		return new_type<Rays::Font>(
-			Rays::font_class(), new Rays::Font(font));
+		return new_type(cFont, new Rays::Font(obj));
+	}
+
+	Value
+	value (const Rays::Font* obj)
+	{
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Font*>(self)
+#define THIS to<Rays::Font*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Font, Rays::font_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Font, cFont)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<Rays::Font>(klass, new Rays::Font);
+	return new_type<Rays::Font>(klass);
 }
 
 static
 VALUE initialize(VALUE self)
 {
-	CHECK_OBJ(self, Rays::Font, Rays::font_class());
+	RUCY_CHECK_OBJ(self, Rays::Font, cFont);
 	if (argc < 0 || 2 < argc)
 		arg_count_error("Font#initialize", argc, 0, 1, 2);
 
 	const char* name = (argc >= 1) ? argv[0].c_str()    : NULL;
 	float size       = (argc >= 2) ? to<float>(argv[1]) : 0;
-	*this = Rays::Font(name, size);
+	*THIS = Rays::Font(name, size);
 
 	return self;
 }
@@ -71,7 +77,7 @@ VALUE name(VALUE self)
 {
 	CHECK;
 
-	return value(this->name().c_str());
+	return value(THIS->name().c_str());
 }
 
 static
@@ -79,7 +85,7 @@ VALUE size(VALUE self)
 {
 	CHECK;
 
-	return value(this->size());
+	return value(THIS->size());
 }
 
 static
@@ -88,8 +94,8 @@ VALUE width(VALUE self, VALUE str)
 	CHECK;
 
 	coord width = 0;
-	if (!this->get_extent(&width, NULL, str.c_str()))
-		error("Font#width(%s) failed.", str.inspect().c_str());
+	if (!THIS->get_width(&width, str.c_str()))
+		rays_error("Font#width(%s) failed.", str.inspect().c_str());
 
 	return value(width);
 }
@@ -100,8 +106,8 @@ VALUE height(VALUE self)
 	CHECK;
 
 	coord height = 0;
-	if (!this->get_extent(NULL, &height, NULL))
-		error("Font#height() failed.");
+	if (!THIS->get_height(&height))
+		rays_error("Font#height() failed.");
 
 	return value(height);
 }
@@ -110,15 +116,13 @@ VALUE height(VALUE self)
 void
 Init_font ()
 {
-	Module m = rb_define_module("Rays");
-
-	Class c = rb_define_class_under(m, "Font", rb_cObject);
-	Rays::cFont = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
-	rb_define_method(c, "name", RUBY_METHOD_FUNC(name), 0);
-	rb_define_method(c, "size", RUBY_METHOD_FUNC(size), 0);
-	rb_define_method(c, "width", RUBY_METHOD_FUNC(width), 1);
-	rb_define_method(c, "height", RUBY_METHOD_FUNC(height), 0);
+	Module mRays = rb_define_module("Rays");
+
+	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_method(cFont, "name", RUBY_METHOD_FUNC(name), 0);
+	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);
 }

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

@@ -12,12 +12,13 @@ using namespace Rucy;
 using Rays::coord;
 
 
+static Class cImage;
+
+
 namespace Rays
 {
 
 
-	static Class cImage;
-
 	Class
 	image_class ()
 	{
@@ -33,51 +34,59 @@ namespace Rucy
 
 
 	Value
-	value (const Rays::Image& image)
+	value (const Rays::Image& obj)
 	{
-		return new_type<Rays::Image>(
-			Rays::image_class(), new Rays::Image(image));
+		return new_type(cImage, new Rays::Image(obj));
+	}
+
+	Value
+	value (const Rays::Image* obj)
+	{
+		return obj ? value(*obj) : nil();
 	}
 
 
 }// Rucy
 
 
-#define this to<Rays::Image*>(self)
+#define THIS to<Rays::Image*>(self)
 
-#define CHECK CHECK_OBJECT(self, Rays::Image, Rays::image_class())
+#define CHECK RUCY_CHECK_OBJECT(self, Rays::Image, cImage)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return new_type<Rays::Image>(klass, new Rays::Image);
+	return new_type<Rays::Image>(klass);
 }
 
 static
 VALUE initialize(VALUE self)
 {
-	CHECK_OBJ(self, Rays::Image, Rays::image_class());
-	if (argc != 0 && argc != 1 && argc != 2 && argc != 3)
-		arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+	RUCY_CHECK_OBJ(self, Rays::Image, cImage);
+
+	if (argc < 1 || 3 < argc)
+		arg_count_error("Image#initialize", argc, 1, 2, 3);
 
 	if (argc == 0) return self;
 
-	if (argv[1].is_kind_of(Rays::bitmap_class()))
+	if (argv[0].is_kind_of(Rays::bitmap_class()))
 	{
-		if (argc != 1 && argc != 2)
-			arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+		if (argc < 1 || 2 < argc)
+			arg_count_error("Image#initialize", argc, 1, 2);
+
+		const Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
+		if (!bitmap) argument_error();
 
-		const Rays::Bitmap& bitmap = *to<Rays::Bitmap*>(argv[1]);
-		bool alphaonly = (argc == 2) ? to<bool>(argv[2]) : false;
-		*this = Rays::Image(bitmap, alphaonly);
+		bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+		*THIS = Rays::Image(*bitmap, alphaonly);
 	}
 	else
 	{
 		int width  = to<int>(argv[0]);
 		int height = to<int>(argv[1]);
 		uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
-		*this = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
+		*THIS = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
 	}
 
 	return self;
@@ -88,7 +97,7 @@ VALUE width(VALUE self)
 {
 	CHECK;
 
-	return value(this->width());
+	return value(THIS->width());
 }
 
 static
@@ -96,7 +105,7 @@ VALUE height(VALUE self)
 {
 	CHECK;
 
-	return value(this->height());
+	return value(THIS->height());
 }
 
 static
@@ -104,7 +113,7 @@ VALUE color_space(VALUE self)
 {
 	CHECK;
 
-	return value(this->color_space().type());
+	return value(THIS->color_space().type());
 }
 
 static
@@ -112,7 +121,7 @@ VALUE bitmap(VALUE self)
 {
 	CHECK;
 
-	return value(this->bitmap());
+	return value(THIS->bitmap());
 }
 
 static
@@ -120,7 +129,7 @@ VALUE texture(VALUE self)
 {
 	CHECK;
 
-	return value(this->texture());
+	return value(THIS->texture());
 }
 
 
@@ -135,7 +144,7 @@ VALUE load(VALUE self)
 	Rays::Image img;
 	if (!Rays::load_image(&img, path.c_str(), alphaonly))
 	{
-		error(
+		rays_error(
 			"Image.load('%s', %s) failed.",
 			path.c_str(), alphaonly ? "true" : "false");
 	}
@@ -147,17 +156,15 @@ VALUE load(VALUE self)
 void
 Init_image ()
 {
-	Module m = rb_define_module("Rays");
-
-	Class c = rb_define_class_under(m, "Image", rb_cObject);
-	Rays::cImage = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "initialize", RUBY_METHOD_FUNC(initialize), -1);
-	rb_define_method(c, "width", RUBY_METHOD_FUNC(width), 0);
-	rb_define_method(c, "height", RUBY_METHOD_FUNC(height), 0);
-	rb_define_method(c, "color_space", RUBY_METHOD_FUNC(color_space), 0);
-	rb_define_method(c, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
-	rb_define_method(c, "texture", RUBY_METHOD_FUNC(texture), 0);
-	rb_define_function(c, "load", RUBY_METHOD_FUNC(load), -1);
+	Module mRays = rb_define_module("Rays");
+
+	cImage = rb_define_class_under(mRays, "Image", rb_cObject);
+	rb_define_alloc_func(cImage, alloc);
+	rb_define_private_method(cImage, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_method(cImage, "width", RUBY_METHOD_FUNC(width), 0);
+	rb_define_method(cImage, "height", RUBY_METHOD_FUNC(height), 0);
+	rb_define_method(cImage, "color_space", RUBY_METHOD_FUNC(color_space), 0);
+	rb_define_method(cImage, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
+	rb_define_method(cImage, "texture", RUBY_METHOD_FUNC(texture), 0);
+	rb_define_function(cImage, "load", RUBY_METHOD_FUNC(load), -1);
 }