.doc/ext/rays/image.cpp in rays-0.1.12 vs .doc/ext/rays/image.cpp in rays-0.1.13

@@ -1,21 +1,14 @@
 #include "rays/ruby/image.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/color_space.h"
 #include "rays/ruby/bitmap.h"
-#include "rays/ruby/texture.h"
 #include "rays/ruby/painter.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Rays::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Rays::Image)
 
 #define THIS  to<Rays::Image*>(self)
 
 #define CHECK RUCY_CHECK_OBJECT(Rays::Image, self)
@@ -29,52 +22,47 @@
 
 static
 VALUE initialize(VALUE self)
 {
 	RUCY_CHECK_OBJ(Rays::Image, self);
-	check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2, 3);
+	check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2, 3, 4);
 
-	if (argc == 0) return self;
-
 	if (argv[0].is_kind_of(Rays::bitmap_class()))
 	{
 		check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 1, 2);
 
 		const Rays::Bitmap* bitmap = to<Rays::Bitmap*>(argv[0]);
-		if (!bitmap) argument_error(__FILE__, __LINE__);
+		if (!bitmap)
+			argument_error(__FILE__, __LINE__);
 
-		bool alpha_only = (argc == 2) ? to<bool>(argv[1]) : false;
-		*THIS = Rays::Image(*bitmap, alpha_only);
+		float pixel_density = (argc >= 2) ? to<float>(argv[1]) : 1;
+		*THIS = Rays::Image(*bitmap, pixel_density);
 	}
 	else
 	{
-		int width  = to<int>(argv[0]);
-		int height = to<int>(argv[1]);
-		uint colorspace = (argc == 3) ? to<uint>(argv[2]) : (uint) Rays::RGBA;
-		*THIS = Rays::Image(width, height, (Rays::ColorSpaceType) colorspace);
+		check_arg_count(__FILE__, __LINE__, "Image#initialize", argc, 2, 3, 4);
+
+		int width           = to<int>(argv[0]);
+		int height          = to<int>(argv[1]);
+		Rays::ColorSpace cs = (argc >= 3) ? to<Rays::ColorSpace>(argv[2]) : Rays::RGBA;
+		float pixel_density = (argc >= 4) ? to<float>(argv[3]) : 1;
+		*THIS = Rays::Image(width, height, cs, pixel_density);
 	}
 
 	return self;
 }
 
 static
 VALUE initialize_copy(VALUE self, VALUE obj)
 {
 	RUCY_CHECK_OBJ(Rays::Image, self);
 
-	*THIS = to<Rays::Image&>(obj).copy();
+	*THIS = to<Rays::Image&>(obj).dup();
 	return self;
 }
 
 static
-VALUE painter(VALUE self)
-{
-	CHECK;
-	return value(THIS->painter());
-}
-
-static
 VALUE width(VALUE self)
 {
 	CHECK;
 	return value(THIS->width());
 }
@@ -92,28 +80,28 @@
 	CHECK;
 	return value(THIS->color_space());
 }
 
 static
-VALUE alpha_only(VALUE self)
+VALUE pixel_density(VALUE self)
 {
 	CHECK;
-	return value(THIS->alpha_only());
+	return value(THIS->pixel_density());
 }
 
 static
-VALUE bitmap(VALUE self)
+VALUE painter(VALUE self)
 {
 	CHECK;
-	return value(THIS->bitmap());
+	return value(THIS->painter());
 }
 
 static
-VALUE texture(VALUE self)
+VALUE bitmap(VALUE self)
 {
 	CHECK;
-	return value(THIS->texture());
+	return value(THIS->bitmap());
 }
 
 static
 VALUE save(VALUE self, VALUE path)
 {
@@ -122,13 +110,15 @@
 	return self;
 }
 
 
 static
-VALUE load(VALUE self, VALUE path, VALUE alpha_only)
+VALUE load(VALUE self)
 {
-	return value(Rays::load_image(path.c_str(), to<bool>(alpha_only)));
+	check_arg_count(__FILE__, __LINE__, "Image.load", argc, 1);
+
+	return value(Rays::load_image(argv[0].c_str()));
 }
 
 
 static Class cImage;
 
@@ -139,18 +129,17 @@
 
 	cImage = rb_define_class_under(mRays, "Image", rb_cObject);
 	rb_define_alloc_func(cImage, alloc);
 	rb_define_private_method(cImage, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	rb_define_private_method(cImage, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cImage, "painter", RUBY_METHOD_FUNC(painter), 0);
 	rb_define_method(cImage, "width", RUBY_METHOD_FUNC(width), 0);
 	rb_define_method(cImage, "height", RUBY_METHOD_FUNC(height), 0);
 	rb_define_method(cImage, "color_space", RUBY_METHOD_FUNC(color_space), 0);
-	rb_define_method(cImage, "alpha_only", RUBY_METHOD_FUNC(alpha_only), 0);
+	rb_define_method(cImage, "pixel_density", RUBY_METHOD_FUNC(pixel_density), 0);
+	rb_define_method(cImage, "painter", RUBY_METHOD_FUNC(painter), 0);
 	rb_define_method(cImage, "bitmap", RUBY_METHOD_FUNC(bitmap), 0);
-	rb_define_method(cImage, "texture", RUBY_METHOD_FUNC(texture), 0);
 	rb_define_method(cImage, "save", RUBY_METHOD_FUNC(save), 1);
-	rb_define_function(cImage, "load_image", RUBY_METHOD_FUNC(load), 2);
+	rb_define_function(cImage, "load", RUBY_METHOD_FUNC(load), -1);
 }
 
 
 namespace Rays
 {