rays 0.1.2 → 0.1.3

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

@@ -0,0 +1,318 @@
+#include "rays/ruby/bitmap.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::uchar;
+using Rays::ushort;
+using Rays::ulong;
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	static Class cBitmap;
+
+	Class
+	bitmap_class ()
+	{
+		return cBitmap;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Bitmap& bitmap)
+	{
+		return new_type<Rays::Bitmap>(
+			Rays::bitmap_class(), new Rays::Bitmap(bitmap));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Bitmap*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Bitmap, Rays::bitmap_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Bitmap>(klass, new Rays::Bitmap);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK_OBJ(self, Rays::Bitmap, Rays::bitmap_class());
+	if (argc != 0 && argc != 2 && argc != 3)
+		arg_count_error("Bitmap#initialize", argc, 0, 2, 3);
+
+	if (argc == 0) return self;
+
+	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::Bitmap(width, height, (Rays::ColorSpaceType) colorspace);
+	return self;
+}
+
+static
+VALUE width(VALUE self)
+{
+	CHECK;
+
+	return value(this->width());
+}
+
+static
+VALUE height(VALUE self)
+{
+	CHECK;
+
+	return value(this->height());
+}
+
+static
+VALUE color_space(VALUE self)
+{
+	CHECK;
+
+	return value(this->color_space().type());
+}
+
+static
+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);
+
+	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:
+				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:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+
+	return array;
+}
+
+static
+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);
+
+	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:
+				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:
+				error("Bitmap#at: unknown color space");
+		}
+	}
+
+	return color;
+}
+
+
+static
+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());
+
+	return value(bmp);
+}
+
+
+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);
+}

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

@@ -0,0 +1,124 @@
+#include "rays/ruby/font.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	static Class cFont;
+
+	Class
+	font_class ()
+	{
+		return cFont;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Font& font)
+	{
+		return new_type<Rays::Font>(
+			Rays::font_class(), new Rays::Font(font));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Font*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Font, Rays::font_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Font>(klass, new Rays::Font);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK_OBJ(self, Rays::Font, Rays::font_class());
+	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);
+
+	return self;
+}
+
+static
+VALUE name(VALUE self)
+{
+	CHECK;
+
+	return value(this->name().c_str());
+}
+
+static
+VALUE size(VALUE self)
+{
+	CHECK;
+
+	return value(this->size());
+}
+
+static
+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());
+
+	return value(width);
+}
+
+static
+VALUE height(VALUE self)
+{
+	CHECK;
+
+	coord height = 0;
+	if (!this->get_extent(NULL, &height, NULL))
+		error("Font#height() failed.");
+
+	return value(height);
+}
+
+
+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);
+}

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

@@ -0,0 +1,163 @@
+#include "rays/ruby/image.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/bitmap.h>
+#include <rays/ruby/texture.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	static Class cImage;
+
+	Class
+	image_class ()
+	{
+		return cImage;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Image& image)
+	{
+		return new_type<Rays::Image>(
+			Rays::image_class(), new Rays::Image(image));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Image*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Image, Rays::image_class())
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Image>(klass, new Rays::Image);
+}
+
+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);
+
+	if (argc == 0) return self;
+
+	if (argv[1].is_kind_of(Rays::bitmap_class()))
+	{
+		if (argc != 1 && argc != 2)
+			arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+
+		const Rays::Bitmap& bitmap = *to<Rays::Bitmap*>(argv[1]);
+		bool alphaonly = (argc == 2) ? to<bool>(argv[2]) : 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);
+	}
+
+	return self;
+}
+
+static
+VALUE width(VALUE self)
+{
+	CHECK;
+
+	return value(this->width());
+}
+
+static
+VALUE height(VALUE self)
+{
+	CHECK;
+
+	return value(this->height());
+}
+
+static
+VALUE color_space(VALUE self)
+{
+	CHECK;
+
+	return value(this->color_space().type());
+}
+
+static
+VALUE bitmap(VALUE self)
+{
+	CHECK;
+
+	return value(this->bitmap());
+}
+
+static
+VALUE texture(VALUE self)
+{
+	CHECK;
+
+	return value(this->texture());
+}
+
+
+static
+VALUE load(VALUE self)
+{
+	if (argc != 1 && argc != 2) arg_count_error("Image.load", argc, 1, 2);
+
+	Rays::String path = argv[0].c_str();
+	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+
+	Rays::Image img;
+	if (!Rays::load_image(&img, path.c_str(), alphaonly))
+	{
+		error(
+			"Image.load('%s', %s) failed.",
+			path.c_str(), alphaonly ? "true" : "false");
+	}
+
+	return value(img);
+}
+
+
+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);
+}