rays 0.1.13 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b7f128dcb83acfc5ac2d4bbb0b08bab93cbfbc342be7671acfe546cb8c76e27
-  data.tar.gz: 683ab9ce64d7fa95d2f769cddb4e5aca34538bf62aa6afb7ddca30a8e198ee73
+  metadata.gz: 8efafd5f580c6cc07ff8055d96a71d5b4ab7d65146e5d43872f04860b2bf9b7f
+  data.tar.gz: 0f3332f88fd3e413374b65ef70d72a210fbad4faa234a92ebe43ff465d97e99f
 SHA512:
-  metadata.gz: 7c88220a1c00951796d6a20862986ccd507664178fd97b9a7af0632305682d7e4d4a632585633292840ba59c13eff3c9c1a6e4f7b4e9f74ca48d8ccd5af980ab
-  data.tar.gz: fd4fabb2ce0d6c094dade7736892a2eabde0650744eb627f5102515583083580b80097ce3ad4bcf3d14962e6fa403f338aa7115b1c7283f11fed2e6cc1635e56
+  metadata.gz: 04b7cc4a91bf19910f0b846f761d0996d7c06a678a2297c2ac2768233fe56d193464f960300934d0d42496aa4882c67f5c6807285443ddad13a68d311ced3e4d
+  data.tar.gz: a02ba9f0b544539cbd8f826ef858a17704d1a07f8f4268e28aa4b2c95d1aa29ea17c2fa87d0a73241f8ccbe1cfdee6bee3887a974dd8c74375e4159f0b89a9e6

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/color_space.cpp

@@ -181,6 +181,9 @@ 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);
@@ -195,9 +198,6 @@ Init_color_space ()
 	cColorSpace.define_method("has_skip?",  has_skip);
 	cColorSpace.define_method("premult?", is_premult);
 	rb_define_method(cColorSpace, "to_s", RUBY_METHOD_FUNC(to_s), 0);
-
-	for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-		cColorSpace.define_const(COLOR_SPACES[i].name, COLOR_SPACES[i].type);
 }
 
 
@@ -218,16 +218,7 @@ namespace Rucy
 
 		if (convert)
 		{
-			if (argv->is_s() || argv->is_sym())
-			{
-				const char* str = argv[0].c_str();
-				for (size_t i = 0; i < COLOR_SPACES_SIZE; ++i)
-				{
-					if (strcasecmp(str, COLOR_SPACES[i].name) == 0)
-						return Rays::ColorSpace(COLOR_SPACES[i].type);
-				}
-			}
-			else if (argv->is_i())
+			if (argv->is_i() || argv->is_s() || argv->is_sym())
 			{
 				return Rays::ColorSpace(
 					to<Rays::ColorSpaceType>(argv[0]),
@@ -245,7 +236,24 @@ namespace Rucy
 	template <> Rays::ColorSpaceType
 	value_to<Rays::ColorSpaceType> (Value value, bool convert)
 	{
-		return (Rays::ColorSpaceType) value_to<uint>(value, 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;
 	}
 
 

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

@@ -141,6 +141,36 @@ VALUE ellipse(VALUE self, VALUE args, VALUE center, VALUE radius, VALUE hole, VA
 	return self;
 }
 
+static
+VALUE curve(VALUE self, VALUE args, VALUE loop)
+{
+	CHECK;
+
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
+
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->curve(&points[0], points.size(), loop);
+	return self;
+}
+
+static
+VALUE bezier(VALUE self, VALUE args, VALUE loop)
+{
+	CHECK;
+
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
+
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->bezier(&points[0], points.size(), loop);
+	return self;
+}
+
 static
 VALUE image(VALUE self)
 {
@@ -292,6 +322,51 @@ VALUE get_stroke_width(VALUE self)
 	return value(THIS->stroke_width());
 }
 
+static
+VALUE set_stroke_cap(VALUE self, VALUE cap)
+{
+	CHECK;
+	THIS->set_stroke_cap(to<Rays::CapType>(cap));
+	return self;
+}
+
+static
+VALUE get_stroke_cap(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_cap());
+}
+
+static
+VALUE set_stroke_join(VALUE self, VALUE join)
+{
+	CHECK;
+	THIS->set_stroke_join(to<Rays::JoinType>(join));
+	return self;
+}
+
+static
+VALUE get_stroke_join(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_join());
+}
+
+static
+VALUE set_miter_limit(VALUE self, VALUE limit)
+{
+	CHECK;
+	THIS->set_miter_limit(to<coord>(limit));
+	return self;
+}
+
+static
+VALUE get_miter_limit(VALUE self)
+{
+	CHECK;
+	return value(THIS->miter_limit());
+}
+
 static
 VALUE set_nsegment(VALUE self, VALUE nsegment)
 {
@@ -490,6 +565,8 @@ Init_painter ()
 	rb_define_private_method(cPainter, "draw_polyline", RUBY_METHOD_FUNC(polyline), 1);
 	rb_define_private_method(cPainter, "draw_rect", RUBY_METHOD_FUNC(rect), 6);
 	rb_define_private_method(cPainter, "draw_ellipse", RUBY_METHOD_FUNC(ellipse), 6);
+	rb_define_private_method(cPainter, "draw_curve", RUBY_METHOD_FUNC(curve), 2);
+	rb_define_private_method(cPainter, "draw_bezier", RUBY_METHOD_FUNC(bezier), 2);
 	rb_define_method(cPainter, "image", RUBY_METHOD_FUNC(image), -1);
 	rb_define_method(cPainter, "text", RUBY_METHOD_FUNC(text), -1);
 
@@ -504,6 +581,12 @@ Init_painter ()
 	rb_define_method(cPainter, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
 	rb_define_method(cPainter, "stroke_width=", RUBY_METHOD_FUNC(set_stroke_width), 1);
 	rb_define_method(cPainter, "stroke_width", RUBY_METHOD_FUNC(get_stroke_width), 0);
+	rb_define_method(cPainter, "stroke_cap=", RUBY_METHOD_FUNC(set_stroke_cap), 1);
+	rb_define_method(cPainter, "stroke_cap", RUBY_METHOD_FUNC(get_stroke_cap), 0);
+	rb_define_method(cPainter, "stroke_join=", RUBY_METHOD_FUNC(set_stroke_join), 1);
+	rb_define_method(cPainter, "stroke_join", RUBY_METHOD_FUNC(get_stroke_join), 0);
+	rb_define_method(cPainter, "miter_limit=", RUBY_METHOD_FUNC(set_miter_limit), 1);
+	rb_define_method(cPainter, "miter_limit", RUBY_METHOD_FUNC(get_miter_limit), 0);
 	rb_define_method(cPainter, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
 	rb_define_method(cPainter, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
 	rb_define_method(cPainter, "clip=", RUBY_METHOD_FUNC(set_clip), -1);