rays 0.4.0 → 0.5.0

data/src/font.cpp

@@ -3,6 +3,8 @@
 
 #include <string.h>
 #include <assert.h>
+#include <algorithm>
+#include "rays/exception.h"
 
 
 namespace Rays
@@ -12,53 +14,109 @@ namespace Rays
 	struct Font::Data
 	{
 
-		RawFont rawfont;
+		String name, path;
+
+		coord size  = 0;
+
+		int weight  = Font::DEFAULT_WEIGHT;
+
+		bool italic = false;
 
 		bool smooth = true;
 
+		RawFont rawfont;
+
 		mutable RawFont rawfont_for_pixel_density;
 
 		mutable float for_pixel_density = 1;
 
-		const RawFont& get_raw (float pixel_density) const
+		RawFont make_rawfont (coord size) const
 		{
-			assert(pixel_density > 0);
-
-			if (!rawfont || pixel_density == 1)
-				return rawfont;
+			if (!path.empty())
+				return RawFont_load(path.c_str(), size);
+			else
+				return RawFont(name.empty() ? NULL : name.c_str(), size, weight, italic);
+		}
 
-			if (pixel_density != for_pixel_density)
-			{
-				rawfont_for_pixel_density =
-					RawFont(rawfont, rawfont.size() * pixel_density);
-				for_pixel_density = pixel_density;
-			}
+		void remake_rawfont ()
+		{
+			if (!rawfont) return;
 
-			return rawfont_for_pixel_density;
+			rawfont           = make_rawfont(size);
+			for_pixel_density = 1;// drop the cache
 		}
 
 	};// Font::Data
 
 
+	static int
+	clamp_weight (int weight)
+	{
+		return std::clamp(weight, (int) Font::WEIGHT_MIN, (int) Font::WEIGHT_MAX);
+	}
+
 	Font
 	load_font (const char* path, coord size)
 	{
 		Font font;
+		font.self->path    = path ? path : "";
+		font.self->size    = size;
 		font.self->rawfont = RawFont_load(path, size);
 		return font;
 	}
 
-	const Font&
+	static constexpr const char* NULL_NAME = "";
+
+	Font
 	get_default_font ()
 	{
-		static const Font FONT(NULL);
-		return FONT;
+		static const Font FONT(NULL_NAME);
+		return FONT.dup();
 	}
 
 	const RawFont&
 	Font_get_raw (const Font& font, float pixel_density)
 	{
-		return font.self->get_raw(pixel_density);
+		if (pixel_density <= 0)
+			argument_error(__FILE__, __LINE__);
+
+		Font::Data* self = font.self.get();
+
+		if (!self->rawfont || pixel_density == 1)
+			return self->rawfont;
+
+		if (pixel_density != self->for_pixel_density)
+		{
+			self->rawfont_for_pixel_density = self->make_rawfont(self->size * pixel_density);
+			self->for_pixel_density         = pixel_density;
+		}
+
+		return self->rawfont_for_pixel_density;
+	}
+
+	bool
+	Font_has_same_attributes (
+		const Font& font, const char* name, coord size,
+		int weight, bool italic, bool smooth)
+	{
+		if (!font.self->path.empty())
+			return false;
+
+		weight = clamp_weight(weight);
+
+		if (
+			size   != font.size()   ||
+			weight != font.weight() ||
+			italic != font.italic() ||
+			smooth != font.smooth())
+		{
+			return false;
+		}
+
+		if (!name)
+			name = NULL_NAME;
+
+		return name == font.name(false) || name == font.name(true);
 	}
 
 
@@ -66,10 +124,14 @@ namespace Rays
 	{
 	}
 
-	Font::Font (const char* name, coord size, bool smooth)
+	Font::Font (const char* name, coord size, int weight, bool italic, bool smooth)
 	{
-		self->rawfont = RawFont(name, size);
+		self->name    = name ? name : NULL_NAME;
+		self->size    = size;
+		self->weight  = clamp_weight(weight);
+		self->italic  = italic;
 		self->smooth  = smooth;
+		self->rawfont = self->make_rawfont(size);
 	}
 
 	Font::~Font ()
@@ -80,27 +142,61 @@ namespace Rays
 	Font::dup () const
 	{
 		Font f;
-		f.self->rawfont = RawFont(self->rawfont, self->rawfont.size());
-		f.self->smooth  = self->smooth;
+		*f.self = *self;
 		return f;
 	}
 
 	String
-	Font::name () const
+	Font::name (bool resolved) const
 	{
-		return self->rawfont.name();
+		return resolved || self->name.empty() ? self->rawfont.name() : self->name;
 	}
 
 	void
 	Font::set_size (coord size)
 	{
-		self->rawfont = RawFont(self->rawfont, size);
+		if (size == self->size) return;
+
+		self->size = size;
+		self->remake_rawfont();
 	}
 
 	coord
 	Font::size () const
 	{
-		return self->rawfont.size();
+		return self->size;
+	}
+
+	void
+	Font::set_weight (int weight)
+	{
+		weight = clamp_weight(weight);
+
+		if (weight == self->weight) return;
+
+		self->weight = weight;
+		self->remake_rawfont();
+	}
+
+	int
+	Font::weight () const
+	{
+		return self->weight;
+	}
+
+	void
+	Font::set_italic (bool italic)
+	{
+		if (italic == self->italic) return;
+
+		self->italic = italic;
+		self->remake_rawfont();
+	}
+
+	bool
+	Font::italic () const
+	{
+		return self->italic;
 	}
 
 	void

data/src/font.h

@@ -21,9 +21,9 @@ namespace Rays
 
 			RawFont ();
 
-			RawFont (const char* name, coord size);
-
-			RawFont (const This& obj, coord size);
+			RawFont (
+				const char* name, coord size,
+				int weight = Font::DEFAULT_WEIGHT, bool italic = false);
 
 			~RawFont ();
 
@@ -33,8 +33,6 @@ namespace Rays
 
 			String name () const;
 
-			coord size () const;
-
 			coord get_width (const char* str) const;
 
 			coord get_height (
@@ -55,6 +53,10 @@ namespace Rays
 
 	const RawFont& Font_get_raw (const Font& font, float pixel_density);
 
+	bool Font_has_same_attributes (
+		const Font& font, const char* name, coord size,
+		int weight, bool italic, bool smooth);
+
 
 	RawFont RawFont_load (const char* path, coord size);
 

data/src/image.cpp

@@ -3,6 +3,7 @@
 
 #include <math.h>
 #include <assert.h>
+#include <memory>
 #include "rays/exception.h"
 #include "rays/debug.h"
 #include "bitmap.h"
@@ -10,7 +11,7 @@
 
 
 #if 0
-#define PRINT_MODIFIED_FLAGS(message) get_data(this)->print_modified_flags(message)
+#define PRINT_MODIFIED_FLAGS(message) self->print_modified_flags(message)
 #else
 #define PRINT_MODIFIED_FLAGS(message)
 #endif
@@ -20,7 +21,19 @@ namespace Rays
 {
 
 
-	struct ImageData : Image::Data
+	struct Pixels
+	{
+
+		typedef std::shared_ptr<Pixels> Ptr;
+
+		mutable Bitmap bitmap;
+
+		mutable Texture texture;
+
+	};// Pixels
+
+
+	struct Image::Data
 	{
 
 		int width = 0, height = 0;
@@ -31,50 +44,52 @@ namespace Rays
 
 		ColorSpace color_space;
 
-		mutable Bitmap bitmap;
+		Pixels::Ptr pixels;
 
-		mutable Texture texture;
+		std::unique_ptr<Image::Loader> loader;
+
+		Data ()
+		:	pixels(new Pixels())
+		{
+		}
 
 		void print_modified_flags (const char* message)
 		{
 			printf("%s: %d %d %d %d \n",
 				message,
-				bitmap ? 1 : 0,
-				Bitmap_get_modified(bitmap) ? 1 : 0,
-				texture ? 1 : 0,
-				texture.modified() ? 1 : 0);
+				pixels->bitmap ? 1 : 0,
+				Bitmap_get_modified(pixels->bitmap) ? 1 : 0,
+				pixels->texture ? 1 : 0,
+				pixels->texture.modified() ? 1 : 0);
 		}
 
 	};// Image::Data
 
 
-	static ImageData*
-	get_data (Image* image)
-	{
-		return (ImageData*) image->self.get();
-	}
-
-	static const ImageData*
-	get_data (const Image* image)
-	{
-		return (const ImageData*) image->self.get();
-	}
-
-
 	static void
 	clear_modified_flags (Image* image)
 	{
-		ImageData* self = get_data(image);
+		Pixels* pixels = image->self->pixels.get();
 
-		if (self->bitmap)  Bitmap_set_modified(&self->bitmap, false);
-		if (self->texture) self->texture.set_modified(false);
+		if (pixels->bitmap)
+			Bitmap_set_modified(&pixels->bitmap, false);
+
+		if (pixels->texture)
+			pixels->texture.set_modified(false);
 	}
 
 	static void
 	invalidate_texture (Image* image)
 	{
 		image->bitmap();// update bitmap
-		get_data(image)->texture = Texture();
+		image->self->pixels->texture = Texture();
+	}
+
+	static void
+	check_writable (const Image* image)
+	{
+		if (image->self->loader)
+			invalid_state_error(__FILE__, __LINE__, "image is read-only");
 	}
 
 	static Bitmap&
@@ -82,31 +97,32 @@ namespace Rays
 	{
 		assert(image);
 
-		ImageData* self = get_data(image);
+		Image::Data* self = image->self.get();
+		Pixels* pixels    = self->pixels.get();
 
 		if (!*image)
 		{
-			assert(!self->bitmap);
-			return self->bitmap;
+			assert(!pixels->bitmap);
+			return pixels->bitmap;
 		}
 
-		if (!self->bitmap)
+		if (!pixels->bitmap)
 		{
-			if (self->texture)
+			if (pixels->texture)
 			{
 				PRINT_MODIFIED_FLAGS("new bitmap from texture");
-				self->bitmap = Bitmap_from(self->texture);
+				pixels->bitmap = Bitmap_from(pixels->texture);
 			}
 			else
 			{
 				PRINT_MODIFIED_FLAGS("new bitmap");
-				self->bitmap = Bitmap(self->width, self->height, self->color_space);
+				pixels->bitmap = Bitmap(self->width, self->height, self->color_space);
 			}
 			clear_modified_flags(image);
 		}
-		else if (self->texture && self->texture.modified())
+		else if (pixels->texture && pixels->texture.modified())
 		{
-			if (Bitmap_get_modified(self->bitmap))
+			if (Bitmap_get_modified(pixels->bitmap))
 			{
 				invalid_state_error(
 					__FILE__, __LINE__, "bitmap and texture modifications conflicted");
@@ -114,36 +130,42 @@ namespace Rays
 			else
 			{
 				PRINT_MODIFIED_FLAGS("bitmap from texture");
-				self->bitmap = Bitmap_from(self->texture);
+				pixels->bitmap = Bitmap_from(pixels->texture);
 				clear_modified_flags(image);
 			}
 		}
 
-		return self->bitmap;
+		if (self->loader && self->loader->load(&pixels->bitmap))
+			Bitmap_set_modified(&pixels->bitmap);
+
+		return pixels->bitmap;
 	}
 
 	Texture&
 	Image_get_texture (Image& image)
 	{
-		ImageData* self = get_data(&image);
+		Image::Data* self = image.self.get();
+		Pixels* pixels    = self->pixels.get();
 
 		if (!image)
 		{
-			assert(!self->texture);
-			return self->texture;
+			assert(!pixels->texture);
+			return pixels->texture;
 		}
 
-		if (!self->texture)
+		if (self->loader) get_bitmap(&image);
+
+		if (!pixels->texture)
 		{
-			if (self->bitmap)
+			if (pixels->bitmap)
 			{
 				PRINT_MODIFIED_FLAGS("new texture from bitmap");
-				self->texture = Texture(self->bitmap, self->smooth);
+				pixels->texture = Texture(pixels->bitmap, self->smooth);
 			}
 			else
 			{
 				PRINT_MODIFIED_FLAGS("new texture");
-				self->texture = Texture(
+				pixels->texture = Texture(
 					self->width, self->height, self->color_space, self->smooth);
 
 				Painter p = image.painter();
@@ -153,9 +175,9 @@ namespace Rays
 			}
 			clear_modified_flags(&image);
 		}
-		else if (self->bitmap && Bitmap_get_modified(self->bitmap))
+		else if (pixels->bitmap && Bitmap_get_modified(pixels->bitmap))
 		{
-			if (self->texture.modified())
+			if (pixels->texture.modified())
 			{
 				invalid_state_error(
 					__FILE__, __LINE__, "texture and bitmap modifications conflicted");
@@ -163,12 +185,12 @@ namespace Rays
 			else
 			{
 				PRINT_MODIFIED_FLAGS("texture from bitmap");
-				self->texture = self->bitmap;
+				pixels->texture = pixels->bitmap;
 				clear_modified_flags(&image);
 			}
 		}
 
-		return self->texture;
+		return pixels->texture;
 	}
 
 	const Texture&
@@ -184,30 +206,22 @@ namespace Rays
 	}
 
 
-	Image::Data::~Data ()
-	{
-	}
-
-	void
-	Image::Data::preprocess (const Image*) const
+	Image::Loader::~Loader ()
 	{
 	}
 
 
 	Image::Image ()
-	:	self(new ImageData())
 	{
 	}
 
 	Image::Image (
 		int width, int height, const ColorSpace& cs,
 		float pixel_density, bool smooth)
-	:	self(new ImageData())
 	{
 		if (pixel_density <= 0)
 			argument_error(__FILE__, __LINE__, "invalid pixel_density.");
 
-		ImageData* self     = get_data(this);
 		self->width         = (int) (width  * pixel_density);
 		self->height        = (int) (height * pixel_density);
 		self->color_space   = cs;
@@ -216,23 +230,33 @@ namespace Rays
 	}
 
 	Image::Image (const Bitmap& bitmap, float pixel_density, bool smooth)
-	:	self(new ImageData())
 	{
 		if (pixel_density <= 0)
 			argument_error(__FILE__, __LINE__, "invalid pixel_density.");
 
-		ImageData* self     = get_data(this);
-		self->bitmap        = bitmap;
-		self->width         = bitmap.width();
-		self->height        = bitmap.height();
-		self->color_space   = bitmap.color_space();
-		self->pixel_density = pixel_density;
-		self->smooth        = smooth;
+		self->pixels->bitmap = bitmap;
+		self->width          = bitmap.width();
+		self->height         = bitmap.height();
+		self->color_space    = bitmap.color_space();
+		self->pixel_density  = pixel_density;
+		self->smooth         = smooth;
 	}
 
-	Image::Image (Data* data)
-	:	self(data)
+	Image::Image (const Image& pixels, Loader* loader)
 	{
+		std::unique_ptr<Loader> loader_(loader);
+		if (!loader)
+			argument_error(__FILE__, __LINE__, "loader is NULL.");
+		if (!pixels)
+			argument_error(__FILE__, __LINE__, "invalid pixels image.");
+
+		self->width         = pixels.self->width;
+		self->height        = pixels.self->height;
+		self->color_space   = pixels.self->color_space;
+		self->pixel_density = pixels.self->pixel_density;
+		self->smooth        = pixels.self->smooth;
+		self->pixels        = pixels.self->pixels;
+		self->loader        = std::move(loader_);
 	}
 
 	Image::~Image ()
@@ -242,16 +266,12 @@ namespace Rays
 	Image
 	Image::dup () const
 	{
-		self->preprocess(this);
-
 		return Image(bitmap().dup(), pixel_density());
 	}
 
 	void
 	Image::save (const char* path)
 	{
-		self->preprocess(this);
-
 		if (!*this)
 			invalid_state_error(__FILE__, __LINE__);
 
@@ -261,45 +281,31 @@ namespace Rays
 	coord
 	Image::width () const
 	{
-		self->preprocess(this);
-
-		const ImageData* self = get_data(this);
 		return self->width / self->pixel_density;
 	}
 
 	coord
 	Image::height () const
 	{
-		self->preprocess(this);
-
-		const ImageData* self = get_data(this);
 		return self->height / self->pixel_density;
 	}
 
 	const ColorSpace&
 	Image::color_space () const
 	{
-		self->preprocess(this);
-
-		const ImageData* self = get_data(this);
 		return self->color_space;
 	}
 
 	float
 	Image::pixel_density () const
 	{
-		self->preprocess(this);
-
-		const ImageData* self = get_data(this);
 		return self->pixel_density;
 	}
 
 	void
 	Image::set_smooth (bool smooth)
 	{
-		self->preprocess(this);
-
-		ImageData* self = get_data(this);
+		check_writable(this);
 
 		if (smooth == self->smooth) return;
 		self->smooth = smooth;
@@ -309,16 +315,13 @@ namespace Rays
 	bool
 	Image::smooth () const
 	{
-		self->preprocess(this);
-
-		const ImageData* self = get_data(this);
 		return self->smooth;
 	}
 
 	Painter
 	Image::painter ()
 	{
-		self->preprocess(this);
+		check_writable(this);
 
 		Painter p;
 		p.bind(*this);
@@ -328,15 +331,11 @@ namespace Rays
 	Bitmap&
 	Image::bitmap (bool modify)
 	{
-		self->preprocess(this);
+		if (modify) check_writable(this);
 
-		ImageData* self = get_data(this);
-		if (modify)
-		{
-			if (!self->bitmap) get_bitmap(this);
-			Bitmap_set_modified(&self->bitmap);
-		}
-		return get_bitmap(this);
+		Bitmap& bitmap = get_bitmap(this);
+		if (modify) Bitmap_set_modified(&bitmap);
+		return bitmap;
 	}
 
 	const Bitmap&
@@ -345,11 +344,14 @@ namespace Rays
 		return const_cast<Image*>(this)->bitmap();
 	}
 
-	Image::operator bool () const
+	const Image::Loader*
+	Image::loader () const
 	{
-		self->preprocess(this);
+		return self->loader.get();
+	}
 
-		const ImageData* self = get_data(this);
+	Image::operator bool () const
+	{
 		return
 			self->width         > 0 &&
 			self->height        > 0 &&