rays 0.1.6 → 0.1.7

data/ext/rays/bitmap.cpp

@@ -2,7 +2,11 @@
 
 
 #include <rucy.h>
+#include "rays/exception.h"
+#include "rays/ruby/color_space.h"
+#include "rays/ruby/color.h"
 #include "rays/ruby/font.h"
+#include "rays/ruby/texture.h"
 #include "defs.h"
 
 
@@ -10,76 +14,55 @@ using namespace Rucy;
 
 using Rays::uchar;
 using Rays::ushort;
-using Rays::ulong;
+using Rays::uint;
 using Rays::coord;
 
 
 static Class cBitmap;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Bitmap, cBitmap)
 
-namespace Rays
-{
-
-
-	Class
-	bitmap_class ()
-	{
-		return cBitmap;
-	}
+#define THIS  to<Rays::Bitmap*>(self)
 
-
-}// Rays
+#define CHECK RUCY_CHECK_OBJECT(Rays::Bitmap, cBitmap, self)
 
 
-namespace Rucy
+static
+RUCY_DEF_ALLOC(alloc, klass)
 {
-
-
-	Value
-	value (const Rays::Bitmap& obj)
-	{
-		return new_type(cBitmap, new Rays::Bitmap(obj));
-	}
-
-	Value
-	value (const Rays::Bitmap* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
-
-#define THIS to<Rays::Bitmap*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(self, Rays::Bitmap, cBitmap)
-
+	return new_type<Rays::Bitmap>(klass);
+}
+RUCY_END
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF1(initialize_copy, obj)
 {
-	return new_type<Rays::Bitmap>(klass);
+	RUCY_CHECK_OBJ(Rays::Bitmap, cBitmap, self);
+
+	*THIS = to<Rays::Bitmap&>(obj).copy();
+	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF3(setup, width, height, colorspace)
+RUCY_DEF3(setup, width, height, color_space)
 {
-	RUCY_CHECK_OBJ(self, Rays::Bitmap, cBitmap);
-	*THIS = Rays::Bitmap(
-		to<int>(width), to<int>(height),
-		(Rays::ColorSpaceType) to<uint>(colorspace));
+	RUCY_CHECK_OBJ(Rays::Bitmap, cBitmap, self);
+
+	Rays::ColorSpace* cs = to<Rays::ColorSpace*>(color_space);
+	if (!cs)
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Rays::Bitmap(to<int>(width), to<int>(height), *cs);
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(draw_string)
+RUCY_DEFN(draw_string)
 {
 	CHECK;
-	if (argc < 1 || 4 < argc)
-		arg_count_error("Bitmap#draw_string", argc, 1, 2, 3, 4);
+	check_arg_count(__FILE__, __LINE__, "Bitmap#draw_string", argc, 1, 2, 3, 4);
 
 	const char* str        = to<const char*>(argv[0]);
 	coord x                = argc >= 2 ? to<coord>(argv[1]) : 0;
@@ -87,245 +70,89 @@ RUBY_DEFN(draw_string)
 	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());
-	}
-
+	Rays::draw_string(THIS, str, x, y, *font);
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(width)
+RUCY_DEF0(width)
 {
 	CHECK;
 
 	return value(THIS->width());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(height)
+RUCY_DEF0(height)
 {
 	CHECK;
 
 	return value(THIS->height());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(color_space)
+RUCY_DEF0(color_space)
 {
 	CHECK;
 
-	return value(THIS->color_space().type());
+	return value(THIS->color_space());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(at, x, y)
+RUCY_DEF2(at, x, y)
 {
 	CHECK;
 
-	int xx = x.as_i(), yy = y.as_i();
-	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())
-	{
-		float* p = (float*) pixel;
-		switch (THIS->color_space().type())
-		{
-			case Rays::GRAY_float:
-				array.push(p[0]);
-				break;
-			case Rays::RGB_float:
-				array.push(p[0]).push(p[1]).push(p[2]);
-				break;
-			case Rays::RGBA_float:
-				array.push(p[0]).push(p[1]).push(p[2]).push(p[3]);
-				break;
-			case Rays::ARGB_float:
-				array.push(p[1]).push(p[2]).push(p[3]).push(p[0]);
-				break;
-			case Rays::BGR_float:
-				array.push(p[2]).push(p[1]).push(p[0]);
-				break;
-			case Rays::BGRA_float:
-				array.push(p[2]).push(p[1]).push(p[0]).push(p[3]);
-				break;
-			case Rays::ABGR_float:
-				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
-				break;
-			default:
-				rays_error("Bitmap#at: unknown color space");
-		}
-	}
-	else
-	{
-		uchar* p = (uchar*) pixel;
-		switch (THIS->color_space().type())
-		{
-			case Rays::GRAY_8:
-				array.push(*(uchar*) pixel);
-				break;
-			case Rays::GRAY_16:
-				array.push(*(ushort*) pixel);
-				break;
-			case Rays::GRAY_32:
-				array.push(*(ulong*) pixel);
-				break;
-			case Rays::RGB_888:
-				array.push(p[0]).push(p[1]).push(p[2]);
-				break;
-			case Rays::RGBA_8888:
-				array.push(p[0]).push(p[1]).push(p[2]).push(p[3]);
-				break;
-			case Rays::ARGB_8888:
-				array.push(p[1]).push(p[2]).push(p[3]).push(p[0]);
-				break;
-			case Rays::RGBX_8888:
-				array.push(p[0]).push(p[1]).push(p[2]);
-				break;
-			case Rays::XRGB_8888:
-				array.push(p[1]).push(p[2]).push(p[3]);
-				break;
-			case Rays::BGR_888:
-				array.push(p[2]).push(p[1]).push(p[0]);
-				break;
-			case Rays::BGRA_8888:
-				array.push(p[2]).push(p[1]).push(p[0]).push(p[3]);
-				break;
-			case Rays::ABGR_8888:
-				array.push(p[3]).push(p[2]).push(p[1]).push(p[0]);
-				break;
-			case Rays::BGRX_8888:
-				array.push(p[2]).push(p[1]).push(p[0]);
-				break;
-			case Rays::XBGR_8888:
-				array.push(p[3]).push(p[2]).push(p[1]);
-				break;
-			default:
-				rays_error("Bitmap#at: unknown color space");
-		}
-	}
-
-	return array;
+	return value(Rays::Color(THIS->at<void>(x.as_i(), y.as_i()), THIS->color_space()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF3(assign_at, x, y, color)
+RUCY_DEF3(set_at, x, y, color)
 {
 	CHECK;
 
-	int xx = x.as_i(), yy = y.as_i();
-	void* pixel = THIS->at<void*>(xx, yy);
-	if (!pixel) rays_error("Bitmap#assign_at(%d, %d) failed.", xx, yy);
+	Rays::Color* col = to<Rays::Color*>(color);
+	if (!col)
+		argument_error(__FILE__, __LINE__);
 
-	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())
-		{
-			#define C(n) ((float) color[n].as_f())
-			case Rays::GRAY_float:
-				p[0] = C(0);
-				break;
-			case Rays::RGB_float:
-				p[0] = C(0); p[1] = C(1); p[2] = C(2);
-				break;
-			case Rays::RGBA_float:
-				p[0] = C(0); p[1] = C(1); p[2] = C(2); p[3] = C(3);
-				break;
-			case Rays::ARGB_float:
-				p[0] = C(1); p[1] = C(2); p[2] = C(3); p[3] = C(0);
-				break;
-			case Rays::BGR_float:
-				p[0] = C(2); p[1] = C(1); p[2] = C(0);
-				break;
-			case Rays::BGRA_float:
-				p[0] = C(2); p[1] = C(1); p[2] = C(0); p[3] = C(3);
-				break;
-			case Rays::ABGR_float:
-				p[0] = C(3); p[1] = C(2); p[2] = C(1); p[3] = C(0);
-				break;
-			#undef C
-			default:
-				rays_error("Bitmap#at: unknown color space");
-		}
-	}
-	else
-	{
-		uchar* p = (uchar*) pixel;
-		switch (THIS->color_space().type())
-		{
-			#define C(n) ((uchar) color[n].as_i())
-			case Rays::GRAY_8:
-				*(uchar*) pixel = C(0);
-				break;
-			case Rays::GRAY_16:
-				*(ushort*) pixel = C(0);
-				break;
-			case Rays::GRAY_32:
-				*(ulong*) pixel = C(0);
-				break;
-			case Rays::RGB_888:
-				p[0] = C(0); p[1] = C(1); p[2] = C(2);
-				break;
-			case Rays::RGBA_8888:
-				p[0] = C(0); p[1] = C(1); p[2] = C(2); p[3] = C(3);
-				break;
-			case Rays::ARGB_8888:
-				p[0] = C(1); p[1] = C(2); p[2] = C(3); p[3] = C(0);
-				break;
-			case Rays::RGBX_8888:
-				p[0] = C(0); p[1] = C(1); p[2] = C(2);
-				break;
-			case Rays::XRGB_8888:
-				p[0] = C(1); p[1] = C(2); p[2] = C(3);
-				break;
-			case Rays::BGR_888:
-				p[0] = C(2); p[1] = C(1); p[2] = C(0);
-				break;
-			case Rays::BGRA_8888:
-				p[0] = C(2); p[1] = C(1); p[2] = C(0); p[3] = C(3);
-				break;
-			case Rays::ABGR_8888:
-				p[0] = C(3); p[1] = C(2); p[2] = C(1); p[3] = C(0);
-				break;
-			case Rays::BGRX_8888:
-				p[0] = C(2); p[1] = C(1); p[2] = C(0);
-				break;
-			case Rays::XBGR_8888:
-				p[0] = C(3); p[1] = C(2); p[2] = C(1);
-				break;
-			#undef C
-			default:
-				rays_error("Bitmap#at: unknown color space");
-		}
-	}
+	col->get(THIS->at<void>(x.as_i(), y.as_i()), THIS->color_space());
 
 	return color;
 }
-RUBY_END
+RUCY_END
 
+static
+RUCY_DEFN(to_texture)
+{
+	CHECK;
+
+	bool alpha_only = (argc >= 1) ? to<bool>(argv[0]) : false;
+	return value(Rays::Texture(*THIS, alpha_only));
+}
+RUCY_END
 
 static
-RUBY_DEF1(load, path)
+RUCY_DEF1(save, path)
 {
-	Rays::Bitmap bmp;
-	if (!Rays::load_bitmap(&bmp, path.c_str()))
-		rays_error("Bitmap.load('%s') failed.", path.c_str());
+	CHECK;
+
+	Rays::save_bitmap(*THIS, path.c_str());
+	return self;
+}
+RUCY_END
 
-	return value(bmp);
+
+static
+RUCY_DEF1(load, path)
+{
+	return value(Rays::load_bitmap(path.c_str()));
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -333,18 +160,31 @@ Init_bitmap ()
 {
 	Module mRays = define_module("Rays");
 
-	mRays.define_const("GRAY", Rays::GRAY);
-	mRays.define_const("RGB",  Rays::RGB);
-	mRays.define_const("RGBA", Rays::RGBA);
-
 	cBitmap = mRays.define_class("Bitmap");
 	cBitmap.define_alloc_func(alloc);
+	cBitmap.define_private_method("initialize_copy", initialize_copy);
 	cBitmap.define_private_method("setup", setup);
 	cBitmap.define_method("draw_string", draw_string);
 	cBitmap.define_method("width", width);
 	cBitmap.define_method("height", height);
 	cBitmap.define_method("color_space", color_space);
 	cBitmap.define_method("[]", at);
-	cBitmap.define_method("[]=", assign_at);
+	cBitmap.define_method("set_at", set_at);
+	cBitmap.define_method("to_texture", to_texture);
+	cBitmap.define_method("save", save);
 	cBitmap.define_function("load", load);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	bitmap_class ()
+	{
+		return cBitmap;
+	}
+
+
+}// Rays