rays 0.1.47 → 0.1.49

data/.doc/ext/rays/matrix.cpp

@@ -67,6 +67,14 @@ VALUE reset(VALUE self)
 	return self;
 }
 
+static
+VALUE transpose(VALUE self)
+{
+	CHECK;
+	THIS->transpose();
+	return self;
+}
+
 static
 VALUE translate(VALUE self)
 {
@@ -108,10 +116,10 @@ VALUE to_a(VALUE self)
 {
 	CHECK;
 	return array(
-		THIS->x0, THIS->y0, THIS->z0, THIS->w0,
-		THIS->x1, THIS->y1, THIS->z1, THIS->w1,
-		THIS->x2, THIS->y2, THIS->z2, THIS->w2,
-		THIS->x3, THIS->y3, THIS->z3, THIS->w3);
+		THIS->x0, THIS->x1, THIS->x2, THIS->x3,
+		THIS->y0, THIS->y1, THIS->y2, THIS->y3,
+		THIS->z0, THIS->z1, THIS->z2, THIS->z3,
+		THIS->w0, THIS->w1, THIS->w2, THIS->w3);
 }
 
 static
@@ -190,6 +198,51 @@ VALUE s_rotate(VALUE self)
 	return rotate(argc, argv, value(Rays::Matrix()));
 }
 
+static
+VALUE s_ortho(VALUE self)
+{
+	check_arg_count(__FILE__, __LINE__, "Matrix#ortho", argc, 4, 6);
+
+	coord l = to<coord>(argv[0]);
+	coord r = to<coord>(argv[1]);
+	coord t = to<coord>(argv[2]);
+	coord b = to<coord>(argv[3]);
+	if (argc == 4)
+		return value(Rays::ortho(l, r, t, b));
+	else
+		return value(Rays::ortho(l, r, t, b, to<coord>(argv[4]), to<coord>(argv[5])));
+}
+
+static
+VALUE s_perspective(VALUE self, VALUE fov_y, VALUE aspect_ratio, VALUE near, VALUE far)
+{
+	return value(Rays::perspective(
+		to<float>(fov_y), to<float>(aspect_ratio), to<coord>(near), to<coord>(far)));
+}
+
+static
+VALUE s_look_at(VALUE self)
+{
+	check_arg_count(__FILE__, __LINE__, "Matrix#ortho", argc, 3, 6, 9);
+
+	if (argc == 3)
+	{
+		return value(Rays::look_at(
+			to<Rays::Point&>(argv[0]),
+			to<Rays::Point&>(argv[1]),
+			to<Rays::Point&>(argv[2])));
+	}
+	else
+	{
+		return value(Rays::look_at(
+			to<coord>(argv[0]), to<coord>(argv[1]), to<coord>(argv[2]),
+			to<coord>(argv[3]), to<coord>(argv[4]), to<coord>(argv[5]),
+			argc >= 7 ? to<coord>(argv[6]) : 0,
+			argc >= 8 ? to<coord>(argv[7]) : 1,
+			argc >= 9 ? to<coord>(argv[8]) : 0));
+	}
+}
+
 
 static Class cMatrix;
 
@@ -203,9 +256,10 @@ Init_rays_matrix ()
 	rb_define_private_method(cMatrix, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cMatrix, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cMatrix, "reset", RUBY_METHOD_FUNC(reset), -1);
-	rb_define_method(cMatrix, "translate", RUBY_METHOD_FUNC(translate), -1);
-	rb_define_method(cMatrix, "scale", RUBY_METHOD_FUNC(scale), -1);
-	rb_define_method(cMatrix, "rotate", RUBY_METHOD_FUNC(rotate), -1);
+	cMatrix.define_method("transpose!", transpose);
+	cMatrix.define_method("translate!", translate);
+	cMatrix.define_method("scale!",     scale);
+	cMatrix.define_method("rotate!",    rotate);
 	rb_define_method(cMatrix, "to_a", RUBY_METHOD_FUNC(to_a), 0);
 	cMatrix.define_method("*", mult);
 	cMatrix.define_method("[]=", set_at);
@@ -216,6 +270,10 @@ Init_rays_matrix ()
 	rb_define_singleton_method(cMatrix, "translate", RUBY_METHOD_FUNC(s_translate), -1);
 	rb_define_singleton_method(cMatrix, "scale", RUBY_METHOD_FUNC(s_scale), -1);
 	rb_define_singleton_method(cMatrix, "rotate", RUBY_METHOD_FUNC(s_rotate), -1);
+	rb_define_singleton_method(cMatrix, "ortho", RUBY_METHOD_FUNC(s_ortho), -1);
+	rb_define_singleton_method(cMatrix, "perspective", RUBY_METHOD_FUNC(s_perspective), 4);
+	rb_define_singleton_method(cMatrix, "look_at", RUBY_METHOD_FUNC(s_look_at), -1);
+
 }
 
 

data/.doc/ext/rays/native.cpp

@@ -12,7 +12,6 @@ void Init_rays_matrix ();
 
 void Init_rays_painter ();
 void Init_rays_polyline ();
-void Init_rays_polygon_line ();
 void Init_rays_polygon ();
 void Init_rays_bitmap ();
 void Init_rays_image ();
@@ -20,7 +19,7 @@ void Init_rays_font ();
 void Init_rays_shader ();
 void Init_rays_camera ();
 
-void Init_rays_noise ();
+void Init_rays_util ();
 
 
 extern "C" void
@@ -45,7 +44,6 @@ extern "C" void
 
 	Init_rays_painter();
 	Init_rays_polyline();
-	Init_rays_polygon_line();
 	Init_rays_polygon();
 	Init_rays_bitmap();
 	Init_rays_image();
@@ -53,7 +51,7 @@ extern "C" void
 	Init_rays_shader();
 	Init_rays_camera();
 
-	Init_rays_noise();
+	Init_rays_util();
 
 	RUCY_CATCH
 }

data/.doc/ext/rays/painter.cpp

@@ -147,13 +147,25 @@ VALUE polygon(VALUE self)
 	return self;
 }
 
+static
+VALUE point(VALUE self)
+{
+	CHECK;
+
+	std::vector<Rays::Point> points;
+	get_points(&points, argc, argv);
+
+	THIS->points(&points[0], points.size());
+	return self;
+}
+
 static
 VALUE line(VALUE self, VALUE args, VALUE loop)
 {
 	CHECK;
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->line(&points[0], points.size(), loop);
 	return self;
@@ -211,7 +223,7 @@ VALUE curve(VALUE self, VALUE args, VALUE loop)
 		argument_error(__FILE__, __LINE__);
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->curve(&points[0], points.size(), loop);
 	return self;
@@ -226,7 +238,7 @@ VALUE bezier(VALUE self, VALUE args, VALUE loop)
 		argument_error(__FILE__, __LINE__);
 
 	std::vector<Rays::Point> points;
-	get_line_args(&points, args.size(), args.as_array());
+	get_points(&points, args.size(), args.as_array());
 
 	THIS->bezier(&points[0], points.size(), loop);
 	return self;
@@ -458,6 +470,28 @@ VALUE get_nsegment(VALUE self)
 	return value(THIS->nsegment());
 }
 
+static
+VALUE set_line_height(VALUE self, VALUE height)
+{
+	CHECK;
+	THIS->set_line_height(height ? to<coord>(height) : -1);
+	return self;
+}
+
+static
+VALUE get_line_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->line_height());
+}
+
+static
+VALUE get_line_height_raw(VALUE self)
+{
+	CHECK;
+	return value(THIS->line_height(true));
+}
+
 static
 VALUE set_blend_mode(VALUE self, VALUE mode)
 {
@@ -513,6 +547,69 @@ VALUE get_font(VALUE self)
 	return value(THIS->font());
 }
 
+static
+VALUE set_texture(VALUE self, VALUE image)
+{
+	CHECK;
+
+	if (!image)
+		THIS->no_texture();
+	else
+		THIS->set_texture(to<Rays::Image&>(image));
+	return self;
+}
+
+static
+VALUE get_texture(VALUE self)
+{
+	CHECK;
+
+	const Rays::Image& image = THIS->texture();
+	return image ? value(image) : nil();
+}
+
+static
+VALUE no_texture(VALUE self)
+{
+	CHECK;
+	THIS->no_texture();
+	return self;
+}
+
+static
+VALUE set_texcoord_mode(VALUE self, VALUE mode)
+{
+	CHECK;
+
+	THIS->set_texcoord_mode(to<Rays::TexCoordMode>(mode));
+	return self;
+}
+
+static
+VALUE get_texcoord_mode(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->texcoord_mode());
+}
+
+static
+VALUE set_texcoord_wrap(VALUE self, VALUE wrap)
+{
+	CHECK;
+
+	THIS->set_texcoord_wrap(to<Rays::TexCoordWrap>(wrap));
+	return self;
+}
+
+static
+VALUE get_texcoord_wrap(VALUE self)
+{
+	CHECK;
+
+	return value(THIS->texcoord_wrap());
+}
+
 static
 VALUE set_shader(VALUE self)
 {
@@ -658,12 +755,13 @@ Init_rays_painter ()
 	cPainter.define_method(              "painting?", is_painting);
 	rb_define_method(cPainter, "clear", RUBY_METHOD_FUNC(clear), 0);
 	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, "point", RUBY_METHOD_FUNC(point), -1);
+	cPainter.define_private_method("line!",     line);
+	cPainter.define_private_method("polyline!", polyline);
+	cPainter.define_private_method("rect!",     rect);
+	cPainter.define_private_method("ellipse!",  ellipse);
+	cPainter.define_private_method("curve!",    curve);
+	cPainter.define_private_method("bezier!",   bezier);
 	rb_define_method(cPainter, "image", RUBY_METHOD_FUNC(image), -1);
 	rb_define_method(cPainter, "text", RUBY_METHOD_FUNC(text), -1);
 
@@ -688,6 +786,9 @@ Init_rays_painter ()
 	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, "line_height=", RUBY_METHOD_FUNC(set_line_height), 1);
+	rb_define_method(cPainter, "line_height", RUBY_METHOD_FUNC(get_line_height), 0);
+	cPainter.define_method("line_height!", get_line_height_raw);
 	rb_define_method(cPainter, "blend_mode=", RUBY_METHOD_FUNC(set_blend_mode), 1);
 	rb_define_method(cPainter, "blend_mode", RUBY_METHOD_FUNC(get_blend_mode), 0);
 	rb_define_method(cPainter, "clip=", RUBY_METHOD_FUNC(set_clip), -1);
@@ -695,6 +796,13 @@ Init_rays_painter ()
 	rb_define_method(cPainter, "no_clip", RUBY_METHOD_FUNC(no_clip), 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_method(cPainter, "texture=", RUBY_METHOD_FUNC(set_texture), 1);
+	rb_define_method(cPainter, "texture", RUBY_METHOD_FUNC(get_texture), 0);
+	rb_define_method(cPainter, "no_texture", RUBY_METHOD_FUNC(no_texture), 0);
+	rb_define_method(cPainter, "texcoord_mode=", RUBY_METHOD_FUNC(set_texcoord_mode), 1);
+	rb_define_method(cPainter, "texcoord_mode", RUBY_METHOD_FUNC(get_texcoord_mode), 0);
+	rb_define_method(cPainter, "texcoord_wrap=", RUBY_METHOD_FUNC(set_texcoord_wrap), 1);
+	rb_define_method(cPainter, "texcoord_wrap", RUBY_METHOD_FUNC(get_texcoord_wrap), 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);

data/.doc/ext/rays/point.cpp

@@ -79,15 +79,6 @@ VALUE move_by(VALUE self)
 
 static
 VALUE rotate(VALUE self, VALUE degree)
-{
-	CHECK;
-	Rays::Point p = *THIS;
-	p.rotate(to<float>(degree));
-	return value(p);
-}
-
-static
-VALUE rotate_self(VALUE self, VALUE degree)
 {
 	CHECK;
 	THIS->rotate(to<float>(degree));
@@ -258,8 +249,7 @@ Init_rays_point ()
 	rb_define_private_method(cPoint, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	cPoint.define_method("move_to!", move_to);
 	cPoint.define_method("move_by!", move_by);
-	rb_define_method(cPoint, "rotate", RUBY_METHOD_FUNC(rotate), 1);
-	cPoint.define_method("rotate!", rotate_self);
+	cPoint.define_method("rotate!",  rotate);
 	rb_define_method(cPoint, "length", RUBY_METHOD_FUNC(length), 0);
 	rb_define_method(cPoint, "normalize", RUBY_METHOD_FUNC(normalize), 0);
 	rb_define_method(cPoint, "normal", RUBY_METHOD_FUNC(normal), 0);