rays 0.1.47 → 0.1.48

data/.doc/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
 VALUE init(VALUE self)
@@ -77,6 +89,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);
 }
 
 
@@ -177,6 +195,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/.doc/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"
 
@@ -45,7 +45,7 @@ VALUE simplex(VALUE self)
 
 
 void
-Init_rays_noise ()
+Init_rays_util ()
 {
 	Module mRays = rb_define_module("Rays");
 	rb_define_singleton_method(mRays, "perlin", RUBY_METHOD_FUNC(perlin), -1);

data/ChangeLog.md

@@ -1,6 +1,29 @@
 # rays ChangeLog
 
 
+## [v0.1.48] - 2024-01-08
+
+- Add Bitmap#pixels=
+- Add Font#dup, Font#size=, Font.families, and Font.load
+- Add Polyline#with
+- Add Painter#texture, Painter#texcoord_mode,  and Painter#texcoord_wrap
+
+- Delete Polygon::Line because it was merged into Polyline
+
+- Polygon and Polyline can take colors and texcoords for each vertex
+- Polyline.new can take 'hole' parameter
+- 'polygonA + polygonB' means Polygon.new(*polygonA.to_a, *polygonB.to_a)
+- Polygon with only holes raises an ArgumentError
+- Image delegates 'pixels' accessors to Bitmap
+- Use GL_CLAMP_TO_EDGE for texturing
+- Refine Point#inspect(), Color#inspect(), and Font#inspect()
+- default_font() -> get_default_font()
+- rays/include/noise.h -> rays/include/util.h
+
+- Fix Polygon.bezier() returns broken object
+- Fix get_pixels() does not work with float colors
+
+
 ## [v0.1.47] - 2023-12-09
 
 - Add Polygon's singleton methods: points(), lines(), triangles(), triangle_strip(), triangle_fan(), quads(), quad_strip()

data/VERSION

@@ -1 +1 @@
-0.1.47
+0.1.48

data/ext/rays/bitmap.cpp

@@ -72,6 +72,257 @@ RUCY_DEF0(color_space)
 }
 RUCY_END
 
+static void
+set_pixels (Rays::Bitmap* bmp, Value pixels)
+{
+	int w = bmp->width(), h = bmp->height();
+	const auto& cs = bmp->color_space();
+	if (pixels.size() != (w * h * (cs.is_float() ? cs.Bpp() / cs.Bpc() : 1)))
+	{
+		argument_error(
+			__FILE__, __LINE__,
+			"The size of the pixel array does not match the size of the bitmap");
+	}
+
+	const Value* array = pixels.as_array();
+
+	switch (cs.type())
+	{
+		case Rays::GRAY_8:
+		case Rays::ALPHA_8:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint8_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_16:
+		case Rays::ALPHA_16:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint16_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint16_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_32:
+		case Rays::ALPHA_32:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint32_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<uint32_t>(*pa);
+			}
+			break;
+
+		case Rays::GRAY_float:
+		case Rays::ALPHA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, ++pb)
+					*pb = to<float>(*pa);
+			}
+			break;
+
+		case Rays::RGB_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 3)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 16 & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 0  & 0xff);
+				}
+			}
+			break;
+
+		case Rays::RGBA_8888:
+		case Rays::RGBX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 16 & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 0  & 0xff);
+					pb[3] = (uint8_t) (argb >> 24 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::ARGB_8888:
+		case Rays::XRGB_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 24 & 0xff);
+					pb[1] = (uint8_t) (argb >> 16 & 0xff);
+					pb[2] = (uint8_t) (argb >> 8  & 0xff);
+					pb[3] = (uint8_t) (argb >> 0  & 0xff);
+				}
+			}
+			break;
+
+		case Rays::BGR_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 3)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 0  & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 16 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::BGRA_8888:
+		case Rays::BGRX_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 0  & 0xff);
+					pb[1] = (uint8_t) (argb >> 8  & 0xff);
+					pb[2] = (uint8_t) (argb >> 16 & 0xff);
+					pb[3] = (uint8_t) (argb >> 24 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::ABGR_8888:
+		case Rays::XBGR_8888:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[w * y];
+				auto* pb        = bmp->at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++pa, pb += 4)
+				{
+					uint32_t argb = to<uint32_t>(*pa);
+					pb[0] = (uint8_t) (argb >> 24 & 0xff);
+					pb[1] = (uint8_t) (argb >> 0  & 0xff);
+					pb[2] = (uint8_t) (argb >> 8  & 0xff);
+					pb[3] = (uint8_t) (argb >> 16 & 0xff);
+				}
+			}
+			break;
+
+		case Rays::RGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[3 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 3, pb += 3)
+				{
+					pb[0] = to<float>(pa[0]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[2]);
+				}
+			}
+			break;
+
+		case Rays::RGBA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[0]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[2]);
+					pb[3] = to<float>(pa[3]);
+				}
+			}
+			break;
+
+		case Rays::ARGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[3]);
+					pb[1] = to<float>(pa[0]);
+					pb[2] = to<float>(pa[1]);
+					pb[3] = to<float>(pa[2]);
+				}
+			}
+			break;
+
+		case Rays::BGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[3 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 3, pb += 3)
+				{
+					pb[0] = to<float>(pa[2]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[0]);
+				}
+			}
+			break;
+
+		case Rays::BGRA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[2]);
+					pb[1] = to<float>(pa[1]);
+					pb[2] = to<float>(pa[0]);
+					pb[3] = to<float>(pa[3]);
+				}
+			}
+			break;
+
+		case Rays::ABGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const Value* pa = &array[4 * w * y];
+				auto* pb        = bmp->at<float>(0, y);
+				for (int x = 0; x < w; ++x, pa += 4, pb += 4)
+				{
+					pb[0] = to<float>(pa[3]);
+					pb[1] = to<float>(pa[2]);
+					pb[2] = to<float>(pa[1]);
+					pb[3] = to<float>(pa[0]);
+				}
+			}
+			break;
+
+		default:
+			argument_error(__FILE__, __LINE__);
+	}
+}
+
 static inline Value
 to_rgb_value (uint8_t r, uint8_t g, uint8_t b)
 {
@@ -82,7 +333,7 @@ to_rgb_value (uint8_t r, uint8_t g, uint8_t b)
 }
 
 static inline Value
-to_rgba_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+to_argb_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
 {
 	return value(
 		((uint) a) << 24 |
@@ -95,8 +346,8 @@ static void
 get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 {
 	int w = bmp.width(), h = bmp.height();
-
 	const auto& cs = bmp.color_space();
+
 	pixels->clear();
 	pixels->reserve(w * h * (cs.is_float() ? cs.Bpp() / cs.Bpc() : 1));
 
@@ -152,38 +403,22 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 			break;
 
 		case Rays::RGBA_8888:
-			for (int y = 0; y < h; ++y)
-			{
-				const auto* p = bmp.at<uint8_t>(0, y);
-				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgba_value(p[0], p[1], p[2], p[3]));
-			}
-			break;
-
 		case Rays::RGBX_8888:
 			for (int y = 0; y < h; ++y)
 			{
 				const auto* p = bmp.at<uint8_t>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgb_value(p[0], p[1], p[2]));
+					pixels->push_back(to_argb_value(p[0], p[1], p[2], p[3]));
 			}
 			break;
 
 		case Rays::ARGB_8888:
-			for (int y = 0; y < h; ++y)
-			{
-				const auto* p = bmp.at<uint8_t>(0, y);
-				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgba_value(p[1], p[2], p[3], p[0]));
-			}
-			break;
-
 		case Rays::XRGB_8888:
 			for (int y = 0; y < h; ++y)
 			{
 				const auto* p = bmp.at<uint8_t>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgb_value(p[1], p[2], p[3]));
+					pixels->push_back(to_argb_value(p[1], p[2], p[3], p[0]));
 			}
 			break;
 
@@ -197,45 +432,29 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 			break;
 
 		case Rays::BGRA_8888:
-			for (int y = 0; y < h; ++y)
-			{
-				const auto* p = bmp.at<uint8_t>(0, y);
-				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgba_value(p[2], p[1], p[0], p[3]));
-			}
-			break;
-
 		case Rays::BGRX_8888:
 			for (int y = 0; y < h; ++y)
 			{
 				const auto* p = bmp.at<uint8_t>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgb_value(p[2], p[1], p[0]));
+					pixels->push_back(to_argb_value(p[2], p[1], p[0], p[3]));
 			}
 			break;
 
 		case Rays::ABGR_8888:
-			for (int y = 0; y < h; ++y)
-			{
-				const auto* p = bmp.at<uint8_t>(0, y);
-				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgba_value(p[3], p[2], p[1], p[0]));
-			}
-			break;
-
 		case Rays::XBGR_8888:
 			for (int y = 0; y < h; ++y)
 			{
 				const auto* p = bmp.at<uint8_t>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
-					pixels->push_back(to_rgb_value(p[3], p[2], p[1]));
+					pixels->push_back(to_argb_value(p[3], p[2], p[1], p[0]));
 			}
 			break;
 
 		case Rays::RGB_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 3)
 				{
 					pixels->push_back(value(p[0]));
@@ -248,7 +467,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::RGBA_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[0]));
@@ -262,7 +481,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::ARGB_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[1]));
@@ -276,7 +495,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::BGR_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 3)
 				{
 					pixels->push_back(value(p[2]));
@@ -289,7 +508,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::BGRA_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[2]));
@@ -303,7 +522,7 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 		case Rays::ABGR_float:
 			for (int y = 0; y < h; ++y)
 			{
-				const auto* p = bmp.at<uint8_t>(0, y);
+				const auto* p = bmp.at<float>(0, y);
 				for (int x = 0; x < w; ++x, p += 4)
 				{
 					pixels->push_back(value(p[3]));
@@ -320,10 +539,32 @@ get_pixels (auto* pixels, const Rays::Bitmap& bmp)
 }
 
 static
-RUCY_DEF0(pixels)
+RUCY_DEF1(set_pixels, pixels)
+{
+	CHECK;
+
+	if (sizeof(VALUE) <= 4)
+	{
+		not_implemented_error(
+			__FILE__, __LINE__, "Bitmap#pixels=() does not support 32-bit platforms");
+	}
+
+	set_pixels(THIS, pixels);
+	return pixels;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_pixels)
 {
 	CHECK;
 
+	if (sizeof(VALUE) <= 4)
+	{
+		not_implemented_error(
+			__FILE__, __LINE__, "Bitmap#pixels() does not support 32-bit platforms");
+	}
+
 	std::vector<VALUE> pixels;
 	get_pixels(&pixels, *THIS);
 	return value(pixels.size(), (const Value*) &pixels[0]);
@@ -371,7 +612,8 @@ Init_rays_bitmap ()
 	cBitmap.define_method("width",  width);
 	cBitmap.define_method("height", height);
 	cBitmap.define_method("color_space", color_space);
-	cBitmap.define_method("pixels", pixels);
+	cBitmap.define_method("pixels=", set_pixels);
+	cBitmap.define_method("pixels",  get_pixels);
 	cBitmap.define_method("[]=", set_at);
 	cBitmap.define_method("[]",  get_at);
 }

data/ext/rays/camera.cpp

@@ -139,8 +139,8 @@ RUCY_DEF0(device_names)
 	auto names = Rays::get_camera_device_names();
 
 	std::vector<Value> v;
-	for (auto it = names.begin(), end = names.end(); it != end; ++it)
-		v.emplace_back(value(it->c_str()));
+	for (const auto& name : names)
+		v.emplace_back(name.c_str());
 	return value(v.size(), &v[0]);
 }
 RUCY_END

data/ext/rays/defs.cpp

@@ -1,16 +1,14 @@
 #include "defs.h"
 
 
-#include <assert.h>
 #include "rays/ruby/bounds.h"
+#include "rays/ruby/color.h"
 #include "rays/ruby/point.h"
 
 
 void
-get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
+get_points (std::vector<Rays::Point>* points, int argc, const Value* argv)
 {
-	assert(points && argv);
-
 	points->clear();
 
 	if (argc <= 0)
@@ -37,6 +35,36 @@ get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
 	}
 }
 
+void
+get_colors (std::vector<Rays::Color>* colors, int argc, const Value* argv)
+{
+	colors->clear();
+
+	if (argc <= 0)
+		return;
+
+	if (argv[0].is_num())
+	{
+		if (argc % 3 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		colors->reserve(argc / 3);
+		for (int i = 0; i < argc; i += 3)
+		{
+			colors->emplace_back(
+				to<float>(argv[i + 0]),
+				to<float>(argv[i + 1]),
+				to<float>(argv[i + 2]));
+		}
+	}
+	else
+	{
+		colors->reserve(argc);
+		for (int i = 0; i < argc; ++i)
+			colors->emplace_back(to<Rays::Color>(argv[i]));
+	}
+}
+
 static uint
 get_nsegment (Value nsegment)
 {
@@ -53,8 +81,6 @@ void get_rect_args (
 	Value round, Value lefttop, Value righttop, Value leftbottom, Value rightbottom,
 	Value nsegment)
 {
-	assert(x && y && w && h && lt && rt && lb && rb && nseg && argv);
-
 	if (argc <= 0)
 		argument_error(__FILE__, __LINE__);
 
@@ -124,8 +150,6 @@ void get_ellipse_args (
 	Value center, Value radius, Value hole, Value angle_from, Value angle_to,
 	Value nsegment)
 {
-	assert(x && y && w && h && hole_size && from && to_ && nseg && argv);
-
 	if (argc <= 0)
 	{
 		*x = *y = *w = *h = 0;