rays 0.1.6 → 0.1.7

data/.doc/ext/rays/color_space.cpp

@@ -0,0 +1,174 @@
+#include "rays/ruby/color_space.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cColorSpace;
+
+RUCY_DEFINE_VALUE_FROM_TO(Rays::ColorSpace, cColorSpace)
+
+#define THIS  to<Rays::ColorSpace*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Rays::ColorSpace, cColorSpace, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::ColorSpace>(klass);
+}
+
+static
+VALUE setup(VALUE self, VALUE type, VALUE premultiplied)
+{
+	CHECK;
+
+	*THIS = Rays::ColorSpace(
+		(Rays::ColorSpaceType) to<uint>(type),
+		to<bool>(premultiplied));
+	return self;
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Rays::ColorSpace&>(obj);
+	return self;
+}
+
+static
+VALUE type(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->type());
+}
+
+static
+VALUE is_gray(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_gray());
+}
+
+static
+VALUE is_rgb(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_rgb());
+}
+
+static
+VALUE is_bgr(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_bgr());
+}
+
+static
+VALUE is_float(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_float());
+}
+
+static
+VALUE has_alpha(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->has_alpha());
+}
+
+static
+VALUE has_skip(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->has_skip());
+}
+
+static
+VALUE is_premult(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_premult());
+}
+
+
+void
+Init_color_space ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	cColorSpace = rb_define_class_under(mRays, "ColorSpace", rb_cObject);
+	rb_define_alloc_func(cColorSpace, alloc);
+	rb_define_private_method(cColorSpace, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_private_method(cColorSpace, "setup", RUBY_METHOD_FUNC(setup), 2);
+	rb_define_method(cColorSpace, "type", RUBY_METHOD_FUNC(type), 0);
+	cColorSpace.define_method("gray?",    is_gray);
+	cColorSpace.define_method("rgb?",     is_rgb);
+	cColorSpace.define_method("bgr?",     is_bgr);
+	cColorSpace.define_method("float?",   is_float);
+	cColorSpace.define_method("alpha?",   has_alpha);
+	cColorSpace.define_method("skip?",    has_skip);
+	cColorSpace.define_method("premult?", is_premult);
+
+	cColorSpace.define_const("GRAY_8",     Rays::GRAY_8);
+	cColorSpace.define_const("GRAY_16",    Rays::GRAY_16);
+	cColorSpace.define_const("GRAY_24",    Rays::GRAY_24);
+	cColorSpace.define_const("GRAY_32",    Rays::GRAY_32);
+	cColorSpace.define_const("GRAY_float", Rays::GRAY_float);
+	cColorSpace.define_const("RGB_888",    Rays:: RGB_888);
+	cColorSpace.define_const("RGBA_8888",  Rays:: RGBA_8888);
+	cColorSpace.define_const("RGBX_8888",  Rays:: RGBX_8888);
+	cColorSpace.define_const("ARGB_8888",  Rays::ARGB_8888);
+	cColorSpace.define_const("XRGB_8888",  Rays::XRGB_8888);
+	cColorSpace.define_const("BGR_888",    Rays:: BGR_888);
+	cColorSpace.define_const("BGRA_8888",  Rays:: BGRA_8888);
+	cColorSpace.define_const("BGRX_8888",  Rays:: BGRX_8888);
+	cColorSpace.define_const("ABGR_8888",  Rays::ABGR_8888);
+	cColorSpace.define_const("XBGR_8888",  Rays::XBGR_8888);
+	cColorSpace.define_const("RGB_float",  Rays:: RGB_float);
+	cColorSpace.define_const("RGBA_float", Rays:: RGBA_float);
+	cColorSpace.define_const("ARGB_float", Rays::ARGB_float);
+	cColorSpace.define_const("BGR_float",  Rays:: BGR_float);
+	cColorSpace.define_const("BGRA_float", Rays:: BGRA_float);
+	cColorSpace.define_const("ABGR_float", Rays::ABGR_float);
+	cColorSpace.define_const("GRAY",       Rays::GRAY);
+	cColorSpace.define_const("RGB",        Rays:: RGB);
+	cColorSpace.define_const("BGR",        Rays:: BGR);
+	cColorSpace.define_const("RGBA",       Rays:: RGBA);
+	cColorSpace.define_const("RGBX",       Rays:: RGBX);
+	cColorSpace.define_const("ARGB",       Rays::ARGB);
+	cColorSpace.define_const("XRGB",       Rays::XRGB);
+	cColorSpace.define_const("BGRA",       Rays:: BGRA);
+	cColorSpace.define_const("BGRX",       Rays:: BGRX);
+	cColorSpace.define_const("ABGR",       Rays::ABGR);
+	cColorSpace.define_const("XBGR",       Rays::XBGR);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	color_space_class ()
+	{
+		return cColorSpace;
+	}
+
+
+}// Rays

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

@@ -12,44 +12,11 @@ using Rays::coord;
 
 static Class cFont;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Font, cFont)
 
-namespace Rays
-{
-
-
-	Class
-	font_class ()
-	{
-		return cFont;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Font& obj)
-	{
-		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 RUCY_CHECK_OBJECT(self, Rays::Font, cFont)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Font, cFont, self)
 
 
 static
@@ -61,9 +28,8 @@ VALUE alloc(VALUE klass)
 static
 VALUE initialize(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Font, cFont);
-	if (argc < 0 || 2 < argc)
-		arg_count_error("Font#initialize", argc, 0, 1, 2);
+	RUCY_CHECK_OBJ(Rays::Font, cFont, self);
+	check_arg_count(__FILE__, __LINE__, "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;
@@ -72,11 +38,19 @@ VALUE initialize(VALUE self)
 	return self;
 }
 
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	RUCY_CHECK_OBJ(Rays::Font, cFont, self);
+
+	*THIS = to<Rays::Font&>(obj).copy();
+	return self;
+}
+
 static
 VALUE name(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->name().c_str());
 }
 
@@ -84,7 +58,6 @@ static
 VALUE size(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->size());
 }
 
@@ -92,24 +65,14 @@ static
 VALUE width(VALUE self, VALUE str)
 {
 	CHECK;
-
-	coord width = 0;
-	if (!THIS->get_width(&width, str.c_str()))
-		rays_error("Font#width(%s) failed.", str.inspect().c_str());
-
-	return value(width);
+	return value(THIS->get_width(str.c_str()));
 }
 
 static
 VALUE height(VALUE self)
 {
 	CHECK;
-
-	coord height = 0;
-	if (!THIS->get_height(&height))
-		rays_error("Font#height() failed.");
-
-	return value(height);
+	return value(THIS->get_height());
 }
 
 
@@ -121,8 +84,23 @@ Init_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(size), 0);
 	rb_define_method(cFont, "width", RUBY_METHOD_FUNC(width), 1);
 	rb_define_method(cFont, "height", RUBY_METHOD_FUNC(height), 0);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	font_class ()
+	{
+		return cFont;
+	}
+
+
+}// Rays

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

@@ -2,8 +2,10 @@
 
 
 #include <rucy.h>
-#include <rays/ruby/bitmap.h>
-#include <rays/ruby/texture.h>
+#include "rays/ruby/color_space.h"
+#include "rays/ruby/bitmap.h"
+#include "rays/ruby/texture.h"
+#include "rays/ruby/painter.h"
 #include "defs.h"
 
 
@@ -14,44 +16,11 @@ using Rays::coord;
 
 static Class cImage;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Image, cImage)
 
-namespace Rays
-{
-
-
-	Class
-	image_class ()
-	{
-		return cImage;
-	}
+#define THIS  to<Rays::Image*>(self)
 
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Image& obj)
-	{
-		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 CHECK RUCY_CHECK_OBJECT(self, Rays::Image, cImage)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Image, cImage, self)
 
 
 static
@@ -63,23 +32,20 @@ VALUE alloc(VALUE klass)
 static
 VALUE initialize(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Image, cImage);
-
-	if (argc < 1 || 3 < argc)
-		arg_count_error("Image#initialize", argc, 1, 2, 3);
+	RUCY_CHECK_OBJ(Rays::Image, cImage, self);
+	check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2, 3);
 
 	if (argc == 0) return self;
 
 	if (argv[0].is_kind_of(Rays::bitmap_class()))
 	{
-		if (argc < 1 || 2 < argc)
-			arg_count_error("Image#initialize", argc, 1, 2);
+		check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2);
 
 		const Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
-		if (!bitmap) argument_error();
+		if (!bitmap) argument_error(__FILE__, __LINE__);
 
-		bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
-		*THIS = Rays::Image(*bitmap, alphaonly);
+		bool alpha_only = (argc == 2) ? to<bool>(argv[1]) : false;
+		*THIS = Rays::Image(*bitmap, alpha_only);
 	}
 	else
 	{
@@ -93,10 +59,25 @@ VALUE initialize(VALUE self)
 }
 
 static
-VALUE width(VALUE self)
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	RUCY_CHECK_OBJ(Rays::Image, cImage, self);
+
+	*THIS = to<Rays::Image&>(obj).copy();
+	return self;
+}
+
+static
+VALUE painter(VALUE self)
 {
 	CHECK;
+	return value(THIS->painter());
+}
 
+static
+VALUE width(VALUE self)
+{
+	CHECK;
 	return value(THIS->width());
 }
 
@@ -104,7 +85,6 @@ static
 VALUE height(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->height());
 }
 
@@ -112,15 +92,20 @@ static
 VALUE color_space(VALUE self)
 {
 	CHECK;
+	return value(THIS->color_space());
+}
 
-	return value(THIS->color_space().type());
+static
+VALUE alpha_only(VALUE self)
+{
+	CHECK;
+	return value(THIS->alpha_only());
 }
 
 static
 VALUE bitmap(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->bitmap());
 }
 
@@ -128,28 +113,22 @@ static
 VALUE texture(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->texture());
 }
 
-
 static
-VALUE load(VALUE self)
+VALUE save(VALUE self, VALUE path)
 {
-	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;
+	CHECK;
+	Rays::save_image(*THIS, path.c_str());
+	return self;
+}
 
-	Rays::Image img;
-	if (!Rays::load_image(&img, path.c_str(), alphaonly))
-	{
-		rays_error(
-			"Image.load('%s', %s) failed.",
-			path.c_str(), alphaonly ? "true" : "false");
-	}
 
-	return value(img);
+static
+VALUE load(VALUE self, VALUE path, VALUE alpha_only)
+{
+	return value(Rays::load_image(path.c_str(), to<bool>(alpha_only)));
 }
 
 
@@ -161,10 +140,28 @@ Init_image ()
 	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_private_method(cImage, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cImage, "painter", RUBY_METHOD_FUNC(painter), 0);
 	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, "alpha_only", RUBY_METHOD_FUNC(alpha_only), 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);
+	rb_define_method(cImage, "save", RUBY_METHOD_FUNC(save), 1);
+	rb_define_function(cImage, "load_image", RUBY_METHOD_FUNC(load), 2);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	image_class ()
+	{
+		return cImage;
+	}
+
+
+}// Rays

data/.doc/ext/rays/matrix.cpp

@@ -10,44 +10,11 @@ using namespace Rucy;
 
 static Class cMatrix;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Matrix, cMatrix)
 
-namespace Rays
-{
-
-
-	Class
-	matrix_class ()
-	{
-		return cMatrix;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Matrix& obj)
-	{
-		return new_type(cMatrix, new Rays::Matrix(obj));
-	}
-
-	Value
-	value (const Rays::Matrix* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
+#define THIS  to<Rays::Matrix*>(self)
 
-
-#define THIS to<Rays::Matrix*>(self)
-
-#define CHECK RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix)
+#define CHECK RUCY_CHECK_OBJ(Rays::Matrix, cMatrix, self)
 
 
 static
@@ -59,10 +26,8 @@ VALUE alloc(VALUE klass)
 static
 VALUE initialize(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix);
-
-	if (argc != 0 && argc != 1 && argc != 16)
-		arg_count_error("Matrix#initialize", argc, 0, 1, 16);
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
 
 	if (argc == 0) return self;
 
@@ -87,12 +52,8 @@ VALUE initialize(VALUE self)
 static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
-	RUCY_CHECK_OBJ(self, Rays::Matrix, cMatrix);
-
-	Rays::Matrix* matrix = to<Rays::Matrix*>(obj);
-	if (!matrix) argument_error();
-
-	*THIS = *matrix;
+	CHECK;
+	*THIS = to<Rays::Matrix&>(obj);
 	return self;
 }
 
@@ -100,9 +61,7 @@ static
 VALUE set(VALUE self)
 {
 	CHECK;
-
-	if (argc != 0 && argc != 1 && argc != 16)
-		arg_count_error("Matrix#initialize", argc, 0, 1, 16);
+	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
 
 	switch (argc)
 	{
@@ -130,7 +89,6 @@ static
 VALUE at(VALUE self, VALUE row, VALUE column)
 {
 	CHECK;
-
 	return value(THIS->at(row.as_i(), column.as_i()));
 }
 
@@ -147,3 +105,17 @@ Init_matrix ()
 	rb_define_method(cMatrix, "set", RUBY_METHOD_FUNC(set), -1);
 	rb_define_method(cMatrix, "at", RUBY_METHOD_FUNC(at), 2);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	matrix_class ()
+	{
+		return cMatrix;
+	}
+
+
+}// Rays

data/.doc/ext/rays/native.cpp

@@ -9,26 +9,33 @@ void Init_rays ();
 void Init_point ();
 void Init_bounds ();
 void Init_color ();
+void Init_color_space ();
 void Init_bitmap ();
 void Init_texture ();
 void Init_image ();
 void Init_font ();
+void Init_shader ();
 void Init_painter ();
 
 
 extern "C" void
 Init_native ()
 {
-	if (!Rucy::init())
-		raise(rb_eLoadError, "Rucy::init() failed.");
+	RUCY_TRY
+
+	Rucy::init();
 
 	Init_rays();
 	Init_point();
 	Init_bounds();
 	Init_color();
+	Init_color_space();
 	Init_bitmap();
 	Init_texture();
 	Init_image();
 	Init_font();
+	Init_shader();
 	Init_painter();
+
+	RUCY_CATCH
 }