rays 0.1.1

data/ext/rays/font.cpp

@@ -0,0 +1,125 @@
+#include "rays/ruby/font.h"
+
+
+#include <rucy.h>
+#include "rays.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	Class
+	font_class ()
+	{
+		static Class c = rays_module().define_class("Font");
+		return c;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Font& font)
+	{
+		return new_type<Rays::Font>(
+			Rays::font_class(), new Rays::Font(font));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Font*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Font, Rays::font_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Font>(klass, new Rays::Font);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	CHECK_OBJ(self, Rays::Font, Rays::font_class());
+	if (argc < 0 || 2 < argc)
+		arg_count_error("Font#initialize", argc, 0, 1, 2);
+
+	const char* name = (argc >= 1) ? argv[0].c_str()    : NULL;
+	float size       = (argc >= 2) ? to<float>(argv[1]) : 0;
+	*this = Rays::Font(name, size);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(name)
+{
+	CHECK;
+
+	return value(this->name().c_str());
+}
+RUBY_END
+
+static
+RUBY_DEF0(size)
+{
+	CHECK;
+
+	return value(this->size());
+}
+RUBY_END
+
+static
+RUBY_DEF1(width, str)
+{
+	CHECK;
+
+	coord width = 0;
+	if (!this->get_extent(&width, NULL, str.c_str()))
+		error("Font#width(%s) failed.", str.inspect().c_str());
+
+	return value(width);
+}
+RUBY_END
+
+static
+RUBY_DEF0(height)
+{
+	CHECK;
+
+	coord height = 0;
+	if (!this->get_extent(NULL, &height, NULL))
+		error("Font#height() failed.");
+
+	return value(height);
+}
+RUBY_END
+
+
+void
+Init_font ()
+{
+	Rays::font_class()
+		.define_alloc_func(alloc)
+		.define_method("initialize", initialize)
+		.define_method("name", name)
+		.define_method("size", size)
+		.define_method("width", width)
+		.define_method("height", height);
+}

data/ext/rays/image.cpp

@@ -0,0 +1,166 @@
+#include "rays/ruby/image.h"
+
+
+#include <rucy.h>
+#include "rays.h"
+#include "rays/ruby/bitmap.h"
+#include "rays/ruby/texture.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	Class
+	image_class ()
+	{
+		static Class c = rays_module().define_class("Image");
+		return c;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Image& image)
+	{
+		return new_type<Rays::Image>(
+			Rays::image_class(), new Rays::Image(image));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Image*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Image, Rays::image_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Image>(klass, new Rays::Image);
+}
+RUBY_END
+
+static
+RUBY_DEFN(initialize)
+{
+	CHECK_OBJ(self, Rays::Image, Rays::image_class());
+	if (argc != 0 && argc != 1 && argc != 2 && argc != 3)
+		arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+
+	if (argc == 0) return self;
+
+	if (argv[1].is_kind_of(Rays::bitmap_class()))
+	{
+		if (argc != 1 && argc != 2)
+			arg_count_error("Image#initialize", argc, 0, 1, 2, 3);
+
+		const Rays::Bitmap& bitmap = *to<Rays::Bitmap*>(argv[1]);
+		bool alphaonly = (argc == 2) ? to<bool>(argv[2]) : false;
+		*this = Rays::Image(bitmap, alphaonly);
+	}
+	else
+	{
+		int width  = to<int>(argv[0]);
+		int height = to<int>(argv[1]);
+		uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
+		*this = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(width)
+{
+	CHECK;
+
+	return value(this->width());
+}
+RUBY_END
+
+static
+RUBY_DEF0(height)
+{
+	CHECK;
+
+	return value(this->height());
+}
+RUBY_END
+
+static
+RUBY_DEF0(color_space)
+{
+	CHECK;
+
+	return value(this->color_space().type());
+}
+RUBY_END
+
+static
+RUBY_DEF0(bitmap)
+{
+	CHECK;
+
+	return value(this->bitmap());
+}
+RUBY_END
+
+static
+RUBY_DEF0(texture)
+{
+	CHECK;
+
+	return value(this->texture());
+}
+RUBY_END
+
+
+static
+RUBY_DEFN(load)
+{
+	if (argc != 1 && argc != 2) arg_count_error("Image.load", argc, 1, 2);
+
+	Rays::String path = argv[0].c_str();
+	bool alphaonly = (argc == 2) ? to<bool>(argv[1]) : false;
+
+	Rays::Image img;
+	if (!Rays::load_image(&img, path.c_str(), alphaonly))
+	{
+		error(
+			"Image.load('%s', %s) failed.",
+			path.c_str(), alphaonly ? "true" : "false");
+	}
+
+	return value(img);
+}
+RUBY_END
+
+
+void
+Init_image ()
+{
+	Rays::image_class()
+		.define_alloc_func(alloc)
+		.define_method("initialize", initialize)
+		.define_method("width", width)
+		.define_method("height", height)
+		.define_method("color_space", color_space)
+		.define_method("bitmap", bitmap)
+		.define_method("texture", texture)
+		.define_function("load", load);
+}

data/ext/rays/native.cpp

@@ -0,0 +1,24 @@
+#include <rucy.h>
+
+
+void Init_rays ();
+void Init_bitmap ();
+void Init_texture ();
+void Init_image ();
+void Init_font ();
+void Init_painter ();
+
+
+extern "C" void
+Init_native ()
+{
+	if (!Rucy::init())
+		Rucy::raise(rb_eLoadError, "Rucy::init() failed.");
+
+	Init_rays();
+	Init_bitmap();
+	Init_texture();
+	Init_image();
+	Init_font();
+	Init_painter();
+}

data/ext/rays/painter.cpp

@@ -0,0 +1,573 @@
+#include "rays/ruby/painter.h"
+
+
+#include <rucy.h>
+#include "rays.h"
+#include "rays/ruby/image.h"
+#include "rays/ruby/font.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	Class
+	painter_class ()
+	{
+		static Class c = rays_module().define_class("Painter");
+		return c;
+	}
+
+
+}// Rays
+
+
+namespace Rucy
+{
+
+
+	Value
+	value (const Rays::Painter& painter)
+	{
+		return new_type<Rays::Painter>(
+			Rays::painter_class(), new Rays::Painter(painter));
+	}
+
+
+}// Rucy
+
+
+#define this to<Rays::Painter*>(self)
+
+#define CHECK CHECK_OBJECT(self, Rays::Painter, Rays::painter_class())
+
+
+static
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Rays::Painter>(klass, new Rays::Painter);
+}
+RUBY_END
+
+static
+RUBY_DEF4(canvas, x, y, width, height)
+{
+	CHECK;
+
+	coord xx = to<coord>(x);
+	coord yy = to<coord>(y);
+	coord ww = to<coord>(width);
+	coord hh = to<coord>(height);
+	if (!this->canvas(xx, yy, ww, hh))
+		error("Painter#canvas(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(begin)
+{
+	CHECK;
+
+	if (!this->begin())
+		error("Painter#begin() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(end)
+{
+	CHECK;
+
+	if (!this->end())
+		error("Painter#end() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(push)
+{
+	CHECK;
+
+	if (!this->push())
+		error("Painter#push() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(pop)
+{
+	CHECK;
+
+	if (!this->pop())
+		error("Painter#pop() failed.");
+
+	return self;
+}
+RUBY_END
+
+
+static
+RUBY_DEF4(line, x1_, y1_, x2_, y2_)
+{
+	CHECK;
+
+	coord x1 = to<coord>(x1_);
+	coord y1 = to<coord>(y1_);
+	coord x2 = to<coord>(x2_);
+	coord y2 = to<coord>(y2_);
+	if (!this->line(x1, y1, x2, y2))
+		error("Painter#line(%f, %f, %f, %f) failed.", x1, y1, x2, y2);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF4(rect, x, y, width, height)
+{
+	CHECK;
+
+	coord xx = to<coord>(x);
+	coord yy = to<coord>(y);
+	coord ww = to<coord>(width);
+	coord hh = to<coord>(height);
+	if (!this->rect(xx, yy, ww, hh))
+		error("Painter#rect(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(ellipse)
+{
+	CHECK;
+	if (argc < 3 || 6 < argc)
+		arg_count_error("Painter#ellipse", argc, 4, 5, 6);
+
+	coord xx   = to<coord>(argv[0]);
+	coord yy   = to<coord>(argv[1]);
+	coord ww   = to<coord>(argv[2]);
+	coord hh   = (argc >= 4) ? to<coord>(argv[3]) : 0;
+	coord min_ = (argc >= 5) ? to<coord>(argv[4]) : 0;
+	uint nseg  = (argc >= 6) ? to<uint>(argv[5])  : 0;
+	if (!this->ellipse(xx, yy, ww, hh, min_, nseg))
+	{
+		error(
+			"Painter#ellipse(%f, %f, %f, %f, %f, %d) failed.",
+			xx, yy, ww, hh, min_, nseg);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(arc)
+{
+	CHECK;
+	if (argc < 3 || 8 < argc)
+		arg_count_error("Painter#ellipse", argc, 4, 5, 6, 7, 8);
+
+	coord xx   = to<coord>(argv[0]);
+	coord yy   = to<coord>(argv[1]);
+	coord ww   = to<coord>(argv[2]);
+	coord hh   = (argc >= 4) ? to<coord>(argv[3]) : 0;
+	float from = (argc >= 5) ? to<float>(argv[4]) : 0;
+	float to_  = (argc >= 6) ? to<float>(argv[5]) : 360;
+	coord min_ = (argc >= 7) ? to<coord>(argv[6]) : 0;
+	uint nseg  = (argc >= 8) ? to<uint>(argv[7])  : 0;
+	if (!this->arc(xx, yy, ww, hh, from, to_, min_, nseg))
+	{
+		error(
+			"Painter#arc(%f, %f, %f, %f, %f, %f, %f, %d) failed.",
+			xx, yy, ww, hh, from, to_, min_, nseg);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(image)
+{
+	CHECK;
+	if (argc != 1 && argc != 3 && argc != 5 && argc != 7 && argc != 9)
+		arg_count_error("Painter#image", argc, 1, 3, 5, 7, 9);
+
+	const Rays::Image* image = to<Rays::Image*>(argv[0]);
+	if (!image)
+		argument_error("%s is not an image.", argv[0].inspect().c_str());
+
+	if (argc == 1)
+	{
+		if (!this->image(*image))
+			error("Painter#image(%s) failed.", argv[0].inspect().c_str());
+	}
+	else if (argc == 3)
+	{
+		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
+		if (!this->image(*image, x, y))
+		{
+			error(
+				"Painter#image(%s, %f, %f) failed.",
+				argv[0].inspect().c_str(), x, y);
+		}
+	}
+	else if (argc == 5)
+	{
+		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
+		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
+		if (!this->image(*image, x, y, w, h))
+		{
+			error(
+				"Painter#image(%s, %f, %f, %f, %f) failed.",
+				argv[0].inspect().c_str(), x, y, w, h);
+		}
+	}
+	else if (argc == 7)
+	{
+		coord sx = to<coord>(argv[1]), dx = to<coord>(argv[5]);
+		coord sy = to<coord>(argv[2]), dy = to<coord>(argv[6]);
+		coord sw = to<coord>(argv[3]);
+		coord sh = to<coord>(argv[4]);
+		if (!this->image(*image, sx, sy, sw, sh, dx, dy))
+		{
+			error(
+				"Painter#image(%s, %f, %f, %f, %f, %f, %f) failed.",
+				argv[0].inspect().c_str(), sx, sy, sw, sh, dx, dy);
+		}
+	}
+	else if (argc == 9)
+	{
+		coord sx = to<coord>(argv[1]), dx = to<coord>(argv[5]);
+		coord sy = to<coord>(argv[2]), dy = to<coord>(argv[6]);
+		coord sw = to<coord>(argv[3]), dw = to<coord>(argv[7]);
+		coord sh = to<coord>(argv[4]), dh = to<coord>(argv[8]);
+		if (!this->image(*image, sx, sy, sw, sh, dx, dy, dw, dh))
+		{
+			error(
+				"Painter#image(%s, %f, %f, %f, %f, %f, %f, %f, %f) failed.",
+				argv[0].inspect().c_str(), sx, sy, sw, sh, dx, dy, dw, dh);
+		}
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEFN(text)
+{
+	CHECK;
+	if (argc != 1 && argc != 3 && argc != 4 && argc != 5 && argc != 7)
+		arg_count_error("Painter#text", argc, 1, 3, 4, 5, 7);
+
+	if (argc == 1)
+	{
+		if (!this->text(argv[0].c_str()))
+			error("Painter#text(%s) failed.", argv[0].inspect().c_str());
+	}
+	else if (argc == 3)
+	{
+		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
+		if (!this->text(argv[0].c_str(), x, y))
+		{
+			error(
+				"Painter#text(%s, %f, %f) failed.",
+				argv[0].inspect().c_str(), x, y);
+		}
+	}
+	else if (argc == 4)
+	{
+		const Rays::Font* font = to<Rays::Font*>(argv[3]);
+		if (!font || !*font)
+			error("Painter#text: invalid font.");
+
+		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
+		if (!this->text(argv[0].c_str(), x, y, *font))
+		{
+			error(
+				"Painter#image(%s, %f, %f, %s) failed.",
+				argv[0].inspect().c_str(), x, y, argv[3].inspect().c_str());
+		}
+	}
+	else if (argc == 5)
+	{
+		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
+		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
+		if (!this->text(argv[0].c_str(), x, y, w, h))
+		{
+			error(
+				"Painter#text(%s, %f, %f, %f, %f) failed.",
+				argv[0].inspect().c_str(), x, y, w, h);
+		}
+	}
+	else if (argc == 7)
+	{
+		const Rays::Font* font = to<Rays::Font*>(argv[3]);
+		if (!font || !*font)
+			error("Painter#text: invalid font.");
+
+		coord x = to<coord>(argv[1]), w = to<coord>(argv[3]);
+		coord y = to<coord>(argv[2]), h = to<coord>(argv[4]);
+		if (!this->text(argv[0].c_str(), x, y, w, h, *font))
+		{
+			error(
+				"Painter#image(%s, %f, %f, %f, %f, %s) failed.",
+				argv[0].inspect().c_str(), x, y, w, h, argv[3].inspect().c_str());
+		}
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_clear)
+{
+	CHECK;
+
+	coord red = 0, green = 0, blue = 0, alpha = 0;
+	if (!this->get_clear(&red, &green, &blue, &alpha))
+		error("failed to get color for clear.");
+
+	Value ret[] = {red, green, blue, alpha};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEFN(set_clear)
+{
+	CHECK;
+	if (argc < 1 || 4 < argc)
+		arg_count_error("Painter#set_clear", argc, 1, 2, 3, 4);
+
+	if (argc == 1 || argc == 2)
+	{
+		float v = to<float>(argv[0]);
+		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
+		if (!this->set_clear(v, v, v, a))
+			error("Painter#set_clear(%f, %f) failed.", v, a);
+	}
+	else
+	{
+		float r = to<float>(argv[0]);
+		float g = to<float>(argv[1]);
+		float b = to<float>(argv[2]);
+		float a = (argc == 4) ? to<float>(argv[3]) : 1;
+		if (!this->set_clear(r, g, b, a))
+			error("Painter#set_clear(%f, %f, %f, %f) failed.", r, g, b, a);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(no_clear)
+{
+	CHECK;
+
+	if (!this->no_clear())
+		error("Painter#no_clear() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_fill)
+{
+	CHECK;
+
+	coord red = 0, green = 0, blue = 0, alpha = 0;
+	if (!this->get_fill(&red, &green, &blue, &alpha))
+		error("failed to get color for fill.");
+
+	Value ret[] = {red, green, blue, alpha};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEFN(set_fill)
+{
+	CHECK;
+	if (argc < 1 || 4 < argc)
+		arg_count_error("Painter#set_fill", argc, 1, 2, 3, 4);
+
+	if (argc == 1 || argc == 2)
+	{
+		float v = to<float>(argv[0]);
+		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
+		if (!this->set_fill(v, v, v, a))
+			error("Painter#set_fill(%f, %f) failed.", v, a);
+	}
+	else
+	{
+		float r = to<float>(argv[0]);
+		float g = to<float>(argv[1]);
+		float b = to<float>(argv[2]);
+		float a = (argc == 4) ? to<float>(argv[3]) : 1;
+		if (!this->set_fill(r, g, b, a))
+			error("Painter#set_fill(%f, %f, %f, %f) failed.", r, g, b, a);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(no_fill)
+{
+	CHECK;
+
+	if (!this->no_fill())
+		error("Painter#no_fill() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_stroke)
+{
+	CHECK;
+
+	coord red = 0, green = 0, blue = 0, alpha = 0;
+	if (!this->get_stroke(&red, &green, &blue, &alpha))
+		error("failed to get color for stroke.");
+
+	Value ret[] = {red, green, blue, alpha};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEFN(set_stroke)
+{
+	CHECK;
+	if (argc < 1 || 4 < argc)
+		arg_count_error("Painter#set_stroke", argc, 1, 2, 3, 4);
+
+	if (argc == 1 || argc == 2)
+	{
+		float v = to<float>(argv[0]);
+		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
+		if (!this->set_stroke(v, v, v, a))
+			error("Painter#set_stroke(%f, %f) failed.", v, a);
+	}
+	else
+	{
+		float r = to<float>(argv[0]);
+		float g = to<float>(argv[1]);
+		float b = to<float>(argv[2]);
+		float a = (argc == 4) ? to<float>(argv[3]) : 1;
+		if (!this->set_stroke(r, g, b, a))
+			error("Painter#set_stroke(%f, %f, %f, %f) failed.", r, g, b, a);
+	}
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(no_stroke)
+{
+	CHECK;
+
+	if (!this->no_stroke())
+		error("Painter#no_stroke() failed.");
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_clip)
+{
+	CHECK;
+
+	coord x = 0, y = 0, width = 0, height = 0;
+	if (!this->get_clip(&x, &y, &width, &height))
+		error("failed to get clip rect.");
+
+	Value ret[] = {x, y, width, height};
+	return value(4, ret);
+}
+RUBY_END
+
+static
+RUBY_DEF4(set_clip, x, y, width, height)
+{
+	CHECK;
+
+	coord xx = to<coord>(x), ww = to<coord>(width);
+	coord yy = to<coord>(y), hh = to<coord>(height);
+	if (!this->set_clip(xx, yy, ww, hh))
+		error("Painter#set_clip(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(no_clip)
+{
+	CHECK;
+
+	if (!this->no_clip())
+		error("Painter#no_clip() failed.");
+
+	return self;
+}
+RUBY_END
+
+
+void
+Init_painter ()
+{
+	Rays::painter_class()
+		.define_alloc_func(alloc)
+
+		.define_method("canvas", canvas)
+		.define_method("begin", begin)
+		.define_method("end", end)
+		.define_method("push", push)
+		.define_method("pop", pop)
+
+		.define_private_method("draw_line", line)
+		.define_private_method("draw_rect", rect)
+		.define_private_method("draw_ellipse", ellipse)
+		.define_private_method("draw_arc", arc)
+		.define_private_method("draw_image", image)
+		.define_private_method("draw_text", text)
+
+		.define_method("get_fill", get_fill)
+		.define_method("set_fill", set_fill)
+		.define_method("no_fill",  no_fill)
+		.define_method("get_stroke", get_stroke)
+		.define_method("set_stroke", set_stroke)
+		.define_method("no_stroke",  no_stroke)
+		.define_method("get_clear", get_clear)
+		.define_method("set_clear", set_clear)
+		.define_method("no_clear",  no_clear)
+		.define_method("get_clip", get_clip)
+		.define_method("set_clip", set_clip)
+		.define_method("no_clip",  no_clip);
+}