rays 0.1.11 → 0.1.16

data/.doc/ext/rays/point.cpp

@@ -1,16 +1,10 @@
 #include "rays/ruby/point.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Rays::coord;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Point)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Point)
 
 #define THIS  to<Rays::Point*>(self)
 
@@ -29,21 +23,8 @@ VALUE initialize(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Point#initialize", argc, 0, 1, 2, 3);
 
-	switch (argc)
-	{
-		case 1:
-			*THIS = Rays::Point(to<coord>(argv[0]));
-			break;
-
-		case 2:
-			*THIS = Rays::Point(to<coord>(argv[0]), to<coord>(argv[1]));
-			break;
-
-		case 3:
-			*THIS = Rays::Point(
-				to<coord>(argv[0]), to<coord>(argv[1]), to<coord>(argv[2]));
-			break;
-	}
+	if (argc >= 1)
+		*THIS = to<Rays::Point>(argc, argv);
 
 	return self;
 }
@@ -95,6 +76,22 @@ VALUE move_by(VALUE self)
 	return self;
 }
 
+static
+VALUE rotate(VALUE self, VALUE degree)
+{
+	CHECK;
+	Rays::Point p = *THIS;
+	p.rotate(to<float>(degree));
+	return value(p);
+}
+
+static
+VALUE rotate_self(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->rotate(to<float>(degree));
+}
+
 static
 VALUE length(VALUE self)
 {
@@ -121,7 +118,8 @@ static
 VALUE set_x(VALUE self, VALUE x)
 {
 	CHECK;
-	return value(THIS->x = to<coord>(x));
+	THIS->x = to<coord>(x);
+	return x;
 }
 
 static
@@ -135,7 +133,8 @@ static
 VALUE set_y(VALUE self, VALUE y)
 {
 	CHECK;
-	return value(THIS->y = to<coord>(y));
+	THIS->y = to<coord>(y);
+	return y;
 }
 
 static
@@ -149,7 +148,8 @@ static
 VALUE set_z(VALUE self, VALUE z)
 {
 	CHECK;
-	return value(THIS->z = to<coord>(z));
+	THIS->z = to<coord>(z);
+	return z;
 }
 
 static
@@ -160,47 +160,54 @@ VALUE get_z(VALUE self)
 }
 
 static
-VALUE add(VALUE self, VALUE point)
+VALUE negate(VALUE self)
 {
 	CHECK;
-
-	Rays::Point p = *THIS;
-	p += to<Rays::Point&>(point);
-	return value(p);
+	return value(-*THIS);
 }
 
 static
-VALUE sub(VALUE self, VALUE point)
+VALUE add(VALUE self)
 {
 	CHECK;
-
-	Rays::Point p = *THIS;
-	p -= to<Rays::Point&>(point);
-	return value(p);
+	if (argc == 1 && argv->is_num())
+		return value(*THIS + to<coord>(*argv));
+	else
+		return value(*THIS + to<Rays::Point>(argc, argv));
 }
 
 static
-VALUE mult(VALUE self, VALUE point)
+VALUE sub(VALUE self)
 {
 	CHECK;
-
-	Rays::Point p = *THIS;
-	p *= to<Rays::Point&>(point);
-	return value(p);
+	if (argc == 1 && argv->is_num())
+		return value(*THIS - to<coord>(*argv));
+	else
+		return value(*THIS - to<Rays::Point>(argc, argv));
 }
 
 static
-VALUE div(VALUE self, VALUE point)
+VALUE mult(VALUE self)
 {
 	CHECK;
+	if (argc == 1 && argv->is_num())
+		return value(*THIS * to<coord>(*argv));
+	else
+		return value(*THIS * to<Rays::Point>(argc, argv));
+}
 
-	Rays::Point p = *THIS;
-	p /= to<Rays::Point&>(point);
-	return value(p);
+static
+VALUE div(VALUE self)
+{
+	CHECK;
+	if (argc == 1 && argv->is_num())
+		return value(*THIS / to<coord>(*argv));
+	else
+		return value(*THIS / to<Rays::Point>(argc, argv));
 }
 
 static
-VALUE array_get(VALUE self, VALUE index)
+VALUE set_at(VALUE self, VALUE index, VALUE value)
 {
 	CHECK;
 
@@ -208,11 +215,12 @@ VALUE array_get(VALUE self, VALUE index)
 	if (i < 0 || 2 < i)
 		index_error(__FILE__, __LINE__);
 
-	return value((*THIS)[i]);
+	(*THIS)[i] = to<coord>(value);
+	return value;
 }
 
 static
-VALUE array_set(VALUE self, VALUE index, VALUE value)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
 
@@ -220,8 +228,7 @@ VALUE array_set(VALUE self, VALUE index, VALUE value)
 	if (i < 0 || 2 < i)
 		index_error(__FILE__, __LINE__);
 
-	(*THIS)[i] = to<coord>(value);
-	return value;
+	return value((*THIS)[i]);
 }
 
 static
@@ -231,6 +238,18 @@ VALUE inspect(VALUE self)
 	return value(Xot::stringf("#<Rays::Point %s>", THIS->inspect().c_str()));
 }
 
+static
+VALUE dot(VALUE self, VALUE p1, VALUE p2)
+{
+	return value(Rays::dot(to<Rays::Point>(p1), to<Rays::Point>(p2)));
+}
+
+static
+VALUE cross(VALUE self, VALUE p1, VALUE p2)
+{
+	return value(Rays::cross(to<Rays::Point>(p1), to<Rays::Point>(p2)));
+}
+
 
 static Class cPoint;
 
@@ -245,6 +264,8 @@ Init_point ()
 	rb_define_private_method(cPoint, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	cPoint.define_method("move_to!", move_to);
 	cPoint.define_method("move_by!", move_by);
+	rb_define_method(cPoint, "rotate", RUBY_METHOD_FUNC(rotate), 1);
+	cPoint.define_method("rotate!", rotate_self);
 	rb_define_method(cPoint, "length", RUBY_METHOD_FUNC(length), 0);
 	rb_define_method(cPoint, "normalize", RUBY_METHOD_FUNC(normalize), 0);
 	rb_define_method(cPoint, "normal", RUBY_METHOD_FUNC(normal), 0);
@@ -254,13 +275,16 @@ Init_point ()
 	rb_define_method(cPoint, "y", RUBY_METHOD_FUNC(get_y), 0);
 	rb_define_method(cPoint, "z=", RUBY_METHOD_FUNC(set_z), 1);
 	rb_define_method(cPoint, "z", RUBY_METHOD_FUNC(get_z), 0);
-	rb_define_method(cPoint, "op_add", RUBY_METHOD_FUNC(add), 1);
-	rb_define_method(cPoint, "op_sub", RUBY_METHOD_FUNC(sub), 1);
-	rb_define_method(cPoint, "op_mult", RUBY_METHOD_FUNC(mult), 1);
-	rb_define_method(cPoint, "op_div", RUBY_METHOD_FUNC(div), 1);
-	cPoint.define_method("[]",  array_get);
-	cPoint.define_method("[]=", array_set);
+	cPoint.define_method("-@", negate);
+	cPoint.define_method("+", add);
+	cPoint.define_method("-", sub);
+	cPoint.define_method("*", mult);
+	cPoint.define_method("/", div);
+	cPoint.define_method("[]=", set_at);
+	cPoint.define_method("[]",  get_at);
 	rb_define_method(cPoint, "inspect", RUBY_METHOD_FUNC(inspect), 0);
+	rb_define_module_function(cPoint, "dot", RUBY_METHOD_FUNC(dot), 2);
+	rb_define_module_function(cPoint, "cross", RUBY_METHOD_FUNC(cross), 2);
 }
 
 
@@ -269,43 +293,38 @@ namespace Rucy
 
 
 	template <> Rays::Point
-	value_to<Rays::Point> (Value value, bool convert)
+	value_to<Rays::Point> (int argc, const Value* argv, bool convert)
 	{
-		if (convert)
+		if (argc == 1 && argv->is_array())
 		{
-			size_t argc = 0;
-			Value* argv = NULL;
-			if (value.is_array())
-			{
-				argc = value.size();
-				argv = value.as_array();
-			}
-			else
-			{
-				argc = 1;
-				argv = &value;
-			}
+			argc = argv->size();
+			argv = argv->as_array();
+		}
 
-			if (argc < 1)
-				Rucy::argument_error(__FILE__, __LINE__);
+		assert(argc == 0 || (argc > 0 && argv));
 
-			if (argv[0].is_kind_of(Rays::point_class()))
-				value = argv[0];
-			else if (argv[0].is_i() || argv[0].is_f())
+		if (convert)
+		{
+			if (argc == 0)
+				return Rays::Point();
+			else if (argv->is_num())
 			{
 				switch (argc)
 				{
-					#define V(i) argv[i].as_f(true)
+					#define V(i) to<coord>(argv[i])
 					case 1: return Rays::Point(V(0));
 					case 2: return Rays::Point(V(0), V(1));
 					case 3: return Rays::Point(V(0), V(1), V(2));
 					#undef V
-					default: Rucy::argument_error(__FILE__, __LINE__);
+					default: argument_error(__FILE__, __LINE__);
 				}
 			}
 		}
 
-		return value_to<Rays::Point&>(value, convert);
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Point&>(*argv, convert);
 	}
 
 

data/.doc/ext/rays/polygon.cpp

@@ -0,0 +1,313 @@
+#include "rays/ruby/polygon.h"
+
+
+#include <vector>
+#include <functional>
+#include "rays/ruby/bounds.h"
+#include "rays/ruby/polyline.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon)
+
+#define THIS  to<Rays::Polygon*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Polygon>(klass);
+}
+
+static
+VALUE setup(VALUE self, VALUE args, VALUE loop)
+{
+	CHECK;
+
+	if (args[0].is_kind_of(Rays::polyline_class()))
+		*THIS = to<Rays::Polygon>(args.size(), args.as_array());
+	else
+	{
+		std::vector<Rays::Point> points;
+		get_line_args(&points, args.size(), args.as_array());
+		*THIS = Rays::Polygon(&points[0], points.size(), loop);
+	}
+}
+
+static
+VALUE expand(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Polygon#expand", argc, 1, 2, 3, 4);
+
+	coord width         =             to<coord>         (argv[0]);
+	Rays::CapType cap   = argc >= 2 ? to<Rays::CapType> (argv[1]) : Rays::CAP_DEFAULT;
+	Rays::JoinType join = argc >= 3 ? to<Rays::JoinType>(argv[2]) : Rays::JOIN_DEFAULT;
+	coord ml            = argc >= 4 ? to<coord>         (argv[3]) : Rays::JOIN_DEFAULT_MITER_LIMIT;
+
+	Rays::Polygon polygon;
+	THIS->expand(&polygon, width, cap, join, ml);
+	return value(polygon);
+}
+
+static
+VALUE bounds(VALUE self)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+
+static
+VALUE size(VALUE self)
+{
+	CHECK;
+	return value(THIS->size());
+}
+
+static
+VALUE empty(VALUE self)
+{
+	CHECK;
+	return value(THIS->empty());
+}
+
+static
+VALUE get_at(VALUE self, VALUE index)
+{
+	CHECK;
+
+	int size = (int) THIS->size();
+	int i    = to<int>(index);
+	if (i < 0) i += size;
+
+	if (i < 0 || size <= i)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
+}
+
+static
+VALUE each(VALUE self)
+{
+	CHECK;
+
+	Value ret = Qnil;
+	for (const auto& line : *THIS)
+		ret = rb_yield(value(line));
+	return ret;
+}
+
+static void
+each_polygon (const Value& value, std::function<void(const Rays::Polygon&)> fun)
+{
+	int size           = value.size();
+	const Value* array = value.as_array();
+
+	for (int i = 0; i < size; ++i)
+		fun(to<Rays::Polygon&>(array[i]));
+}
+
+static
+VALUE op_sub(VALUE self, VALUE obj)
+{
+	CHECK;
+
+	if (obj.is_array())
+	{
+		Rays::Polygon result = *THIS;
+		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		{
+			result = result - polygon;
+		});
+		return value(result);
+	}
+	else
+		return value(*THIS - to<Rays::Polygon&>(obj));
+}
+
+static
+VALUE op_and(VALUE self, VALUE obj)
+{
+	CHECK;
+
+	if (obj.is_array())
+	{
+		Rays::Polygon result = *THIS;
+		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		{
+			result = result & polygon;
+		});
+		return value(result);
+	}
+	else
+		return value(*THIS & to<Rays::Polygon&>(obj));
+}
+
+static
+VALUE op_or(VALUE self, VALUE obj)
+{
+	CHECK;
+
+	if (obj.is_array())
+	{
+		Rays::Polygon result = *THIS;
+		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		{
+			result = result | polygon;
+		});
+		return value(result);
+	}
+	else
+		return value(*THIS | to<Rays::Polygon&>(obj));
+}
+
+static
+VALUE op_xor(VALUE self, VALUE obj)
+{
+	CHECK;
+
+	if (obj.is_array())
+	{
+		Rays::Polygon result = *THIS;
+		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		{
+			result = result ^ polygon;
+		});
+		return value(result);
+	}
+	else
+		return value(*THIS ^ to<Rays::Polygon&>(obj));
+}
+
+static
+VALUE create_rect(VALUE self, VALUE
+	args, VALUE round, VALUE lefttop, VALUE righttop, VALUE leftbottom, VALUE rightbottom, VALUE nsegment)
+{
+	coord x, y, w, h, lt, rt, lb, rb;
+	uint nseg;
+	get_rect_args(
+		&x, &y, &w, &h, &lt, &rt, &lb, &rb, &nseg,
+		args.size(), args.as_array(),
+		round, lefttop, righttop, leftbottom, rightbottom, nsegment);
+
+	return value(Rays::create_rect(x, y, w, h, lt, rt, lb, rb, nseg));
+}
+
+static
+VALUE create_ellipse(VALUE self, VALUE
+	args, VALUE center, VALUE radius, VALUE hole, VALUE angle_from, VALUE angle_to, VALUE nsegment)
+{
+	coord x, y, w, h;
+	Rays::Point hole_size;
+	float from, to_;
+	uint nseg;
+	get_ellipse_args(
+		&x, &y, &w, &h, &hole_size, &from, &to_, &nseg,
+		args.size(), args.as_array(),
+		center, radius, hole, angle_from, angle_to, nsegment);
+
+	return value(Rays::create_ellipse(x, y, w, h, hole_size, from, to_, nseg));
+}
+
+static
+VALUE create_curve(VALUE self, VALUE args, VALUE loop)
+{
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	return value(Rays::create_curve(&points[0], points.size(), loop));
+}
+
+static
+VALUE create_bezier(VALUE self, VALUE args, VALUE loop)
+{
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	return value(Rays::create_bezier(&points[0], points.size(), loop));
+}
+
+
+static Class cPolygon;
+
+void
+Init_polygon ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	cPolygon = rb_define_class_under(mRays, "Polygon", rb_cObject);
+	rb_define_alloc_func(cPolygon, alloc);
+	rb_define_private_method(cPolygon, "setup", RUBY_METHOD_FUNC(setup), 2);
+	rb_define_method(cPolygon, "expand", RUBY_METHOD_FUNC(expand), -1);
+	rb_define_method(cPolygon, "bounds", RUBY_METHOD_FUNC(bounds), 0);
+	rb_define_method(cPolygon, "size", RUBY_METHOD_FUNC(size), 0);
+	cPolygon.define_method("empty?", empty);
+	cPolygon.define_method("[]", get_at);
+	rb_define_method(cPolygon, "each", RUBY_METHOD_FUNC(each), 0);
+	cPolygon.define_method("+", op_or);
+	cPolygon.define_method("-", op_sub);
+	cPolygon.define_method("&", op_and);
+	cPolygon.define_method("|", op_or);
+	cPolygon.define_method("^", op_xor);
+	rb_define_singleton_method(cPolygon, "create_rect", RUBY_METHOD_FUNC(create_rect), 7);
+	rb_define_singleton_method(cPolygon, "create_ellipse", RUBY_METHOD_FUNC(create_ellipse), 7);
+	rb_define_singleton_method(cPolygon, "create_curve", RUBY_METHOD_FUNC(create_curve), 2);
+	rb_define_singleton_method(cPolygon, "create_bezier", RUBY_METHOD_FUNC(create_bezier), 2);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Polygon
+	value_to<Rays::Polygon> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc == 0 || (argc > 0 && argv));
+
+		if (convert)
+		{
+			if (argc <= 0)
+				return Rays::Polygon();
+			else if (argv->is_kind_of(Rays::polygon_line_class()))
+			{
+				std::vector<Rays::Polygon::Line> lines;
+				lines.reserve(argc);
+				for (int i = 0; i < argc; ++i)
+					lines.emplace_back(to<Rays::Polygon::Line&>(argv[i]));
+				return Rays::Polygon(&lines[0], lines.size());
+			}
+			else if (argv->is_kind_of(Rays::polyline_class()))
+				return Rays::Polygon(to<Rays::Polyline&>(*argv));
+			else if (argv->is_num() || argv->is_array())
+			{
+				std::vector<Rays::Point> points;
+				get_line_args(&points, argc, argv);
+				return Rays::Polygon(&points[0], points.size());
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Polygon&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	polygon_class ()
+	{
+		return cPolygon;
+	}
+
+
+}// Rays