rays 0.1.6 → 0.1.7

data/ext/rays/painter.cpp

@@ -2,11 +2,13 @@
 
 
 #include <rucy.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/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/shader.h"
 #include "defs.h"
 
 
@@ -17,55 +19,22 @@ using Rays::coord;
 
 static Class cPainter;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Painter, cPainter)
 
-namespace Rays
-{
-
-
-	Class
-	painter_class ()
-	{
-		return cPainter;
-	}
-
-
-}// Rays
-
-
-namespace Rucy
-{
-
-
-	Value
-	value (const Rays::Painter& obj)
-	{
-		return new_type(cPainter, new Rays::Painter(obj));
-	}
-
-	Value
-	value (const Rays::Painter* obj)
-	{
-		return obj ? value(*obj) : nil();
-	}
-
-
-}// Rucy
-
+#define THIS  to<Rays::Painter*>(self)
 
-#define THIS to<Rays::Painter*>(self)
-
-#define CHECK RUCY_CHECK_OBJECT(self, Rays::Painter, cPainter)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Painter, cPainter, self)
 
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Rays::Painter>(klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF4(canvas, x, y, width, height)
+RUCY_DEF4(canvas, x, y, width, height)
 {
 	CHECK;
 
@@ -73,156 +42,155 @@ RUBY_DEF4(canvas, x, y, width, height)
 	coord yy = to<coord>(y);
 	coord ww = to<coord>(width);
 	coord hh = to<coord>(height);
-	if (!THIS->canvas(xx, yy, ww, hh))
-		rays_error("Painter#canvas(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	THIS->canvas(xx, yy, ww, hh);
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(begin_paint)
+RUCY_DEF0(begin_paint)
 {
 	CHECK;
-
-	if (!THIS->begin())
-		rays_error("Painter#begin_paint() failed.");
-
+	THIS->begin();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(end_paint)
+RUCY_DEF0(end_paint)
 {
 	CHECK;
-
-	if (!THIS->end())
-		rays_error("Painter#end_paint() failed.");
-
+	THIS->end();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 
 static
-RUBY_DEF4(line, x1_, y1_, x2_, y2_)
+RUCY_DEFN(line)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#line", argc, 2, 4);
 
-	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))
-		rays_error("Painter#line(%f, %f, %f, %f) failed.", x1, y1, x2, y2);
+	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF4(rect, x, y, width, height)
+RUCY_DEFN(rect)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#rect", argc, 1, 4);
 
-	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))
-		rays_error("Painter#rect(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	if (argc == 1)
+		THIS->rect(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->rect(x, y, w, h);
+	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(ellipse)
+RUCY_DEFN(ellipse)
 {
 	CHECK;
-	if (argc < 3 || 6 < argc)
-		arg_count_error("Painter#ellipse", argc, 4, 5, 6);
+	check_arg_count(__FILE__, __LINE__, "Painter#ellipse", argc, 1, 2, 3, 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))
+	if (argv[0].is_kind_of(Rays::bounds_class()))
 	{
-		rays_error(
-			"Painter#ellipse(%f, %f, %f, %f, %f, %d) failed.",
-			xx, yy, ww, hh, min_, nseg);
+		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);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(arc)
+RUCY_DEFN(arc)
 {
 	CHECK;
-	if (argc < 3 || 8 < argc)
-		arg_count_error("Painter#ellipse", argc, 4, 5, 6, 7, 8);
+	check_arg_count(__FILE__, __LINE__, "Painter#ellipse", argc, 1, 2, 3, 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))
+	if (argv[0].is_kind_of(Rays::bounds_class()))
+	{
+		const Rays::Bounds& b = to<Rays::Bounds&>(argv[0]);
+		float from = (argc >= 2) ? to<float>(argv[1]) : 0;
+		float to_  = (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, from, to_, min_, nseg);
+	}
+	else
 	{
-		rays_error(
-			"Painter#arc(%f, %f, %f, %f, %f, %f, %f, %d) failed.",
-			xx, yy, ww, hh, from, to_, min_, nseg);
+		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 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;
+		THIS->arc(x, y, w, h, from, to_, min_, nseg);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(image)
+RUCY_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);
+	check_arg_count(__FILE__, __LINE__, "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());
+		argument_error(__FILE__, __LINE__, "%s is not an image.", argv[0].inspect().c_str());
 
 	if (argc == 1)
-	{
-		if (!THIS->image(*image))
-			rays_error("Painter#image(%s) failed.", argv[0].inspect().c_str());
-	}
+		THIS->image(*image);
 	else if (argc == 3)
 	{
 		coord x = to<coord>(argv[1]), y = to<coord>(argv[2]);
-		if (!THIS->image(*image, x, y))
-		{
-			rays_error(
-				"Painter#image(%s, %f, %f) failed.",
-				argv[0].inspect().c_str(), x, y);
-		}
+		THIS->image(*image, 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))
-		{
-			rays_error(
-				"Painter#image(%s, %f, %f, %f, %f) failed.",
-				argv[0].inspect().c_str(), x, y, w, h);
-		}
+		THIS->image(*image, x, y, w, h);
 	}
 	else if (argc == 7)
 	{
@@ -230,12 +198,7 @@ RUBY_DEFN(image)
 		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))
-		{
-			rays_error(
-				"Painter#image(%s, %f, %f, %f, %f, %f, %f) failed.",
-				argv[0].inspect().c_str(), sx, sy, sw, sh, dx, dy);
-		}
+		THIS->image(*image, sx, sy, sw, sh, dx, dy);
 	}
 	else if (argc == 9)
 	{
@@ -243,98 +206,85 @@ RUBY_DEFN(image)
 		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))
-		{
-			rays_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);
-		}
+		THIS->image(*image, sx, sy, sw, sh, dx, dy, dw, dh);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(text)
+RUCY_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);
+	check_arg_count(__FILE__, __LINE__, "Painter#text", argc, 1, 3, 4, 5, 7);
 
 	if (argc == 1)
-	{
-		if (!THIS->text(argv[0].c_str()))
-			rays_error("Painter#text(%s) failed.", argv[0].inspect().c_str());
-	}
+		THIS->text(argv[0].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))
-		{
-			rays_error(
-				"Painter#text(%s, %f, %f) failed.",
-				argv[0].inspect().c_str(), x, y);
-		}
+		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("Painter#text: invalid font.");
+			rays_error(__FILE__, __LINE__, "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))
-		{
-			rays_error(
-				"Painter#image(%s, %f, %f, %s) failed.",
-				argv[0].inspect().c_str(), x, y, argv[3].inspect().c_str());
-		}
+		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]);
-		if (!THIS->text(argv[0].c_str(), x, y, w, h))
-		{
-			rays_error(
-				"Painter#text(%s, %f, %f, %f, %f) failed.",
-				argv[0].inspect().c_str(), x, y, w, h);
-		}
+		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("Painter#text: invalid 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]);
-		if (!THIS->text(argv[0].c_str(), x, y, w, h, font))
-		{
-			rays_error(
-				"Painter#image(%s, %f, %f, %f, %f, %s) failed.",
-				argv[0].inspect().c_str(), x, y, w, h, argv[3].inspect().c_str());
-		}
+		THIS->text(argv[0].c_str(), x, y, w, h, font);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF0(clear)
+{
+	CHECK;
+	THIS->clear();
+}
+RUCY_END
+
+static
+RUCY_DEF0(bounds)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+RUCY_END
 
 static
-RUBY_DEFN(set_background)
+RUCY_DEFN(set_background)
 {
 	CHECK;
-	if (argc < 1 || 4 < argc)
-		arg_count_error("Painter#set_background", argc, 1, 2, 3, 4);
+	check_arg_count(__FILE__, __LINE__, "Painter#set_background", argc, 1, 2, 3, 4);
 
-	if (argc == 1 || argc == 2)
+	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;
-		if (!THIS->set_background(v, v, v, a))
-			rays_error("Painter#set_background(%f, %f) failed.", v, a);
+		THIS->set_background(v, v, v, a);
 	}
 	else
 	{
@@ -342,48 +292,43 @@ RUBY_DEFN(set_background)
 		float g = to<float>(argv[1]);
 		float b = to<float>(argv[2]);
 		float a = (argc == 4) ? to<float>(argv[3]) : 1;
-		if (!THIS->set_background(r, g, b, a))
-			rays_error("Painter#set_background(%f, %f, %f, %f) failed.", r, g, b, a);
+		THIS->set_background(r, g, b, a);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(no_background)
+RUCY_DEF0(no_background)
 {
 	CHECK;
-
-	if (!THIS->no_background())
-		rays_error("Painter#no_clear() failed.");
-
+	THIS->no_background();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_background)
+RUCY_DEF0(get_background)
 {
 	CHECK;
-
 	return value(THIS->background());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(set_fill)
+RUCY_DEFN(set_fill)
 {
 	CHECK;
-	if (argc < 1 || 4 < argc)
-		arg_count_error("Painter#set_fill", argc, 1, 2, 3, 4);
+	check_arg_count(__FILE__, __LINE__, "Painter#set_fill", argc, 1, 2, 3, 4);
 
-	if (argc == 1 || argc == 2)
+	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;
-		if (!THIS->set_fill(v, v, v, a))
-			rays_error("Painter#set_fill(%f, %f) failed.", v, a);
+		THIS->set_fill(v, v, v, a);
 	}
 	else
 	{
@@ -391,48 +336,43 @@ RUBY_DEFN(set_fill)
 		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))
-			rays_error("Painter#set_fill(%f, %f, %f, %f) failed.", r, g, b, a);
+		THIS->set_fill(r, g, b, a);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(no_fill)
+RUCY_DEF0(no_fill)
 {
 	CHECK;
-
-	if (!THIS->no_fill())
-		rays_error("Painter#no_fill() failed.");
-
+	THIS->no_fill();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_fill)
+RUCY_DEF0(get_fill)
 {
 	CHECK;
-
 	return value(THIS->fill());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(set_stroke)
+RUCY_DEFN(set_stroke)
 {
 	CHECK;
-	if (argc < 1 || 4 < argc)
-		arg_count_error("Painter#set_stroke", argc, 1, 2, 3, 4);
+	check_arg_count(__FILE__, __LINE__, "Painter#set_stroke", argc, 1, 2, 3, 4);
 
-	if (argc == 1 || argc == 2)
+	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;
-		if (!THIS->set_stroke(v, v, v, a))
-			rays_error("Painter#set_stroke(%f, %f) failed.", v, a);
+		THIS->set_stroke(v, v, v, a);
 	}
 	else
 	{
@@ -440,161 +380,234 @@ RUBY_DEFN(set_stroke)
 		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))
-			rays_error("Painter#set_stroke(%f, %f, %f, %f) failed.", r, g, b, a);
+		THIS->set_stroke(r, g, b, a);
 	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(no_stroke)
+RUCY_DEF0(no_stroke)
 {
 	CHECK;
-
-	if (!THIS->no_stroke())
-		rays_error("Painter#no_stroke() failed.");
-
+	THIS->no_stroke();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_stroke)
+RUCY_DEF0(get_stroke)
 {
 	CHECK;
-
 	return value(THIS->stroke());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF4(set_clip, x, y, width, height)
+RUCY_DEFN(set_clip)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#set_clip", argc, 1, 4);
 
-	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))
-		rays_error("Painter#set_clip(%f, %f, %f, %f) failed.", xx, yy, ww, hh);
+	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(no_clip)
+RUCY_DEF0(no_clip)
 {
 	CHECK;
-
-	if (!THIS->no_clip())
-		rays_error("Painter#no_clip() failed.");
-
+	THIS->no_clip();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_clip)
+RUCY_DEF0(get_clip)
 {
 	CHECK;
-
 	return value(THIS->clip());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_font, font)
+RUCY_DEFN(set_font)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#set_font", argc, 0, 1, 2);
 
-	const Rays::Font* f = font.is_nil()
-		? &Rays::default_font()
-		: to<Rays::Font*>(font);
-	if (!f || !*f) argument_error();
+	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__);
 
-	if (!THIS->set_font(*f))
-		rays_error("Painter#set_font(%s) failed.", font.inspect().c_str());
+		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);
+	}
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_font)
+RUCY_DEF0(get_font)
 {
 	CHECK;
-
 	return value(THIS->font());
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF0(push_attr)
+{
+	CHECK;
+	THIS->push_attr();
+	return self;
+}
+RUCY_END
 
 static
-RUBY_DEF0(push_attrs)
+RUCY_DEF0(pop_attr)
 {
 	CHECK;
+	THIS->pop_attr();
+	return self;
+}
+RUCY_END
+
 
-	if (!THIS->push_attrs())
-		rays_error("Painter#push_attrs() failed.");
+static
+RUCY_DEF1(attach_shader, shader)
+{
+	CHECK;
+	THIS->attach(to<Rays::Shader&>(shader));
+	return self;
+}
+RUCY_END
 
+static
+RUCY_DEF1(detach_shader, shader)
+{
+	CHECK;
+	THIS->detach(to<Rays::Shader&>(shader));
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(pop_attrs)
+RUCY_DEFN(set_uniform)
 {
 	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 self;
+}
+RUCY_END
 
-	if (!THIS->pop_attrs())
-		rays_error("Painter#pop_attrs() failed.");
+static
+RUCY_DEF0(push_shader)
+{
+	CHECK;
+	THIS->push_shader();
+	return self;
+}
+RUCY_END
 
+static
+RUCY_DEF0(pop_shader)
+{
+	CHECK;
+	THIS->pop_shader();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 
 static
-RUBY_DEFN(translate)
+RUCY_DEFN(translate)
 {
 	CHECK;
-	if (argc < 2 || 3 < argc)
-		arg_count_error("Painter#translate", argc, 2, 3);
+	check_arg_count(__FILE__, __LINE__, "Painter#translate", argc, 2, 3);
 
 	coord xx = to<coord>(argv[0]);
 	coord yy = to<coord>(argv[1]);
 	coord zz = (argc >= 3) ? to<coord>(argv[2]) : 0;
-	if (!THIS->translate(xx, yy, zz))
-		rays_error("Painter#translate(%f %f %f) failed.", xx, yy, zz);
+	THIS->translate(xx, yy, zz);
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(scale)
+RUCY_DEFN(scale)
 {
 	CHECK;
-	if (argc < 2 || 3 < argc)
-		arg_count_error("Painter#scale", argc, 2, 3);
+	check_arg_count(__FILE__, __LINE__, "Painter#scale", argc, 2, 3);
 
 	coord xx = to<coord>(argv[0]);
 	coord yy = to<coord>(argv[1]);
 	coord zz = (argc >= 3) ? to<coord>(argv[2]) : 1;
-	if (!THIS->scale(xx, yy, zz))
-		rays_error("Painter#scale(%f %f %f) failed.", xx, yy, zz);
+	THIS->scale(xx, yy, zz);
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(rotate)
+RUCY_DEFN(rotate)
 {
 	CHECK;
-	if (argc != 1 && argc != 3 && argc != 4)
-		arg_count_error("Painter#rotate", argc, 1, 3, 4);
+	check_arg_count(__FILE__, __LINE__, "Painter#rotate", argc, 1, 3, 4);
 
 	coord aa = to<coord>(argv[0]), xx = 0, yy = 0, zz = 1;
 	if (argc >= 3)
@@ -604,57 +617,46 @@ RUBY_DEFN(rotate)
 		zz = argc >= 4 ? to<coord>(argv[3]) : 0;
 	}
 
-	if (!THIS->rotate(aa, xx, yy, zz))
-		rays_error("Painter#rotate(%f %f %f %f) failed.", aa, xx, yy, zz);
+	THIS->rotate(aa, xx, yy, zz);
 
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(set_matrix)
+RUCY_DEFN(set_matrix)
 {
 	CHECK;
-
-	if (!THIS->set_matrix())
-		rays_error("Painter#set_matrix() failed.");
-
+	THIS->set_matrix();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_matrix)
+RUCY_DEF0(get_matrix)
 {
 	CHECK;
-
 	return value(THIS->matrix());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(push_matrix)
+RUCY_DEF0(push_matrix)
 {
 	CHECK;
-
-	if (!THIS->push_matrix())
-		rays_error("Painter#push_matrix() failed.");
-
+	THIS->push_matrix();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(pop_matrix)
+RUCY_DEF0(pop_matrix)
 {
 	CHECK;
-
-	if (!THIS->pop_matrix())
-		rays_error("Painter#pop_matrix() failed.");
-
+	THIS->pop_matrix();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -666,8 +668,8 @@ Init_painter ()
 	cPainter.define_alloc_func(alloc);
 
 	cPainter.define_method("canvas", canvas);
-	cPainter.define_method("begin_paint", begin_paint);
-	cPainter.define_method("end_paint", end_paint);
+	cPainter.define_private_method("begin_paint", begin_paint);
+	cPainter.define_private_method("end_paint", end_paint);
 
 	cPainter.define_method("line", line);
 	cPainter.define_method("rect", rect);
@@ -676,28 +678,50 @@ Init_painter ()
 	cPainter.define_method("image", image);
 	cPainter.define_method("text", text);
 
-	cPainter.define_method("set_background", set_background);
-	cPainter.define_method("no_background",  no_background);
-	cPainter.define_method("get_background", get_background);
-	cPainter.define_method("set_fill", set_fill);
-	cPainter.define_method("no_fill",  no_fill);
-	cPainter.define_method("get_fill", get_fill);
-	cPainter.define_method("set_stroke", set_stroke);
-	cPainter.define_method("no_stroke",  no_stroke);
-	cPainter.define_method("get_stroke", get_stroke);
-	cPainter.define_method("set_clip", set_clip);
-	cPainter.define_method("no_clip",  no_clip);
-	cPainter.define_method("get_clip", get_clip);
-	cPainter.define_method("set_font", set_font);
-	cPainter.define_method("get_font", get_font);
-	cPainter.define_method("push_attrs", push_attrs);
-	cPainter.define_method("pop_attrs", pop_attrs);
+	cPainter.define_method("clear", clear);
+	cPainter.define_method("bounds", bounds);
+	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_method("translate", translate);
-	cPainter.define_method("scale", push_matrix);
-	cPainter.define_method("rotate", push_matrix);
-	cPainter.define_method("set_matrix", push_matrix);
-	cPainter.define_method("get_matrix", push_matrix);
+	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("push_matrix", push_matrix);
 	cPainter.define_method("pop_matrix", pop_matrix);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	painter_class ()
+	{
+		return cPainter;
+	}
+
+
+}// Rays