rays 0.1.46 → 0.1.48

data/ext/rays/polyline.cpp

@@ -3,6 +3,7 @@
 
 #include <assert.h>
 #include <vector>
+#include "rays/ruby/color.h"
 #include "rays/ruby/point.h"
 #include "rays/ruby/bounds.h"
 #include "rays/ruby/polygon.h"
@@ -24,13 +25,15 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF2(setup, points, loop)
+RUCY_DEF6(setup, points, loop, fill, colors, texcoords, hole)
 {
 	CHECK;
 
-	std::vector<Rays::Point> array;
-	get_line_args(&array, points.size(), points.as_array());
-	*THIS = Rays::Polyline(&array[0], array.size(), loop);
+	CreateParams params(points, colors, texcoords);
+	*THIS = Rays::Polyline(
+		params.ppoints(), params.size(), loop, fill,
+		params.pcolors(), params.ptexcoords(),
+		hole);
 }
 RUCY_END
 
@@ -60,13 +63,29 @@ RUCY_DEF0(bounds)
 RUCY_END
 
 static
-RUCY_DEF0(loop)
+RUCY_DEF0(is_loop)
 {
 	CHECK;
 	return value(THIS->loop());
 }
 RUCY_END
 
+static
+RUCY_DEF0(is_fill)
+{
+	CHECK;
+	return value(THIS->fill());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_hole)
+{
+	CHECK;
+	return value(THIS->hole());
+}
+RUCY_END
+
 static
 RUCY_DEF0(size)
 {
@@ -100,7 +119,31 @@ RUCY_DEF1(get_at, index)
 RUCY_END
 
 static
-RUCY_DEF0(each)
+RUCY_DEF0(has_points)
+{
+	CHECK;
+	return value(THIS->points() && !THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_colors)
+{
+	CHECK;
+	return value(THIS->colors() && !THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_texcoords)
+{
+	CHECK;
+	return value(THIS->texcoords() && !THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_point)
 {
 	CHECK;
 
@@ -111,6 +154,42 @@ RUCY_DEF0(each)
 }
 RUCY_END
 
+static
+RUCY_DEF0(each_color)
+{
+	CHECK;
+
+	const Rays::Color* colors = THIS->colors();
+
+	Value ret = Qnil;
+	if (colors)
+	{
+		size_t size = THIS->size();
+		for (size_t i = 0; i < size; ++i)
+			ret = rb_yield(value(colors[i]));
+	}
+	return ret;
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_texcoord)
+{
+	CHECK;
+
+	const Rays::Coord3* texcoords = THIS->texcoords();
+
+	Value ret = Qnil;
+	if (texcoords)
+	{
+		size_t size = THIS->size();
+		for (size_t i = 0; i < size; ++i)
+			ret = rb_yield(value(*(Rays::Point*) &texcoords[i]));
+	}
+	return ret;
+}
+RUCY_END
+
 
 static Class cPolyline;
 
@@ -124,11 +203,18 @@ Init_rays_polyline ()
 	cPolyline.define_private_method("setup", setup);
 	cPolyline.define_method("expand", expand);
 	cPolyline.define_method("bounds", bounds);
-	cPolyline.define_method("loop?", loop);
+	cPolyline.define_method("loop?", is_loop);
+	cPolyline.define_method("fill?", is_fill);
+	cPolyline.define_method("hole?", is_hole);
 	cPolyline.define_method("size", size);
 	cPolyline.define_method("empty?", is_empty);
 	cPolyline.define_method("[]", get_at);
-	cPolyline.define_method("each", each);
+	cPolyline.define_method("points?",    has_points);
+	cPolyline.define_method("colors?",    has_colors);
+	cPolyline.define_method("texcoords?", has_texcoords);
+	cPolyline.define_private_method("each_point!",    each_point);
+	cPolyline.define_private_method("each_color!",    each_color);
+	cPolyline.define_private_method("each_texcoord!", each_texcoord);
 }
 
 
@@ -148,7 +234,7 @@ namespace Rucy
 			else if (argv->is_num() || argv->is_array())
 			{
 				std::vector<Rays::Point> points;
-				get_line_args(&points, argc, argv);
+				get_points(&points, argc, argv);
 				return Rays::Polyline(&points[0], points.size());
 			}
 		}

data/ext/rays/rays.cpp

@@ -9,6 +9,8 @@
 RUCY_DEFINE_CONVERT_TO(Rays::CapType)
 RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
 RUCY_DEFINE_CONVERT_TO(Rays::BlendMode)
+RUCY_DEFINE_CONVERT_TO(Rays::TexCoordMode)
+RUCY_DEFINE_CONVERT_TO(Rays::TexCoordWrap)
 
 
 template <typename T>
@@ -16,7 +18,7 @@ struct EnumType
 {
 	const char* name;
 	const char* short_name;
-	T type;
+	T value;
 };
 
 static std::vector<EnumType<Rays::CapType>> CAP_TYPES({
@@ -43,6 +45,16 @@ static std::vector<EnumType<Rays::BlendMode>> BLEND_MODES({
 	{"BLEND_REPLACE",   "REPLACE",   Rays::BLEND_REPLACE},
 });
 
+static std::vector<EnumType<Rays::TexCoordMode>> TEXCOORD_MODES({
+	{"TEXCOORD_IMAGE",  "IMAGE",  Rays::TEXCOORD_IMAGE},
+	{"TEXCOORD_NORMAL", "NORMAL", Rays::TEXCOORD_NORMAL},
+});
+
+static std::vector<EnumType<Rays::TexCoordWrap>> TEXCOORD_WRAPS({
+	{"TEXCOORD_CLAMP",  "CLAMP",  Rays::TEXCOORD_CLAMP},
+	{"TEXCOORD_REPEAT", "REPEAT", Rays::TEXCOORD_REPEAT},
+});
+
 
 static
 RUCY_DEF0(init)
@@ -72,13 +84,19 @@ Init_rays ()
 	mRays.define_singleton_method("fin!", fin);
 
 	for (auto it = CAP_TYPES.begin(); it != CAP_TYPES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
 
 	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
 
 	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
-		mRays.define_const(it->name, it->type);
+		mRays.define_const(it->name, it->value);
+
+	for (auto it = TEXCOORD_MODES.begin(); it != TEXCOORD_MODES.end(); ++it)
+		mRays.define_const(it->name, it->value);
+
+	for (auto it = TEXCOORD_WRAPS.begin(); it != TEXCOORD_WRAPS.end(); ++it)
+		mRays.define_const(it->name, it->value);
 }
 
 
@@ -102,7 +120,7 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid cap type -- %s", str);
@@ -133,7 +151,7 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid join type -- %s", str);
@@ -164,18 +182,80 @@ namespace Rucy
 						strcasecmp(str, it->name)       == 0 ||
 						strcasecmp(str, it->short_name) == 0)
 					{
-						return it->type;
+						return it->value;
 					}
 				}
 				argument_error(__FILE__, __LINE__, "invalid blend mode -- %s", str);
 			}
 		}
 
-		int type = value_to<int>(*argv, convert);
-		if (type < 0 || Rays::BLEND_MAX <= type)
-			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", type);
+		int mode = value_to<int>(*argv, convert);
+		if (mode < 0 || Rays::BLEND_MAX <= mode)
+			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", mode);
+
+		return (Rays::BlendMode) mode;
+	}
+
+
+	template <> Rays::TexCoordMode
+	value_to<Rays::TexCoordMode> (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 = TEXCOORD_MODES.begin(); it != TEXCOORD_MODES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->value;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid texcoord mode -- %s", str);
+			}
+		}
+
+		int mode = value_to<int>(*argv, convert);
+		if (mode < 0 || Rays::TEXCOORD_MODE_MAX <= mode)
+			argument_error(__FILE__, __LINE__, "invalid texcoord mode -- %d", mode);
+
+		return (Rays::TexCoordMode) mode;
+	}
+
+
+	template <> Rays::TexCoordWrap
+	value_to<Rays::TexCoordWrap> (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 = TEXCOORD_WRAPS.begin(); it != TEXCOORD_WRAPS.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->value;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid texcoord wrap -- %s", str);
+			}
+		}
+
+		int wrap = value_to<int>(*argv, convert);
+		if (wrap < 0 || Rays::TEXCOORD_WRAP_MAX <= wrap)
+			argument_error(__FILE__, __LINE__, "invalid texcoord wrap -- %d", wrap);
 
-		return (Rays::BlendMode) type;
+		return (Rays::TexCoordWrap) wrap;
 	}
 
 

data/ext/rays/{noise.cpp → util.cpp}

@@ -1,4 +1,4 @@
-#include "rays/noise.h"
+#include "rays/util.h"
 #include "rays/ruby/point.h"
 #include "defs.h"
 
@@ -47,7 +47,7 @@ RUCY_END
 
 
 void
-Init_rays_noise ()
+Init_rays_util ()
 {
 	Module mRays = define_module("Rays");
 	mRays.define_singleton_method("perlin", perlin);

data/include/rays/defs.h

@@ -82,6 +82,30 @@ namespace Rays
 	};// BlendMode
 
 
+	enum TexCoordMode
+	{
+
+		TEXCOORD_IMAGE = 0,
+
+		TEXCOORD_NORMAL,
+
+		TEXCOORD_MODE_MAX
+
+	};// TexCoordMode
+
+
+	enum TexCoordWrap
+	{
+
+		TEXCOORD_CLAMP = 0,
+
+		TEXCOORD_REPEAT,
+
+		TEXCOORD_WRAP_MAX
+
+	};// TexCoordWrap
+
+
 }// Rays
 
 

data/include/rays/font.h

@@ -4,6 +4,8 @@
 #define __RAYS_FONT_H__
 
 
+#include <vector>
+#include <map>
 #include <xot/pimpl.h>
 #include <rays/defs.h>
 
@@ -17,15 +19,21 @@ namespace Rays
 
 		public:
 
+			enum {DEFAULT_SIZE = 12};
+
 			Font ();
 
-			Font (const char* name, coord size = 0);
+			Font (const char* name, coord size = DEFAULT_SIZE);
 
 			~Font ();
 
+			Font dup () const;
+
 			String name () const;
 
-			coord size () const;
+			void set_size (coord size);
+
+			coord    size () const;
 
 			coord get_width (const char* str) const;
 
@@ -45,7 +53,13 @@ namespace Rays
 	};// Font
 
 
-	const Font& default_font ();
+	typedef std::map<String, std::vector<String>> FontFamilyMap;
+
+	const FontFamilyMap& get_font_families ();
+
+	Font load_font (const char* path, coord size = Font::DEFAULT_SIZE);
+
+	const Font& get_default_font ();
 
 
 }// Rays

data/include/rays/matrix.h

@@ -43,6 +43,8 @@ namespace Rays
 
 		Matrix (const coord* elements, size_t size);
 
+		Matrix (void* null);
+
 		This dup () const;
 
 		This& reset (coord value = 1);

data/include/rays/painter.h

@@ -65,7 +65,17 @@ namespace Rays
 
 			void clear ();
 
-			void polygon (const Polygon& polygon);
+			void polygon (
+				const Polygon& polygon, coord x = 0, coord y = 0);
+
+			void polygon (
+				const Polygon& polygon, const Point& position);
+
+			void polygon (
+				const Polygon& polygon, coord x, coord y, coord width, coord height);
+
+			void polygon (
+				const Polygon& polygon, const Bounds& bounds);
 
 			void line (coord x1, coord y1, coord x2, coord y2);
 
@@ -205,6 +215,10 @@ namespace Rays
 
 			coord    stroke_width () const;
 
+			void set_stroke_outset (float outset);
+
+			float    stroke_outset () const;
+
 			void set_stroke_cap (CapType cap);
 
 			CapType  stroke_cap () const;
@@ -239,6 +253,20 @@ namespace Rays
 
 			const Font& font () const;
 
+			void     set_texture (const Image& image);
+
+			void      no_texture ();
+
+			const Image& texture () const;
+
+			void     set_texcoord_mode (TexCoordMode mode);
+
+			TexCoordMode texcoord_mode () const;
+
+			void     set_texcoord_wrap (TexCoordWrap wrap);
+
+			TexCoordWrap texcoord_wrap () const;
+
 			void      set_shader (const Shader& shader);
 
 			void       no_shader ();

data/include/rays/polygon.h

@@ -20,45 +20,19 @@ namespace Rays
 
 		public:
 
-			struct Line : public Polyline
-			{
+			typedef std::vector<Polyline>        PolylineList;
 
-				typedef Polyline Super;
-
-				public:
-
-					Line ();
-
-					Line (
-						const Point* points, size_t size,
-						bool loop = true,
-						bool hole = false);
-
-					Line (const Polyline& polyline, bool hole = false);
-
-					bool hole () const;
-
-					operator bool () const;
-
-					bool operator ! () const;
-
-				private:
-
-					bool hole_;
-
-			};// Line
-
-			typedef std::vector<Line> LineList;
-
-			typedef LineList::const_iterator const_iterator;
+			typedef PolylineList::const_iterator const_iterator;
 
 			Polygon ();
 
-			Polygon (const Point* points, size_t size, bool loop = true);
+			Polygon (
+				const Point* points, size_t size, bool loop = true,
+				const Color* colors = NULL, const Coord3* texcoords = NULL);
 
 			Polygon (const Polyline& polyline);
 
-			Polygon (const Line* lines, size_t size);
+			Polygon (const Polyline* polylines, size_t size);
 
 			~Polygon ();
 
@@ -79,12 +53,14 @@ namespace Rays
 
 			const_iterator end () const;
 
-			const Line& operator [] (size_t index) const;
+			const Polyline& operator [] (size_t index) const;
 
 			operator bool () const;
 
 			bool operator ! () const;
 
+			friend Polygon operator + (const Polygon& lhs, const Polyline& rhs);
+
 			friend Polygon operator + (const Polygon& lhs, const Polygon& rhs);
 
 			friend Polygon operator - (const Polygon& lhs, const Polygon& rhs);
@@ -110,6 +86,13 @@ namespace Rays
 	};// Polygon
 
 
+	Polygon create_point (coord x, coord y);
+
+	Polygon create_point (const Point& point);
+
+	Polygon create_points (const Point* points, size_t size);
+
+
 	Polygon create_line (coord x1, coord y1, coord x2, coord y2);
 
 	Polygon create_line (const Point& p1, const Point& p2);
@@ -118,6 +101,29 @@ namespace Rays
 
 	Polygon create_line (const Polyline& polyline);
 
+	Polygon create_lines (const Point* points, size_t size);
+
+
+	Polygon create_triangle (
+		coord x1, coord y1, coord x2, coord y2, coord x3, coord y3,
+		bool loop = true);
+
+	Polygon create_triangle (
+		const Point& p1, const Point& p2, const Point& p3,
+		bool loop = true);
+
+	Polygon create_triangles (
+		const Point* points, size_t size, bool loop = true,
+		const Color* colors = NULL, const Coord3* texcoords = NULL);
+
+	Polygon create_triangle_strip (
+		const Point* points, size_t size,
+		const Color* colors = NULL, const Coord3* texcoords = NULL);
+
+	Polygon create_triangle_fan (
+		const Point* points, size_t size,
+		const Color* colors = NULL, const Coord3* texcoords = NULL);
+
 
 	Polygon create_rect (
 		coord x, coord y, coord width, coord height,
@@ -142,6 +148,24 @@ namespace Rays
 		uint nsegment = 0);
 
 
+	Polygon create_quad (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop = true);
+
+	Polygon create_quad (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop = true);
+
+	Polygon create_quads (
+		const Point* points, size_t size, bool loop = true,
+		const Color* colors = NULL, const Coord3* texcoords = NULL);
+
+	Polygon create_quad_strip (
+		const Point* points, size_t size,
+		const Color* colors = NULL, const Coord3* texcoords = NULL);
+
+
 	Polygon create_ellipse (
 		coord x, coord y, coord width, coord height = 0,
 		const Point& hole_size = 0,

data/include/rays/polyline.h

@@ -15,6 +15,7 @@ namespace Rays
 {
 
 
+	struct Color;
 	class Polygon;
 
 
@@ -29,7 +30,15 @@ namespace Rays
 
 			Polyline ();
 
-			Polyline (const Point* points, size_t size, bool loop = false);
+			Polyline (
+				const Point* points, size_t size, bool loop = false,
+				const Color* colors = NULL, const Coord3* texcoords = NULL,
+				bool hole = false);
+
+			Polyline (
+				const Point* points, size_t size, bool loop, bool fill,
+				const Color* colors = NULL, const Coord3* texcoords = NULL,
+				bool hole = false);
 
 			~Polyline ();
 
@@ -44,6 +53,16 @@ namespace Rays
 
 			bool loop () const;
 
+			bool fill () const;
+
+			bool hole () const;
+
+			const Point* points () const;
+
+			const Color* colors () const;
+
+			const Coord3* texcoords () const;
+
 			size_t size () const;
 
 			bool empty () const;

data/include/rays/ruby/polygon.h

@@ -11,8 +11,6 @@
 
 RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon)
 
-RUCY_DECLARE_VALUE_OR_ARRAY_FROM_TO(Rays::Polygon::Line)
-
 
 namespace Rays
 {
@@ -21,9 +19,6 @@ namespace Rays
 	Rucy::Class polygon_class ();
 	// class Rays::Polygon
 
-	Rucy::Class polygon_line_class ();
-	// class Rays::Polygon::Line
-
 
 }// Rays
 
@@ -38,12 +33,6 @@ namespace Rucy
 		return Rays::polygon_class();
 	}
 
-	template <> inline Class
-	get_ruby_class<Rays::Polygon::Line> ()
-	{
-		return Rays::polygon_line_class();
-	}
-
 
 }// Rucy
 

data/include/rays/ruby/rays.h

@@ -15,6 +15,10 @@ RUCY_DECLARE_CONVERT_TO(Rays::JoinType)
 
 RUCY_DECLARE_CONVERT_TO(Rays::BlendMode)
 
+RUCY_DECLARE_CONVERT_TO(Rays::TexCoordMode)
+
+RUCY_DECLARE_CONVERT_TO(Rays::TexCoordWrap)
+
 
 namespace Rays
 {

data/include/rays/{noise.h → util.h}

@@ -1,7 +1,7 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __RAYS_NOISE_H__
-#define __RAYS_NOISE_H__
+#ifndef __RAYS_UTIL_H__
+#define __RAYS_UTIL_H__
 
 
 #include <rays/defs.h>