rays 0.1.12 → 0.1.13

data/ext/rays/polygon_line.cpp

@@ -0,0 +1,99 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Polygon::Line>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF3(setup, points, loop, 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);
+}
+RUCY_END
+
+static
+RUCY_DEF0(hole)
+{
+	CHECK;
+	return value(THIS->hole());
+}
+RUCY_END
+
+
+static Class cPolygonLine;
+
+void
+Init_polygon_line ()
+{
+	Module mRays   = define_module("Rays");
+	Class cPolygon = mRays.define_class("Polygon");
+
+	cPolygonLine = cPolygon.define_class("Line", Rays::polyline_class());
+	cPolygonLine.define_alloc_func(alloc);
+	cPolygonLine.define_private_method("setup", setup);
+	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/ext/rays/polyline.cpp

@@ -0,0 +1,170 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Polyline>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF2(setup, points, loop)
+{
+	CHECK;
+
+	std::vector<Rays::Point> array;
+	get_line_args(&array, points.size(), points.as_array());
+	*THIS = Rays::Polyline(&array[0], array.size(), loop);
+}
+RUCY_END
+
+static
+RUCY_DEF1(expand, width)
+{
+	CHECK;
+
+	Rays::Polygon polygon;
+	THIS->expand(&polygon, to<coord>(width));
+	return value(polygon);
+}
+RUCY_END
+
+static
+RUCY_DEF0(bounds)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+RUCY_END
+
+static
+RUCY_DEF0(loop)
+{
+	CHECK;
+	return value(THIS->loop());
+}
+RUCY_END
+
+static
+RUCY_DEF0(size)
+{
+	CHECK;
+	return value(THIS->size());
+}
+RUCY_END
+
+static
+RUCY_DEF0(empty)
+{
+	CHECK;
+	return value(THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF1(at, 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]);
+}
+RUCY_END
+
+static
+RUCY_DEF0(each)
+{
+	CHECK;
+
+	Value ret;
+	for (const auto& point : *THIS)
+		ret = rb_yield(value(point));
+	return ret;
+}
+RUCY_END
+
+
+static Class cPolyline;
+
+void
+Init_polyline ()
+{
+	Module mRays = define_module("Rays");
+
+	cPolyline = mRays.define_class("Polyline");
+	cPolyline.define_alloc_func(alloc);
+	cPolyline.define_private_method("setup", setup);
+	cPolyline.define_method("expand", expand);
+	cPolyline.define_method("bounds", bounds);
+	cPolyline.define_method("loop?", loop);
+	cPolyline.define_method("size", size);
+	cPolyline.define_method("empty?", empty);
+	cPolyline.define_method("[]", at);
+	cPolyline.define_method("each", each);
+}
+
+
+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/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
 RUCY_DEF0(init)
 {
@@ -23,14 +18,6 @@ RUCY_DEF0(fin)
 }
 RUCY_END
 
-static
-RUCY_DEF0(init_offscreen_context)
-{
-	Rays::init_offscreen_context();
-	return self;
-}
-RUCY_END
-
 
 static Module mRays;
 
@@ -40,7 +27,6 @@ Init_rays ()
 	mRays = define_module("Rays");
 	mRays.define_singleton_method("init!", init);
 	mRays.define_singleton_method("fin!", fin);
-	mRays.define_singleton_method("init_offscreen_context", init_offscreen_context);
 }
 
 

data/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)
 
@@ -23,14 +19,61 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF1(initialize, source)
+RUCY_DEF1(setup, source)
 {
 	RUCY_CHECK_OBJ(Rays::Shader, self);
 
-	if (!source.is_s())
+	*THIS = to<Rays::Shader>(source);
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_uniform)
+{
+	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;
 }
 RUCY_END
@@ -45,10 +88,42 @@ Init_shader ()
 
 	cShader = mRays.define_class("Shader");
 	cShader.define_alloc_func(alloc);
-	cShader.define_private_method("initialize", initialize);
+	cShader.define_private_method("setup", setup);
+	cShader.define_private_method("set_uniform", set_uniform);
 }
 
 
+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/include/rays.h

@@ -7,15 +7,23 @@
 #include <rays/defs.h>
 #include <rays/rays.h>
 #include <rays/exception.h>
+#include <rays/debug.h>
+
+#include <rays/coord.h>
 #include <rays/point.h>
+#include <rays/bounds.h>
+#include <rays/color.h>
 #include <rays/color_space.h>
+#include <rays/matrix.h>
+
+#include <rays/polyline.h>
+#include <rays/polygon.h>
 #include <rays/bitmap.h>
-#include <rays/texture.h>
 #include <rays/image.h>
 #include <rays/font.h>
 #include <rays/shader.h>
+
 #include <rays/painter.h>
-#include <rays/opengl.h>
 
 
 #endif//EOH