rays 0.4.0 → 0.5.0

data/src/ios/font.mm

@@ -5,6 +5,7 @@
 #include <memory>
 #import <CoreGraphics/CGContext.h>
 #import <CoreText/CoreText.h>
+#import <UIKit/UIKit.h>
 #include <xot/string.h>
 #include <xot/util.h>
 #include "rays/exception.h"
@@ -18,6 +19,8 @@ namespace Rays
 
 	typedef std::shared_ptr<const __CFAttributedString> CFAttributedStringPtr;
 
+	typedef std::shared_ptr<const __CTFontDescriptor>   CTFontDescriptorPtr;
+
 	typedef std::shared_ptr<CGDataProvider>             CGDataProviderPtr;
 
 	typedef std::shared_ptr<CGFont>                     CGFontPtr;
@@ -30,8 +33,6 @@ namespace Rays
 
 		CTFontRef font = NULL;
 
-		String path;
-
 		~Data ()
 		{
 			if (font)
@@ -44,6 +45,63 @@ namespace Rays
 	};// RawFont::Data
 
 
+	static const struct {int weight; CGFloat native;} NATIVE_WEIGHTS[] =
+	{
+		{Font::WEIGHT_MIN,        -1.0},
+		{Font::WEIGHT_THIN,       UIFontWeightUltraLight},
+		{Font::WEIGHT_EXTRALIGHT, UIFontWeightThin},
+		{Font::WEIGHT_LIGHT,      UIFontWeightLight},
+		{Font::WEIGHT_NORMAL,     UIFontWeightRegular},
+		{Font::WEIGHT_MEDIUM,     UIFontWeightMedium},
+		{Font::WEIGHT_SEMIBOLD,   UIFontWeightSemibold},
+		{Font::WEIGHT_BOLD,       UIFontWeightBold},
+		{Font::WEIGHT_EXTRABOLD,  UIFontWeightHeavy},
+		{Font::WEIGHT_BLACK,      UIFontWeightBlack},
+		{Font::WEIGHT_MAX,        1.0}
+	};
+
+	static CGFloat
+	to_native_weight (int weight)
+	{
+		size_t last = sizeof(NATIVE_WEIGHTS) / sizeof(NATIVE_WEIGHTS[0]) - 1;
+		for (size_t i = 1; i <= last; ++i)
+		{
+			if (weight > NATIVE_WEIGHTS[i].weight) continue;
+
+			const auto& lo = NATIVE_WEIGHTS[i - 1];
+			const auto& hi = NATIVE_WEIGHTS[i];
+			CGFloat t      = (CGFloat) (weight - lo.weight) / (hi.weight - lo.weight);
+			return lo.native + (hi.native - lo.native) * t;
+		}
+		return NATIVE_WEIGHTS[last].native;
+	}
+
+	static CTFontRef
+	create_styled_font (CTFontRef base, coord size, int weight, bool italic)
+	{
+		Xot::CFStringPtr family(CTFontCopyFamilyName(base), Xot::safe_cfrelease);
+		if (!family) return NULL;
+
+		NSDictionary* traits     =
+		@{
+			(id) kCTFontWeightTrait:   @(to_native_weight(weight)),
+			(id) kCTFontSymbolicTrait: @(italic ? kCTFontTraitItalic : 0)
+		};
+		NSDictionary* attributes =
+		@{
+			(id) kCTFontFamilyNameAttribute: (__bridge NSString*) family.get(),
+			(id) kCTFontTraitsAttribute:     traits
+		};
+
+		CTFontDescriptorPtr descriptor(
+			CTFontDescriptorCreateWithAttributes((__bridge CFDictionaryRef) attributes),
+			Xot::safe_cfrelease);
+		if (!descriptor) return NULL;
+
+		return CTFontCreateWithFontDescriptor(descriptor.get(), size, NULL);
+	}
+
+
 	static CTLinePtr
 	make_line (CTFontRef font, const char* str)
 	{
@@ -64,15 +122,15 @@ namespace Rays
 			CFDictionaryCreate(
 				NULL, (const void**) &keys, (const void**) &values, nkeys,
 				&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks),
-			CFRelease);
+			Xot::safe_cfrelease);
 
 		CFAttributedStringPtr attrstr(
 			CFAttributedStringCreate(NULL, Xot::String(str).to_cfstr().get(), attr.get()),
-			CFRelease);
+			Xot::safe_cfrelease);
 
 		return CTLinePtr(
 			CTLineCreateWithAttributedString(attrstr.get()),
-			CFRelease);
+			Xot::safe_cfrelease);
 	}
 
 	const FontFamilyMap&
@@ -117,7 +175,6 @@ namespace Rays
 
 		RawFont rawfont;
 		rawfont.self->font = ctfont;
-		rawfont.self->path = path;
 		return rawfont;
 	}
 
@@ -126,20 +183,23 @@ namespace Rays
 	{
 	}
 
-	RawFont::RawFont (const char* name, coord size)
+	RawFont::RawFont (const char* name, coord size, int weight, bool italic)
 	{
-		self->font = name
+		CTFontRef font = name
 			?	CTFontCreateWithName(Xot::String(name).to_cfstr().get(), size, NULL)
 			:	CTFontCreateUIFontForLanguage(kCTFontSystemFontType, size, NULL);
-	}
 
-	RawFont::RawFont (const This& obj, coord size)
-	{
-		const char* path = obj.self->path.empty() ? NULL : obj.self->path.c_str();
-		if (path)
-			*this = RawFont_load(path, size);
-		else
-			self->font = CTFontCreateWithName(obj.name().to_cfstr().get(), size, NULL);
+		if (font && (weight != Font::WEIGHT_NORMAL || italic))
+		{
+			CTFontRef styled = create_styled_font(font, size, weight, italic);
+			if (styled)
+			{
+				CFRelease(font);
+				font = styled;
+			}
+		}
+
+		self->font = font;
 	}
 
 	RawFont::~RawFont ()
@@ -190,17 +250,10 @@ namespace Rays
 	{
 		if (!*this) return "";
 
-		Xot::CFStringPtr str(CTFontCopyFullName(self->font), CFRelease);
+		Xot::CFStringPtr str(CTFontCopyFullName(self->font), Xot::safe_cfrelease);
 		return Xot::to_s(str);
 	}
 
-	coord
-	RawFont::size () const
-	{
-		if (!*this) return 0;
-		return CTFontGetSize(self->font);
-	}
-
 	coord
 	RawFont::get_width (const char* str) const
 	{

data/src/opengl/color_space.cpp

@@ -30,7 +30,10 @@ namespace Rays
 		if (format)
 		{
 			     if (cs.is_rgb())   *format = cs.has_alpha() ? GL_RGBA  : GL_RGB;
-		#ifndef IOS
+		#ifdef IOS
+			else if (cs.is_bgr() && cs.has_alpha())
+			                        *format = GL_BGRA_EXT;
+		#else
 			else if (cs.is_bgr())   *format = cs.has_alpha() ? GL_BGRA  : GL_BGR;
 		#endif
 			else if (cs.is_gray())  *format = GL_LUMINANCE;

data/src/opengl/painter.cpp

@@ -132,7 +132,7 @@ namespace Rays
 
 			const uint* get () const
 			{
-				return &indices[0];
+				return indices.data();
 			}
 
 		private:
@@ -249,7 +249,7 @@ namespace Rays
 
 			if (!buffers.empty())
 			{
-				glDeleteBuffers((GLsizei) buffers.size(), &buffers[0]);
+				glDeleteBuffers((GLsizei) buffers.size(), buffers.data());
 				OpenGL_check_error(__FILE__, __LINE__);
 			}
 
@@ -259,53 +259,75 @@ namespace Rays
 
 		void apply_blend_mode ()
 		{
+			// sources arrive premultiplied (see rays/shader.h), so the source color
+			// is never scaled by GL_SRC_ALPHA here, and alpha always accumulates
+			// as a union: a = a_src + a_dst * (1 - a_src)
+
 			switch (state.blend_mode)
 			{
 				case BLEND_NORMAL:
 					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
 					glBlendFuncSeparate(
-						GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_ADD:
 					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ONE,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_SUBTRACT:
 					glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ONE,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_LIGHTEST:
 					glBlendEquationSeparate(GL_MAX, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ONE,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_DARKEST:
 					glBlendEquationSeparate(GL_MIN, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_ONE, GL_ONE, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ONE,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					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);
+						GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR,
+						GL_ONE,                 GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_MULTIPLY:
+					// assumes an opaque destination; the Cs * (1 - Ad) term of the
+					// exact formula is not expressible with fixed-function blending
 					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_ZERO, GL_SRC_COLOR, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA,
+						GL_ONE,       GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_SCREEN:
 					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_ONE_MINUS_DST_COLOR, GL_ONE, GL_ONE, GL_ONE);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ONE_MINUS_SRC_COLOR,
+						GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 					break;
 
 				case BLEND_REPLACE:
 					glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-					glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
+					glBlendFuncSeparate(
+						GL_ONE, GL_ZERO,
+						GL_ONE, GL_ZERO);
 					break;
 
 				default:
@@ -489,7 +511,7 @@ namespace Rays
 			std::vector<Color> colors_(npoints, *color);
 			apply_attribute(
 				self, program, names.attribute_color_names,
-				(const Coord4*) &colors_[0], npoints);
+				(const Coord4*) colors_.data(), npoints);
 #else
 			for (const auto& name : names.attribute_color_names)
 			{
@@ -841,6 +863,12 @@ namespace Rays
 		if (!self->is_painting())
 			invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
 
+		if (Xot::check_and_remove_flag(&self->flags, Painter::Data::CLEAR_DEPTH))
+		{
+			glClear(GL_DEPTH_BUFFER_BIT);
+			OpenGL_check_error(__FILE__, __LINE__);
+		}
+
 		std::unique_ptr<TextureInfo> ptexinfo;
 		texinfo = setup_texinfo(self, texinfo, &ptexinfo);
 		shader  = setup_shader(self, shader, texinfo);
@@ -862,8 +890,9 @@ namespace Rays
 			if (!setup_triangle_fan_indices(&fan_indices, npoints))
 				return;
 			batch(
-				painter, MODE_TRIANGLES, color, points, npoints, &fan_indices[0], fan_indices.size(),
-				colors, texcoords, texinfo, *shader);
+				painter, MODE_TRIANGLES, color, points, npoints,
+				fan_indices.data(), fan_indices.size(), colors, texcoords,
+				texinfo, *shader);
 		}
 		else
 		{
@@ -953,6 +982,13 @@ namespace Rays
 		if (width  == 0) width  = str_w;
 		if (height == 0) height = str_h;
 
+		// the baseline where Font's ascent tells, of the font at density 1:
+		// the font drawn at density may round its ascent apart from it
+		coord ascent = 0, ascent_drawn = 0;
+		font.get_height(&ascent);
+		rawfont.get_height(&ascent_drawn);
+		y += ascent - ascent_drawn / density;
+
 		Painter_draw_image(
 			painter, self->text_image,
 			0, 0, str_w, str_h,
@@ -962,6 +998,39 @@ namespace Rays
 		debug_draw_text_line(painter, font, x, y, str_w / density, str_h / density);
 	}
 
+	bool
+	Painter_get_pixel (Color* color, Painter* painter, coord x, coord y)
+	{
+		if (!color)
+			argument_error(__FILE__, __LINE__);
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
+
+		PainterData* self = get_data(painter);
+
+		const Bounds& vp = self->viewport;
+		if (!vp.is_include(x, y))
+			return false;
+
+		if (self->is_painting())
+			draw_batch(self);
+
+		float density = self->pixel_density;
+		GLint px      = (GLint) ((x - vp.x) * density);
+		GLint py      = (GLint) ((y - vp.y) * density);
+		if (!self->frame_buffer)
+			py = (GLint) (vp.height * density) - 1 - py;
+
+		FrameBufferBinder binder(self->frame_buffer ? self->frame_buffer.id() : 0);
+
+		GLubyte rgba[4] = {0, 0, 0, 0};
+		glReadPixels(px, py, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, rgba);
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		color->reset8(rgba[0], rgba[1], rgba[2], rgba[3]);
+		return true;
+	}
+
 
 	Painter::Painter ()
 	:	self(new PainterData())
@@ -1050,9 +1119,8 @@ namespace Rays
 		self->batcher.init(self->state);
 
 		Xot::remove_flag(&self->flags, Painter::Data::UNBATCHABLE_STATE_CHANGED);
+		Xot::   add_flag(&self->flags, Painter::Data::CLEAR_DEPTH);
 		Xot::   add_flag(&self->flags, Painter::Data::PAINTING);
-
-		glClear(GL_DEPTH_BUFFER_BIT);
 	}
 
 	void
@@ -1075,7 +1143,7 @@ namespace Rays
 		self->opengl_state.pop();
 		self->default_indices.clear();
 
-		glFinish();
+		glFlush();
 
 		if (self->frame_buffer)
 			FrameBuffer_unbind();
@@ -1092,7 +1160,7 @@ namespace Rays
 		Painter_flush(this);
 
 		const Color& c = self->state.background;
-		glClearColor(c.red, c.green, c.blue, c.alpha);
+		glClearColor(c.red * c.alpha, c.green * c.alpha, c.blue * c.alpha, c.alpha);
 		glClear(GL_COLOR_BUFFER_BIT);
 		OpenGL_check_error(__FILE__, __LINE__);
 	}

data/src/opengl/shader.cpp

@@ -72,7 +72,7 @@ namespace Rays
 			"varying vec4 " + V_COLOR + ";\n"
 			"void main ()\n"
 			"{\n"
-			"  gl_FragColor = " + V_COLOR + ";\n"
+			"  gl_FragColor = vec4(" + V_COLOR + ".rgb * " + V_COLOR + ".a, " + V_COLOR + ".a);\n"
 			"}\n");
 	}
 
@@ -95,7 +95,8 @@ namespace Rays
 				V_TEXCOORD_MIN + ".xy, " +
 				V_TEXCOORD_MAX + ".xy - " + U_TEXCOORD_PIXEL + ".xy);\n"
 			"  vec4 _rays_color    = texture2D(" + U_TEXTURE + ", _rays_texcoord);\n"
-			"  gl_FragColor        = " + V_COLOR + " * _rays_color;\n"
+			"  gl_FragColor        = _rays_color *\n"
+			"    vec4(" + V_COLOR + ".rgb * " + V_COLOR + ".a, " + V_COLOR + ".a);\n"
 			"}\n");
 	}
 
@@ -114,9 +115,11 @@ namespace Rays
 			"{\n"
 			"  vec2 _rays_min      = " + V_TEXCOORD_MIN + ".xy;\n"
 			"  vec2 _rays_len      = " + V_TEXCOORD_MAX + ".xy - _rays_min;\n"
-			"  vec2 _rays_texcoord = mod(" + V_TEXCOORD + ".xy - _rays_min, _rays_len) + _rays_min;\n"
+			"  vec2 _rays_texcoord =\n"
+			"    mod(" + V_TEXCOORD + ".xy - _rays_min, _rays_len) + _rays_min;\n"
 			"  vec4 _rays_color    = texture2D(" + U_TEXTURE + ", _rays_texcoord);\n"
-			"  gl_FragColor        = " + V_COLOR + " * _rays_color;\n"
+			"  gl_FragColor        = _rays_color *\n"
+			"    vec4(" + V_COLOR + ".rgb * " + V_COLOR + ".a, " + V_COLOR + ".a);\n"
 			"}\n");
 	}
 
@@ -131,16 +134,15 @@ namespace Rays
 			"uniform sampler2D " + U_TEXTURE + ";\n"
 			"void main ()\n"
 			"{\n"
-			"  vec4 _rays_col = texture2D(" + U_TEXTURE + ", " + V_TEXCOORD + ".xy);\n"
-			#if defined(OSX) || defined(IOS) || defined(LINUX)
-			// restore premultiplied rgb values
-			"  vec3 _rays_rgb = _rays_col.a != 0.0 ? _rays_col.rgb / _rays_col.a : _rays_col.rgb;\n"
-			"  gl_FragColor   = " + V_COLOR + " * vec4(_rays_rgb, _rays_col.a);\n"
-			#elif defined(WIN32)
-			"  float _rays_a  = (_rays_col.r + _rays_col.g + _rays_col.b) / 3.0;\n"
-			"  gl_FragColor   = " + V_COLOR + " * vec4(1.0, 1.0, 1.0, _rays_a);\n"
+			"  vec4 _rays_tex = texture2D(" + U_TEXTURE + ", " + V_TEXCOORD + ".xy);\n"
+			"  vec4 _rays_col =\n"
+			"    vec4(" + V_COLOR + ".rgb * " + V_COLOR + ".a, " + V_COLOR + ".a);\n"
+			#if defined(WIN32)
+			// GDI writes no alpha; white text on black gives the coverage
+			"  float _rays_a  = (_rays_tex.r + _rays_tex.g + _rays_tex.b) / 3.0;\n"
+			"  gl_FragColor   = _rays_col * _rays_a;\n"
 			#else
-			"  gl_FragColor   = " + V_COLOR + " * _rays_col;\n"
+			"  gl_FragColor   = _rays_tex * _rays_col;\n"
 			#endif
 			"}\n");
 	}

data/src/opengl/texture.cpp

@@ -203,7 +203,7 @@ namespace Rays
 			glTexImage2D(
 				GL_TEXTURE_2D, 0, internalformat, width, height, 0, format, type,
 				bitmap ? bitmap->pixels() : NULL);
-			npot = OpenGL_has_error();
+			npot = !OpenGL_has_error();
 		}
 
 		if (!npot)
@@ -213,7 +213,7 @@ namespace Rays
 			int height_pow2 = min_pow2(height);
 
 			glTexImage2D(
-				GL_TEXTURE_2D, 0, format, width_pow2, height_pow2, 0, format, type,
+				GL_TEXTURE_2D, 0, internalformat, width_pow2, height_pow2, 0, format, type,
 				bitmap ? resize_bitmap(*bitmap, width_pow2, height_pow2)->pixels() : NULL);
 			OpenGL_check_error(__FILE__, __LINE__);
 

data/src/opengl/win32/opengl.cpp

@@ -11,17 +11,18 @@ namespace Rays
 {
 
 
-	static const char* WINDOW_CLASS = "Rays:OffscreenWindow";
+	static const wchar_t* WINDOW_CLASS = L"Rays:OffscreenWindow";
 
 
 	const PIXELFORMATDESCRIPTOR*
-	get_pixel_format_descriptor ()
+	OpenGL_get_pixel_format_descriptor ()
 	{
 		static const PIXELFORMATDESCRIPTOR PFD =
 		{
 			sizeof(PIXELFORMATDESCRIPTOR), 1,
-			PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
-			PFD_TYPE_RGBA, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0,
+			PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
+			PFD_DOUBLEBUFFER   | PFD_SUPPORT_COMPOSITION,
+			PFD_TYPE_RGBA, 24, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 16, 0, 0,
 			PFD_MAIN_PLANE, 0, 0, 0, 0
 		};
 		return &PFD;
@@ -39,26 +40,26 @@ namespace Rays
 
 		OffscreenContext ()
 		{
-			WNDCLASS wc      = {0};
-			wc.lpfnWndProc   = DefWindowProc;
-			wc.hInstance     = GetModuleHandle(NULL);
+			WNDCLASSW wc     = {0};
+			wc.lpfnWndProc   = DefWindowProcW;
+			wc.hInstance     = GetModuleHandleW(NULL);
 			wc.lpszClassName = WINDOW_CLASS;
 			wc.style         = CS_OWNDC;
-			if (!RegisterClass(&wc))
+			if (!RegisterClassW(&wc))
 			{
 				// It's OK to be registered by the duplicated Rays module
 				if (GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
 					system_error(__FILE__, __LINE__);
 			}
 
-			hwnd = CreateWindowEx(
-				WS_EX_LAYERED, WINDOW_CLASS, "", WS_POPUP, 0, 0, 1, 1,
-				NULL, NULL, GetModuleHandle(NULL), NULL);
+			hwnd = CreateWindowExW(
+				WS_EX_LAYERED, WINDOW_CLASS, L"", WS_POPUP, 0, 0, 1, 1,
+				NULL, NULL, GetModuleHandleW(NULL), NULL);
 			if (!hwnd)
 				system_error(__FILE__, __LINE__);
 
 			hdc             = GetDC(hwnd);
-			const auto* pfd = get_pixel_format_descriptor();
+			const auto* pfd = OpenGL_get_pixel_format_descriptor();
 			int pf          = ChoosePixelFormat(hdc, pfd);
 			if (!SetPixelFormat(hdc, pf, pfd))
 				system_error(__FILE__, __LINE__);
@@ -127,6 +128,10 @@ namespace Rays
 	activate_offscreen_context ()
 	{
 		const auto* c = get_opengl_offscreen_context();
+
+		if (wglGetCurrentContext() == c->hrc)
+			return;
+
 		if (!wglMakeCurrent(c->hdc, c->hrc))
 			system_error(__FILE__, __LINE__);
 	}