rays 0.1.12 → 0.1.17

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

@@ -0,0 +1,96 @@
+#include "rays/ruby/polygon.h"
+
+
+#include "rays/ruby/polyline.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
+
+#define THIS  to<Rays::Polygon::Line*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Polygon::Line, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Polygon::Line>(klass);
+}
+
+static
+VALUE setup(VALUE self, VALUE points, VALUE loop, VALUE hole)
+{
+	CHECK;
+
+	std::vector<Rays::Point> array;
+	get_line_args(&array, points.size(), points.as_array());
+	*THIS = Rays::Polygon::Line(&array[0], array.size(), loop, hole);
+}
+
+static
+VALUE hole(VALUE self)
+{
+	CHECK;
+	return value(THIS->hole());
+}
+
+
+static Class cPolygonLine;
+
+void
+Init_polygon_line ()
+{
+	Module mRays = rb_define_module("Rays");
+	Class cPolygon = rb_define_class_under(mRays, "Polygon", rb_cObject);
+
+	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
+	rb_define_alloc_func(cPolygonLine, alloc);
+	rb_define_private_method(cPolygonLine, "setup", RUBY_METHOD_FUNC(setup), 3);
+	cPolygonLine.define_method("hole?", hole);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Polygon::Line
+	value_to<Rays::Polygon::Line> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc == 0 || (argc > 0 && argv));
+
+		if (convert)
+		{
+			if (argc <= 0)
+				return Rays::Polygon::Line();
+			else if (argv->is_num() || argv->is_array())
+			{
+				std::vector<Rays::Point> points;
+				get_line_args(&points, argc, argv);
+				return Rays::Polygon::Line(&points[0], points.size());
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Polygon::Line&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	polygon_line_class ()
+	{
+		return cPolygonLine;
+	}
+
+
+}// Rays

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

@@ -0,0 +1,167 @@
+#include "rays/ruby/polyline.h"
+
+
+#include <vector>
+#include "rays/ruby/point.h"
+#include "rays/ruby/bounds.h"
+#include "rays/ruby/polygon.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Polyline)
+
+#define THIS  to<Rays::Polyline*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Rays::Polyline, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Polyline>(klass);
+}
+
+static
+VALUE setup(VALUE self, VALUE points, VALUE loop)
+{
+	CHECK;
+
+	std::vector<Rays::Point> array;
+	get_line_args(&array, points.size(), points.as_array());
+	*THIS = Rays::Polyline(&array[0], array.size(), loop);
+}
+
+static
+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, width, cap, join, ml);
+	return value(polygon);
+}
+
+static
+VALUE bounds(VALUE self)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+
+static
+VALUE loop(VALUE self)
+{
+	CHECK;
+	return value(THIS->loop());
+}
+
+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& point : *THIS)
+		ret = rb_yield(value(point));
+	return ret;
+}
+
+
+static Class cPolyline;
+
+void
+Init_polyline ()
+{
+	Module mRays = rb_define_module("Rays");
+
+	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, "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("[]", get_at);
+	rb_define_method(cPolyline, "each", RUBY_METHOD_FUNC(each), 0);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> Rays::Polyline
+	value_to<Rays::Polyline> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc == 0 || (argc > 0 && argv));
+
+		if (convert)
+		{
+			if (argc <= 0)
+				return Rays::Polyline();
+			else if (argv->is_num() || argv->is_array())
+			{
+				std::vector<Rays::Point> points;
+				get_line_args(&points, argc, argv);
+				return Rays::Polyline(&points[0], points.size());
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Polyline&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Rays
+{
+
+
+	Class
+	polyline_class ()
+	{
+		return cPolyline;
+	}
+
+
+}// Rays

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

@@ -1,10 +1,33 @@
-#include <rucy.h>
-#include "rays/rays.h"
-#include "rays/opengl.h"
+#include "rays/ruby/rays.h"
+
+
+#include <vector>
 #include "defs.h"
 
 
-using namespace Rucy;
+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
@@ -21,13 +44,6 @@ VALUE fin(VALUE self)
 	return self;
 }
 
-static
-VALUE init_offscreen_context(VALUE self)
-{
-	Rays::init_offscreen_context();
-	return self;
-}
-
 
 static Module mRays;
 
@@ -35,12 +51,87 @@ void
 Init_rays ()
 {
 	mRays = rb_define_module("Rays");
+
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
-	rb_define_singleton_method(mRays, "init_offscreen_context", RUBY_METHOD_FUNC(init_offscreen_context), 0);
+
+	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/.doc/ext/rays/shader.cpp

@@ -1,14 +1,10 @@
 #include "rays/ruby/shader.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Shader)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Shader)
 
 #define THIS  to<Rays::Shader*>(self)
 
@@ -22,14 +18,60 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE source)
+VALUE setup(VALUE self, VALUE source)
 {
 	RUCY_CHECK_OBJ(Rays::Shader, self);
 
-	if (!source.is_s())
+	*THIS = to<Rays::Shader>(source);
+}
+
+static
+VALUE set_uniform(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#set_uniform", argc, 2, 3, 4, 5);
+
+	#define Ai(n) (argv[n].as_i())
+	#define Af(n) ((float) argv[n].as_f())
+
+	const char* name = argv[0].c_str();
+	if (argv[1].is_array())
+	{
+		argc = argv[1].size();
+		argv = argv[1].as_array();
+	}
+	else
+	{
+		argc -= 1;
+		argv += 1;
+	}
+
+	if (argv[0].is_i())
+	{
+		switch (argc)
+		{
+			case 1: THIS->set_uniform(name, Ai(0)); break;
+			case 2: THIS->set_uniform(name, Ai(0), Ai(1)); break;
+			case 3: THIS->set_uniform(name, Ai(0), Ai(1), Ai(2)); break;
+			case 4: THIS->set_uniform(name, Ai(0), Ai(1), Ai(2), Ai(3)); break;
+		}
+	}
+	else if (argv[0].is_f())
+	{
+		switch (argc)
+		{
+			case 1: THIS->set_uniform(name, Af(0)); break;
+			case 2: THIS->set_uniform(name, Af(0), Af(1)); break;
+			case 3: THIS->set_uniform(name, Af(0), Af(1), Af(2)); break;
+			case 4: THIS->set_uniform(name, Af(0), Af(1), Af(2), Af(3)); break;
+		}
+	}
+	else
 		argument_error(__FILE__, __LINE__);
 
-	*THIS = Rays::Shader(source.c_str());
+	#undef Ai
+	#undef Af
+
 	return self;
 }
 
@@ -43,10 +85,42 @@ Init_shader ()
 
 	cShader = rb_define_class_under(mRays, "Shader", rb_cObject);
 	rb_define_alloc_func(cShader, alloc);
-	rb_define_private_method(cShader, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_private_method(cShader, "setup", RUBY_METHOD_FUNC(setup), 1);
+	rb_define_private_method(cShader, "set_uniform", RUBY_METHOD_FUNC(set_uniform), -1);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::Shader
+	value_to<Rays::Shader> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s())
+				return Rays::Shader(argv[0].c_str());
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Shader&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {