rays 0.1.15 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c784fe46265f04062957d138081db6de0d9e257600be215741d120563534420c
-  data.tar.gz: d58b4c10a2e9f0591a6465aea2b36f01de4f0720187acd2fbf98608162bb77d0
+  metadata.gz: b024121da2cf3b4ac1ece9ae33ec4005ad3d39e048babec1856ec01976022cdd
+  data.tar.gz: f20ecfdd2812170af9fb233bb7f32a5219221b77c09f8b24faa80788294c3c67
 SHA512:
-  metadata.gz: 2a4771e03c225cd3f84c0d723ee3072d3a1403eec5028e38c1cc00ddda5e27dbd6ed4db14bee3fa9c8f412e49928cf4b9fd13f5cc5ae79b80149438dd3f9c96c
-  data.tar.gz: 17567e4b335014d772f80f35c1a44859893605c65912469f00aac2ecc6f6a9a1c024d1303b42a24e78dd59b8797cc41f2af1b47627755250e74f5eac12dbc031
+  metadata.gz: 5acf9ecd53dc6c9cbf9ebd13194f41497185bd7f6b24712fe9a7ee55f2a9fbba5bbda61ba3bc832d035b3bdb2e6be6626d5daa0ae61713438fc82b02b65c9839
+  data.tar.gz: 37a16d92503200564afcdca07a242d3b2932800ff4c0ebb85aae78b74b76b1ab02967c3a7e76d9968c1be4eb1491e6e18074f60b0cecbf165451c8ebb6a0ca06

data/.doc/ext/rays/camera.cpp

@@ -0,0 +1,171 @@
+#include "rays/ruby/camera.h"
+
+
+#include "rays/ruby/image.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Camera)
+
+#define THIS  to<Rays::Camera*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Camera, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Camera>(klass);
+}
+
+static
+VALUE setup(VALUE self, VALUE device_name, VALUE min_width, VALUE min_height, VALUE resize, VALUE crop)
+{
+	RUCY_CHECK_OBJ(Rays::Camera, self);
+
+	*THIS = Rays::Camera(
+		device_name ? to<const char*>(device_name) : NULL,
+		to<int>(min_width), to<int>(min_height),
+		to<bool>(resize), to<bool>(crop));
+	return self;
+}
+
+static
+VALUE start(VALUE self)
+{
+	CHECK;
+	return value(THIS->start());
+}
+
+static
+VALUE stop(VALUE self)
+{
+	CHECK;
+	THIS->stop();
+}
+
+static
+VALUE is_active(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_active());
+}
+
+static
+VALUE set_min_width(VALUE self, VALUE width)
+{
+	CHECK;
+	THIS->set_min_width(to<int>(width));
+	return value(THIS->min_width());
+}
+
+static
+VALUE min_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->min_width());
+}
+
+static
+VALUE set_min_height(VALUE self, VALUE height)
+{
+	CHECK;
+	THIS->set_min_height(to<int>(height));
+	return value(THIS->min_height());
+}
+
+static
+VALUE min_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->min_height());
+}
+
+static
+VALUE set_resize(VALUE self, VALUE resize)
+{
+	CHECK;
+	THIS->set_resize(to<bool>(resize));
+	return value(THIS->is_resize());
+}
+
+static
+VALUE is_resize(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+
+static
+VALUE set_crop(VALUE self, VALUE crop)
+{
+	CHECK;
+	THIS->set_crop(to<bool>(crop));
+	return value(THIS->is_crop());
+}
+
+static
+VALUE is_crop(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_crop());
+}
+
+static
+VALUE image(VALUE self)
+{
+	CHECK;
+	const Rays::Image* img = THIS->image();
+	return img ? value(*img) : nil();
+}
+
+static
+VALUE device_names(VALUE self)
+{
+	auto names = Rays::get_camera_device_names();
+
+	std::vector<Value> v;
+	for (auto it = names.begin(), end = names.end(); it != end; ++it)
+		v.emplace_back(value(it->c_str()));
+	return value(v.size(), &v[0]);
+}
+
+
+static Class cCamera;
+
+void
+Init_camera ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	cCamera = rb_define_class_under(mRays, "Camera", rb_cObject);
+	rb_define_alloc_func(cCamera, alloc);
+	rb_define_private_method(cCamera, "setup", RUBY_METHOD_FUNC(setup), 5);
+	rb_define_method(cCamera, "start", RUBY_METHOD_FUNC(start), 0);
+	rb_define_method(cCamera, "stop", RUBY_METHOD_FUNC(stop), 0);
+	cCamera.define_method("active?", is_active);
+	rb_define_method(cCamera, "min_width=", RUBY_METHOD_FUNC(set_min_width), 1);
+	rb_define_method(cCamera, "min_width", RUBY_METHOD_FUNC(min_width), 0);
+	rb_define_method(cCamera, "min_height=", RUBY_METHOD_FUNC(set_min_height), 1);
+	rb_define_method(cCamera, "min_height", RUBY_METHOD_FUNC(min_height), 0);
+	rb_define_method(cCamera, "resize=", RUBY_METHOD_FUNC(set_resize), 1);
+	cCamera.define_method("resize?",  is_resize);
+	rb_define_method(cCamera, "crop=", RUBY_METHOD_FUNC(set_crop), 1);
+	cCamera.define_method("crop?",    is_crop);
+	rb_define_method(cCamera, "image", RUBY_METHOD_FUNC(image), 0);
+	rb_define_module_function(cCamera, "device_names", RUBY_METHOD_FUNC(device_names), 0);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	camera_class ()
+	{
+		return cCamera;
+	}
+
+
+}// Rays

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

@@ -198,9 +198,8 @@ Init_color ()
 	rb_define_method(cColor, "blue", RUBY_METHOD_FUNC(get_blue), 0);
 	rb_define_method(cColor, "alpha=", RUBY_METHOD_FUNC(set_alpha), 1);
 	rb_define_method(cColor, "alpha", RUBY_METHOD_FUNC(get_alpha), 0);
-
-	rb_define_function(cColor, "hsv", RUBY_METHOD_FUNC(hsv), -1);
-	rb_define_function(cColor, "set_palette_color", RUBY_METHOD_FUNC(set_palette_color), -1);
+	rb_define_module_function(cColor, "hsv", RUBY_METHOD_FUNC(hsv), -1);
+	rb_define_module_function(cColor, "set_palette_color", RUBY_METHOD_FUNC(set_palette_color), -1);
 }
 
 

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

@@ -55,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;
 
@@ -70,6 +97,9 @@ Init_font ()
 	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);
 }
 
 

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

@@ -138,7 +138,7 @@ Init_image ()
 	rb_define_method(cImage, "painter", RUBY_METHOD_FUNC(painter), 0);
 	rb_define_method(cImage, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
 	rb_define_method(cImage, "save", RUBY_METHOD_FUNC(save), 1);
-	rb_define_function(cImage, "load", RUBY_METHOD_FUNC(load), -1);
+	rb_define_module_function(cImage, "load", RUBY_METHOD_FUNC(load), -1);
 }
 
 

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

@@ -9,6 +9,7 @@ void Init_color ();
 void Init_color_space ();
 void Init_matrix ();
 
+void Init_painter ();
 void Init_polyline ();
 void Init_polygon_line ();
 void Init_polygon ();
@@ -16,8 +17,7 @@ void Init_bitmap ();
 void Init_image ();
 void Init_font ();
 void Init_shader ();
-
-void Init_painter ();
+void Init_camera ();
 
 void Init_noise ();
 
@@ -41,6 +41,7 @@ extern "C" void
 	Init_color_space();
 	Init_matrix();
 
+	Init_painter();
 	Init_polyline();
 	Init_polygon_line();
 	Init_polygon();
@@ -48,8 +49,7 @@ extern "C" void
 	Init_image();
 	Init_font();
 	Init_shader();
-
-	Init_painter();
+	Init_camera();
 
 	Init_noise();
 

data/.doc/ext/rays/painter.cpp

@@ -326,12 +326,7 @@ static
 VALUE set_stroke_cap(VALUE self, VALUE cap)
 {
 	CHECK;
-
-	int type = to<int>(cap);
-	if (type < 0 || Rays::CAP_MAX <= type)
-		argument_error(__FILE__, __LINE__, "invalid stroke cap -- %d", type);
-
-	THIS->set_stroke_cap((Rays::CapType) type);
+	THIS->set_stroke_cap(to<Rays::CapType>(cap));
 	return self;
 }
 
@@ -346,12 +341,7 @@ static
 VALUE set_stroke_join(VALUE self, VALUE join)
 {
 	CHECK;
-
-	int type = to<int>(join);
-	if (type < 0 || Rays::JOIN_MAX <= type)
-		argument_error(__FILE__, __LINE__, "invalid stroke join -- %d", type);
-
-	THIS->set_stroke_join((Rays::JoinType) type);
+	THIS->set_stroke_join(to<Rays::JoinType>(join));
 	return self;
 }
 

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

@@ -238,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;
 
@@ -271,6 +283,8 @@ Init_point ()
 	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);
 }
 
 

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

@@ -74,7 +74,7 @@ VALUE empty(VALUE self)
 }
 
 static
-VALUE at(VALUE self, VALUE index)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
 
@@ -93,7 +93,7 @@ VALUE each(VALUE self)
 {
 	CHECK;
 
-	Value ret;
+	Value ret = Qnil;
 	for (const auto& line : *THIS)
 		ret = rb_yield(value(line));
 	return ret;
@@ -244,7 +244,7 @@ Init_polygon ()
 	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("[]", at);
+	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);

data/.doc/ext/rays/polyline.cpp

@@ -76,7 +76,7 @@ VALUE empty(VALUE self)
 }
 
 static
-VALUE at(VALUE self, VALUE index)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
 
@@ -95,7 +95,7 @@ VALUE each(VALUE self)
 {
 	CHECK;
 
-	Value ret;
+	Value ret = Qnil;
 	for (const auto& point : *THIS)
 		ret = rb_yield(value(point));
 	return ret;
@@ -117,7 +117,7 @@ Init_polyline ()
 	cPolyline.define_method("loop?", loop);
 	rb_define_method(cPolyline, "size", RUBY_METHOD_FUNC(size), 0);
 	cPolyline.define_method("empty?", empty);
-	cPolyline.define_method("[]", at);
+	cPolyline.define_method("[]", get_at);
 	rb_define_method(cPolyline, "each", RUBY_METHOD_FUNC(each), 0);
 }
 

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

@@ -1,43 +1,33 @@
 #include "rays/ruby/rays.h"
 
 
+#include <vector>
 #include "defs.h"
 
 
-RUCY_DEFINE_VALUE_OR_ARRAY_TO(Rays::CapType)
-RUCY_DEFINE_VALUE_OR_ARRAY_TO(Rays::JoinType)
+RUCY_DEFINE_CONVERT_TO(Rays::CapType)
+RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
 
 
-static struct CapTypeEnum
+template <typename T>
+struct EnumType
 {
 	const char* name;
-	Rays::CapType type;
-}
-CAP_TYPES[] =
-{
-	{"CAP_BUTT",   Rays::CAP_BUTT},
-	{"CAP_ROUND",  Rays::CAP_ROUND},
-	{"CAP_SQUARE", Rays::CAP_SQUARE},
+	const char* short_name;
+	T type;
 };
 
-static const size_t CAP_TYPES_SIZE =
-	sizeof(CAP_TYPES) / sizeof(CAP_TYPES[0]);
-
-
-static struct JoinTypeEnum
-{
-	const char* name;
-	Rays::JoinType type;
-}
-JOIN_TYPES[] =
-{
-	{"JOIN_MITER",  Rays::JOIN_MITER},
-	{"JOIN_ROUND",  Rays::JOIN_ROUND},
-	{"JOIN_SQUARE", Rays::JOIN_SQUARE},
-};
+static std::vector<EnumType<Rays::CapType>> CAP_TYPES({
+	{"CAP_BUTT",   "BUTT",   Rays::CAP_BUTT},
+	{"CAP_ROUND",  "ROUND",  Rays::CAP_ROUND},
+	{"CAP_SQUARE", "SQUARE", Rays::CAP_SQUARE},
+});
 
-static const size_t JOIN_TYPES_SIZE =
-	sizeof(JOIN_TYPES) / sizeof(JOIN_TYPES[0]);
+static std::vector<EnumType<Rays::JoinType>> JOIN_TYPES({
+	{"JOIN_MITER",  "MITER",  Rays::JOIN_MITER},
+	{"JOIN_ROUND",  "ROUND",  Rays::JOIN_ROUND},
+	{"JOIN_SQUARE", "SQUARE", Rays::JOIN_SQUARE},
+});
 
 
 static
@@ -65,11 +55,11 @@ Init_rays ()
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
 
-	for (size_t i = 0; i < CAP_TYPES_SIZE; ++i)
-		mRays.define_const(CAP_TYPES[i].name, CAP_TYPES[i].type);
+	for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
+		mRays.define_const(it->name, it->type);
 
-	for (size_t i = 0; i < JOIN_TYPES_SIZE; ++i)
-		mRays.define_const(JOIN_TYPES[i].name, JOIN_TYPES[i].type);
+	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
+		mRays.define_const(it->name, it->type);
 }
 
 
@@ -87,16 +77,21 @@ namespace Rucy
 			if (argv->is_s() || argv->is_sym())
 			{
 				const char* str = argv->c_str();
-				for (size_t i = 0; i < CAP_TYPES_SIZE; ++i)
+				for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
 				{
-					if (strcasecmp(str, CAP_TYPES[i].name) == 0)
-						return CAP_TYPES[i].type;
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
 				}
+				argument_error(__FILE__, __LINE__, "invalid cap type -- %s", str);
 			}
 		}
 
-		uint type = value_to<uint>(*argv, convert);
-		if (type >= Rays::CAP_MAX)
+		int type = value_to<int>(*argv, convert);
+		if (type < 0 || Rays::CAP_MAX <= type)
 			argument_error(__FILE__, __LINE__, "invalid cap type -- %d", type);
 
 		return (Rays::CapType) type;
@@ -113,16 +108,21 @@ namespace Rucy
 			if (argv->is_s() || argv->is_sym())
 			{
 				const char* str = argv->c_str();
-				for (size_t i = 0; i < JOIN_TYPES_SIZE; ++i)
+				for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
 				{
-					if (strcasecmp(str, JOIN_TYPES[i].name) == 0)
-						return JOIN_TYPES[i].type;
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
 				}
+				argument_error(__FILE__, __LINE__, "invalid join type -- %s", str);
 			}
 		}
 
-		uint type = value_to<uint>(*argv, convert);
-		if (type >= Rays::JOIN_MAX)
+		int type = value_to<int>(*argv, convert);
+		if (type < 0 || Rays::JOIN_MAX <= type)
 			argument_error(__FILE__, __LINE__, "invalid join type -- %d", type);
 
 		return (Rays::JoinType) type;