rays 0.1.11 → 0.1.16

data/.doc/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/.doc/ext/rays/noise.cpp

@@ -0,0 +1,53 @@
+#include "rays/noise.h"
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+static
+VALUE perlin(VALUE self)
+{
+	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);
+}
+
+static
+VALUE simplex(VALUE self)
+{
+	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);
+}
+
+
+void
+Init_noise ()
+{
+	Module mRays = rb_define_module("Rays");
+	rb_define_singleton_method(mRays, "perlin", RUBY_METHOD_FUNC(perlin), -1);
+	rb_define_singleton_method(mRays, "simplex", RUBY_METHOD_FUNC(simplex), -1);
+}

data/.doc/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)
@@ -52,6 +46,13 @@ VALUE bounds(VALUE self)
 	return value(THIS->bounds());
 }
 
+static
+VALUE pixel_density(VALUE self)
+{
+	CHECK;
+	return value(THIS->pixel_density());
+}
+
 
 static
 VALUE begin_paint(VALUE self)
@@ -77,139 +78,96 @@ VALUE clear(VALUE self)
 }
 
 static
-VALUE line(VALUE self)
+VALUE polygon(VALUE self, VALUE 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;
 }
 
 static
-VALUE lines(VALUE self)
+VALUE line(VALUE self, VALUE args, VALUE 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;
+}
+
+static
+VALUE polyline(VALUE self, VALUE poly)
+{
+	CHECK;
 
-	THIS->lines((Rays::Point*) &points[0], points.size());
+	THIS->line(to<Rays::Polyline&>(poly));
 	return self;
 }
 
 static
-VALUE polygon(VALUE self)
+VALUE rect(VALUE self, VALUE args, VALUE round, VALUE lefttop, VALUE righttop, VALUE leftbottom, VALUE 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;
 }
 
 static
-VALUE rect(VALUE self)
+VALUE ellipse(VALUE self, VALUE args, VALUE center, VALUE radius, VALUE hole, VALUE angle_from, VALUE 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;
 }
 
 static
-VALUE ellipse(VALUE self)
+VALUE curve(VALUE self, VALUE args, VALUE 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;
 }
 
 static
-VALUE arc(VALUE self)
+VALUE bezier(VALUE self, VALUE args, VALUE 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;
 }
 
@@ -260,7 +218,7 @@ static
 VALUE text(VALUE self)
 {
 	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());
@@ -269,61 +227,32 @@ VALUE text(VALUE self)
 		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;
 }
 
+
 static
 VALUE set_background(VALUE self)
 {
 	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;
 }
 
+static
+VALUE get_background(VALUE self)
+{
+	CHECK;
+	return value(THIS->background());
+}
+
 static
 VALUE no_background(VALUE self)
 {
@@ -333,36 +262,18 @@ VALUE no_background(VALUE self)
 }
 
 static
-VALUE get_background(VALUE self)
+VALUE set_fill(VALUE self)
 {
 	CHECK;
-	return value(THIS->background());
+	THIS->set_fill(to<Rays::Color>(argc, argv));
+	return self;
 }
 
 static
-VALUE set_fill(VALUE self)
+VALUE get_fill(VALUE self)
 {
 	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());
 }
 
 static
@@ -374,36 +285,18 @@ VALUE no_fill(VALUE self)
 }
 
 static
-VALUE get_fill(VALUE self)
+VALUE set_stroke(VALUE self)
 {
 	CHECK;
-	return value(THIS->fill());
+	THIS->set_stroke(to<Rays::Color>(argc, argv));
+	return self;
 }
 
 static
-VALUE set_stroke(VALUE self)
+VALUE get_stroke(VALUE self)
 {
 	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());
 }
 
 static
@@ -415,165 +308,158 @@ VALUE no_stroke(VALUE self)
 }
 
 static
-VALUE get_stroke(VALUE self)
+VALUE set_stroke_width(VALUE self, VALUE width)
 {
 	CHECK;
-	return value(THIS->stroke());
+	THIS->set_stroke_width(to<coord>(width));
+	return self;
 }
 
 static
-VALUE set_clip(VALUE self)
+VALUE get_stroke_width(VALUE self)
 {
 	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());
 }
 
 static
-VALUE no_clip(VALUE self)
+VALUE set_stroke_cap(VALUE self, VALUE cap)
 {
 	CHECK;
-	THIS->no_clip();
+	THIS->set_stroke_cap(to<Rays::CapType>(cap));
 	return self;
 }
 
 static
-VALUE get_clip(VALUE self)
+VALUE get_stroke_cap(VALUE self)
 {
 	CHECK;
-	return value(THIS->clip());
+	return value(THIS->stroke_cap());
 }
 
 static
-VALUE set_font(VALUE self)
+VALUE set_stroke_join(VALUE self, VALUE 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;
+}
 
-		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
+VALUE get_stroke_join(VALUE self)
+{
+	CHECK;
+	return value(THIS->stroke_join());
+}
 
+static
+VALUE set_miter_limit(VALUE self, VALUE limit)
+{
+	CHECK;
+	THIS->set_miter_limit(to<coord>(limit));
 	return self;
 }
 
 static
-VALUE get_font(VALUE self)
+VALUE get_miter_limit(VALUE self)
 {
 	CHECK;
-	return value(THIS->font());
+	return value(THIS->miter_limit());
 }
 
 static
-VALUE push_attr(VALUE self)
+VALUE set_nsegment(VALUE self, VALUE nsegment)
 {
 	CHECK;
-	THIS->push_attr();
+	THIS->set_nsegment(nsegment ? to<int>(nsegment) : 0);
 	return self;
 }
 
 static
-VALUE pop_attr(VALUE self)
+VALUE get_nsegment(VALUE self)
 {
 	CHECK;
-	THIS->pop_attr();
+	return value(THIS->nsegment());
+}
+
+static
+VALUE set_clip(VALUE self)
+{
+	CHECK;
+	THIS->set_clip(to<Rays::Bounds>(argc, argv));
 	return self;
 }
 
+static
+VALUE get_clip(VALUE self)
+{
+	CHECK;
+	return value(THIS->clip());
+}
 
 static
-VALUE attach_shader(VALUE self, VALUE shader)
+VALUE no_clip(VALUE self)
 {
 	CHECK;
-	THIS->attach(to<Rays::Shader&>(shader));
+	THIS->no_clip();
 	return self;
 }
 
 static
-VALUE detach_shader(VALUE self, VALUE shader)
+VALUE set_font(VALUE self)
 {
 	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;
 }
 
 static
-VALUE set_uniform(VALUE self)
+VALUE get_font(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "Painter#set_uniform", argc, 2, 3, 4, 5);
+	return value(THIS->font());
+}
 
-	#define Ai(n) (argv[n].as_i())
-	#define Af(n) ((float) argv[n].as_f())
+static
+VALUE set_shader(VALUE self)
+{
+	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;
+}
 
-	#undef Ai
-	#undef Af
+static
+VALUE get_shader(VALUE self)
+{
+	CHECK;
+	return value(THIS->shader());
+}
 
+static
+VALUE no_shader(VALUE self)
+{
+	CHECK;
+	THIS->no_shader();
 	return self;
 }
 
 static
-VALUE push_shader(VALUE self)
+VALUE push_state(VALUE self)
 {
 	CHECK;
-	THIS->push_shader();
+	THIS->push_state();
 	return self;
 }
 
 static
-VALUE pop_shader(VALUE self)
+VALUE pop_state(VALUE self)
 {
 	CHECK;
-	THIS->pop_shader();
+	THIS->pop_state();
 	return self;
 }
 
@@ -629,8 +515,8 @@ static
 VALUE set_matrix(VALUE self)
 {
 	CHECK;
-	THIS->set_matrix();
-	return self;
+	THIS->set_matrix(to<Rays::Matrix>(argc, argv));
+	return value(THIS->matrix());
 }
 
 static
@@ -669,47 +555,56 @@ Init_painter ()
 
 	rb_define_method(cPainter, "canvas", RUBY_METHOD_FUNC(canvas), 4);
 	rb_define_method(cPainter, "bounds", RUBY_METHOD_FUNC(bounds), 0);
+	rb_define_method(cPainter, "pixel_density", RUBY_METHOD_FUNC(pixel_density), 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, "clear", RUBY_METHOD_FUNC(clear), 0);
-	rb_define_method(cPainter, "line", RUBY_METHOD_FUNC(line), -1);
-	rb_define_method(cPainter, "lines", RUBY_METHOD_FUNC(lines), -1);
-	rb_define_method(cPainter, "polygon", RUBY_METHOD_FUNC(polygon), -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, "polygon", RUBY_METHOD_FUNC(polygon), 1);
+	rb_define_private_method(cPainter, "draw_line", RUBY_METHOD_FUNC(line), 2);
+	rb_define_private_method(cPainter, "draw_polyline", RUBY_METHOD_FUNC(polyline), 1);
+	rb_define_private_method(cPainter, "draw_rect", RUBY_METHOD_FUNC(rect), 6);
+	rb_define_private_method(cPainter, "draw_ellipse", RUBY_METHOD_FUNC(ellipse), 6);
+	rb_define_private_method(cPainter, "draw_curve", RUBY_METHOD_FUNC(curve), 2);
+	rb_define_private_method(cPainter, "draw_bezier", RUBY_METHOD_FUNC(bezier), 2);
 	rb_define_method(cPainter, "image", RUBY_METHOD_FUNC(image), -1);
 	rb_define_method(cPainter, "text", RUBY_METHOD_FUNC(text), -1);
 
-	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, "background=", RUBY_METHOD_FUNC(set_background), -1);
+	rb_define_method(cPainter, "background", RUBY_METHOD_FUNC(get_background), 0);
 	rb_define_method(cPainter, "no_background", RUBY_METHOD_FUNC(no_background), 0);
-	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, "fill=", RUBY_METHOD_FUNC(set_fill), -1);
+	rb_define_method(cPainter, "fill", RUBY_METHOD_FUNC(get_fill), 0);
 	rb_define_method(cPainter, "no_fill", RUBY_METHOD_FUNC(no_fill), 0);
-	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, "stroke=", RUBY_METHOD_FUNC(set_stroke), -1);
+	rb_define_method(cPainter, "stroke", RUBY_METHOD_FUNC(get_stroke), 0);
 	rb_define_method(cPainter, "no_stroke", RUBY_METHOD_FUNC(no_stroke), 0);
-	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, "stroke_width=", RUBY_METHOD_FUNC(set_stroke_width), 1);
+	rb_define_method(cPainter, "stroke_width", RUBY_METHOD_FUNC(get_stroke_width), 0);
+	rb_define_method(cPainter, "stroke_cap=", RUBY_METHOD_FUNC(set_stroke_cap), 1);
+	rb_define_method(cPainter, "stroke_cap", RUBY_METHOD_FUNC(get_stroke_cap), 0);
+	rb_define_method(cPainter, "stroke_join=", RUBY_METHOD_FUNC(set_stroke_join), 1);
+	rb_define_method(cPainter, "stroke_join", RUBY_METHOD_FUNC(get_stroke_join), 0);
+	rb_define_method(cPainter, "miter_limit=", RUBY_METHOD_FUNC(set_miter_limit), 1);
+	rb_define_method(cPainter, "miter_limit", RUBY_METHOD_FUNC(get_miter_limit), 0);
+	rb_define_method(cPainter, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
+	rb_define_method(cPainter, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
+	rb_define_method(cPainter, "clip=", RUBY_METHOD_FUNC(set_clip), -1);
+	rb_define_method(cPainter, "clip", RUBY_METHOD_FUNC(get_clip), 0);
 	rb_define_method(cPainter, "no_clip", RUBY_METHOD_FUNC(no_clip), 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, "font=", RUBY_METHOD_FUNC(set_font), -1);
+	rb_define_method(cPainter, "font", RUBY_METHOD_FUNC(get_font), 0);
+	rb_define_private_method(cPainter, "set_shader", RUBY_METHOD_FUNC(set_shader), -1);
+	rb_define_method(cPainter, "shader", RUBY_METHOD_FUNC(get_shader), 0);
+	rb_define_method(cPainter, "no_shader", RUBY_METHOD_FUNC(no_shader), 0);
+	rb_define_method(cPainter, "push_state", RUBY_METHOD_FUNC(push_state), 0);
+	rb_define_method(cPainter, "pop_state", RUBY_METHOD_FUNC(pop_state), 0);
 
 	rb_define_method(cPainter, "translate", RUBY_METHOD_FUNC(translate), -1);
 	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, "matrix=", RUBY_METHOD_FUNC(set_matrix), -1);
+	rb_define_method(cPainter, "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);
 }