rays 0.1.12 → 0.1.17

data/ext/rays/native.cpp

@@ -1,24 +1,25 @@
-#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_painter ();
+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_camera ();
 
-void Init_painter ();
+void Init_noise ();
 
 
 extern "C" void
@@ -38,14 +39,19 @@ extern "C" void
 	Init_bounds();
 	Init_color();
 	Init_color_space();
+	Init_matrix();
 
+	Init_painter();
+	Init_polyline();
+	Init_polygon_line();
+	Init_polygon();
 	Init_bitmap();
-	Init_texture();
 	Init_image();
 	Init_font();
 	Init_shader();
+	Init_camera();
 
-	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,102 @@ RUCY_DEF0(clear)
 RUCY_END
 
 static
-RUCY_DEFN(line)
+RUCY_DEF1(polygon, poly)
 {
 	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);
-	}
 
+	THIS->polygon(to<Rays::Polygon&>(poly));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(lines)
+RUCY_DEF2(line, args, loop)
 {
 	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]));
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->line(&points[0], points.size(), loop);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(polyline, poly)
+{
+	CHECK;
 
-	THIS->lines((Rays::Point*) &points[0], points.size());
+	THIS->line(to<Rays::Polyline&>(poly));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(polygon)
+RUCY_DEF6(rect, args, round, lefttop, righttop, leftbottom, rightbottom)
 {
 	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]));
+	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->polygon((Rays::Point*) &points[0], points.size());
+	THIS->rect(x, y, w, h, lt, rt, lb, rb);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(rect)
+RUCY_DEF6(ellipse, args, center, radius, hole, angle_from, angle_to)
 {
 	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);
-	}
+	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
 
 static
-RUCY_DEFN(ellipse)
+RUCY_DEF2(curve, args, loop)
 {
 	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);
-	}
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
 
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
+
+	THIS->curve(&points[0], points.size(), loop);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEFN(arc)
+RUCY_DEF2(bezier, args, loop)
 {
 	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);
-	}
+	if (args.empty())
+		argument_error(__FILE__, __LINE__);
+
+	std::vector<Rays::Point> points;
+	get_line_args(&points, args.size(), args.as_array());
 
+	THIS->bezier(&points[0], points.size(), loop);
 	return self;
 }
 RUCY_END
@@ -273,7 +233,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 +242,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 +281,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 +307,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 +333,177 @@ 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_stroke_cap, cap)
 {
 	CHECK;
-	THIS->no_clip();
+	THIS->set_stroke_cap(to<Rays::CapType>(cap));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_clip)
+RUCY_DEF0(get_stroke_cap)
 {
 	CHECK;
-	return value(THIS->clip());
+	return value(THIS->stroke_cap());
 }
 RUCY_END
 
 static
-RUCY_DEFN(set_font)
+RUCY_DEF1(set_stroke_join, join)
 {
 	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_stroke_join(to<Rays::JoinType>(join));
+	return self;
+}
+RUCY_END
 
-		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);
-	}
+static
+RUCY_DEF0(get_stroke_join)
+{
+	CHECK;
+	return value(THIS->stroke_join());
+}
+RUCY_END
 
+static
+RUCY_DEF1(set_miter_limit, limit)
+{
+	CHECK;
+	THIS->set_miter_limit(to<coord>(limit));
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_font)
+RUCY_DEF0(get_miter_limit)
 {
 	CHECK;
-	return value(THIS->font());
+	return value(THIS->miter_limit());
 }
 RUCY_END
 
 static
-RUCY_DEF0(push_attr)
+RUCY_DEF1(set_nsegment, nsegment)
 {
 	CHECK;
-	THIS->push_attr();
+	THIS->set_nsegment(nsegment ? to<int>(nsegment) : 0);
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(pop_attr)
+RUCY_DEF0(get_nsegment)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_clip)
 {
 	CHECK;
-	THIS->pop_attr();
+	THIS->set_clip(to<Rays::Bounds>(argc, argv));
 	return self;
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_clip)
+{
+	CHECK;
+	return value(THIS->clip());
+}
+RUCY_END
 
 static
-RUCY_DEF1(attach_shader, shader)
+RUCY_DEF0(no_clip)
 {
 	CHECK;
-	THIS->attach(to<Rays::Shader&>(shader));
+	THIS->no_clip();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF1(detach_shader, shader)
+RUCY_DEFN(set_font)
 {
 	CHECK;
-	THIS->detach(to<Rays::Shader&>(shader));
+	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_DEFN(set_uniform)
+RUCY_DEF0(get_font)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_uniform", argc, 2, 3, 4, 5);
+	return value(THIS->font());
+}
+RUCY_END
 
-	#define Ai(n) (argv[n].as_i())
-	#define Af(n) ((float) argv[n].as_f())
+static
+RUCY_DEFN(set_shader)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#set_shader", argc, 1);
 
-	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__);
+	THIS->set_shader(to<Rays::Shader>(argc, argv));
+	return self;
+}
+RUCY_END
 
-	#undef Ai
-	#undef Af
+static
+RUCY_DEF0(get_shader)
+{
+	CHECK;
+	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 +563,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 +607,56 @@ 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_private_method("draw_curve",    curve);
+	cPainter.define_private_method("draw_bezier",   bezier);
+	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(   "stroke_cap=",   set_stroke_cap);
+	cPainter.define_method(   "stroke_cap",    get_stroke_cap);
+	cPainter.define_method(   "stroke_join=",  set_stroke_join);
+	cPainter.define_method(   "stroke_join",   get_stroke_join);
+	cPainter.define_method("miter_limit=", set_miter_limit);
+	cPainter.define_method("miter_limit",  get_miter_limit);
+	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);
 }