rays 0.1.47 → 0.1.49

data/ext/rays/polygon.cpp

@@ -1,7 +1,6 @@
 #include "rays/ruby/polygon.h"
 
 
-#include <assert.h>
 #include <vector>
 #include <functional>
 #include "rays/ruby/bounds.h"
@@ -24,7 +23,7 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF2(setup, args, loop)
+RUCY_DEF4(setup, args, loop, colors, texcoords)
 {
 	CHECK;
 
@@ -32,9 +31,10 @@ RUCY_DEF2(setup, args, loop)
 		*THIS = to<Rays::Polygon>(args.size(), args.as_array());
 	else
 	{
-		std::vector<Rays::Point> points;
-		get_line_args(&points, args.size(), args.as_array());
-		*THIS = Rays::Polygon(&points[0], points.size(), loop);
+		CreateParams params(args, colors, texcoords);
+		*THIS = Rays::Polygon(
+			params.ppoints(), params.size(), loop,
+			params.pcolors(), params.ptexcoords());
 	}
 }
 RUCY_END
@@ -102,22 +102,63 @@ RUCY_DEF0(each)
 	CHECK;
 
 	Value ret = Qnil;
-	for (const auto& line : *THIS)
-		ret = rb_yield(value(line));
+	for (const auto& polyline : *THIS)
+		ret = rb_yield(value(polyline));
 	return ret;
 }
 RUCY_END
 
-static void
-each_polygon (const Value& value, std::function<void(const Rays::Polygon&)> fun)
+template <typename T>
+static inline void
+each_poly (const Value& value, auto fun)
 {
 	int size           = value.size();
 	const Value* array = value.as_array();
 
 	for (int i = 0; i < size; ++i)
-		fun(to<Rays::Polygon&>(array[i]));
+		fun(to<T&>(array[i]));
 }
 
+static
+RUCY_DEF1(op_add, obj)
+{
+	CHECK;
+
+	if (obj.is_kind_of(Rays::polyline_class()))
+		return value(*THIS + to<Rays::Polyline&>(obj));
+
+	if (obj.is_kind_of(Rays::polygon_class()))
+		return value(*THIS + to<Rays::Polygon&>(obj));
+
+	if (!obj.is_array())
+		argument_error(__FILE__, __LINE__);
+
+	if (obj.empty()) return self;
+
+	std::vector<Rays::Polyline> polylines;
+	for (const auto& polyline : to<Rays::Polygon&>(self))
+		polylines.emplace_back(polyline);
+
+	if (obj[0].is_kind_of(Rays::polyline_class()))
+	{
+		each_poly<Rays::Polyline>(obj, [&](const auto& polyline)
+		{
+			polylines.emplace_back(polyline);
+		});
+	}
+	else
+	{
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
+		{
+			for (const auto& polyline : polygon)
+				polylines.emplace_back(polyline);
+		});
+	}
+
+	return value(Rays::Polygon(&polylines[0], polylines.size()));
+}
+RUCY_END
+
 static
 RUCY_DEF1(op_sub, obj)
 {
@@ -126,7 +167,7 @@ RUCY_DEF1(op_sub, obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result - polygon;
 		});
@@ -145,7 +186,7 @@ RUCY_DEF1(op_and, obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result & polygon;
 		});
@@ -164,7 +205,7 @@ RUCY_DEF1(op_or, obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result | polygon;
 		});
@@ -183,7 +224,7 @@ RUCY_DEF1(op_xor, obj)
 	if (obj.is_array())
 	{
 		Rays::Polygon result = *THIS;
-		each_polygon(obj, [&](const Rays::Polygon& polygon)
+		each_poly<Rays::Polygon>(obj, [&](const auto& polygon)
 		{
 			result = result ^ polygon;
 		});
@@ -195,131 +236,126 @@ RUCY_DEF1(op_xor, obj)
 RUCY_END
 
 static
-RUCY_DEF1(create_points, args)
+RUCY_DEF1(create_points, points)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_POINTS, &points[0], points.size()));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_points(params.ppoints(), params.size()));
 }
 RUCY_END
 
 static
-RUCY_DEF1(create_lines, args)
+RUCY_DEF2(create_line, points, loop)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_LINES, &points[0], points.size()));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_line(params.ppoints(), params.size(), loop));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_line_strip, args, loop)
+RUCY_DEF1(create_lines, points)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_LINE_STRIP, &points[0], points.size(), loop));
+	CreateParams params(points, nil(), nil());
+	return value(Rays::create_lines(params.ppoints(), params.size()));
 }
 RUCY_END
 
 static
-RUCY_DEF7(create_rect,
-	args, round, lefttop, righttop, leftbottom, rightbottom, nsegment)
+RUCY_DEF4(create_triangles, points, loop, colors, texcoords)
 {
-	coord x, y, w, h, lt, rt, lb, rb;
-	uint nseg;
-	get_rect_args(
-		&x, &y, &w, &h, &lt, &rt, &lb, &rb, &nseg,
-		args.size(), args.as_array(),
-		round, lefttop, righttop, leftbottom, rightbottom, nsegment);
-
-	return value(Rays::create_rect(x, y, w, h, lt, rt, lb, rb, nseg));
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangles(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
 }
 RUCY_END
 
 static
-RUCY_DEF7(create_ellipse,
-	args, center, radius, hole, angle_from, angle_to, nsegment)
+RUCY_DEF3(create_triangle_strip, points, colors, texcoords)
 {
-	coord x, y, w, h;
-	Rays::Point hole_size;
-	float from, to_;
-	uint nseg;
-	get_ellipse_args(
-		&x, &y, &w, &h, &hole_size, &from, &to_, &nseg,
-		args.size(), args.as_array(),
-		center, radius, hole, angle_from, angle_to, nsegment);
-
-	return value(Rays::create_ellipse(x, y, w, h, hole_size, from, to_, nseg));
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_triangles, args, loop)
+RUCY_DEF3(create_triangle_fan, points, colors, texcoords)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_TRIANGLES, &points[0], points.size(), loop));
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_triangle_fan(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
 }
 RUCY_END
 
 static
-RUCY_DEF1(create_triangle_strip, args)
+RUCY_DEF7(create_rect,
+	args, round, lefttop, righttop, leftbottom, rightbottom, nsegment)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_TRIANGLE_STRIP, &points[0], points.size()));
+	coord x, y, w, h, lt, rt, lb, rb;
+	uint nseg;
+	get_rect_args(
+		&x, &y, &w, &h, &lt, &rt, &lb, &rb, &nseg,
+		args.size(), args.as_array(),
+		round, lefttop, righttop, leftbottom, rightbottom, nsegment);
+
+	return value(Rays::create_rect(x, y, w, h, lt, rt, lb, rb, nseg));
 }
 RUCY_END
 
 static
-RUCY_DEF1(create_triangle_fan, args)
+RUCY_DEF4(create_quads, points, loop, colors, texcoords)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_TRIANGLE_FAN, &points[0], points.size()));
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quads(
+		params.ppoints(), params.size(), loop,
+		params.pcolors(), params.ptexcoords()));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_quads, args, loop)
+RUCY_DEF3(create_quad_strip, points, colors, texcoords)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(
-		Rays::Polygon(Rays::DRAW_QUADS, &points[0], points.size(), loop));
+	CreateParams params(points, colors, texcoords);
+	return value(Rays::create_quad_strip(
+		params.ppoints(), params.size(),
+		params.pcolors(), params.ptexcoords()));
 }
 RUCY_END
 
 static
-RUCY_DEF1(create_quad_strip, args)
+RUCY_DEF7(create_ellipse,
+	args, center, radius, hole, angle_from, angle_to, nsegment)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-	return value(Rays::Polygon(Rays::DRAW_QUAD_STRIP, &points[0], points.size()));
+	coord x, y, w, h;
+	Rays::Point hole_size;
+	float from, to_;
+	uint nseg;
+	get_ellipse_args(
+		&x, &y, &w, &h, &hole_size, &from, &to_, &nseg,
+		args.size(), args.as_array(),
+		center, radius, hole, angle_from, angle_to, nsegment);
+
+	return value(Rays::create_ellipse(x, y, w, h, hole_size, from, to_, nseg));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_curve, args, loop)
+RUCY_DEF3(create_curve, points, loop, nsegment)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-
-	return value(Rays::create_curve(&points[0], points.size(), loop));
+	CreateParams params(points, nil(), nil());
+	uint nseg = nsegment ? 0 : to<uint>(nsegment);
+	return value(Rays::create_curve(params.ppoints(), params.size(), loop, nseg));
 }
 RUCY_END
 
 static
-RUCY_DEF2(create_bezier, args, loop)
+RUCY_DEF3(create_bezier, points, loop, nsegment)
 {
-	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
-
-	return value(Rays::create_bezier(&points[0], points.size(), loop));
+	CreateParams params(points, nil(), nil());
+	uint nseg = nsegment ? 0 : to<uint>(nsegment);
+	return value(Rays::create_bezier(params.ppoints(), params.size(), loop, nseg));
 }
 RUCY_END
 
@@ -336,25 +372,25 @@ Init_rays_polygon ()
 	cPolygon.define_private_method("setup", setup);
 	cPolygon.define_method("expand", expand);
 	cPolygon.define_method("bounds", bounds);
-	cPolygon.define_method("size", size);
+	cPolygon.define_method("size",   size);
 	cPolygon.define_method("empty?", is_empty);
 	cPolygon.define_method("[]", get_at);
 	cPolygon.define_method("each", each);
-	cPolygon.define_method("+", op_or);
+	cPolygon.define_method("+", op_add);
 	cPolygon.define_method("-", op_sub);
 	cPolygon.define_method("&", op_and);
 	cPolygon.define_method("|", op_or);
 	cPolygon.define_method("^", op_xor);
 	cPolygon.define_singleton_method("points!",         create_points);
+	cPolygon.define_singleton_method("line!",           create_line);
 	cPolygon.define_singleton_method("lines!",          create_lines);
-	cPolygon.define_singleton_method("line_strip!",     create_line_strip);
-	cPolygon.define_singleton_method("rect!",           create_rect);
-	cPolygon.define_singleton_method("ellipse!",        create_ellipse);
 	cPolygon.define_singleton_method("triangles!",      create_triangles);
 	cPolygon.define_singleton_method("triangle_strip!", create_triangle_strip);
 	cPolygon.define_singleton_method("triangle_fan!",   create_triangle_fan);
+	cPolygon.define_singleton_method("rect!",           create_rect);
 	cPolygon.define_singleton_method("quads!",          create_quads);
 	cPolygon.define_singleton_method("quad_strip!",     create_quad_strip);
+	cPolygon.define_singleton_method("ellipse!",        create_ellipse);
 	cPolygon.define_singleton_method("curve!",          create_curve);
 	cPolygon.define_singleton_method("bezier!",         create_bezier);
 }
@@ -367,26 +403,27 @@ namespace Rucy
 	template <> Rays::Polygon
 	value_to<Rays::Polygon> (int argc, const Value* argv, bool convert)
 	{
-		assert(argc == 0 || (argc > 0 && argv));
-
 		if (convert)
 		{
 			if (argc <= 0)
 				return Rays::Polygon();
-			else if (argv->is_kind_of(Rays::polygon_line_class()))
+			else if (argv->is_kind_of(Rays::polyline_class()))
 			{
-				std::vector<Rays::Polygon::Line> lines;
-				lines.reserve(argc);
-				for (int i = 0; i < argc; ++i)
-					lines.emplace_back(to<Rays::Polygon::Line&>(argv[i]));
-				return Rays::Polygon(&lines[0], lines.size());
+				if (argc == 1)
+					return Rays::Polygon(to<Rays::Polyline&>(*argv));
+				else
+				{
+					std::vector<Rays::Polyline> polylines;
+					polylines.reserve(argc);
+					for (int i = 0; i < argc; ++i)
+						polylines.emplace_back(to<Rays::Polyline&>(argv[i]));
+					return Rays::Polygon(&polylines[0], polylines.size());
+				}
 			}
-			else if (argv->is_kind_of(Rays::polyline_class()))
-				return Rays::Polygon(to<Rays::Polyline&>(*argv));
 			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::Polygon(&points[0], points.size());
 			}
 		}

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>
@@ -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)
@@ -79,6 +91,12 @@ Init_rays ()
 
 	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
 		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);
 }
 
 
@@ -179,6 +197,68 @@ namespace Rucy
 	}
 
 
+	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::TexCoordWrap) wrap;
+	}
+
+
 }// Rucy
 
 

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/color.h

@@ -72,7 +72,9 @@ namespace Rays
 
 	Color rgb8 (int   red, int   green, int   blue, int   alpha = 255);
 
-	Color hsv (float hue, float saturation, float value, float alpha = 1);
+	Color    hsv (float  hue, float  saturation, float  value, float alpha = 1);
+
+	void get_hsv (float* hue, float* saturation, float* value, const Color& color);
 
 
 }// Rays