rays 0.1.6 → 0.1.7

data/.doc/ext/rays/bounds.cpp

@@ -2,7 +2,7 @@
 
 
 #include <rucy.h>
-#include <rays/ruby/point.h>
+#include "rays/ruby/point.h"
 #include "defs.h"
 
 
@@ -13,44 +13,11 @@ using Rays::coord;
 
 static Class cBounds;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Bounds, cBounds)
 
-namespace Rays
-{
-
-
-	Class
-	bounds_class ()
-	{
-		return cBounds;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Bounds& obj)
-	{
-		return new_type(cBounds, new Rays::Bounds(obj));
-	}
-
-	Value
-	value (const Rays::Bounds* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
+#define THIS  to<Rays::Bounds*>(self)
 
-#define THIS to<Rays::Bounds*>(self)
-
-#define CHECK RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds)
+#define CHECK RUCY_CHECK_OBJ(Rays::Bounds, cBounds, self)
 
 
 static
@@ -62,10 +29,8 @@ VALUE alloc(VALUE klass)
 static
 VALUE initialize(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds);
-
-	if (argc != 0 && argc != 1 && argc != 2 && argc != 3 && argc != 4 && argc != 6)
-		arg_count_error("Bounds#initialize", argc, 0, 1, 2, 3, 4, 6);
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#initialize", argc, 0, 1, 2, 3, 4, 6);
 
 	if (argc == 0) return self;
 
@@ -103,12 +68,159 @@ VALUE initialize(VALUE self)
 static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
-	RUCY_CHECK_OBJ(self, Rays::Bounds, cBounds);
+	CHECK;
+	*THIS = to<Rays::Bounds&>(obj);
+	return self;
+}
+
+static
+VALUE intersect(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#intersect?", argc, 1, 2);
+
+	const Rays::Bounds& bounds = to<Rays::Bounds&>(argv[0]);
+	int dimension              = argc >= 2 ? to<int>(argv[1]) : 2;
+
+	return value(THIS->is_intersect(bounds, dimension));
+}
+
+static
+VALUE include(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#include?", argc, 1, 2);
+
+	const Rays::Point& point = to<Rays::Point&>(argv[0]);
+	int dimension            = argc >= 2 ? to<int>(argv[1]) : 2;
+
+	return value(THIS->is_include(point, dimension));
+}
+
+static
+VALUE move_to(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#move_to", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->move_to(to<Rays::Point&>(argv[0]));
+	else
+	{
+		if (argv[0].is_array())
+		{
+			argc = argv[0].size();
+			argv = argv[0].as_array();
+		}
+
+		const Rays::Point& p = THIS->position();
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
+		THIS->move_to(x, y, z);
+	}
+
+	return self;
+}
+
+static
+VALUE move_by(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#move_by", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->move_by(to<Rays::Point&>(argv[0]));
+	else
+	{
+		if (argv[0].is_array())
+		{
+			argc = argv[0].size();
+			argv = argv[0].as_array();
+		}
+
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
+		THIS->move_by(x, y, z);
+	}
+
+	return self;
+}
+
+static
+VALUE resize_to(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#resize_to", argc, 1, 2, 3);
 
-	Rays::Bounds* bounds = to<Rays::Bounds*>(obj);
-	if (!bounds) argument_error();
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->resize_to(to<Rays::Point&>(argv[0]));
+	else
+	{
+		if (argv[0].is_array())
+		{
+			argc = argv[0].size();
+			argv = argv[0].as_array();
+		}
+
+		const Rays::Point& p = THIS->size();
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
+		THIS->resize_to(x, y, z);
+	}
+
+	return self;
+}
+
+static
+VALUE resize_by(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#resize_by", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->resize_by(to<Rays::Point&>(argv[0]));
+	else
+	{
+		if (argv[0].is_array())
+		{
+			argc = argv[0].size();
+			argv = argv[0].as_array();
+		}
+
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
+		THIS->resize_by(x, y, z);
+	}
+
+	return self;
+}
+
+static
+VALUE inset_by(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#inset_by", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->inset_by(to<Rays::Point&>(argv[0]));
+	else
+	{
+		if (argv[0].is_array())
+		{
+			argc = argv[0].size();
+			argv = argv[0].as_array();
+		}
+
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
+		THIS->inset_by(x, y, z);
+	}
 
-	*THIS = *bounds;
 	return self;
 }
 
@@ -317,14 +429,14 @@ VALUE get_front(VALUE self)
 }
 
 static
-VALUE set_position(VALUE self, VALUE pos)
+VALUE set_position(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#set_position", argc, 1, 2, 3);
 
-	Rays::Point* p = to<Rays::Point*>(pos);
-	if (!p) argument_error("%s is not a Rays::Point.", pos.inspect().c_str());
-
-	return value(THIS->position() = *p);
+	coord* pos = THIS->position().array;
+	for (int i = 0; i < 3; ++i)
+		if (argc > i && !argv[i].is_nil()) pos[i] = to<coord>(argv[i]);
 }
 
 static
@@ -336,14 +448,14 @@ VALUE get_position(VALUE self)
 }
 
 static
-VALUE set_size(VALUE self, VALUE size)
+VALUE set_size(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#set_size", argc, 1, 2, 3);
 
-	Rays::Point* p = to<Rays::Point*>(size);
-	if (!p) argument_error("%s is not a Rays::Point.", size.inspect().c_str());
-
-	return value(THIS->size() = *p);
+	coord* size = THIS->size().array;
+	for (int i = 0; i < 3; ++i)
+		if (argc > i && !argv[i].is_nil()) size[i] = to<coord>(argv[i]);
 }
 
 static
@@ -354,6 +466,87 @@ VALUE get_size(VALUE self)
 	return value(THIS->size());
 }
 
+static
+VALUE set_center(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Bounds#set_center", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->set_center(to<Rays::Point&>(argv[0]));
+	else
+	{
+		Rays::Point p = THIS->center();
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
+		THIS->set_center(x, y, z);
+	}
+
+	return value(THIS->center());
+}
+
+static
+VALUE center(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->center());
+}
+
+static
+VALUE array_get(VALUE self, VALUE index)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 1 < i)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
+}
+
+static
+VALUE array_set(VALUE self, VALUE index, VALUE value)
+{
+	CHECK;
+
+	int i = index.as_i();
+	if (i < 0 || 1 < i)
+		index_error(__FILE__, __LINE__);
+
+	(*THIS)[i] = to<Rays::Point&>(value);
+	return value;
+}
+
+static
+VALUE and_(VALUE self, VALUE bounds)
+{
+	CHECK;
+
+	Rays::Bounds b = *THIS;
+	b &= to<Rays::Bounds&>(bounds);
+	return value(b);
+}
+
+static
+VALUE or_(VALUE self, VALUE bounds)
+{
+	CHECK;
+
+	Rays::Bounds b = *THIS;
+	b |= to<Rays::Bounds&>(bounds);
+	return value(b);
+}
+
+static
+VALUE inspect(VALUE self)
+{
+	CHECK;
+
+	return value(Xot::stringf("#<Rays::Bounds %s>", THIS->inspect().c_str()));
+}
+
 
 void
 Init_bounds ()
@@ -364,6 +557,13 @@ Init_bounds ()
 	rb_define_alloc_func(cBounds, alloc);
 	rb_define_private_method(cBounds, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cBounds, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	cBounds.define_method("intersect?", intersect);
+	cBounds.define_method("include?",   include);
+	cBounds.define_method("move_to!",   move_to);
+	cBounds.define_method("move_by!",   move_by);
+	cBounds.define_method("resize_to!", resize_to);
+	cBounds.define_method("resize_by!", resize_by);
+	cBounds.define_method("inset_by!",  inset_by);
 	rb_define_method(cBounds, "x=", RUBY_METHOD_FUNC(set_x), 1);
 	rb_define_method(cBounds, "x", RUBY_METHOD_FUNC(get_x), 0);
 	rb_define_method(cBounds, "y=", RUBY_METHOD_FUNC(set_y), 1);
@@ -388,8 +588,90 @@ Init_bounds ()
 	rb_define_method(cBounds, "back", RUBY_METHOD_FUNC(get_back), 0);
 	rb_define_method(cBounds, "front=", RUBY_METHOD_FUNC(set_front), 1);
 	rb_define_method(cBounds, "front", RUBY_METHOD_FUNC(get_front), 0);
-	rb_define_method(cBounds, "position=", RUBY_METHOD_FUNC(set_position), 1);
+	rb_define_method(cBounds, "set_position", RUBY_METHOD_FUNC(set_position), -1);
 	rb_define_method(cBounds, "position", RUBY_METHOD_FUNC(get_position), 0);
-	rb_define_method(cBounds, "size=", RUBY_METHOD_FUNC(set_size), 1);
+	rb_define_method(cBounds, "set_size", RUBY_METHOD_FUNC(set_size), -1);
 	rb_define_method(cBounds, "size", RUBY_METHOD_FUNC(get_size), 0);
+	rb_define_method(cBounds, "set_center", RUBY_METHOD_FUNC(set_center), -1);
+	rb_define_method(cBounds, "center", RUBY_METHOD_FUNC(center), 0);
+	cBounds.define_method("[]",  array_get);
+	cBounds.define_method("[]=", array_set);
+	cBounds.define_method("&", and_);
+	cBounds.define_method("|", or_);
+	rb_define_method(cBounds, "inspect", RUBY_METHOD_FUNC(inspect), 0);
 }
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Bounds
+	value_to<Rays::Bounds> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			size_t argc = 0;
+			Value* argv = NULL;
+			if (value.is_array())
+			{
+				argc = value.size();
+				argv = value.as_array();
+			}
+			else
+			{
+				argc = 1;
+				argv = &value;
+			}
+
+			if (argc < 1)
+				Rucy::argument_error(__FILE__, __LINE__);
+
+			if (argv[0].is_kind_of(Rays::bounds_class()))
+				value = argv[0];
+			else if (argv[0].is_kind_of(Rays::point_class()))
+			{
+				switch (argc)
+				{
+					#define V(i) to<Rays::Point&>(argv[i])
+					case 1: return Rays::Bounds(V(0));
+					case 2: return Rays::Bounds(V(0), V(1));
+					#undef V
+					default: Rucy::argument_error(__FILE__, __LINE__);
+				}
+			}
+			else if (argv[0].is_i() || argv[0].is_f())
+			{
+				switch (argc)
+				{
+					#define V(i) argv[i].as_f(true)
+					case 1: return Rays::Bounds(V(0));
+					case 2: return Rays::Bounds(V(0), V(1));
+					case 3: return Rays::Bounds(V(0), V(1), V(2));
+					case 4: return Rays::Bounds(V(0), V(1), V(2), V(3));
+					case 6: return Rays::Bounds(V(0), V(1), V(2), V(3), V(4), V(5));
+					#undef V
+					default: Rucy::argument_error(__FILE__, __LINE__);
+				}
+			}
+		}
+
+		return value_to<Rays::Bounds&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	bounds_class ()
+	{
+		return cBounds;
+	}
+
+
+}// Rays

data/.doc/ext/rays/color.cpp

@@ -10,44 +10,11 @@ using namespace Rucy;
 
 static Class cColor;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Color, cColor)
 
-namespace Rays
-{
+#define THIS  to<Rays::Color*>(self)
 
-
-	Class
-	color_class ()
-	{
-		return cColor;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Color& obj)
-	{
-		return new_type(cColor, new Rays::Color(obj));
-	}
-
-	Value
-	value (const Rays::Color* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
-
-#define THIS to<Rays::Color*>(self)
-
-#define CHECK RUCY_CHECK_OBJ(self, Rays::Color, cColor)
+#define CHECK RUCY_CHECK_OBJ(Rays::Color, cColor, self)
 
 
 static
@@ -57,12 +24,10 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE setup(VALUE self)
 {
-	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
-
-	if (argc < 0 || 4 < argc)
-		arg_count_error("Color#initialize", argc, 0, 1, 2, 3, 4);
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Color#initialize", argc, 0, 1, 2, 3, 4);
 
 	if (argc == 0) return self;
 
@@ -94,12 +59,8 @@ VALUE initialize(VALUE self)
 static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
-	RUCY_CHECK_OBJ(self, Rays::Color, cColor);
-
-	Rays::Color* color = to<Rays::Color*>(obj);
-	if (!color) argument_error();
-
-	*THIS = *color;
+	CHECK;
+	*THIS = to<Rays::Color&>(obj);
 	return self;
 }
 
@@ -175,7 +136,7 @@ Init_color ()
 
 	cColor = rb_define_class_under(mRays, "Color", rb_cObject);
 	rb_define_alloc_func(cColor, alloc);
-	rb_define_private_method(cColor, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cColor, "setup", RUBY_METHOD_FUNC(setup), -1);
 	rb_define_private_method(cColor, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cColor, "red=", RUBY_METHOD_FUNC(set_red), 1);
 	rb_define_method(cColor, "red", RUBY_METHOD_FUNC(get_red), 0);
@@ -186,3 +147,52 @@ Init_color ()
 	rb_define_method(cColor, "alpha=", RUBY_METHOD_FUNC(set_alpha), 1);
 	rb_define_method(cColor, "alpha", RUBY_METHOD_FUNC(get_alpha), 0);
 }
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Color
+	value_to<Rays::Color> (Value value, bool convert)
+	{
+		if (convert)
+		{
+			if (value.is_i() || value.is_f())
+				return Rays::Color(value.as_f(true));
+			else if (value.is_array())
+			{
+				int size = value.size();
+				if (size <= 0 || 4 < size)
+					Rucy::argument_error(__FILE__, __LINE__);
+
+				Value* a = value.as_array();
+				switch (size)
+				{
+					case 1: return Rays::Color(a[0].as_f(true));
+					case 2: return Rays::Color(a[0].as_f(true), a[1].as_f(true));
+					case 3: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true));
+					case 4: return Rays::Color(a[0].as_f(true), a[1].as_f(true), a[2].as_f(true), a[3].as_f(true));
+				}
+			}
+		}
+
+		return value_to<Rays::Color&>(value, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	color_class ()
+	{
+		return cColor;
+	}
+
+
+}// Rays