rays 0.1.13 → 0.1.18

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

@@ -26,7 +26,7 @@ VALUE setup(VALUE self, VALUE args, VALUE loop)
 {
 	CHECK;
 
-	if (loop)
+	if (args[0].is_kind_of(Rays::polyline_class()))
 		*THIS = to<Rays::Polygon>(args.size(), args.as_array());
 	else
 	{
@@ -37,12 +37,18 @@ VALUE setup(VALUE self, VALUE args, VALUE loop)
 }
 
 static
-VALUE expand(VALUE self, VALUE width)
+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, to<coord>(width));
+	THIS->expand(&polygon, width, cap, join, ml);
 	return value(polygon);
 }
 
@@ -68,7 +74,7 @@ VALUE empty(VALUE self)
 }
 
 static
-VALUE at(VALUE self, VALUE index)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
 
@@ -87,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;
@@ -205,6 +211,24 @@ VALUE create_ellipse(VALUE self, VALUE
 	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;
 
@@ -216,11 +240,11 @@ Init_polygon ()
 	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, "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("[]", 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);
@@ -229,6 +253,8 @@ Init_polygon ()
 	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);
 }
 
 

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

@@ -32,12 +32,18 @@ VALUE setup(VALUE self, VALUE points, VALUE loop)
 }
 
 static
-VALUE expand(VALUE self, VALUE width)
+VALUE expand(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Polyline#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, to<coord>(width));
+	THIS->expand(&polygon, width, cap, join, ml);
 	return value(polygon);
 }
 
@@ -70,7 +76,7 @@ VALUE empty(VALUE self)
 }
 
 static
-VALUE at(VALUE self, VALUE index)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
 
@@ -89,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;
@@ -106,12 +112,12 @@ Init_polyline ()
 	cPolyline = rb_define_class_under(mRays, "Polyline", rb_cObject);
 	rb_define_alloc_func(cPolyline, alloc);
 	rb_define_private_method(cPolyline, "setup", RUBY_METHOD_FUNC(setup), 2);
-	rb_define_method(cPolyline, "expand", RUBY_METHOD_FUNC(expand), 1);
+	rb_define_method(cPolyline, "expand", RUBY_METHOD_FUNC(expand), -1);
 	rb_define_method(cPolyline, "bounds", RUBY_METHOD_FUNC(bounds), 0);
 	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,7 +1,35 @@
-#include "rays/rays.h"
+#include "rays/ruby/rays.h"
+
+
+#include <vector>
 #include "defs.h"
 
 
+RUCY_DEFINE_CONVERT_TO(Rays::CapType)
+RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
+
+
+template <typename T>
+struct EnumType
+{
+	const char* name;
+	const char* short_name;
+	T type;
+};
+
+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 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
 VALUE init(VALUE self)
 {
@@ -23,11 +51,87 @@ void
 Init_rays ()
 {
 	mRays = rb_define_module("Rays");
+
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
+
+	for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
+		mRays.define_const(it->name, it->type);
+
+	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
+		mRays.define_const(it->name, it->type);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::CapType
+	value_to<Rays::CapType> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid cap type -- %s", str);
+			}
+		}
+
+		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;
+	}
+
+
+	template <> Rays::JoinType
+	value_to<Rays::JoinType> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid join type -- %s", str);
+			}
+		}
+
+		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;
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {
 

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 xord.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -29,6 +29,9 @@ use_external_library 'https://github.com/greenm01/poly2tri',
   incdir: 'poly2tri',
   srcdir: 'poly2tri'
 
+use_external_library 'https://github.com/andrewwillmott/splines-lib.git',
+  excludes: 'Test\.cpp'
+
 build_native_library
 build_ruby_extension
 test_ruby_extension

data/VERSION

@@ -1 +1 @@
-0.1.13
+0.1.18

data/ext/rays/bitmap.cpp

@@ -110,7 +110,7 @@ Init_bitmap ()
 	cBitmap.define_alloc_func(alloc);
 	cBitmap.define_private_method("initialize",      initialize);
 	cBitmap.define_private_method("initialize_copy", initialize_copy);
-	cBitmap.define_method("width", width);
+	cBitmap.define_method("width",  width);
 	cBitmap.define_method("height", height);
 	cBitmap.define_method("color_space", color_space);
 	cBitmap.define_method("[]=", set_at);

data/ext/rays/camera.cpp

@@ -0,0 +1,186 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Camera>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF5(setup, device_name, min_width, min_height, resize, 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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(start)
+{
+	CHECK;
+	return value(THIS->start());
+}
+RUCY_END
+
+static
+RUCY_DEF0(stop)
+{
+	CHECK;
+	THIS->stop();
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_active)
+{
+	CHECK;
+	return value(THIS->is_active());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_min_width, width)
+{
+	CHECK;
+	THIS->set_min_width(to<int>(width));
+	return value(THIS->min_width());
+}
+RUCY_END
+
+static
+RUCY_DEF0(min_width)
+{
+	CHECK;
+	return value(THIS->min_width());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_min_height, height)
+{
+	CHECK;
+	THIS->set_min_height(to<int>(height));
+	return value(THIS->min_height());
+}
+RUCY_END
+
+static
+RUCY_DEF0(min_height)
+{
+	CHECK;
+	return value(THIS->min_height());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_resize, resize)
+{
+	CHECK;
+	THIS->set_resize(to<bool>(resize));
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_resize)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_crop, crop)
+{
+	CHECK;
+	THIS->set_crop(to<bool>(crop));
+	return value(THIS->is_crop());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_crop)
+{
+	CHECK;
+	return value(THIS->is_crop());
+}
+RUCY_END
+
+static
+RUCY_DEF0(image)
+{
+	CHECK;
+	const Rays::Image* img = THIS->image();
+	return img ? value(*img) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(device_names)
+{
+	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]);
+}
+RUCY_END
+
+
+static Class cCamera;
+
+void
+Init_camera ()
+{
+	Module mRays = define_module("Rays");
+
+	cCamera = mRays.define_class("Camera");
+	cCamera.define_alloc_func(alloc);
+	cCamera.define_private_method("setup", setup);
+	cCamera.define_method("start", start);
+	cCamera.define_method("stop",  stop);
+	cCamera.define_method("active?", is_active);
+	cCamera.define_method("min_width=",  set_min_width);
+	cCamera.define_method("min_width",       min_width);
+	cCamera.define_method("min_height=", set_min_height);
+	cCamera.define_method("min_height",      min_height);
+	cCamera.define_method("resize=", set_resize);
+	cCamera.define_method("resize?",  is_resize);
+	cCamera.define_method("crop=",   set_crop);
+	cCamera.define_method("crop?",    is_crop);
+	cCamera.define_method("image", image);
+	cCamera.define_module_function("device_names", device_names);
+}
+
+
+namespace Rays
+{
+
+
+	Class
+	camera_class ()
+	{
+		return cCamera;
+	}
+
+
+}// Rays