rays 0.1.2 → 0.1.3

data/.doc/ext/rays/native.cpp

@@ -0,0 +1,28 @@
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+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())
+		raise(rb_eLoadError, "Rucy::init() failed.");
+
+	Init_rays();
+	Init_bitmap();
+	Init_texture();
+	Init_image();
+	Init_font();
+	Init_painter();
+}

data/.doc/ext/rays/painter.cpp

@@ -0,0 +1,554 @@
+#include "rays/ruby/painter.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/image.h>
+#include <rays/ruby/font.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Rays::coord;
+
+
+namespace Rays
+{
+
+
+	static Class cPainter;
+
+	Class
+	painter_class ()
+	{
+		return cPainter;
+	}
+
+
+}// 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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Rays::Painter>(klass, new Rays::Painter);
+}
+
+static
+VALUE canvas(VALUE self, VALUE x, VALUE y, VALUE width, VALUE 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;
+}
+
+static
+VALUE begin(VALUE self)
+{
+	CHECK;
+
+	if (!this->begin())
+		error("Painter#begin() failed.");
+
+	return self;
+}
+
+static
+VALUE end(VALUE self)
+{
+	CHECK;
+
+	if (!this->end())
+		error("Painter#end() failed.");
+
+	return self;
+}
+
+static
+VALUE push_matrix(VALUE self)
+{
+	CHECK;
+
+	if (!this->push_matrix())
+		error("Painter#push_matrix() failed.");
+
+	return self;
+}
+
+static
+VALUE pop_matrix(VALUE self)
+{
+	CHECK;
+
+	if (!this->pop_matrix())
+		error("Painter#pop_matrix() failed.");
+
+	return self;
+}
+
+
+static
+VALUE line(VALUE self, VALUE x1_, VALUE y1_, VALUE x2_, VALUE 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;
+}
+
+static
+VALUE rect(VALUE self, VALUE x, VALUE y, VALUE width, VALUE 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;
+}
+
+static
+VALUE ellipse(VALUE self)
+{
+	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;
+}
+
+static
+VALUE arc(VALUE self)
+{
+	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;
+}
+
+static
+VALUE image(VALUE self)
+{
+	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;
+}
+
+static
+VALUE text(VALUE self)
+{
+	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;
+}
+
+static
+VALUE get_clear(VALUE self)
+{
+	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);
+}
+
+static
+VALUE set_clear(VALUE self)
+{
+	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;
+}
+
+static
+VALUE no_clear(VALUE self)
+{
+	CHECK;
+
+	if (!this->no_clear())
+		error("Painter#no_clear() failed.");
+
+	return self;
+}
+
+static
+VALUE get_fill(VALUE self)
+{
+	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);
+}
+
+static
+VALUE set_fill(VALUE self)
+{
+	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;
+}
+
+static
+VALUE no_fill(VALUE self)
+{
+	CHECK;
+
+	if (!this->no_fill())
+		error("Painter#no_fill() failed.");
+
+	return self;
+}
+
+static
+VALUE get_stroke(VALUE self)
+{
+	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);
+}
+
+static
+VALUE set_stroke(VALUE self)
+{
+	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;
+}
+
+static
+VALUE no_stroke(VALUE self)
+{
+	CHECK;
+
+	if (!this->no_stroke())
+		error("Painter#no_stroke() failed.");
+
+	return self;
+}
+
+static
+VALUE get_clip(VALUE self)
+{
+	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);
+}
+
+static
+VALUE set_clip(VALUE self, VALUE x, VALUE y, VALUE width, VALUE 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;
+}
+
+static
+VALUE no_clip(VALUE self)
+{
+	CHECK;
+
+	if (!this->no_clip())
+		error("Painter#no_clip() failed.");
+
+	return self;
+}
+
+
+void
+Init_painter ()
+{
+	Module m = rb_define_module("Rays");
+
+	Class c = rb_define_class_under(m, "Painter", rb_cObject);
+	Rays::cPainter = c;
+
+	rb_define_alloc_func(c, alloc);
+
+	rb_define_method(c, "canvas", RUBY_METHOD_FUNC(canvas), 4);
+	rb_define_method(c, "begin", RUBY_METHOD_FUNC(begin), 0);
+	rb_define_method(c, "end", RUBY_METHOD_FUNC(end), 0);
+	rb_define_method(c, "push_matrix", RUBY_METHOD_FUNC(push_matrix), 0);
+	rb_define_method(c, "pop_matrix", RUBY_METHOD_FUNC(pop_matrix), 0);
+
+	rb_define_private_method(c, "draw_line", RUBY_METHOD_FUNC(line), 4);
+	rb_define_private_method(c, "draw_rect", RUBY_METHOD_FUNC(rect), 4);
+	rb_define_private_method(c, "draw_ellipse", RUBY_METHOD_FUNC(ellipse), -1);
+	rb_define_private_method(c, "draw_arc", RUBY_METHOD_FUNC(arc), -1);
+	rb_define_private_method(c, "draw_image", RUBY_METHOD_FUNC(image), -1);
+	rb_define_private_method(c, "draw_text", RUBY_METHOD_FUNC(text), -1);
+
+	rb_define_method(c, "get_fill", RUBY_METHOD_FUNC(get_fill), 0);
+	rb_define_method(c, "set_fill", RUBY_METHOD_FUNC(set_fill), -1);
+	rb_define_method(c, "no_fill", RUBY_METHOD_FUNC(no_fill), 0);
+	rb_define_method(c, "get_stroke", RUBY_METHOD_FUNC(get_stroke), 0);
+	rb_define_method(c, "set_stroke", RUBY_METHOD_FUNC(set_stroke), -1);
+	rb_define_method(c, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
+	rb_define_method(c, "get_clear", RUBY_METHOD_FUNC(get_clear), 0);
+	rb_define_method(c, "set_clear", RUBY_METHOD_FUNC(set_clear), -1);
+	rb_define_method(c, "no_clear", RUBY_METHOD_FUNC(no_clear), 0);
+	rb_define_method(c, "get_clip", RUBY_METHOD_FUNC(get_clip), 0);
+	rb_define_method(c, "set_clip", RUBY_METHOD_FUNC(set_clip), 4);
+	rb_define_method(c, "no_clip", RUBY_METHOD_FUNC(no_clip), 0);
+}