rays 0.1.11 → 0.1.16

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
 {
 

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

@@ -1,19 +1,12 @@
 #include "rays/ruby/image.h"
 
 
-#include <rucy.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"
 
 
-using namespace Rucy;
-
-using Rays::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Rays::Image)
 
 #define THIS  to<Rays::Image*>(self)
@@ -31,26 +24,28 @@ static
 VALUE initialize(VALUE self)
 {
 	RUCY_CHECK_OBJ(Rays::Image, self);
-	check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2, 3);
-
-	if (argc == 0) return self;
+	check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2, 3, 4);
 
 	if (argv[0].is_kind_of(Rays::bitmap_class()))
 	{
 		check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2);
 
 		const Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
-		if (!bitmap) argument_error(__FILE__, __LINE__);
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
 
-		bool alpha_only = (argc == 2) ? to<bool>(argv[1]) : false;
-		*THIS = Rays::Image(*bitmap, alpha_only);
+		float pixel_density = (argc >= 2) ? to<float>(argv[1]) : 1;
+		*THIS = Rays::Image(*bitmap, pixel_density);
 	}
 	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);
+		check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 2, 3, 4);
+
+		int width           = to<int>(argv[0]);
+		int height          = to<int>(argv[1]);
+		Rays::ColorSpace cs = (argc >= 3) ? to<Rays::ColorSpace>(argv[2]) : Rays::RGBA;
+		float pixel_density = (argc >= 4) ? to<float>(argv[3]) : 1;
+		*THIS = Rays::Image(width, height, cs, pixel_density);
 	}
 
 	return self;
@@ -61,17 +56,10 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	RUCY_CHECK_OBJ(Rays::Image, self);
 
-	*THIS = to<Rays::Image&>(obj).copy();
+	*THIS = to<Rays::Image&>(obj).dup();
 	return self;
 }
 
-static
-VALUE painter(VALUE self)
-{
-	CHECK;
-	return value(THIS->painter());
-}
-
 static
 VALUE width(VALUE self)
 {
@@ -94,24 +82,24 @@ VALUE color_space(VALUE self)
 }
 
 static
-VALUE alpha_only(VALUE self)
+VALUE pixel_density(VALUE self)
 {
 	CHECK;
-	return value(THIS->alpha_only());
+	return value(THIS->pixel_density());
 }
 
 static
-VALUE bitmap(VALUE self)
+VALUE painter(VALUE self)
 {
 	CHECK;
-	return value(THIS->bitmap());
+	return value(THIS->painter());
 }
 
 static
-VALUE texture(VALUE self)
+VALUE bitmap(VALUE self)
 {
 	CHECK;
-	return value(THIS->texture());
+	return value(THIS->bitmap());
 }
 
 static
@@ -124,9 +112,11 @@ VALUE save(VALUE self, VALUE path)
 
 
 static
-VALUE load(VALUE self, VALUE path, VALUE alpha_only)
+VALUE load(VALUE self)
 {
-	return value(Rays::load_image(path.c_str(), to<bool>(alpha_only)));
+	check_arg_count(__FILE__, __LINE__, "Image.load", argc, 1);
+
+	return value(Rays::load_image(argv[0].c_str()));
 }
 
 
@@ -141,15 +131,14 @@ Init_image ()
 	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, "pixel_density", RUBY_METHOD_FUNC(pixel_density), 0);
+	rb_define_method(cImage, "painter", RUBY_METHOD_FUNC(painter), 0);
 	rb_define_method(cImage, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
-	rb_define_method(cImage, "texture", RUBY_METHOD_FUNC(texture), 0);
 	rb_define_method(cImage, "save", RUBY_METHOD_FUNC(save), 1);
-	rb_define_function(cImage, "load_image", RUBY_METHOD_FUNC(load), 2);
+	rb_define_module_function(cImage, "load", RUBY_METHOD_FUNC(load), -1);
 }
 
 

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

@@ -1,14 +1,11 @@
 #include "rays/ruby/matrix.h"
 
 
-#include <rucy.h>
+#include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Matrix)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Matrix)
 
 #define THIS  to<Rays::Matrix*>(self)
 
@@ -27,22 +24,8 @@ VALUE initialize(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
 
-	if (argc == 0) return self;
-
-	switch (argc)
-	{
-		case 1:
-			*THIS = Rays::Matrix(to<float>(argv[0]));
-			break;
-
-		case 16:
-			*THIS = Rays::Matrix(
-				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
-				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
-				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
-				to<float>(argv[12]), to<float>(argv[13]), to<float>(argv[14]), to<float>(argv[15]));
-			break;
-	}
+	if (argc > 0)
+		*THIS = to<Rays::Matrix>(argc, argv);
 
 	return self;
 }
@@ -56,23 +39,23 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE set(VALUE self)
+VALUE reset(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
+	check_arg_count(__FILE__, __LINE__, "Matrix#reset", argc, 0, 1, 16);
 
 	switch (argc)
 	{
 		case 0:
-			*THIS = Rays::Matrix();
+			THIS->reset();
 			break;
 
 		case 1:
-			*THIS = Rays::Matrix(to<float>(argv[0]));
+			THIS->reset(to<float>(argv[0]));
 			break;
 
 		case 16:
-			*THIS = Rays::Matrix(
+			THIS->reset(
 				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
 				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
 				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
@@ -84,12 +67,128 @@ VALUE set(VALUE self)
 }
 
 static
-VALUE at(VALUE self, VALUE row, VALUE column)
+VALUE translate(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#translate", argc, 1, 2, 3);
+
+	THIS->translate(to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE scale(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#scale", argc, 1, 2, 3);
+
+	THIS->scale(to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE rotate(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#rotate", argc, 1, 2, 4);
+
+	float degree = to<float>(argv[0]);
+
+	if (argc == 1)
+		THIS->rotate(degree);
+	else
+		THIS->rotate(degree, to<Rays::Point>(argc - 1, argv + 1));
+
+	return self;
+}
+
+static
+VALUE to_a(VALUE self)
+{
+	CHECK;
+	return array(
+		THIS->x0, THIS->y0, THIS->z0, THIS->w0,
+		THIS->x1, THIS->y1, THIS->z1, THIS->w1,
+		THIS->x2, THIS->y2, THIS->z2, THIS->w2,
+		THIS->x3, THIS->y3, THIS->z3, THIS->w3);
+}
+
+static
+VALUE mult(VALUE self, VALUE val)
+{
+	CHECK;
+
+	if (val.is_kind_of(Rays::matrix_class()))
+		return value(*THIS * to<Rays::Matrix&>(val));
+
+	if (val.is_kind_of(Rays::point_class()))
+		return value(*THIS * to<Rays::Point&>(val));
+
+	if (val.is_array())
+	{
+		if (val.size() == 16)
+			return value(*THIS * to<Rays::Matrix>(val));
+		else
+			return value(*THIS * to<Rays::Point>(val));
+	}
+
+	argument_error(__FILE__, __LINE__);
+}
+
+static
+VALUE set_at(VALUE self, VALUE row, VALUE column, VALUE val)
+{
+	CHECK;
+	return value(THIS->at(row.as_i(), column.as_i()) = to<float>(val));
+}
+
+static
+VALUE get_at(VALUE self, VALUE row, VALUE column)
 {
 	CHECK;
 	return value(THIS->at(row.as_i(), column.as_i()));
 }
 
+static
+VALUE compare(VALUE self, VALUE other)
+{
+	CHECK;
+
+	const Rays::Matrix& a = *THIS;
+	const Rays::Matrix& b = to<const Rays::Matrix&>(other);
+	for (int i = 0; i < Rays::Matrix::NELEM; ++i)
+	{
+		if (a[i] == b[i]) continue;
+		return value(a[i] < b[i] ? -1 : +1);
+	}
+	return value(0);
+}
+
+static
+VALUE inspect(VALUE self)
+{
+	CHECK;
+	return value(Xot::stringf("#<Rays::Matrix %s>", THIS->inspect().c_str()));
+}
+
+static
+VALUE s_translate(VALUE self)
+{
+	return translate(argc, argv, value(Rays::Matrix()));
+}
+
+static
+VALUE s_scale(VALUE self)
+{
+	return scale(argc, argv, value(Rays::Matrix()));
+}
+
+static
+VALUE s_rotate(VALUE self)
+{
+	return rotate(argc, argv, value(Rays::Matrix()));
+}
+
 
 static Class cMatrix;
 
@@ -102,11 +201,69 @@ Init_matrix ()
 	rb_define_alloc_func(cMatrix, alloc);
 	rb_define_private_method(cMatrix, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cMatrix, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cMatrix, "set", RUBY_METHOD_FUNC(set), -1);
-	rb_define_method(cMatrix, "at", RUBY_METHOD_FUNC(at), 2);
+	rb_define_method(cMatrix, "reset", RUBY_METHOD_FUNC(reset), -1);
+	rb_define_method(cMatrix, "translate", RUBY_METHOD_FUNC(translate), -1);
+	rb_define_method(cMatrix, "scale", RUBY_METHOD_FUNC(scale), -1);
+	rb_define_method(cMatrix, "rotate", RUBY_METHOD_FUNC(rotate), -1);
+	rb_define_method(cMatrix, "to_a", RUBY_METHOD_FUNC(to_a), 0);
+	cMatrix.define_method("*", mult);
+	cMatrix.define_method("[]=", set_at);
+	cMatrix.define_method("[]",  get_at);
+	cMatrix.define_method("<=>", compare);
+	rb_define_method(cMatrix, "inspect", RUBY_METHOD_FUNC(inspect), 0);
+
+	rb_define_singleton_method(cMatrix, "translate", RUBY_METHOD_FUNC(s_translate), -1);
+	rb_define_singleton_method(cMatrix, "scale", RUBY_METHOD_FUNC(s_scale), -1);
+	rb_define_singleton_method(cMatrix, "rotate", RUBY_METHOD_FUNC(s_rotate), -1);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::Matrix
+	value_to<Rays::Matrix> (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::Matrix();
+			else if (argv->is_num())
+			{
+				switch (argc)
+				{
+					#define V(i) argv[i].as_f(true)
+					case 1:  return Rays::Matrix(V(0));
+					case 16: return Rays::Matrix(
+						V(0),  V(1),  V(2),  V(3),
+						V(4),  V(5),  V(6),  V(7),
+						V(8),  V(9),  V(10), V(11),
+						V(12), V(13), V(14), V(15));
+					#undef V
+					default: argument_error(__FILE__, __LINE__);
+				}
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Matrix&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {