rays 0.1.6 → 0.1.7

data/.doc/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,44 +19,11 @@ using Rays::coord;
 
 static Class cPainter;
 
+RUCY_DEFINE_VALUE_FROM_TO(Rays::Painter, cPainter)
 
-namespace Rays
-{
-
+#define THIS  to<Rays::Painter*>(self)
 
-	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 CHECK RUCY_CHECK_OBJECT(self, Rays::Painter, cPainter)
+#define CHECK RUCY_CHECK_OBJECT(Rays::Painter, cPainter, self)
 
 
 static
@@ -72,8 +41,7 @@ VALUE canvas(VALUE self, VALUE x, VALUE y, VALUE width, VALUE 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;
 }
@@ -82,10 +50,7 @@ static
 VALUE begin_paint(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->begin())
-		rays_error("Painter#begin_paint() failed.");
-
+	THIS->begin();
 	return self;
 }
 
@@ -93,40 +58,47 @@ static
 VALUE end_paint(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->end())
-		rays_error("Painter#end_paint() failed.");
-
+	THIS->end();
 	return self;
 }
 
 
 static
-VALUE line(VALUE self, VALUE x1_, VALUE y1_, VALUE x2_, VALUE y2_)
+VALUE line(VALUE self)
 {
 	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;
 }
 
 static
-VALUE rect(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE rect(VALUE self)
 {
 	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;
 }
@@ -135,20 +107,24 @@ static
 VALUE ellipse(VALUE self)
 {
 	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;
@@ -158,22 +134,28 @@ static
 VALUE arc(VALUE self)
 {
 	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;
@@ -183,38 +165,24 @@ 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);
+	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)
 	{
@@ -222,12 +190,7 @@ VALUE image(VALUE self)
 		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)
 	{
@@ -235,12 +198,7 @@ VALUE image(VALUE self)
 		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;
@@ -250,81 +208,71 @@ 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);
+	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;
 }
 
+static
+VALUE clear(VALUE self)
+{
+	CHECK;
+	THIS->clear();
+}
+
+static
+VALUE bounds(VALUE self)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+
 static
 VALUE set_background(VALUE self)
 {
 	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
 	{
@@ -332,8 +280,7 @@ VALUE set_background(VALUE self)
 		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;
@@ -343,10 +290,7 @@ static
 VALUE no_background(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->no_background())
-		rays_error("Painter#no_clear() failed.");
-
+	THIS->no_background();
 	return self;
 }
 
@@ -354,7 +298,6 @@ static
 VALUE get_background(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->background());
 }
 
@@ -362,15 +305,15 @@ static
 VALUE set_fill(VALUE self)
 {
 	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
 	{
@@ -378,8 +321,7 @@ VALUE set_fill(VALUE self)
 		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;
@@ -389,10 +331,7 @@ static
 VALUE no_fill(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->no_fill())
-		rays_error("Painter#no_fill() failed.");
-
+	THIS->no_fill();
 	return self;
 }
 
@@ -400,7 +339,6 @@ static
 VALUE get_fill(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->fill());
 }
 
@@ -408,15 +346,15 @@ static
 VALUE set_stroke(VALUE self)
 {
 	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
 	{
@@ -424,8 +362,7 @@ VALUE set_stroke(VALUE self)
 		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;
@@ -435,10 +372,7 @@ static
 VALUE no_stroke(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->no_stroke())
-		rays_error("Painter#no_stroke() failed.");
-
+	THIS->no_stroke();
 	return self;
 }
 
@@ -446,19 +380,25 @@ static
 VALUE get_stroke(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->stroke());
 }
 
 static
-VALUE set_clip(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE set_clip(VALUE self)
 {
 	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;
 }
@@ -467,10 +407,7 @@ static
 VALUE no_clip(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->no_clip())
-		rays_error("Painter#no_clip() failed.");
-
+	THIS->no_clip();
 	return self;
 }
 
@@ -478,22 +415,31 @@ static
 VALUE get_clip(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->clip());
 }
 
 static
-VALUE set_font(VALUE self, VALUE font)
+VALUE set_font(VALUE self)
 {
 	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;
 }
@@ -502,29 +448,94 @@ static
 VALUE get_font(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->font());
 }
 
 static
-VALUE push_attrs(VALUE self)
+VALUE push_attr(VALUE self)
+{
+	CHECK;
+	THIS->push_attr();
+	return self;
+}
+
+static
+VALUE pop_attr(VALUE self)
 {
 	CHECK;
+	THIS->pop_attr();
+	return self;
+}
+
 
-	if (!THIS->push_attrs())
-		rays_error("Painter#push_attrs() failed.");
+static
+VALUE attach_shader(VALUE self, VALUE shader)
+{
+	CHECK;
+	THIS->attach(to<Rays::Shader&>(shader));
+	return self;
+}
 
+static
+VALUE detach_shader(VALUE self, VALUE shader)
+{
+	CHECK;
+	THIS->detach(to<Rays::Shader&>(shader));
 	return self;
 }
 
 static
-VALUE pop_attrs(VALUE self)
+VALUE set_uniform(VALUE self)
 {
 	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;
+}
 
-	if (!THIS->pop_attrs())
-		rays_error("Painter#pop_attrs() failed.");
+static
+VALUE push_shader(VALUE self)
+{
+	CHECK;
+	THIS->push_shader();
+	return self;
+}
 
+static
+VALUE pop_shader(VALUE self)
+{
+	CHECK;
+	THIS->pop_shader();
 	return self;
 }
 
@@ -533,14 +544,12 @@ static
 VALUE translate(VALUE self)
 {
 	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;
 }
@@ -549,14 +558,12 @@ static
 VALUE scale(VALUE self)
 {
 	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;
 }
@@ -565,8 +572,7 @@ static
 VALUE rotate(VALUE self)
 {
 	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)
@@ -576,8 +582,7 @@ VALUE rotate(VALUE self)
 		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;
 }
@@ -586,10 +591,7 @@ static
 VALUE set_matrix(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->set_matrix())
-		rays_error("Painter#set_matrix() failed.");
-
+	THIS->set_matrix();
 	return self;
 }
 
@@ -597,7 +599,6 @@ static
 VALUE get_matrix(VALUE self)
 {
 	CHECK;
-
 	return value(THIS->matrix());
 }
 
@@ -605,10 +606,7 @@ static
 VALUE push_matrix(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->push_matrix())
-		rays_error("Painter#push_matrix() failed.");
-
+	THIS->push_matrix();
 	return self;
 }
 
@@ -616,10 +614,7 @@ static
 VALUE pop_matrix(VALUE self)
 {
 	CHECK;
-
-	if (!THIS->pop_matrix())
-		rays_error("Painter#pop_matrix() failed.");
-
+	THIS->pop_matrix();
 	return self;
 }
 
@@ -633,38 +628,60 @@ Init_painter ()
 	rb_define_alloc_func(cPainter, alloc);
 
 	rb_define_method(cPainter, "canvas", RUBY_METHOD_FUNC(canvas), 4);
-	rb_define_method(cPainter, "begin_paint", RUBY_METHOD_FUNC(begin_paint), 0);
-	rb_define_method(cPainter, "end_paint", RUBY_METHOD_FUNC(end_paint), 0);
+	rb_define_private_method(cPainter, "begin_paint", RUBY_METHOD_FUNC(begin_paint), 0);
+	rb_define_private_method(cPainter, "end_paint", RUBY_METHOD_FUNC(end_paint), 0);
 
-	rb_define_method(cPainter, "line", RUBY_METHOD_FUNC(line), 4);
-	rb_define_method(cPainter, "rect", RUBY_METHOD_FUNC(rect), 4);
+	rb_define_method(cPainter, "line", RUBY_METHOD_FUNC(line), -1);
+	rb_define_method(cPainter, "rect", RUBY_METHOD_FUNC(rect), -1);
 	rb_define_method(cPainter, "ellipse", RUBY_METHOD_FUNC(ellipse), -1);
 	rb_define_method(cPainter, "arc", RUBY_METHOD_FUNC(arc), -1);
 	rb_define_method(cPainter, "image", RUBY_METHOD_FUNC(image), -1);
 	rb_define_method(cPainter, "text", RUBY_METHOD_FUNC(text), -1);
 
-	rb_define_method(cPainter, "set_background", RUBY_METHOD_FUNC(set_background), -1);
+	rb_define_method(cPainter, "clear", RUBY_METHOD_FUNC(clear), 0);
+	rb_define_method(cPainter, "bounds", RUBY_METHOD_FUNC(bounds), 0);
+	rb_define_private_method(cPainter, "set_background", RUBY_METHOD_FUNC(set_background), -1);
+	rb_define_private_method(cPainter, "get_background", RUBY_METHOD_FUNC(get_background), 0);
 	rb_define_method(cPainter, "no_background", RUBY_METHOD_FUNC(no_background), 0);
-	rb_define_method(cPainter, "get_background", RUBY_METHOD_FUNC(get_background), 0);
-	rb_define_method(cPainter, "set_fill", RUBY_METHOD_FUNC(set_fill), -1);
+	rb_define_private_method(cPainter, "set_fill", RUBY_METHOD_FUNC(set_fill), -1);
+	rb_define_private_method(cPainter, "get_fill", RUBY_METHOD_FUNC(get_fill), 0);
 	rb_define_method(cPainter, "no_fill", RUBY_METHOD_FUNC(no_fill), 0);
-	rb_define_method(cPainter, "get_fill", RUBY_METHOD_FUNC(get_fill), 0);
-	rb_define_method(cPainter, "set_stroke", RUBY_METHOD_FUNC(set_stroke), -1);
+	rb_define_private_method(cPainter, "set_stroke", RUBY_METHOD_FUNC(set_stroke), -1);
+	rb_define_private_method(cPainter, "get_stroke", RUBY_METHOD_FUNC(get_stroke), 0);
 	rb_define_method(cPainter, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
-	rb_define_method(cPainter, "get_stroke", RUBY_METHOD_FUNC(get_stroke), 0);
-	rb_define_method(cPainter, "set_clip", RUBY_METHOD_FUNC(set_clip), 4);
+	rb_define_private_method(cPainter, "set_clip", RUBY_METHOD_FUNC(set_clip), -1);
+	rb_define_private_method(cPainter, "get_clip", RUBY_METHOD_FUNC(get_clip), 0);
 	rb_define_method(cPainter, "no_clip", RUBY_METHOD_FUNC(no_clip), 0);
-	rb_define_method(cPainter, "get_clip", RUBY_METHOD_FUNC(get_clip), 0);
-	rb_define_method(cPainter, "set_font", RUBY_METHOD_FUNC(set_font), 1);
-	rb_define_method(cPainter, "get_font", RUBY_METHOD_FUNC(get_font), 0);
-	rb_define_method(cPainter, "push_attrs", RUBY_METHOD_FUNC(push_attrs), 0);
-	rb_define_method(cPainter, "pop_attrs", RUBY_METHOD_FUNC(pop_attrs), 0);
+	rb_define_private_method(cPainter, "set_font", RUBY_METHOD_FUNC(set_font), -1);
+	rb_define_private_method(cPainter, "get_font", RUBY_METHOD_FUNC(get_font), 0);
+	rb_define_method(cPainter, "push_attr", RUBY_METHOD_FUNC(push_attr), 0);
+	rb_define_method(cPainter, "pop_attr", RUBY_METHOD_FUNC(pop_attr), 0);
+
+	rb_define_private_method(cPainter, "attach_shader", RUBY_METHOD_FUNC(attach_shader), 1);
+	rb_define_private_method(cPainter, "detach_shader", RUBY_METHOD_FUNC(detach_shader), 1);
+	rb_define_private_method(cPainter, "set_uniform", RUBY_METHOD_FUNC(set_uniform), -1);
+	rb_define_method(cPainter, "push_shader", RUBY_METHOD_FUNC(push_shader), 0);
+	rb_define_method(cPainter, "pop_shader", RUBY_METHOD_FUNC(pop_shader), 0);
 
 	rb_define_method(cPainter, "translate", RUBY_METHOD_FUNC(translate), -1);
-	rb_define_method(cPainter, "scale", RUBY_METHOD_FUNC(push_matrix), 0);
-	rb_define_method(cPainter, "rotate", RUBY_METHOD_FUNC(push_matrix), 0);
-	rb_define_method(cPainter, "set_matrix", RUBY_METHOD_FUNC(push_matrix), 0);
-	rb_define_method(cPainter, "get_matrix", RUBY_METHOD_FUNC(push_matrix), 0);
+	rb_define_method(cPainter, "scale", RUBY_METHOD_FUNC(scale), -1);
+	rb_define_method(cPainter, "rotate", RUBY_METHOD_FUNC(rotate), -1);
+	rb_define_private_method(cPainter, "set_matrix", RUBY_METHOD_FUNC(set_matrix), -1);
+	rb_define_private_method(cPainter, "get_matrix", RUBY_METHOD_FUNC(get_matrix), 0);
 	rb_define_method(cPainter, "push_matrix", RUBY_METHOD_FUNC(push_matrix), 0);
 	rb_define_method(cPainter, "pop_matrix", RUBY_METHOD_FUNC(pop_matrix), 0);
 }
+
+
+namespace Rays
+{
+
+
+	Class
+	painter_class ()
+	{
+		return cPainter;
+	}
+
+
+}// Rays