rays 0.1.25 → 0.1.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6f7cc20d72750eb7d8ff9364831172720065e9f0339f0f865760c56b31e515b
-  data.tar.gz: dd31681766629607b2fa461ae12d6904d325c0b8babba803faaf0443b0472242
+  metadata.gz: 38052c848aef75871de813ae9cc59a956672b1c6b8db25b55916f041ae0df976
+  data.tar.gz: d1f462fce0b73364a015fa1826eef17c3d1a4ac0b4378590f20438d87ce8e1cf
 SHA512:
-  metadata.gz: f72e8c4cf249c3c7646a8d627e941dca67e7ac29a35d907e0c9ceac7522e3cdfd0df45e9eec8253a92fb70f031d53b5660eab594e50adfe6b8d12e4cb56b9a4e
-  data.tar.gz: e7f4017fd414def3b492173e6a61f53a9fc2fef18dbe409eb7be6e27840ecbe2a26af60f62d7d507dc6ba12bd740e7606da2871ea218db1e5e5b116a242f8a84
+  metadata.gz: 9e01828d4ac2ad4749a9d050d3890669be7e35dd057cc92b0dae23f645954b44bf7f3775d193ef36d9590d10879175a7937b28ceddf0bf9fd29a84723f0cfdbe
+  data.tar.gz: da8b670d9e704d4cc48070d5d252ec504e433f00222160a5c42ccf7a036eabc1a31580b6318da59672bc8576b0dddf84fce635ce9194f4a462eebfc8d4e03451

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

@@ -26,15 +26,51 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE canvas(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE canvas(VALUE self)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#canvas", argc, 4, 5, 6, 7);
 
-	coord xx = to<coord>(x);
-	coord yy = to<coord>(y);
-	coord ww = to<coord>(width);
-	coord hh = to<coord>(height);
-	THIS->canvas(xx, yy, ww, hh);
+	switch (argc)
+	{
+		case 4:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]));
+			break;
+
+		case 5:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<float>(argv[4]));
+			break;
+
+		case 6:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<coord>(argv[4]),
+				to<coord>(argv[5]));
+			break;
+
+		case 7:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<coord>(argv[4]),
+				to<coord>(argv[5]),
+				to<float>(argv[6]));
+			break;
+	}
 
 	return self;
 }
@@ -382,6 +418,21 @@ VALUE get_nsegment(VALUE self)
 	return value(THIS->nsegment());
 }
 
+static
+VALUE set_blend_mode(VALUE self, VALUE mode)
+{
+	CHECK;
+	THIS->set_blend_mode(to<Rays::BlendMode>(mode));
+	return self;
+}
+
+static
+VALUE get_blend_mode(VALUE self)
+{
+	CHECK;
+	return value(THIS->blend_mode());
+}
+
 static
 VALUE set_clip(VALUE self)
 {
@@ -428,7 +479,10 @@ VALUE set_shader(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Painter#set_shader", argc, 1);
 
-	THIS->set_shader(to<Rays::Shader>(argc, argv));
+	if (argc >= 1 && !argv[0])
+		THIS->no_shader();
+	else
+		THIS->set_shader(to<Rays::Shader>(argc, argv));
 	return self;
 }
 
@@ -436,7 +490,9 @@ static
 VALUE get_shader(VALUE self)
 {
 	CHECK;
-	return value(THIS->shader());
+
+	const Rays::Shader& shader = THIS->shader();
+	return shader ? value(shader) : nil();
 }
 
 static
@@ -553,7 +609,7 @@ Init_painter ()
 	cPainter = rb_define_class_under(mRays, "Painter", rb_cObject);
 	rb_define_alloc_func(cPainter, alloc);
 
-	rb_define_method(cPainter, "canvas", RUBY_METHOD_FUNC(canvas), 4);
+	rb_define_method(cPainter, "canvas", RUBY_METHOD_FUNC(canvas), -1);
 	rb_define_method(cPainter, "bounds", RUBY_METHOD_FUNC(bounds), 0);
 	rb_define_method(cPainter, "pixel_density", RUBY_METHOD_FUNC(pixel_density), 0);
 
@@ -589,6 +645,8 @@ Init_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, "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);
 	rb_define_method(cPainter, "clip", RUBY_METHOD_FUNC(get_clip), 0);
 	rb_define_method(cPainter, "no_clip", RUBY_METHOD_FUNC(no_clip), 0);

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

@@ -7,6 +7,7 @@
 
 RUCY_DEFINE_CONVERT_TO(Rays::CapType)
 RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
+RUCY_DEFINE_CONVERT_TO(Rays::BlendMode)
 
 
 template <typename T>
@@ -29,6 +30,18 @@ static std::vector<EnumType<Rays::JoinType>> JOIN_TYPES({
 	{"JOIN_SQUARE", "SQUARE", Rays::JOIN_SQUARE},
 });
 
+static std::vector<EnumType<Rays::BlendMode>> BLEND_MODES({
+	{"BLEND_NORMAL",    "NORMAL",    Rays::BLEND_NORMAL},
+	{"BLEND_ADD",       "ADD",       Rays::BLEND_ADD},
+	{"BLEND_SUBTRACT",  "SUBTRACT",  Rays::BLEND_SUBTRACT},
+	{"BLEND_LIGHTEST",  "LIGHTEST",  Rays::BLEND_LIGHTEST},
+	{"BLEND_DARKEST",   "DARKEST",   Rays::BLEND_DARKEST},
+	{"BLEND_EXCLUSION", "EXCLUSION", Rays::BLEND_EXCLUSION},
+	{"BLEND_MULTIPLY",  "MULTIPLY",  Rays::BLEND_MULTIPLY},
+	{"BLEND_SCREEN",    "SCREEN",    Rays::BLEND_SCREEN},
+	{"BLEND_REPLACE",   "REPLACE",   Rays::BLEND_REPLACE},
+});
+
 
 static
 VALUE init(VALUE self)
@@ -60,6 +73,9 @@ Init_rays ()
 
 	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
 		mRays.define_const(it->name, it->type);
+
+	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
+		mRays.define_const(it->name, it->type);
 }
 
 
@@ -129,6 +145,37 @@ namespace Rucy
 	}
 
 
+	template <> Rays::BlendMode
+	value_to<Rays::BlendMode> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid blend mode -- %s", str);
+			}
+		}
+
+		int type = value_to<int>(*argv, convert);
+		if (type < 0 || Rays::BLEND_MAX <= type)
+			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", type);
+
+		return (Rays::BlendMode) type;
+	}
+
+
 }// Rucy
 
 

data/Rakefile

@@ -38,4 +38,4 @@ test_ruby_extension
 generate_documents
 build_ruby_gem
 
-task :default => :test
+task :default => :ext

data/VERSION

@@ -1 +1 @@
-0.1.25
+0.1.28

data/ext/rays/painter.cpp

@@ -27,15 +27,51 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEF4(canvas, x, y, width, height)
+RUCY_DEFN(canvas)
 {
 	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Painter#canvas", argc, 4, 5, 6, 7);
 
-	coord xx = to<coord>(x);
-	coord yy = to<coord>(y);
-	coord ww = to<coord>(width);
-	coord hh = to<coord>(height);
-	THIS->canvas(xx, yy, ww, hh);
+	switch (argc)
+	{
+		case 4:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]));
+			break;
+
+		case 5:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<float>(argv[4]));
+			break;
+
+		case 6:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<coord>(argv[4]),
+				to<coord>(argv[5]));
+			break;
+
+		case 7:
+			THIS->canvas(
+				to<coord>(argv[0]),
+				to<coord>(argv[1]),
+				to<coord>(argv[2]),
+				to<coord>(argv[3]),
+				to<coord>(argv[4]),
+				to<coord>(argv[5]),
+				to<float>(argv[6]));
+			break;
+	}
 
 	return self;
 }
@@ -417,6 +453,23 @@ RUCY_DEF0(get_nsegment)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_blend_mode, mode)
+{
+	CHECK;
+	THIS->set_blend_mode(to<Rays::BlendMode>(mode));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_blend_mode)
+{
+	CHECK;
+	return value(THIS->blend_mode());
+}
+RUCY_END
+
 static
 RUCY_DEFN(set_clip)
 {
@@ -468,7 +521,10 @@ RUCY_DEFN(set_shader)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Painter#set_shader", argc, 1);
 
-	THIS->set_shader(to<Rays::Shader>(argc, argv));
+	if (argc >= 1 && !argv[0])
+		THIS->no_shader();
+	else
+		THIS->set_shader(to<Rays::Shader>(argc, argv));
 	return self;
 }
 RUCY_END
@@ -477,7 +533,9 @@ static
 RUCY_DEF0(get_shader)
 {
 	CHECK;
-	return value(THIS->shader());
+
+	const Rays::Shader& shader = THIS->shader();
+	return shader ? value(shader) : nil();
 }
 RUCY_END
 
@@ -641,6 +699,8 @@ Init_painter ()
 	cPainter.define_method("miter_limit",  get_miter_limit);
 	cPainter.define_method("nsegment=", set_nsegment);
 	cPainter.define_method("nsegment",  get_nsegment);
+	cPainter.define_method("blend_mode=", set_blend_mode);
+	cPainter.define_method("blend_mode",  get_blend_mode);
 	cPainter.define_method(   "clip=", set_clip);
 	cPainter.define_method(   "clip",  get_clip);
 	cPainter.define_method("no_clip",   no_clip);

data/ext/rays/rays.cpp

@@ -7,6 +7,7 @@
 
 RUCY_DEFINE_CONVERT_TO(Rays::CapType)
 RUCY_DEFINE_CONVERT_TO(Rays::JoinType)
+RUCY_DEFINE_CONVERT_TO(Rays::BlendMode)
 
 
 template <typename T>
@@ -29,6 +30,18 @@ static std::vector<EnumType<Rays::JoinType>> JOIN_TYPES({
 	{"JOIN_SQUARE", "SQUARE", Rays::JOIN_SQUARE},
 });
 
+static std::vector<EnumType<Rays::BlendMode>> BLEND_MODES({
+	{"BLEND_NORMAL",    "NORMAL",    Rays::BLEND_NORMAL},
+	{"BLEND_ADD",       "ADD",       Rays::BLEND_ADD},
+	{"BLEND_SUBTRACT",  "SUBTRACT",  Rays::BLEND_SUBTRACT},
+	{"BLEND_LIGHTEST",  "LIGHTEST",  Rays::BLEND_LIGHTEST},
+	{"BLEND_DARKEST",   "DARKEST",   Rays::BLEND_DARKEST},
+	{"BLEND_EXCLUSION", "EXCLUSION", Rays::BLEND_EXCLUSION},
+	{"BLEND_MULTIPLY",  "MULTIPLY",  Rays::BLEND_MULTIPLY},
+	{"BLEND_SCREEN",    "SCREEN",    Rays::BLEND_SCREEN},
+	{"BLEND_REPLACE",   "REPLACE",   Rays::BLEND_REPLACE},
+});
+
 
 static
 RUCY_DEF0(init)
@@ -62,6 +75,9 @@ Init_rays ()
 
 	for (auto it = JOIN_TYPES.begin(); it != JOIN_TYPES.end(); ++it)
 		mRays.define_const(it->name, it->type);
+
+	for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
+		mRays.define_const(it->name, it->type);
 }
 
 
@@ -131,6 +147,37 @@ namespace Rucy
 	}
 
 
+	template <> Rays::BlendMode
+	value_to<Rays::BlendMode> (int argc, const Value* argv, bool convert)
+	{
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argv->is_s() || argv->is_sym())
+			{
+				const char* str = argv->c_str();
+				for (auto it = BLEND_MODES.begin(); it != BLEND_MODES.end(); ++it)
+				{
+					if (
+						strcasecmp(str, it->name)       == 0 ||
+						strcasecmp(str, it->short_name) == 0)
+					{
+						return it->type;
+					}
+				}
+				argument_error(__FILE__, __LINE__, "invalid blend mode -- %s", str);
+			}
+		}
+
+		int type = value_to<int>(*argv, convert);
+		if (type < 0 || Rays::BLEND_MAX <= type)
+			argument_error(__FILE__, __LINE__, "invalid blend mode -- %d", type);
+
+		return (Rays::BlendMode) type;
+	}
+
+
 }// Rucy
 
 

data/include/rays/defs.h

@@ -56,6 +56,32 @@ namespace Rays
 	};// JoinType
 
 
+	enum BlendMode
+	{
+
+		BLEND_NORMAL = 0,
+
+		BLEND_ADD,
+
+		BLEND_SUBTRACT,
+
+		BLEND_LIGHTEST,
+
+		BLEND_DARKEST,
+
+		BLEND_EXCLUSION,
+
+		BLEND_MULTIPLY,
+
+		BLEND_SCREEN,
+
+		BLEND_REPLACE,
+
+		BLEND_MAX
+
+	};// BlendMode
+
+
 }// Rays
 
 

data/include/rays/painter.h

@@ -174,7 +174,8 @@ namespace Rays
 			//
 			// states
 			//
-			void     set_background (float red, float green, float blue, float alpha = 1, bool clear = true);
+			void     set_background (
+				float red, float green, float blue, float alpha = 1, bool clear = true);
 
 			void     set_background (const Color& color, bool clear = true);
 
@@ -218,6 +219,10 @@ namespace Rays
 
 			uint     nsegment () const;
 
+			void  set_blend_mode (BlendMode mode);
+
+			BlendMode blend_mode () const;
+
 			void      set_clip (coord x, coord y, coord width, coord height);
 
 			void      set_clip (const Bounds& bounds);

data/include/rays/ruby/rays.h

@@ -25,5 +25,7 @@ RUCY_DECLARE_CONVERT_TO(Rays::CapType)
 
 RUCY_DECLARE_CONVERT_TO(Rays::JoinType)
 
+RUCY_DECLARE_CONVERT_TO(Rays::BlendMode)
+
 
 #endif//EOH

data/lib/rays/painter.rb

@@ -108,9 +108,21 @@ module Rays
       square: JOIN_SQUARE
     }
 
+    const_symbol_accessor :blend_mode, **{
+      normal:    BLEND_NORMAL,
+      add:       BLEND_ADD,
+      subtract:  BLEND_SUBTRACT,
+      lightest:  BLEND_LIGHTEST,
+      darkest:   BLEND_DARKEST,
+      exclusion: BLEND_EXCLUSION,
+      multiply:  BLEND_MULTIPLY,
+      screen:    BLEND_SCREEN,
+      replace:   BLEND_REPLACE
+    }
+
     universal_accessor :background, :fill, :stroke, :color,
       :stroke_width, :stroke_cap, :stroke_join, :miter_limit,
-      :nsegment, :shader, :clip, :font
+      :nsegment, :blend_mode, :shader, :clip, :font
 
     private
 

data/rays.gemspec

@@ -28,8 +28,8 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 2.6.0'
 
-  s.add_runtime_dependency 'xot',  '~> 0.1.25'
-  s.add_runtime_dependency 'rucy', '~> 0.1.25'
+  s.add_runtime_dependency 'xot',  '~> 0.1.28'
+  s.add_runtime_dependency 'rucy', '~> 0.1.28'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/frame_buffer.cpp

@@ -110,7 +110,7 @@ namespace Rays
 
 		self->texture = texture;
 
-#if 0
+#if 1
 		int w = texture.reserved_width(), h = texture.reserved_height();
 		if (
 			w != self->render_buffer.width() ||
@@ -119,8 +119,7 @@ namespace Rays
 			RenderBuffer rb = RenderBuffer(w, h);
 
 			glFramebufferRenderbuffer(
-				GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-				GL_RENDERBUFFER, rb.id());
+				GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rb.id());
 			OpenGL_check_error(__FILE__, __LINE__);
 
 			self->render_buffer = rb;

data/src/ios/bitmap.mm

@@ -224,9 +224,26 @@ namespace Rays
 		return bitmap.self->modified;
 	}
 
+	static CFStringRef
+	get_bitmap_type (const char* path_)
+	{
+		String path = path_;
+		path = path.downcase();
+		if (path.ends_with(".png")) return kUTTypePNG;
+		if (path.ends_with(".gif")) return kUTTypeGIF;
+		if (path.ends_with(".bmp")) return kUTTypeBMP;
+		if (path.ends_with(".jpg") || path.ends_with(".jpeg")) return kUTTypeJPEG;
+		if (path.ends_with(".tif") || path.ends_with(".tiff")) return kUTTypeTIFF;
+		return nil;
+	}
+
 	void
 	Bitmap_save (const Bitmap& bmp, const char* path_)
 	{
+		const CFStringRef type = get_bitmap_type(path_);
+		if (!type)
+			argument_error(__FILE__, __LINE__, "unknown image file type");
+
 		std::shared_ptr<CGImage> img(bmp.self->get_image(), CGImageRelease);
 		if (!img)
 			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
@@ -237,7 +254,7 @@ namespace Rays
 			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
 
 		std::shared_ptr<CGImageDestination> dest(
-			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			CGImageDestinationCreateWithURL((CFURLRef) url, type, 1, NULL),
 			safe_cfrelease);
 		if (!dest)
 			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");

data/src/osx/bitmap.mm

@@ -223,9 +223,26 @@ namespace Rays
 		return bitmap.self->modified;
 	}
 
+	static CFStringRef
+	get_bitmap_type (const char* path_)
+	{
+		String path = path_;
+		path = path.downcase();
+		if (path.ends_with(".png")) return kUTTypePNG;
+		if (path.ends_with(".gif")) return kUTTypeGIF;
+		if (path.ends_with(".bmp")) return kUTTypeBMP;
+		if (path.ends_with(".jpg") || path.ends_with(".jpeg")) return kUTTypeJPEG;
+		if (path.ends_with(".tif") || path.ends_with(".tiff")) return kUTTypeTIFF;
+		return nil;
+	}
+
 	void
 	Bitmap_save (const Bitmap& bmp, const char* path_)
 	{
+		const CFStringRef type = get_bitmap_type(path_);
+		if (!type)
+			argument_error(__FILE__, __LINE__, "unknown image file type");
+
 		std::shared_ptr<CGImage> img(bmp.self->get_image(), CGImageRelease);
 		if (!img)
 			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
@@ -236,7 +253,7 @@ namespace Rays
 			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
 
 		std::shared_ptr<CGImageDestination> dest(
-			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			CGImageDestinationCreateWithURL((CFURLRef) url, type, 1, NULL),
 			safe_cfrelease);
 		if (!dest)
 			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");

data/src/painter.cpp

@@ -56,6 +56,8 @@ namespace Rays
 
 		uint nsegment;
 
+		BlendMode blend_mode;
+
 		Bounds clip;
 
 		Font font;
@@ -72,6 +74,7 @@ namespace Rays
 			stroke_join    = JOIN_DEFAULT;
 			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
 			nsegment       = 0;
+			blend_mode     = BLEND_NORMAL;
 			clip           .reset(-1);
 			font           = default_font();
 			shader         = Shader();
@@ -107,7 +110,7 @@ namespace Rays
 			return
 				texture &&
 				texcoord_min.x < texcoord_max.x &&
-				texcoord_min.x < texcoord_max.y;
+				texcoord_min.y < texcoord_max.y;
 		}
 
 		bool operator ! () const
@@ -125,10 +128,14 @@ namespace Rays
 
 		GLclampf color_clear[4];
 
+		GLboolean depth_test;
+		GLint depth_func;
+
 		GLboolean scissor_test;
 		GLint scissor_box[4];
 
 		GLboolean blend;
+		GLint blend_equation_rgb, blend_equation_alpha;
 		GLint blend_src_rgb, blend_src_alpha, blend_dst_rgb, blend_dst_alpha;
 
 		GLint framebuffer_binding;
@@ -139,10 +146,15 @@ namespace Rays
 
 			glGetFloatv(GL_COLOR_CLEAR_VALUE, color_clear);
 
+			glGetBooleanv(GL_DEPTH_TEST, &depth_test);
+			glGetIntegerv(GL_DEPTH_FUNC, &depth_func);
+
 			glGetBooleanv(GL_SCISSOR_TEST, &scissor_test);
 			glGetIntegerv(GL_SCISSOR_BOX, scissor_box);
 
 			glGetBooleanv(GL_BLEND, &blend);
+			glGetIntegerv(GL_BLEND_EQUATION_RGB,   &blend_equation_rgb);
+			glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &blend_equation_alpha);
 			glGetIntegerv(GL_BLEND_SRC_RGB,   &blend_src_rgb);
 			glGetIntegerv(GL_BLEND_SRC_ALPHA, &blend_src_alpha);
 			glGetIntegerv(GL_BLEND_DST_RGB,   &blend_dst_rgb);
@@ -158,10 +170,14 @@ namespace Rays
 			glClearColor(
 				color_clear[0], color_clear[1], color_clear[2], color_clear[3]);
 
+			enable(GL_DEPTH_TEST, depth_test);
+			glDepthFunc(depth_func);
+
 			enable(GL_SCISSOR_TEST, scissor_test);
 			glScissor(scissor_box[0], scissor_box[1], scissor_box[2], scissor_box[3]);
 
 			enable(GL_BLEND, blend);
+			glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
 			glBlendFuncSeparate(
 				blend_src_rgb, blend_dst_rgb, blend_src_alpha, blend_dst_alpha);
 
@@ -566,7 +582,7 @@ namespace Rays
 	Painter::canvas (
 		coord x, coord y, coord width, coord height, float pixel_density)
 	{
-		canvas(Bounds(x, y, -100, width, height, 200), pixel_density);
+		canvas(x, y, 0, width, height, 0, pixel_density);
 	}
 
 	void
@@ -639,10 +655,14 @@ namespace Rays
 		self->opengl_state.push();
 
 		//glEnable(GL_CULL_FACE);
-		glEnable(GL_BLEND);
-		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+
+		glEnable(GL_DEPTH_TEST);
+		glDepthFunc(GL_LEQUAL);
 		OpenGL_check_error(__FILE__, __LINE__);
 
+		glEnable(GL_BLEND);
+		set_blend_mode(self->state.blend_mode);
+
 		FrameBuffer& fb = self->frame_buffer;
 		if (fb) FrameBuffer_bind(fb.id());
 
@@ -656,16 +676,23 @@ namespace Rays
 		coord x1 = vp.x, x2 = vp.x + vp.width;
 		coord y1 = vp.y, y2 = vp.y + vp.height;
 		coord z1 = vp.z, z2 = vp.z + vp.depth;
-		if (z1 == 0 && z2 == 0) {z1 = -100; z2 = 200;}
+		if (z1 == 0 && z2 == 0) {z1 = -1000; z2 = 1000;}
 		if (!fb) std::swap(y1, y2);
 
 		self->position_matrix.reset(1);
 		self->position_matrix *= to_rays(glm::ortho(x1, x2, y1, y2));
+
+		// map z to 0.0-1.0
+		self->position_matrix.scale(1, 1, 1.0 / (z2 - z1));
+		self->position_matrix.translate(0, 0, -z2);
+
 		//self->position_matrix.translate(0.375f, 0.375f);
 
 		self->update_clip();
 
 		self->painting = true;
+
+		glClear(GL_DEPTH_BUFFER_BIT);
 	}
 
 	void
@@ -703,7 +730,7 @@ namespace Rays
 
 		const Color& c = self->state.background;
 		glClearColor(c.red, c.green, c.blue, c.alpha);
-		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		glClear(GL_COLOR_BUFFER_BIT);
 		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
@@ -1293,6 +1320,72 @@ namespace Rays
 		return self->state.nsegment;
 	}
 
+	void
+	Painter::set_blend_mode (BlendMode mode)
+	{
+		self->state.blend_mode = mode;
+		switch (mode)
+		{
+			case BLEND_NORMAL:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(
+					GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_ADD:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_SUBTRACT:
+				glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_LIGHTEST:
+				glBlendEquationSeparate(GL_MAX, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_DARKEST:
+				glBlendEquationSeparate(GL_MIN, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_EXCLUSION:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(
+					GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_MULTIPLY:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_SCREEN:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ONE, GL_ONE, GL_ONE);
+				break;
+
+			case BLEND_REPLACE:
+				glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+				glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+				break;
+
+			default:
+				argument_error(__FILE__, __LINE__, "unknown blend mode");
+				break;
+		}
+		OpenGL_check_error(__FILE__, __LINE__);
+	}
+
+	BlendMode
+	Painter::blend_mode () const
+	{
+		return self->state.blend_mode;
+	}
+
 	void
 	Painter::set_clip (coord x, coord y, coord width, coord height)
 	{
@@ -1318,9 +1411,19 @@ namespace Rays
 		return self->state.clip;
 	}
 
+	static bool
+	has_same_font (const Font& font, const char* name, coord size)
+	{
+		return
+			font.size() == size &&
+			font.name() == (name ? name : default_font().name().c_str());
+	}
+
 	void
 	Painter::set_font (const char* name, coord size)
 	{
+		if (has_same_font(self->state.font, name, size)) return;
+
 		set_font(Font(name, size));
 	}
 

data/src/render_buffer.cpp

@@ -54,8 +54,11 @@ namespace Rays
 				#else
 					GL_DEPTH_COMPONENT24,
 				#endif
-				width,
-				height);
+				width_,
+				height_);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			glBindRenderbuffer(GL_RENDERBUFFER, 0);
 			OpenGL_check_error(__FILE__, __LINE__);
 
 			width  = width_;

data/test/test_image.rb

@@ -6,11 +6,12 @@ require_relative 'helper'
 
 class TestImage < Test::Unit::TestCase
 
-  W = 10
-  H = 10
+  def image(*args)
+    Rays::Image.new(*args)
+  end
 
-  def image(w = W, h = H, *args)
-    Rays::Image.new w, h, *args
+  def load(path)
+    Rays::Image.load path
   end
 
   def color(r = 0, g = 0, b = 0, a = 0)
@@ -22,12 +23,12 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_initialize()
-    assert_equal W, image.width
-    assert_equal H, image.height
+    assert_equal 10, image(10, 20).width
+    assert_equal 10, image(20, 10).height
   end
 
   def test_dup()
-    o          = image
+    o          = image 10, 10
     assert_equal color(0, 0, 0, 0), o[0, 0]
     o[0, 0]    = color(1, 0, 0, 0)
     assert_equal color(1, 0, 0, 0), o[0, 0]
@@ -39,12 +40,12 @@ class TestImage < Test::Unit::TestCase
   end
 
   def test_bitmap()
-    assert_equal W, image.bitmap.width
-    assert_equal H, image.bitmap.height
+    assert_equal 10, image(10, 20).bitmap.width
+    assert_equal 10, image(20, 10).bitmap.height
   end
 
   def test_painter()
-    pa = image.painter
+    pa = image(10, 10).painter
     assert_equal color(0, 0, 0, 0), pa.background
     assert_equal color(1, 1, 1, 1), pa.fill
     assert_equal color(1, 1, 1, 0), pa.stroke
@@ -73,4 +74,38 @@ class TestImage < Test::Unit::TestCase
     assert drawn {|p| p.text "a"}
   end
 
+  def test_save_load()
+    def get_image_type(filename)
+      `file #{filename}`.match(/#{filename}: ([^,]+),/)[1]
+    end
+
+    img    = image(10, 10).paint {fill 1, 0, 0; ellipse 0, 0, 10}
+    pixels = img.bitmap.to_a
+    paths  = %w[png jpg jpeg gif bmp tif tiff].map {|ext| "#{__dir__}/testimage.#{ext}"}
+
+    png, jpg, jpeg, gif, bmp, tif, tiff = paths
+
+    paths.each {|path| img.save path}
+
+    assert_equal 'PNG image data',  get_image_type(png)
+    assert_equal 'JPEG image data', get_image_type(jpg)
+    assert_equal 'JPEG image data', get_image_type(jpeg)
+    assert_equal 'GIF image data',  get_image_type(gif)
+    assert_equal 'PC bitmap',       get_image_type(bmp)
+    assert_equal 'TIFF image data', get_image_type(tif)
+    assert_equal 'TIFF image data', get_image_type(tiff)
+
+    assert_equal pixels,   load(png) .then {|o| o.bitmap.to_a}
+    assert_equal [10, 10], load(jpg) .then {|o| [o.width, o.height]}
+    assert_equal [10, 10], load(jpeg).then {|o| [o.width, o.height]}
+    assert_equal pixels,   load(gif) .then {|o| o.bitmap.to_a}
+    assert_equal [10, 10], load(bmp) .then {|o| [o.width, o.height]}
+    assert_equal pixels,   load(tif) .then {|o| o.bitmap.to_a}
+    assert_equal pixels,   load(tiff).then {|o| o.bitmap.to_a}
+
+    paths.each {|path| File.delete path}
+
+    assert_raise(ArgumentError) {img.save 'testimage.unknown'}
+  end
+
 end# TestImage

data/test/test_painter.rb

@@ -18,6 +18,28 @@ class TestPainter < Test::Unit::TestCase
     Rays::Color.new(*args)
   end
 
+  def image(w = 16, h = 16, bg: 0, &block)
+    Rays::Image.new(w, h)
+      .paint {background bg}
+      .tap {|img| img.paint(&block) if block}
+  end
+
+  def assert_gray(expected, actual)
+    assert_in_epsilon expected, actual, 0.02
+  end
+
+  def assert_rgb(expected, actual)
+    (0..2).each do |i|
+      assert_gray expected[i], actual[i]
+    end
+  end
+
+  def assert_rgba(expected, actual)
+    (0..3).each do |i|
+      assert_gray expected[i], actual[i]
+    end
+  end
+
   def setup()
     Rays::Color.set_palette_color :rgb001, color(0, 0, 1)
   end
@@ -124,6 +146,19 @@ class TestPainter < Test::Unit::TestCase
     assert_equal         4, pa.miter_limit
   end
 
+  def test_blend_mode_accessor()
+    pa = painter
+    assert_equal        :normal,   pa.blend_mode
+    pa.blend_mode =     :add
+    assert_equal        :add,      pa.blend_mode
+    pa.blend_mode       :subtract
+    assert_equal        :subtract, pa.blend_mode
+    pa.push blend_mode: :multiply do |_|
+      assert_equal      :multiply, pa.blend_mode
+    end
+    assert_equal        :subtract, pa.blend_mode
+  end
+
   def test_clip_accessor()
     pa = painter
     pa.clip = [1, 2, 3, 4]
@@ -182,6 +217,122 @@ class TestPainter < Test::Unit::TestCase
     assert_equal color(0, 1, 0), pa.fill
   end
 
+  def test_blend_mode_normal()
+    i = image do
+      blend_mode :normal
+      fill 0.1, 0.2, 0.3
+      rect 0, 0, 2
+      fill 0.4, 0.5, 0.6
+      rect 1, 0, 2
+    end
+    assert_rgb [0.1, 0.2, 0.3], i[0, 0]
+    assert_rgb [0.4, 0.5, 0.6], i[1, 0]
+    assert_rgb [0.4, 0.5, 0.6], i[2, 0]
+  end
+
+  def test_blend_mode_add()
+    i = image do
+      fill 0.1, 0.2, 0.3
+      rect 0, 0, 2
+      blend_mode :add
+      fill 0.4, 0.5, 0.6
+      rect 1, 0, 2
+    end
+    assert_rgb [0.1, 0.2, 0.3], i[0, 0]
+    assert_rgb [0.5, 0.7, 0.9], i[1, 0]
+    assert_rgb [0.4, 0.5, 0.6], i[2, 0]
+  end
+
+  def test_blend_mode_subtract()
+    i = image bg: 1 do
+      fill 0.4, 0.5, 0.6
+      rect 0, 0, 2
+      blend_mode :subtract
+      fill 0.1, 0.2, 0.3
+      rect 1, 0, 2
+    end
+    assert_rgb [0.4, 0.5, 0.6], i[0, 0]
+    assert_rgb [0.3, 0.3, 0.3], i[1, 0]
+    assert_rgb [0.9, 0.8, 0.7], i[2, 0]
+  end
+
+  def test_blend_mode_lightest()
+    i = image do
+      fill 0.4, 0.5, 0.6
+      rect 0, 0, 2
+      blend_mode :lightest
+      fill 0.1, 0.2, 0.3
+      rect 1, 0, 2
+    end
+    assert_rgb [0.4, 0.5, 0.6], i[0, 0]
+    assert_rgb [0.4, 0.5, 0.6], i[1, 0]
+    assert_rgb [0.1, 0.2, 0.3], i[2, 0]
+  end
+
+  def test_blend_mode_darkest()
+    i = image bg: 1 do
+      fill 0.1, 0.2, 0.3
+      rect 0, 0, 2
+      blend_mode :darkest
+      fill 0.4, 0.5, 0.6
+      rect 1, 0, 2
+    end
+    assert_rgb [0.1, 0.2, 0.3], i[0, 0]
+    assert_rgb [0.1, 0.2, 0.3], i[1, 0]
+    assert_rgb [0.4, 0.5, 0.6], i[2, 0]
+  end
+
+  def test_blend_mode_exclusion()
+    # no tests
+  end
+
+  def test_blend_mode_multiply()
+    i = image bg: 1 do
+      fill 0.2, 0.4, 0.6
+      rect 0, 0, 2
+      blend_mode :multiply
+      fill 0.5
+      rect 1, 0, 2
+    end
+    assert_rgb [0.2, 0.4, 0.6], i[0, 0]
+    assert_rgb [0.1, 0.2, 0.3], i[1, 0]
+    assert_rgb [0.5, 0.5, 0.5], i[2, 0]
+  end
+
+  def test_blend_mode_screen()
+    i = image bg: 0.8 do
+      fill 0.2, 0.4, 0.6
+      rect 0, 0, 2
+      blend_mode :screen
+      fill 0.5
+      rect 1, 0, 2
+    end
+    assert_rgb [0.2, 0.4, 0.6], i[0, 0]
+    assert_rgb [0.6, 0.7, 0.8], i[1, 0]
+    assert_rgb [0.9, 0.9, 0.9], i[2, 0]
+  end
+
+  def test_blend_mode_replace()
+    i = image bg: 1 do
+      fill 0.1, 0.2, 0.3, 0.4
+      rect 0, 0, 2
+      blend_mode :replace
+      fill 0.5, 0.6, 0.7, 0.8
+      rect 1, 0, 2
+    end
+    assert_rgba [0.5, 0.6, 0.7, 0.8], i[1, 0]
+    assert_rgba [0.5, 0.6, 0.7, 0.8], i[2, 0]
+  end
+
+  def test_blend_mode_invalid()
+    assert_raise(ArgumentError) do
+      image {blend_mode :invalid}
+    end
+    assert_raise(ArgumentError) do
+      image {blend_mode nil}
+    end
+  end
+
   def test_push()
     pa = painter
     pa.fill =           [1, 0, 0]
@@ -224,7 +375,23 @@ class TestPainter < Test::Unit::TestCase
   end
 
   def test_shader()
-    img = Rays::Image.new(10, 10).paint {
+    image.paint do |pa|
+      assert_nil pa.shader
+
+      pa.shader = Rays::Shader.new "void main() {gl_FragColor = vec4(0.0);}"
+      assert_instance_of Rays::Shader, pa.shader
+
+      pa.shader = nil
+      assert_nil pa.shader
+
+      pa.shader = "void main() {gl_FragColor = vec4(0.0);}"
+      assert_instance_of Rays::Shader, pa.shader
+
+      pa.no_shader
+      assert_nil pa.shader
+    end
+
+    img = image.paint {
       shader "void main() {gl_FragColor = vec4(0.0, 0.0, 1.0, 1.0);}"
       fill   1, 0, 0
       rect   bounds

data/test/test_painter_shape.rb

@@ -99,4 +99,4 @@ class TestPainterShape < Test::Unit::TestCase
     assert_equal 0, img[99, 99].a
   end
 
-end# TestPainter
+end# TestPainterShape

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rays
 version: !ruby/object:Gem::Version
-  version: 0.1.25
+  version: 0.1.28
 platform: ruby
 authors:
 - xordog
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-04 00:00:00.000000000 Z
+date: 2022-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xot
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.25
+        version: 0.1.28
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.25
+        version: 0.1.28
 - !ruby/object:Gem::Dependency
   name: rucy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.25
+        version: 0.1.28
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.25
+        version: 0.1.28
 description: This library helps you to develop graphics application with OpenGL.
 email: xordog@gmail.com
 executables: []
@@ -252,7 +252,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: A Drawing Engine using OpenGL.