rays 0.4.0 → 0.5.0

data/src/osx/font.mm

@@ -6,6 +6,7 @@
 #import <ApplicationServices/ApplicationServices.h>
 #import <AppKit/AppKit.h>
 #include <xot/string.h>
+#include <xot/util.h>
 #include "rays/exception.h"
 
 
@@ -17,6 +18,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;
@@ -29,8 +32,6 @@ namespace Rays
 
 		CTFontRef font = NULL;
 
-		String path;
-
 		~Data ()
 		{
 			if (font)
@@ -43,6 +44,63 @@ namespace Rays
 	};// RawFont::Data
 
 
+	static const struct {int weight; CGFloat native;} NATIVE_WEIGHTS[] =
+	{
+		{Font::WEIGHT_MIN,        -1.0},
+		{Font::WEIGHT_THIN,       NSFontWeightUltraLight},
+		{Font::WEIGHT_EXTRALIGHT, NSFontWeightThin},
+		{Font::WEIGHT_LIGHT,      NSFontWeightLight},
+		{Font::WEIGHT_NORMAL,     NSFontWeightRegular},
+		{Font::WEIGHT_MEDIUM,     NSFontWeightMedium},
+		{Font::WEIGHT_SEMIBOLD,   NSFontWeightSemibold},
+		{Font::WEIGHT_BOLD,       NSFontWeightBold},
+		{Font::WEIGHT_EXTRABOLD,  NSFontWeightHeavy},
+		{Font::WEIGHT_BLACK,      NSFontWeightBlack},
+		{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)
 	{
@@ -63,15 +121,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&
@@ -118,7 +176,6 @@ namespace Rays
 
 		RawFont rawfont;
 		rawfont.self->font = ctfont;
-		rawfont.self->path = path;
 		return rawfont;
 	}
 
@@ -127,20 +184,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(kCTFontUIFontSystem, 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 ()
@@ -189,17 +249,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/painter.cpp

@@ -7,6 +7,7 @@
 #include "rays/debug.h"
 #include "polygon.h"
 #include "image.h"
+#include "font.h"
 
 
 namespace Rays
@@ -741,21 +742,20 @@ namespace Rays
 		return self->state.clip;
 	}
 
-	static bool
-	has_same_font (const Font& font, const char* name, coord size, bool smooth)
-	{
-		return
-			font.size()   == size &&
-			font.smooth() == smooth &&
-			font.name()   == (name ? name : get_default_font().name().c_str());
-	}
-
 	void
-	Painter::set_font (const char* name, coord size, bool smooth)
+	Painter::set_font (
+		const char* name, coord size, int weight, bool italic, bool smooth)
 	{
-		if (has_same_font(self->state.font, name, size, smooth)) return;
+		if (weight < 0)
+			weight = Font::DEFAULT_WEIGHT;
+
+		if (Font_has_same_attributes(
+			self->state.font, name, size, weight, italic, smooth))
+		{
+			return;
+		}
 
-		set_font(Font(name, size, smooth));
+		set_font(Font(name, size, weight, italic, smooth));
 	}
 
 	void

data/src/painter.h

@@ -179,7 +179,9 @@ namespace Rays
 
 			PAINTING                  = Xot::bit(1, Painter::FLAG_LAST),
 
-			UNBATCHABLE_STATE_CHANGED = Xot::bit(2, Painter::FLAG_LAST),
+			CLEAR_DEPTH               = Xot::bit(2, Painter::FLAG_LAST),
+
+			UNBATCHABLE_STATE_CHANGED = Xot::bit(3, Painter::FLAG_LAST),
 
 		};// Flag
 
@@ -237,6 +239,8 @@ namespace Rays
 		Painter* painter, const Font& font, const char* line, coord x, coord y,
 		coord width = 0, coord height = 0);
 
+	bool Painter_get_pixel (Color* color, Painter* painter, coord x, coord y);
+
 
 }// Rays
 

data/src/polygon.cpp

@@ -147,18 +147,18 @@ namespace Rays
 				{
 					draw_polygon(
 						painter, MODE_TRIANGLES,
-						&points[0],  points.size(),
-						&indices[0], indices.size(),
-						&(*pcolors)[0],
-						ptexcoords ? &(*ptexcoords)[0] : NULL);
+						points.data(),  points.size(),
+						indices.data(), indices.size(),
+						pcolors->data(),
+						ptexcoords ? ptexcoords->data() : NULL);
 				}
 				else
 				{
 					draw_polygon(
 						painter, MODE_TRIANGLES, color,
-						&points[0],  points.size(),
-						&indices[0], indices.size(),
-						ptexcoords ? &(*ptexcoords)[0] : NULL);
+						points.data(),  points.size(),
+						indices.data(), indices.size(),
+						ptexcoords ? ptexcoords->data() : NULL);
 				}
 			}
 
@@ -227,7 +227,7 @@ namespace Rays
 				size_t index_offset = 0;
 				for (const auto& seg : segments)
 				{
-					Polyline polyline(&points[0] + seg.begin, seg.end - seg.begin);
+					Polyline polyline(points.data() + seg.begin, seg.end - seg.begin);
 					if (!seg.hole)
 					{
 						triangulate(polylines, index_offset);
@@ -902,7 +902,7 @@ namespace Rays
 					points.emplace_back(make_ellipse_point(
 						x, y, width, height, radian_from, radian_to, nsegment, seg));
 				}
-				append(Polyline(&points[0], points.size(), true));
+				append(Polyline(points.data(), points.size(), true));
 
 				if (has_hole)
 				{
@@ -916,7 +916,7 @@ namespace Rays
 							hole_x, hole_y, hole_size.x, hole_size.y,
 							radian_from, radian_to, nsegment, seg));
 					}
-					append(Polyline(&points[0], points.size(), true, NULL, NULL, true));
+					append(Polyline(points.data(), points.size(), true, NULL, NULL, true));
 				}
 			}
 
@@ -961,7 +961,7 @@ namespace Rays
 					}
 				}
 
-				append(Polyline(&points[0], points.size(), true));
+				append(Polyline(points.data(), points.size(), true));
 			}
 
 			Point make_ellipse_point (
@@ -1040,7 +1040,7 @@ namespace Rays
 			array.reserve(size + 1);
 			array.insert(array.begin(), points, points + size);
 			array.emplace_back(points[0]);
-			polygon->self->append(Polyline(&array[0], array.size(), true, false));
+			polygon->self->append(Polyline(array.data(), array.size(), true, false));
 		}
 #endif
 		return p;
@@ -1138,9 +1138,9 @@ namespace Rays
 		}
 
 		p.self->append(Polyline(
-			&points_[0], points_.size(), true,
-			pcolors_    ? &(*pcolors_)[0]    : NULL,
-			ptexcoords_ ? &(*ptexcoords_)[0] : NULL));
+			points_.data(), points_.size(), true,
+			pcolors_    ? pcolors_->data()    : NULL,
+			ptexcoords_ ? ptexcoords_->data() : NULL));
 		if (size >= 4)
 		{
 			p.self->append(Polyline(
@@ -1297,9 +1297,9 @@ namespace Rays
 		}
 
 		p.self->append(Polyline(
-			&points_[0], points_.size(), true,
-			pcolors_    ? &(*pcolors_)[0]    : NULL,
-			ptexcoords_ ? &(*ptexcoords_)[0] : NULL));
+			points_.data(), points_.size(), true,
+			pcolors_    ? pcolors_->data()    : NULL,
+			ptexcoords_ ? ptexcoords_->data() : NULL));
 		for (size_t i = 2; i < in_last; i += 2)
 		{
 			p.self->append(Polyline(
@@ -1410,7 +1410,7 @@ namespace Rays
 			}
 		}
 
-		return create_line(&result[0], result.size(), loop);
+		return create_line(result.data(), result.size(), loop);
 	}
 
 	Polygon
@@ -1632,7 +1632,7 @@ namespace Rays
 		for (const auto& polyline : lhs)
 			polylines.emplace_back(polyline);
 		polylines.emplace_back(rhs);
-		return Polygon(&polylines[0], polylines.size());
+		return Polygon(polylines.data(), polylines.size());
 	}
 
 	Polygon
@@ -1641,7 +1641,7 @@ namespace Rays
 		std::vector<Polyline> polylines;
 		for (const auto& polyline : lhs) polylines.emplace_back(polyline);
 		for (const auto& polyline : rhs) polylines.emplace_back(polyline);
-		return Polygon(&polylines[0], polylines.size());
+		return Polygon(polylines.data(), polylines.size());
 	}
 
 	Polygon

data/src/polyline.cpp

@@ -129,7 +129,7 @@ namespace Rays
 
 		Polyline pl;
 		pl.self->reset(
-			&cleaned[0], NULL, NULL, cleaned.size(), loop, loop, hole,
+			cleaned.data(), NULL, NULL, cleaned.size(), loop, loop, hole,
 			[](const IntPoint& point) {return from_clipper(point);});
 		return pl;
 	}
@@ -224,21 +224,21 @@ namespace Rays
 	Polyline::points () const
 	{
 		const auto& v = self->points;
-		return !v.empty() ? &v[0] : NULL;
+		return !v.empty() ? v.data() : NULL;
 	}
 
 	const Color*
 	Polyline::colors () const
 	{
 		const auto& pv = self->pcolors;
-		return pv && !pv->empty() ? &(*pv)[0] : NULL;
+		return pv && !pv->empty() ? pv->data() : NULL;
 	}
 
 	const Coord3*
 	Polyline::texcoords () const
 	{
 		const auto& pv = self->ptexcoords;
-		return pv && !pv->empty() ? &(*pv)[0] : NULL;
+		return pv && !pv->empty() ? pv->data() : NULL;
 	}
 
 	size_t

data/src/sdl/bitmap.cpp

@@ -6,6 +6,7 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include <stb_image_write.h>
 
+#include <memory>
 #include <SDL.h>
 #include <xot/util.h>
 #include "rays/exception.h"
@@ -157,11 +158,11 @@ namespace Rays
 		const auto& cs = bitmap.color_space();
 		int w          = bitmap.width();
 		int h          = bitmap.height();
-		int pitch      = w * cs.Bpp();
+		int row_size   = w * cs.Bpp();
 
-		std::unique_ptr<uchar[]> pixels(new uchar[h * pitch]);
+		std::unique_ptr<uchar[]> pixels(new uchar[h * row_size]);
 		for (int y = 0; y < h; ++y)
-			memcpy(pixels.get() + pitch * y, bitmap.at<uchar>(0, y), pitch);
+			memcpy(pixels.get() + row_size * y, bitmap.at<uchar>(0, y), row_size);
 
 		String ext = extension;
 		ext.downcase();
@@ -196,6 +197,10 @@ namespace Rays
 			p.end();
 			bmp = img.bitmap();
 		}
+
+		if (bmp.color_space().has_alpha())
+			bmp = bmp.dup(false);// stb_image_write expects straight alpha
+
 		save_bitmap(bmp, path);
 	}
 
@@ -206,16 +211,17 @@ namespace Rays
 			argument_error(__FILE__, __LINE__);
 
 		int w = 0, h = 0, Bpp = 0;
-		uchar* pixels = stbi_load(path, &w, &h, &Bpp, 0);
+		std::unique_ptr<uchar, decltype(&stbi_image_free)>
+			pixels(stbi_load(path, &w, &h, &Bpp, 0), stbi_image_free);
 		if (!pixels)
 			rays_error(__FILE__, __LINE__, "failed to load: '%s'", path);
 
 		ColorSpace cs;
 		switch (Bpp)
 		{
-			case 1: cs = GRAY_8;    break;
-			case 3: cs = RGB_888;   break;
-			case 4: cs = RGBA_8888; break;
+			case 1: cs = GRAY_8;  break;
+			case 3: cs = RGB_888; break;
+			case 4: cs = ColorSpace(RGBA_8888, false); break;// stb_image gives straight alpha
 			default:
 				rays_error(__FILE__, __LINE__, "unsupported image file: '%s'", path);
 		}
@@ -224,11 +230,11 @@ namespace Rays
 		if (!bmp)
 			rays_error(__FILE__, __LINE__, "failed to create Bitmap object");
 
-		int pitch = Bpp * w;
+		int size = Bpp * w;
 		for (int y = 0; y < h; ++y)
-			memcpy(bmp.at<uchar>(0, y), pixels + pitch * y, pitch);
+			memcpy(bmp.at<uchar>(0, y), pixels.get() + size * y, size);
 
-		return bmp;
+		return cs.has_alpha() ? bmp.dup(true) : bmp;
 	}