rays 0.1.12 → 0.1.17

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

@@ -1,18 +1,65 @@
 #include "rays/ruby/color_space.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::ColorSpace)
 
+#define THIS  to<Rays::ColorSpace*>(self)
 
-RUCY_DEFINE_VALUE_FROM_TO(Rays::ColorSpace)
+#define CHECK RUCY_CHECK_OBJECT(Rays::ColorSpace, self)
 
-#define THIS  to<Rays::ColorSpace*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Rays::ColorSpace, self)
+static struct ColorSpaceEnum
+{
+	const char* name;
+	Rays::ColorSpaceType type;
+}
+COLOR_SPACES[] =
+{
+	{"GRAY",        Rays::GRAY},
+	{"ALPHA",       Rays::ALPHA},
+	{"RGB",         Rays:: RGB},
+	{"BGR",         Rays:: BGR},
+	{"RGBA",        Rays:: RGBA},
+	{"RGBX",        Rays:: RGBX},
+	{"ARGB",        Rays::ARGB},
+	{"XRGB",        Rays::XRGB},
+	{"BGRA",        Rays:: BGRA},
+	{"BGRX",        Rays:: BGRX},
+	{"ABGR",        Rays::ABGR},
+	{"XBGR",        Rays::XBGR},
+	{"GRAY_8",      Rays::GRAY_8},
+	{"GRAY_16",     Rays::GRAY_16},
+	{"GRAY_24",     Rays::GRAY_24},
+	{"GRAY_32",     Rays::GRAY_32},
+	{"GRAY_float",  Rays::GRAY_float},
+	{"ALPHA_8",     Rays::ALPHA_8},
+	{"ALPHA_16",    Rays::ALPHA_16},
+	{"ALPHA_24",    Rays::ALPHA_24},
+	{"ALPHA_32",    Rays::ALPHA_32},
+	{"ALPHA_float", Rays::ALPHA_float},
+	{"RGB_888",     Rays:: RGB_888},
+	{"RGBA_8888",   Rays:: RGBA_8888},
+	{"RGBX_8888",   Rays:: RGBX_8888},
+	{"ARGB_8888",   Rays::ARGB_8888},
+	{"XRGB_8888",   Rays::XRGB_8888},
+	{"BGR_888",     Rays:: BGR_888},
+	{"BGRA_8888",   Rays:: BGRA_8888},
+	{"BGRX_8888",   Rays:: BGRX_8888},
+	{"ABGR_8888",   Rays::ABGR_8888},
+	{"XBGR_8888",   Rays::XBGR_8888},
+	{"RGB_float",   Rays:: RGB_float},
+	{"RGBA_float",  Rays:: RGBA_float},
+	{"ARGB_float",  Rays::ARGB_float},
+	{"BGR_float",   Rays:: BGR_float},
+	{"BGRA_float",  Rays:: BGRA_float},
+	{"ABGR_float",  Rays::ABGR_float},
+};
+
+static const size_t COLOR_SPACES_SIZE =
+	sizeof(COLOR_SPACES) / sizeof(COLOR_SPACES[0]);
 
 
 static
@@ -22,13 +69,12 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE setup(VALUE self, VALUE type, VALUE premultiplied)
+VALUE initialize(VALUE self)
 {
-	CHECK;
+	RUCY_CHECK_OBJ(Rays::ColorSpace, self);
+	check_arg_count(__FILE__, __LINE__, "ColorSpace#initialize", argc, 1, 2);
 
-	*THIS = Rays::ColorSpace(
-		(Rays::ColorSpaceType) to<uint>(type),
-		to<bool>(premultiplied));
+	*THIS = to<Rays::ColorSpace>(argc, argv);
 	return self;
 }
 
@@ -56,6 +102,14 @@ VALUE is_gray(VALUE self)
 	return value(THIS->is_gray());
 }
 
+static
+VALUE is_alpha(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->is_alpha());
+}
+
 static
 VALUE is_rgb(VALUE self)
 {
@@ -104,6 +158,21 @@ VALUE is_premult(VALUE self)
 	return value(THIS->is_premult());
 }
 
+static
+VALUE to_s(VALUE self)
+{
+	CHECK;
+
+	Rays::ColorSpaceType type = THIS->type();
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+	{
+		if (type == COLOR_SPACES[i].type)
+			return value(COLOR_SPACES[i].name);
+	}
+
+	invalid_object_error(__FILE__, __LINE__);
+}
+
 
 static Class cColorSpace;
 
@@ -112,54 +181,85 @@ Init_color_space ()
 {
 	Module mRays = rb_define_module("Rays");
 
+	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+		mRays.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
+
 	cColorSpace = rb_define_class_under(mRays, "ColorSpace", rb_cObject);
 	rb_define_alloc_func(cColorSpace, alloc);
+	rb_define_private_method(cColorSpace, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	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("alpha?",   is_alpha);
 	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("has_alpha?", has_alpha);
+	cColorSpace.define_method("has_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);
+	rb_define_method(cColorSpace, "to_s", RUBY_METHOD_FUNC(to_s), 0);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::ColorSpace
+	value_to<Rays::ColorSpace> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_i() || argv->is_s() || argv->is_sym())
+			{
+				return Rays::ColorSpace(
+					to<Rays::ColorSpaceType>(argv[0]),
+					argc >= 2 ? to<bool>(argv[1]) : true);
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::ColorSpace&>(*argv, convert);
+	}
+
+
+	template <> Rays::ColorSpaceType
+	value_to<Rays::ColorSpaceType> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			if (value.is_s() || value.is_sym())
+			{
+				const char* str = value.c_str();
+				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
+				{
+					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
+						return COLOR_SPACES[i].type;
+				}
+			}
+		}
+
+		uint type = value_to<uint>(value, convert);
+		if (type >= Rays::COLORSPACE_MAX)
+			argument_error(__FILE__, __LINE__, "invalid color space type -- %d", type);
+
+		return (Rays::ColorSpaceType) type;
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {
 

data/.doc/ext/rays/defs.cpp

@@ -0,0 +1,183 @@
+#include "defs.h"
+
+
+#include <assert.h>
+#include "rays/ruby/bounds.h"
+#include "rays/ruby/point.h"
+
+
+void
+get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
+{
+	assert(points && argv);
+
+	points->clear();
+
+	if (argc <= 0)
+		return;
+
+	if (argv[0].is_num())
+	{
+		if (argc % 2 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		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));
+		}
+	}
+	else
+	{
+		points->reserve(argc);
+		for (int i = 0; i < argc; ++i)
+			points->emplace_back(to<Rays::Point>(argv[i]));
+	}
+}
+
+static uint
+get_nsegment (Value nsegment)
+{
+	int value = nsegment ? to<int>(nsegment) : 0;
+	if (value < 0) value = 0;
+	return (uint) value;
+}
+
+void get_rect_args (
+	coord* x, coord* y, coord* w, coord* h,
+	coord* lt, coord* rt, coord* lb, coord* rb,
+	uint* nseg,
+	int argc, const Value* argv,
+	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__);
+
+	if (argv[0].is_kind_of(Rays::bounds_class()))
+	{
+		Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
+		*x  = b.x;
+		*y  = b.y;
+		*w  = b.w;
+		*h  = b.h;
+		*lt = argc >= 2 ? to<coord>(argv[1]) : 0;
+		*rt = argc >= 3 ? to<coord>(argv[2]) : *lt;
+		*lb = argc >= 4 ? to<coord>(argv[3]) : *lt;
+		*rb = argc >= 5 ? to<coord>(argv[4]) : *lt;
+	}
+	else if (argv[0].is_kind_of(Rays::point_class()))
+	{
+		if (argc < 2)
+			argument_error(__FILE__, __LINE__);
+
+		Rays::Point& p = to<Rays::Point&>(argv[0]);
+		*x  = p.x;
+		*y  = p.y;
+		*w  =             to<coord>(argv[1]);
+		*h  = argc >= 3 ? to<coord>(argv[2]) : *w;
+		*lt = argc >= 4 ? to<coord>(argv[3]) : 0;
+		*rt = argc >= 5 ? to<coord>(argv[4]) : *lt;
+		*lb = argc >= 6 ? to<coord>(argv[5]) : *lt;
+		*rb = argc >= 7 ? to<coord>(argv[6]) : *lt;
+	}
+	else if (argc <= 2)
+	{
+		*x = *y = *lt = *rt = *lb = *rb = 0;
+		*w =             to<coord>(argv[0]);
+		*h = argc >= 2 ? to<coord>(argv[1]) : *w;
+	}
+	else
+	{
+		*x  =             to<coord>(argv[0]);
+		*y  =             to<coord>(argv[1]);
+		*w  =             to<coord>(argv[2]);
+		*h  = argc >= 4 ? to<coord>(argv[3]) : *w;
+		*lt = argc >= 5 ? to<coord>(argv[4]) : 0;
+		*rt = argc >= 6 ? to<coord>(argv[5]) : *lt;
+		*lb = argc >= 7 ? to<coord>(argv[6]) : *lt;
+		*rb = argc >= 8 ? to<coord>(argv[7]) : *lt;
+	}
+
+	if (! lefttop)     lefttop    = round;
+	if (!righttop)    righttop    = round;
+	if (! leftbottom)  leftbottom = round;
+	if (!rightbottom) rightbottom = round;
+
+	if ( lefttop)    *lt = to<coord>( lefttop);
+	if (righttop)    *rt = to<coord>(righttop);
+	if ( leftbottom) *lb = to<coord>( leftbottom);
+	if (rightbottom) *rb = to<coord>(rightbottom);
+
+	*nseg = get_nsegment(nsegment);
+}
+
+void get_ellipse_args (
+	coord* x, coord* y, coord* w, coord* h,
+	Rays::Point* hole_size, float* from, float* to_,
+	uint* nseg,
+	int argc, const Value* argv,
+	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)
+		argument_error(__FILE__, __LINE__);
+
+	if (argv[0].is_kind_of(Rays::bounds_class()))
+	{
+		const Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
+		*x = b.x;
+		*y = b.y;
+		*w = b.w;
+		*h = b.h;
+	}
+	else if (argv[0].is_kind_of(Rays::point_class()))
+	{
+		if (argc < 2)
+			argument_error(__FILE__, __LINE__);
+
+		const Rays::Point& p = to<Rays::Point&>(argv[0]);
+		*x = p.x;
+		*y = p.y;
+		*w =             to<coord>(argv[1]);
+		*h = argc >= 3 ? to<coord>(argv[2]) : *w;
+	}
+	else if (argc <= 2)
+	{
+		*x = *y = 0;
+		*w =             to<coord>(argv[0]);
+		*h = argc >= 2 ? to<coord>(argv[1]) : *w;
+	}
+	else
+	{
+		*x =             to<coord>(argv[0]);
+		*y =             to<coord>(argv[1]);
+		*w =             to<coord>(argv[2]);
+		*h = argc >= 4 ? to<coord>(argv[3]) : *w;
+	}
+
+	if (center)
+	{
+		Rays::Point p = to<Rays::Point>(center);
+		*x = p.x;
+		*y = p.y;
+	}
+
+	if (radius)
+	{
+		Rays::Point p = to<Rays::Point>(radius);
+		*w = p.x * 2;
+		*h = p.y * 2;
+	}
+
+	*hole_size = hole       ? to<Rays::Point>(hole) : 0;
+	*from      = angle_from ? to<float>(angle_from) : 0;
+	*to_       = angle_to   ? to<float>(angle_to)   : 360;
+	*nseg      = get_nsegment(nsegment);
+}

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

@@ -1,16 +1,10 @@
 #include "rays/ruby/font.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Rays::coord;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Font)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Font)
 
 #define THIS  to<Rays::Font*>(self)
 
@@ -29,19 +23,7 @@ VALUE initialize(VALUE self)
 	RUCY_CHECK_OBJ(Rays::Font, 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;
-	*THIS = Rays::Font(name, size);
-
-	return self;
-}
-
-static
-VALUE initialize_copy(VALUE self, VALUE obj)
-{
-	RUCY_CHECK_OBJ(Rays::Font, self);
-
-	*THIS = to<Rays::Font&>(obj).copy();
+	*THIS = to<Rays::Font>(argc, argv);
 	return self;
 }
 
@@ -73,6 +55,33 @@ VALUE height(VALUE self)
 	return value(THIS->get_height());
 }
 
+static
+VALUE ascent(VALUE self)
+{
+	CHECK;
+	coord ascent = 0;
+	THIS->get_height(&ascent);
+	return value(ascent);
+}
+
+static
+VALUE descent(VALUE self)
+{
+	CHECK;
+	coord descent = 0;
+	THIS->get_height(NULL, &descent);
+	return value(descent);
+}
+
+static
+VALUE leading(VALUE self)
+{
+	CHECK;
+	coord leading = 0;
+	THIS->get_height(NULL, NULL, &leading);
+	return value(leading);
+}
+
 
 static Class cFont;
 
@@ -84,14 +93,53 @@ 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);
+	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);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::Font
+	value_to<Rays::Font> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc == 0 || (argc > 0 && argv));
+
+		if (convert)
+		{
+			if (argc == 0)
+				return Rays::default_font();
+
+			coord size = argc >= 2 ? to<coord>(argv[1]) : 0;
+			if (argv->is_nil())
+				return Rays::Font(NULL, size);
+			else if (argv->is_s() || argv->is_sym())
+				return Rays::Font(argv[0].c_str(), size);
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Font&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {