rays 0.1.46 → 0.1.48

data/ext/rays/bitmap.cpp

@@ -72,6 +72,505 @@ 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)
+{
+	return value(
+		((uint) r) << 16 |
+		((uint) g) << 8  |
+		((uint) b));
+}
+
+static inline Value
+to_argb_value (uint8_t r, uint8_t g, uint8_t b, uint8_t a)
+{
+	return value(
+		((uint) a) << 24 |
+		((uint) r) << 16 |
+		((uint) g) << 8  |
+		((uint) b));
+}
+
+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));
+
+	switch (cs.type())
+	{
+		case Rays::GRAY_8:
+		case Rays::ALPHA_8:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_16:
+		case Rays::ALPHA_16:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint16_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_32:
+		case Rays::ALPHA_32:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint32_t>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::GRAY_float:
+		case Rays::ALPHA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, ++p)
+					pixels->push_back(value(*p));
+			}
+			break;
+
+		case Rays::RGB_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+					pixels->push_back(to_rgb_value(p[0], p[1], p[2]));
+			}
+			break;
+
+		case Rays::RGBA_8888:
+		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_argb_value(p[0], p[1], p[2], p[3]));
+			}
+			break;
+
+		case Rays::ARGB_8888:
+		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_argb_value(p[1], p[2], p[3], p[0]));
+			}
+			break;
+
+		case Rays::BGR_888:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<uint8_t>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+					pixels->push_back(to_rgb_value(p[2], p[1], p[0]));
+			}
+			break;
+
+		case Rays::BGRA_8888:
+		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_argb_value(p[2], p[1], p[0], p[3]));
+			}
+			break;
+
+		case Rays::ABGR_8888:
+		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_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<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+				{
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+				}
+			}
+			break;
+
+		case Rays::RGBA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[3]));
+				}
+			}
+			break;
+
+		case Rays::ARGB_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[3]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		case Rays::BGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 3)
+				{
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		case Rays::BGRA_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+					pixels->push_back(value(p[3]));
+				}
+			}
+			break;
+
+		case Rays::ABGR_float:
+			for (int y = 0; y < h; ++y)
+			{
+				const auto* p = bmp.at<float>(0, y);
+				for (int x = 0; x < w; ++x, p += 4)
+				{
+					pixels->push_back(value(p[3]));
+					pixels->push_back(value(p[2]));
+					pixels->push_back(value(p[1]));
+					pixels->push_back(value(p[0]));
+				}
+			}
+			break;
+
+		default:
+			argument_error(__FILE__, __LINE__);
+	}
+}
+
+static
+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]);
+}
+RUCY_END
+
 static
 RUCY_DEF3(set_at, x, y, color)
 {
@@ -113,6 +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=", 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)
@@ -24,9 +22,9 @@ get_line_args (std::vector<Rays::Point>* points, int argc, const Value* argv)
 		points->reserve(argc / 2);
 		for (int i = 0; i < argc; i += 2)
 		{
-			coord x = to<coord>(argv[i + 0]);
-			coord y = to<coord>(argv[i + 1]);
-			points->emplace_back(Rays::Point(x, y));
+			points->emplace_back(
+				to<coord>(argv[i + 0]),
+				to<coord>(argv[i + 1]));
 		}
 	}
 	else
@@ -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;

data/ext/rays/defs.h

@@ -7,6 +7,7 @@
 #include <vector>
 #include <rucy.h>
 #include "rays/defs.h"
+#include "rays/color.h"
 #include "rays/point.h"
 #include "rays/ruby/defs.h"
 
@@ -16,9 +17,9 @@ using namespace Rucy;
 using Rays::coord;
 
 
-void get_line_args (
-	std::vector<Rays::Point>* points,
-	int argc, const Value* argv);
+void get_points (std::vector<Rays::Point>* points, int argc, const Value* argv);
+
+void get_colors (std::vector<Rays::Color>* colors, int argc, const Value* argv);
 
 void get_rect_args (
 	coord* x,  coord* y,  coord* w,  coord* h,
@@ -35,4 +36,56 @@ void get_ellipse_args (
 	Value nsegment);
 
 
+struct CreateParams
+{
+
+	std::vector<Rays::Point> points;
+
+	std::vector<Rays::Color> colors;
+
+	std::vector<Rays::Point> texcoords;
+
+	CreateParams (
+		const Value& points_, const Value& colors_, const Value& texcoords_)
+	{
+		get_points(&points, points_.size(), points_.as_array());
+
+		if (colors_)
+		{
+			get_colors(&colors, colors_.size(), colors_.as_array());
+			if (colors.size() != points.size())
+				argument_error(__FILE__, __LINE__, "colors.size() != points.size()");
+		}
+
+		if (texcoords_)
+		{
+			get_points(&texcoords, texcoords_.size(), texcoords_.as_array());
+			if (texcoords.size() != points.size())
+				argument_error(__FILE__, __LINE__, "texcoords.size() != points.size()");
+		}
+	}
+
+	const Rays::Point* ppoints () const
+	{
+		return points.empty() ? NULL : &points[0];
+	}
+
+	const Rays::Color* pcolors () const
+	{
+		return colors.empty() ? NULL : &colors[0];
+	}
+
+	const Rays::Point* ptexcoords () const
+	{
+		return texcoords.empty() ? NULL : &texcoords[0];
+	}
+
+	size_t size () const
+	{
+		return points.size();
+	}
+
+};// CreateParams
+
+
 #endif//EOH