rays 0.1.12 → 0.1.13

data/ext/rays/matrix.cpp

@@ -1,14 +1,11 @@
 #include "rays/ruby/matrix.h"
 
 
-#include <rucy.h>
+#include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
-RUCY_DEFINE_VALUE_FROM_TO(Rays::Matrix)
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Rays::Matrix)
 
 #define THIS  to<Rays::Matrix*>(self)
 
@@ -28,22 +25,8 @@ RUCY_DEFN(initialize)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
 
-	if (argc == 0) return self;
-
-	switch (argc)
-	{
-		case 1:
-			*THIS = Rays::Matrix(to<float>(argv[0]));
-			break;
-
-		case 16:
-			*THIS = Rays::Matrix(
-				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
-				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
-				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
-				to<float>(argv[12]), to<float>(argv[13]), to<float>(argv[14]), to<float>(argv[15]));
-			break;
-	}
+	if (argc > 0)
+		*THIS = to<Rays::Matrix>(argc, argv);
 
 	return self;
 }
@@ -59,23 +42,23 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEFN(set)
+RUCY_DEFN(reset)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Matrix#initialize", argc, 0, 1, 16);
+	check_arg_count(__FILE__, __LINE__, "Matrix#reset", argc, 0, 1, 16);
 
 	switch (argc)
 	{
 		case 0:
-			*THIS = Rays::Matrix();
+			THIS->reset();
 			break;
 
 		case 1:
-			*THIS = Rays::Matrix(to<float>(argv[0]));
+			THIS->reset(to<float>(argv[0]));
 			break;
 
 		case 16:
-			*THIS = Rays::Matrix(
+			THIS->reset(
 				to<float>(argv[0]),  to<float>(argv[1]),  to<float>(argv[2]),  to<float>(argv[3]),
 				to<float>(argv[4]),  to<float>(argv[5]),  to<float>(argv[6]),  to<float>(argv[7]),
 				to<float>(argv[8]),  to<float>(argv[9]),  to<float>(argv[10]), to<float>(argv[11]),
@@ -88,13 +71,140 @@ RUCY_DEFN(set)
 RUCY_END
 
 static
-RUCY_DEF2(at, row, column)
+RUCY_DEFN(translate)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#translate", argc, 1, 2, 3);
+
+	THIS->translate(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(scale)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#scale", argc, 1, 2, 3);
+
+	THIS->scale(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(rotate)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Matrix#rotate", argc, 1, 2, 4);
+
+	float degree = to<float>(argv[0]);
+
+	if (argc == 1)
+		THIS->rotate(degree);
+	else
+		THIS->rotate(degree, to<Rays::Point>(argc - 1, argv + 1));
+
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(to_a)
+{
+	CHECK;
+	return array(
+		THIS->x0, THIS->y0, THIS->z0, THIS->w0,
+		THIS->x1, THIS->y1, THIS->z1, THIS->w1,
+		THIS->x2, THIS->y2, THIS->z2, THIS->w2,
+		THIS->x3, THIS->y3, THIS->z3, THIS->w3);
+}
+RUCY_END
+
+static
+RUCY_DEF1(mult, val)
+{
+	CHECK;
+
+	if (val.is_kind_of(Rays::matrix_class()))
+		return value(*THIS * to<Rays::Matrix&>(val));
+
+	if (val.is_kind_of(Rays::point_class()))
+		return value(*THIS * to<Rays::Point&>(val));
+
+	if (val.is_array())
+	{
+		if (val.size() == 16)
+			return value(*THIS * to<Rays::Matrix>(val));
+		else
+			return value(*THIS * to<Rays::Point>(val));
+	}
+
+	argument_error(__FILE__, __LINE__);
+}
+RUCY_END
+
+static
+RUCY_DEF3(set_at, row, column, val)
+{
+	CHECK;
+	return value(THIS->at(row.as_i(), column.as_i()) = to<float>(val));
+}
+RUCY_END
+
+static
+RUCY_DEF2(get_at, row, column)
 {
 	CHECK;
 	return value(THIS->at(row.as_i(), column.as_i()));
 }
 RUCY_END
 
+static
+RUCY_DEF1(compare, other)
+{
+	CHECK;
+
+	const Rays::Matrix& a = *THIS;
+	const Rays::Matrix& b = to<const Rays::Matrix&>(other);
+	for (int i = 0; i < Rays::Matrix::NELEM; ++i)
+	{
+		if (a[i] == b[i]) continue;
+		return value(a[i] < b[i] ? -1 : +1);
+	}
+	return value(0);
+}
+RUCY_END
+
+static
+RUCY_DEF0(inspect)
+{
+	CHECK;
+	return value(Xot::stringf("#<Rays::Matrix %s>", THIS->inspect().c_str()));
+}
+RUCY_END
+
+static
+RUCY_DEFN(s_translate)
+{
+	return translate(argc, argv, value(Rays::Matrix()));
+}
+RUCY_END
+
+static
+RUCY_DEFN(s_scale)
+{
+	return scale(argc, argv, value(Rays::Matrix()));
+}
+RUCY_END
+
+static
+RUCY_DEFN(s_rotate)
+{
+	return rotate(argc, argv, value(Rays::Matrix()));
+}
+RUCY_END
+
 
 static Class cMatrix;
 
@@ -105,13 +215,71 @@ Init_matrix ()
 
 	cMatrix = mRays.define_class("Matrix");
 	cMatrix.define_alloc_func(alloc);
-	cMatrix.define_private_method("initialize", initialize);
+	cMatrix.define_private_method("initialize",      initialize);
 	cMatrix.define_private_method("initialize_copy", initialize_copy);
-	cMatrix.define_method("set", set);
-	cMatrix.define_method("at", at);
+	cMatrix.define_method("reset", reset);
+	cMatrix.define_method("translate", translate);
+	cMatrix.define_method("scale",     scale);
+	cMatrix.define_method("rotate",    rotate);
+	cMatrix.define_method("to_a", to_a);
+	cMatrix.define_method("*", mult);
+	cMatrix.define_method("[]=", set_at);
+	cMatrix.define_method("[]",  get_at);
+	cMatrix.define_method("<=>", compare);
+	cMatrix.define_method("inspect", inspect);
+
+	cMatrix.define_singleton_method("translate", s_translate);
+	cMatrix.define_singleton_method("scale",     s_scale);
+	cMatrix.define_singleton_method("rotate",    s_rotate);
 }
 
 
+namespace Rucy
+{
+
+
+	template <> Rays::Matrix
+	value_to<Rays::Matrix> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc == 0 || (argc > 0 && argv));
+
+		if (convert)
+		{
+			if (argc == 0)
+				return Rays::Matrix();
+			else if (argv->is_num())
+			{
+				switch (argc)
+				{
+					#define V(i) argv[i].as_f(true)
+					case 1:  return Rays::Matrix(V(0));
+					case 16: return Rays::Matrix(
+						V(0),  V(1),  V(2),  V(3),
+						V(4),  V(5),  V(6),  V(7),
+						V(8),  V(9),  V(10), V(11),
+						V(12), V(13), V(14), V(15));
+					#undef V
+					default: argument_error(__FILE__, __LINE__);
+				}
+			}
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Rays::Matrix&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
 namespace Rays
 {
 

data/ext/rays/native.cpp

@@ -1,25 +1,26 @@
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 void Init_rays ();
 
 void Init_point ();
 void Init_bounds ();
 void Init_color ();
 void Init_color_space ();
+void Init_matrix ();
 
+void Init_polyline ();
+void Init_polygon_line ();
+void Init_polygon ();
 void Init_bitmap ();
-void Init_texture ();
 void Init_image ();
 void Init_font ();
 void Init_shader ();
 
 void Init_painter ();
 
+void Init_noise ();
+
 
 extern "C" void
 #ifdef COCOAPODS
@@ -38,14 +39,19 @@ extern "C" void
 	Init_bounds();
 	Init_color();
 	Init_color_space();
+	Init_matrix();
 
+	Init_polyline();
+	Init_polygon_line();
+	Init_polygon();
 	Init_bitmap();
-	Init_texture();
 	Init_image();
 	Init_font();
 	Init_shader();
 
 	Init_painter();
 
+	Init_noise();
+
 	RUCY_CATCH
 }

data/ext/rays/noise.cpp

@@ -0,0 +1,55 @@
+#include "rays/noise.h"
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+static
+RUCY_DEFN(perlin)
+{
+	check_arg_count(__FILE__, __LINE__, "Rays.perlin", argc, 1, 2, 3, 4);
+
+	coord noise = 0;
+	if (argc == 4)
+	{
+		noise = Rays::perlin(
+			to<coord>(argv[0]),
+			to<coord>(argv[1]),
+			to<coord>(argv[2]),
+			to<coord>(argv[3]));
+	}
+	else
+		noise = Rays::perlin(to<Rays::Point>(argc, argv));
+
+	return value(noise);
+}
+RUCY_END
+
+static
+RUCY_DEFN(simplex)
+{
+	check_arg_count(__FILE__, __LINE__, "Rays.simplex", argc, 1, 2, 3, 4);
+
+	coord noise = 0;
+	if (argc == 4)
+	{
+		noise = Rays::simplex(
+			to<coord>(argv[0]),
+			to<coord>(argv[1]),
+			to<coord>(argv[2]),
+			to<coord>(argv[3]));
+	}
+	else
+		noise = Rays::simplex(to<Rays::Point>(argc, argv));
+
+	return value(noise);
+}
+RUCY_END
+
+
+void
+Init_noise ()
+{
+	Module mRays = define_module("Rays");
+	mRays.define_singleton_method("perlin", perlin);
+	mRays.define_singleton_method("simplex", simplex);
+}

data/ext/rays/painter.cpp

@@ -2,22 +2,16 @@
 
 
 #include <vector>
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "rays/ruby/bounds.h"
 #include "rays/ruby/color.h"
 #include "rays/ruby/matrix.h"
-#include "rays/ruby/font.h"
 #include "rays/ruby/image.h"
+#include "rays/ruby/font.h"
 #include "rays/ruby/shader.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Rays::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Rays::Painter)
 
 #define THIS  to<Rays::Painter*>(self)
@@ -55,6 +49,14 @@ RUCY_DEF0(bounds)
 }
 RUCY_END
 
+static
+RUCY_DEF0(pixel_density)
+{
+	CHECK;
+	return value(THIS->pixel_density());
+}
+RUCY_END
+
 
 static
 RUCY_DEF0(begin_paint)
@@ -83,144 +85,70 @@ RUCY_DEF0(clear)
 RUCY_END
 
 static
-RUCY_DEFN(line)
-{
-	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#line", argc, 2, 4);
-
-	if (argc == 2)
-		THIS->line(to<Rays::Point&>(argv[0]), to<Rays::Point&>(argv[1]));
-	else
-	{
-		coord x1 = to<coord>(argv[0]);
-		coord y1 = to<coord>(argv[1]);
-		coord x2 = to<coord>(argv[2]);
-		coord y2 = to<coord>(argv[3]);
-		THIS->line(x1, y1, x2, y2);
-	}
-
-	return self;
-}
-RUCY_END
-
-static
-RUCY_DEFN(lines)
+RUCY_DEF1(polygon, poly)
 {
 	CHECK;
-	if (argc <= 0)
-		argument_error(__FILE__, __LINE__, "Painter#lines");
-
-	std::vector<Rays::Coord3> points;
-	points.reserve(argc);
-	for (int i = 0; i < argc; ++i)
-		points.push_back(to<Rays::Point&>(argv[i]));
 
-	THIS->lines((Rays::Point*) &points[0], points.size());
+	THIS->polygon(to<Rays::Polygon&>(poly));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(polygon)
+RUCY_DEF2(line, args, loop)
 {
 	CHECK;
-	if (argc <= 0)
-		argument_error(__FILE__, __LINE__, "Painter#polygon");
 
-	std::vector<Rays::Coord3> points;
-	points.reserve(argc);
-	for (int i = 0; i < argc; ++i)
-		points.push_back(to<Rays::Point&>(argv[i]));
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
 
-	THIS->polygon((Rays::Point*) &points[0], points.size());
+	THIS->line(&points[0], points.size(), loop);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(rect)
+RUCY_DEF1(polyline, poly)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#rect", argc, 1, 2, 3, 4, 5, 6);
-
-	if (argc <= 3)
-	{
-		Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
-		coord rw        = argc >= 2 ? to<coord>(argv[1]) : 0;
-		coord rh        = argc >= 3 ? to<coord>(argv[2]) : rw;
-		THIS->rect(b, rw, rh);
-	}
-	else
-	{
-		coord x  = to<coord>(argv[0]);
-		coord y  = to<coord>(argv[1]);
-		coord w  = to<coord>(argv[2]);
-		coord h  = to<coord>(argv[3]);
-		coord rw = argc >= 5 ? to<coord>(argv[4]) : 0;
-		coord rh = argc >= 6 ? to<coord>(argv[5]) : rw;
-		THIS->rect(x, y, w, h, rw, rh);
-	}
 
+	THIS->line(to<Rays::Polyline&>(poly));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(ellipse)
+RUCY_DEF6(rect, args, round, lefttop, righttop, leftbottom, rightbottom)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#ellipse", argc, 1, 2, 3, 4, 5, 6);
 
-	if (argv[0].is_kind_of(Rays::bounds_class()))
-	{
-		const Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
-		coord min_ = (argc >= 2) ? to<coord>(argv[1]) : 0;
-		uint nseg  = (argc >= 3) ? to<uint> (argv[2]) : 0;
-		THIS->ellipse(b, min_, nseg);
-	}
-	else
-	{
-		coord x    = to<coord>(argv[0]);
-		coord y    = to<coord>(argv[1]);
-		coord w    = to<coord>(argv[2]);
-		coord h    = (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;
-		THIS->ellipse(x, y, w, h, min_, nseg);
-	}
+	coord x, y, w, h, lt, rt, lb, rb;
+	uint _;
+	get_rect_args(
+		&x, &y, &w, &h, &lt, &rt, &lb, &rb, &_,
+		args.size(), args.as_array(),
+		round, lefttop, righttop, leftbottom, rightbottom, nil());
 
+	THIS->rect(x, y, w, h, lt, rt, lb, rb);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(arc)
+RUCY_DEF6(ellipse, args, center, radius, hole, angle_from, angle_to)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#ellipse", argc, 1, 2, 3, 4, 5, 6, 7, 8);
 
-	if (argv[0].is_kind_of(Rays::bounds_class()))
-	{
-		const Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
-		float begin = (argc >= 2) ? to<float>(argv[1]) : 0;
-		float end   = (argc >= 3) ? to<float>(argv[2]) : 360;
-		coord min_  = (argc >= 4) ? to<coord>(argv[3]) : 0;
-		uint nseg   = (argc >= 5) ? to<uint> (argv[4]) : 0;
-		THIS->arc(b, begin, end, min_, nseg);
-	}
-	else
-	{
-		coord x     = to<coord>(argv[0]);
-		coord y     = to<coord>(argv[1]);
-		coord w     = to<coord>(argv[2]);
-		coord h     = (argc >= 4) ? to<coord>(argv[3]) : 0;
-		float begin = (argc >= 5) ? to<float>(argv[4]) : 0;
-		float end   = (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;
-		THIS->arc(x, y, w, h, begin, end, min_, nseg);
-	}
+	coord x, y, w, h;
+	Rays::Point hole_size;
+	float from, to_;
+	uint _;
+	get_ellipse_args(
+		&x, &y, &w, &h, &hole_size, &from, &to_, &_,
+		args.size(), args.as_array(),
+		center, radius, hole, angle_from, angle_to, nil());
 
+	THIS->ellipse(x, y, w, h, hole_size, from, to_);
 	return self;
 }
 RUCY_END
@@ -273,7 +201,7 @@ static
 RUCY_DEFN(text)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#text", argc, 1, 3, 4, 5, 7);
+	check_arg_count(__FILE__, __LINE__, "Painter#text", argc, 1, 3, 5);
 
 	if (argc == 1)
 		THIS->text(argv[0].c_str());
@@ -282,63 +210,35 @@ RUCY_DEFN(text)
 		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
 		THIS->text(argv[0].c_str(), x, y);
 	}
-	else if (argc == 4)
-	{
-		const Rays::Font* font = to<Rays::Font*>(argv[3]);
-		if (!font || !*font)
-			rays_error(__FILE__, __LINE__, "Painter#text: invalid font.");
-
-		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
-		THIS->text(argv[0].c_str(), x, y, font);
-	}
 	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]);
 		THIS->text(argv[0].c_str(), x, y, w, h);
 	}
-	else if (argc == 7)
-	{
-		const Rays::Font* font = to<Rays::Font*>(argv[3]);
-		if (!font || !*font)
-			rays_error(__FILE__, __LINE__, "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]);
-		THIS->text(argv[0].c_str(), x, y, w, h, font);
-	}
 
 	return self;
 }
 RUCY_END
 
+
 static
 RUCY_DEFN(set_background)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_background", argc, 1, 2, 3, 4);
-
-	if (argc == 1 && argv[0].is_kind_of(Rays::color_class()))
-		THIS->set_background(to<Rays::Color&>(argv[0]));
-	else if (argc == 1 || argc == 2)
-	{
-		float v = to<float>(argv[0]);
-		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		THIS->set_background(v, v, 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;
-		THIS->set_background(r, g, b, a);
-	}
-
+	THIS->set_background(to<Rays::Color>(argc, argv));
 	return self;
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_background)
+{
+	CHECK;
+	return value(THIS->background());
+}
+RUCY_END
+
 static
 RUCY_DEF0(no_background)
 {
@@ -349,37 +249,19 @@ RUCY_DEF0(no_background)
 RUCY_END
 
 static
-RUCY_DEF0(get_background)
+RUCY_DEFN(set_fill)
 {
 	CHECK;
-	return value(THIS->background());
+	THIS->set_fill(to<Rays::Color>(argc, argv));
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_fill)
+RUCY_DEF0(get_fill)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_fill", argc, 1, 2, 3, 4);
-
-	if (argc == 1 && argv[0].is_kind_of(Rays::color_class()))
-		THIS->set_fill(to<Rays::Color&>(argv[0]));
-	else if (argc == 1 || argc == 2)
-	{
-		float v = to<float>(argv[0]);
-		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		THIS->set_fill(v, v, 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;
-		THIS->set_fill(r, g, b, a);
-	}
-
-	return self;
+	return value(THIS->fill());
 }
 RUCY_END
 
@@ -393,37 +275,19 @@ RUCY_DEF0(no_fill)
 RUCY_END
 
 static
-RUCY_DEF0(get_fill)
+RUCY_DEFN(set_stroke)
 {
 	CHECK;
-	return value(THIS->fill());
+	THIS->set_stroke(to<Rays::Color>(argc, argv));
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_stroke)
+RUCY_DEF0(get_stroke)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_stroke", argc, 1, 2, 3, 4);
-
-	if (argc == 1 && argv[0].is_kind_of(Rays::color_class()))
-		THIS->set_stroke(to<Rays::Color&>(argv[0]));
-	else if (argc == 1 || argc == 2)
-	{
-		float v = to<float>(argv[0]);
-		float a = (argc >= 2) ? to<float>(argv[1]) : 1;
-		THIS->set_stroke(v, v, 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;
-		THIS->set_stroke(r, g, b, a);
-	}
-
-	return self;
+	return value(THIS->stroke());
 }
 RUCY_END
 
@@ -437,177 +301,126 @@ RUCY_DEF0(no_stroke)
 RUCY_END
 
 static
-RUCY_DEF0(get_stroke)
+RUCY_DEF1(set_stroke_width, width)
 {
 	CHECK;
-	return value(THIS->stroke());
+	THIS->set_stroke_width(to<coord>(width));
+	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_clip)
+RUCY_DEF0(get_stroke_width)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_clip", argc, 1, 4);
-
-	if (argc == 1)
-		THIS->set_clip(to<Rays::Bounds&>(argv[0]));
-	else
-	{
-		coord x = to<coord>(argv[0]);
-		coord y = to<coord>(argv[1]);
-		coord w = to<coord>(argv[2]);
-		coord h = to<coord>(argv[3]);
-		THIS->set_clip(x, y, w, h);
-	}
-
-	return self;
+	return value(THIS->stroke_width());
 }
 RUCY_END
 
 static
-RUCY_DEF0(no_clip)
+RUCY_DEF1(set_nsegment, nsegment)
 {
 	CHECK;
-	THIS->no_clip();
+	THIS->set_nsegment(nsegment ? to<int>(nsegment) : 0);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_clip)
+RUCY_DEF0(get_nsegment)
 {
 	CHECK;
-	return value(THIS->clip());
+	return value(THIS->nsegment());
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_font)
+RUCY_DEFN(set_clip)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_font", argc, 0, 1, 2);
-
-	if (argc == 0 || argv[0].is_kind_of(Rays::font_class()))
-	{
-		const Rays::Font* f = argc == 0
-			? &Rays::default_font()
-			: to<Rays::Font*>(argv[0]);
-		if (!f || !*f)
-			argument_error(__FILE__, __LINE__);
-
-		THIS->set_font(*f);
-	}
-	else
-	{
-		const char* name = argv[0].c_str();
-		coord size       = argc >= 2 ? to<coord>(argv[1]) : 0;
-		THIS->set_font(name, size);
-	}
-
+	THIS->set_clip(to<Rays::Bounds>(argc, argv));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_font)
+RUCY_DEF0(get_clip)
 {
 	CHECK;
-	return value(THIS->font());
+	return value(THIS->clip());
 }
 RUCY_END
 
 static
-RUCY_DEF0(push_attr)
+RUCY_DEF0(no_clip)
 {
 	CHECK;
-	THIS->push_attr();
+	THIS->no_clip();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(pop_attr)
+RUCY_DEFN(set_font)
 {
 	CHECK;
-	THIS->pop_attr();
+	check_arg_count(__FILE__, __LINE__, "Painter#set_font", argc, 0, 1, 2);
+
+	THIS->set_font(to<Rays::Font>(argc, argv));
 	return self;
 }
 RUCY_END
 
-
 static
-RUCY_DEF1(attach_shader, shader)
+RUCY_DEF0(get_font)
 {
 	CHECK;
-	THIS->attach(to<Rays::Shader&>(shader));
-	return self;
+	return value(THIS->font());
 }
 RUCY_END
 
 static
-RUCY_DEF1(detach_shader, shader)
+RUCY_DEFN(set_shader)
 {
 	CHECK;
-	THIS->detach(to<Rays::Shader&>(shader));
+	check_arg_count(__FILE__, __LINE__, "Painter#set_shader", argc, 1);
+
+	THIS->set_shader(to<Rays::Shader>(argc, argv));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_uniform)
+RUCY_DEF0(get_shader)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_uniform", argc, 2, 3, 4, 5);
-
-	#define Ai(n) (argv[n].as_i())
-	#define Af(n) ((float) argv[n].as_f())
-
-	const char* name = argv[0].c_str();
-	if (argv[1].is_i())
-	{
-		switch (argc)
-		{
-			case 2: THIS->set_uniform(name, Ai(1)); break;
-			case 3: THIS->set_uniform(name, Ai(1), Ai(2)); break;
-			case 4: THIS->set_uniform(name, Ai(1), Ai(2), Ai(3)); break;
-			case 5: THIS->set_uniform(name, Ai(1), Ai(2), Ai(3), Ai(4)); break;
-		}
-	}
-	else if (argv[1].is_f())
-	{
-		switch (argc)
-		{
-			case 2: THIS->set_uniform(name, Af(1)); break;
-			case 3: THIS->set_uniform(name, Af(1), Af(2)); break;
-			case 4: THIS->set_uniform(name, Af(1), Af(2), Af(3)); break;
-			case 5: THIS->set_uniform(name, Af(1), Af(2), Af(3), Af(4)); break;
-		}
-	}
-	else
-		argument_error(__FILE__, __LINE__);
-
-	#undef Ai
-	#undef Af
+	return value(THIS->shader());
+}
+RUCY_END
 
+static
+RUCY_DEF0(no_shader)
+{
+	CHECK;
+	THIS->no_shader();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(push_shader)
+RUCY_DEF0(push_state)
 {
 	CHECK;
-	THIS->push_shader();
+	THIS->push_state();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(pop_shader)
+RUCY_DEF0(pop_state)
 {
 	CHECK;
-	THIS->pop_shader();
+	THIS->pop_state();
 	return self;
 }
 RUCY_END
@@ -667,8 +480,8 @@ static
 RUCY_DEFN(set_matrix)
 {
 	CHECK;
-	THIS->set_matrix();
-	return self;
+	THIS->set_matrix(to<Rays::Matrix>(argc, argv));
+	return value(THIS->matrix());
 }
 RUCY_END
 
@@ -711,47 +524,48 @@ Init_painter ()
 
 	cPainter.define_method("canvas", canvas);
 	cPainter.define_method("bounds", bounds);
+	cPainter.define_method("pixel_density", pixel_density);
 
 	cPainter.define_private_method("begin_paint", begin_paint);
 	cPainter.define_private_method(  "end_paint",   end_paint);
 	cPainter.define_method("clear",   clear);
-	cPainter.define_method("line",    line);
-	cPainter.define_method("lines",   lines);
 	cPainter.define_method("polygon", polygon);
-	cPainter.define_method("rect",    rect);
-	cPainter.define_method("ellipse", ellipse);
-	cPainter.define_method("arc",     arc);
-	cPainter.define_method("image",   image);
-	cPainter.define_method("text",    text);
-
-	cPainter.define_private_method("set_background", set_background);
-	cPainter.define_private_method("get_background", get_background);
-	cPainter.define_method(         "no_background",  no_background);
-	cPainter.define_private_method("set_fill", set_fill);
-	cPainter.define_private_method("get_fill", get_fill);
-	cPainter.define_method(         "no_fill",  no_fill);
-	cPainter.define_private_method("set_stroke", set_stroke);
-	cPainter.define_private_method("get_stroke", get_stroke);
-	cPainter.define_method(         "no_stroke",  no_stroke);
-	cPainter.define_private_method("set_clip", set_clip);
-	cPainter.define_private_method("get_clip", get_clip);
-	cPainter.define_method(         "no_clip",  no_clip);
-	cPainter.define_private_method("set_font", set_font);
-	cPainter.define_private_method("get_font", get_font);
-	cPainter.define_method("push_attr", push_attr);
-	cPainter.define_method( "pop_attr",  pop_attr);
-
-	cPainter.define_private_method("attach_shader", attach_shader);
-	cPainter.define_private_method("detach_shader", detach_shader);
-	cPainter.define_private_method("set_uniform", set_uniform);
-	cPainter.define_method("push_shader", push_shader);
-	cPainter.define_method( "pop_shader",  pop_shader);
+	cPainter.define_private_method("draw_line",     line);
+	cPainter.define_private_method("draw_polyline", polyline);
+	cPainter.define_private_method("draw_rect",     rect);
+	cPainter.define_private_method("draw_ellipse",  ellipse);
+	cPainter.define_method("image", image);
+	cPainter.define_method("text",  text);
+
+	cPainter.define_method(   "background=", set_background);
+	cPainter.define_method(   "background",  get_background);
+	cPainter.define_method("no_background",   no_background);
+	cPainter.define_method(   "fill=", set_fill);
+	cPainter.define_method(   "fill",  get_fill);
+	cPainter.define_method("no_fill",   no_fill);
+	cPainter.define_method(   "stroke=", set_stroke);
+	cPainter.define_method(   "stroke",  get_stroke);
+	cPainter.define_method("no_stroke",   no_stroke);
+	cPainter.define_method(   "stroke_width=", set_stroke_width);
+	cPainter.define_method(   "stroke_width",  get_stroke_width);
+	cPainter.define_method("nsegment=", set_nsegment);
+	cPainter.define_method("nsegment",  get_nsegment);
+	cPainter.define_method(   "clip=", set_clip);
+	cPainter.define_method(   "clip",  get_clip);
+	cPainter.define_method("no_clip",   no_clip);
+	cPainter.define_method("font=", set_font);
+	cPainter.define_method("font",  get_font);
+	cPainter.define_private_method("set_shader", set_shader);
+	cPainter.define_method(            "shader", get_shader);
+	cPainter.define_method(         "no_shader",  no_shader);
+	cPainter.define_method("push_state", push_state);
+	cPainter.define_method( "pop_state",  pop_state);
 
 	cPainter.define_method("translate", translate);
 	cPainter.define_method("scale",     scale);
 	cPainter.define_method("rotate",    rotate);
-	cPainter.define_private_method("set_matrix", set_matrix);
-	cPainter.define_private_method("get_matrix", get_matrix);
+	cPainter.define_method("matrix=", set_matrix);
+	cPainter.define_method("matrix",  get_matrix);
 	cPainter.define_method("push_matrix", push_matrix);
 	cPainter.define_method( "pop_matrix",  pop_matrix);
 }