rays 0.1.12 → 0.1.13

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,161 @@
+#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, VALUE width)
+{
+	CHECK;
+
+	Rays::Polygon polygon;
+	THIS->expand(&polygon, to<coord>(width));
+	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 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;
+	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("[]", 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,12 +1,7 @@
-#include <rucy.h>
 #include "rays/rays.h"
-#include "rays/opengl.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 static
 VALUE init(VALUE self)
 {
@@ -21,13 +16,6 @@ VALUE fin(VALUE self)
 	return self;
 }
 
-static
-VALUE init_offscreen_context(VALUE self)
-{
-	Rays::init_offscreen_context();
-	return self;
-}
-
 
 static Module mRays;
 
@@ -37,7 +25,6 @@ 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);
 }
 
 

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
 {
 

data/README.md

@@ -1,4 +1,4 @@
 
 # Rays - A Drawing Engine using OpenGL.
 
- by snori@xord.org
+ by xordog@gmail.com

data/Rakefile

@@ -2,25 +2,37 @@
 
 
 %w[../xot ../rucy .]
-  .map  {|s| File.expand_path "../#{s}/lib", __FILE__}
+  .map  {|s| File.expand_path "#{s}/lib", __dir__}
   .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
-require 'xot/rake'
+require 'rucy/rake'
+
 require 'xot/module'
 require 'rucy/module'
 require 'rays/module'
 
-include Xot::Rake
-
 
-MODULES     = [Xot, Rucy, Rays].map {|m| m.const_get :Module}
-MODULE      = MODULES.last
+MODULES     = [Xot, Rucy, Rays]
 TESTS_ALONE = ['test/test_rays.rb']
 
+use_external_library 'https://github.com/g-truc/glm',
+  tag: '0.9.8.5',
+  srcdir: 'NOSRC'
 
-task :default => :build
+use_external_library 'https://github.com/skyrpex/clipper',
+  tag: '6.4.2',
+  incdir: 'cpp',
+  srcdir: 'cpp',
+  excludes: 'clipper/cpp/cpp_'
 
-task :build => :ext
+use_external_library 'https://github.com/greenm01/poly2tri',
+  incdir: 'poly2tri',
+  srcdir: 'poly2tri'
 
+build_native_library
+build_ruby_extension
+test_ruby_extension
+generate_documents
+build_ruby_gem
 
-MODULES.each {|m| m.load_tasks :lib, :ext, :test, :doc, :gem}
+task :default => :test