rays 0.1.12 → 0.1.13

data/src/frame_buffer.h

@@ -6,7 +6,7 @@
 
 #include <xot/pimpl.h>
 #include <rays/defs.h>
-#include <rays/opengl.h>
+#include "opengl.h"
 
 
 namespace Rays
@@ -45,7 +45,7 @@ namespace Rays
 
 			struct Data;
 
-			Xot::PImpl<Data, true> self;
+			Xot::PSharedImpl<Data> self;
 
 	};// FrameBuffer
 
@@ -68,9 +68,9 @@ namespace Rays
 	};// FrameBufferBinder
 
 
-	void bind_frame_buffer (GLuint id);
+	void FrameBuffer_bind (GLuint id);
 
-	void unbind_frame_buffer ();
+	void FrameBuffer_unbind ();
 
 
 }// Rays

data/src/image.cpp

@@ -1,9 +1,13 @@
 #include "rays/image.h"
 
 
+#include <math.h>
+#include <assert.h>
 #include "rays/exception.h"
-#include "rays/bitmap.h"
-#include "rays/texture.h"
+#include "rays/debug.h"
+#include "opengl.h"
+#include "bitmap.h"
+#include "texture.h"
 
 
 namespace Rays
@@ -13,171 +17,241 @@ namespace Rays
 	struct Image::Data
 	{
 
-		int width, height;
+		int width = 0, height = 0;
 
 		ColorSpace color_space;
 
-		bool alpha_only;
+		float pixel_density = 1;
 
 		mutable Bitmap bitmap;
 
 		mutable Texture texture;
 
-		Data ()
-		:	width(0), height(0), alpha_only(false)
-		{
-		}
-
 	};// Image::Data
 
 
-	Image::Image ()
+	static void
+	invalidate_texture (Image* image)
 	{
+		image->bitmap();// update bitmap
+		image->self->texture = Texture();
 	}
 
-	Image::Image (int width, int height, const ColorSpace& cs, bool alpha_only)
+	static void
+	invalidate_texture_for_another_context (Image* image)
 	{
-		self->width       = width;
-		self->height      = height;
-		self->color_space = cs;
-		self->alpha_only  = alpha_only;
-	}
+		assert(image);
 
-	Image::Image (const Bitmap& bitmap, bool alpha_only)
-	{
-		self->width       = bitmap.width();
-		self->height      = bitmap.height();
-		self->color_space = bitmap.color_space();
-		self->alpha_only  = alpha_only;
-		self->bitmap      = bitmap;
-	}
+		const Texture& tex = image->self->texture;
+		if (!tex) return;
 
-	Image::~Image ()
-	{
-	}
+		Context tex_context = tex.context();
+		if (!tex_context) return;
 
-	Image
-	Image::copy () const
-	{
-		return Image(width(), height(), color_space(), alpha_only());
-	}
+		Context current_context = OpenGL_get_context();
+		if (tex_context == current_context)
+			return;
 
-	Painter
-	Image::painter ()
-	{
-		Painter p;
-		p.bind(texture());
-		return p;
-	}
-
-	int
-	Image::width () const
-	{
-		return self->width;
+		OpenGL_set_context(tex_context);
+		invalidate_texture(image);
+		OpenGL_set_context(current_context);
 	}
 
-	int
-	Image::height () const
+	static Bitmap&
+	get_bitmap (Image& image)
 	{
-		return self->height;
-	}
+		Image::Data* self = image.self.get();
 
-	const ColorSpace&
-	Image::color_space () const
-	{
-		return self->color_space;
-	}
-
-	bool
-	Image::alpha_only () const
-	{
-		return self->alpha_only;
-	}
+		if (!image)
+		{
+			assert(!self->bitmap);
+			return self->bitmap;
+		}
 
-	Bitmap&
-	Image::bitmap ()
-	{
 		if (!self->bitmap)
 		{
 			if (self->texture)
-				self->bitmap = Bitmap(self->texture);
+				self->bitmap = Bitmap_from(self->texture);
 			else
 				self->bitmap = Bitmap(self->width, self->height, self->color_space);
 		}
-		else if (self->texture && !self->bitmap.dirty() && self->texture.dirty())
-			self->bitmap = Bitmap(self->texture);
+		else if (
+			self->texture &&
+			self->texture.modified() &&
+			!Bitmap_get_modified(self->bitmap))
+		{
+			self->bitmap = Bitmap_from(self->texture);
+		}
 
-		if (self->bitmap)  self->bitmap.set_dirty(false);
-		if (self->texture) self->texture.set_dirty(false);
+		if (self->bitmap)  Bitmap_set_modified(&self->bitmap, false);
+		if (self->texture) self->texture.set_modified(false);
 
 		return self->bitmap;
 	}
 
-	const Bitmap&
-	Image::bitmap () const
-	{
-		return const_cast<This*>(this)->bitmap();
-	}
-
 	Texture&
-	Image::texture ()
+	Image_get_texture (Image& image)
 	{
+		Image::Data* self = image.self.get();
+
+		if (!image)
+		{
+			assert(!self->texture);
+			return self->texture;
+		}
+
+		invalidate_texture_for_another_context(&image);
+
 		if (!self->texture)
 		{
 			if (self->bitmap)
-				self->texture = Texture(self->bitmap, self->alpha_only);
+				self->texture = Texture(self->bitmap);
 			else
 			{
-				self->texture = Texture(
-					self->width, self->height, self->color_space, self->alpha_only);
+				self->texture = Texture(self->width, self->height, self->color_space);
 
-				Painter p;
-				p.bind(self->texture);
+				Painter p = image.painter();
 				p.begin();
 				p.clear();
 				p.end();
 			}
 		}
-		else if (self->bitmap && !self->texture.dirty() && self->bitmap.dirty())
-			self->texture = Texture(self->bitmap, self->alpha_only);
+		else if (
+			self->bitmap &&
+			Bitmap_get_modified(self->bitmap) &&
+			!self->texture.modified())
+		{
+			self->texture = Texture(self->bitmap);
+		}
 
-		if (self->bitmap)  self->bitmap.set_dirty(false);
-		if (self->texture) self->texture.set_dirty(false);
+		if (self->bitmap)  Bitmap_set_modified(&self->bitmap, false);
+		if (self->texture) self->texture.set_modified(false);
 
 		return self->texture;
 	}
 
 	const Texture&
-	Image::texture () const
+	Image_get_texture (const Image& image)
 	{
-		return const_cast<This*>(this)->texture();
+		return Image_get_texture(const_cast<Image&>(image));
 	}
 
-	Image::operator bool () const
+	void
+	save_image (const Image& image, const char* path)
 	{
-		return self->width > 0 && self->height > 0 && self->color_space;
+		if (!image)
+			argument_error(__FILE__, __LINE__);
+
+		return Bitmap_save(image.bitmap(), path);
 	}
 
-	bool
-	Image::operator ! () const
+	Image
+	load_image (const char* path)
+	{
+		return Image(Bitmap_load(path));
+	}
+
+
+	Image::Image ()
 	{
-		return !operator bool();
 	}
 
+	Image::Image (
+		int width, int height, const ColorSpace& cs, float pixel_density)
+	{
+		if (pixel_density <= 0)
+			argument_error(__FILE__, __LINE__, "invalid pixel_density.");
+
+		coord w = width  * pixel_density;
+		coord h = height * pixel_density;
+		if ((w - (int) w) != 0 || (h - (int) h) != 0)
+			argument_error(__FILE__, __LINE__, "invalid size for image.");
+
+		self->width         = w;
+		self->height        = h;
+		self->color_space   = cs;
+		self->pixel_density = pixel_density;
+	}
+
+	Image::Image (const Bitmap& bitmap, float pixel_density)
+	{
+		if (pixel_density <= 0)
+			argument_error(__FILE__, __LINE__, "invalid pixel_density.");
+
+		self->bitmap        = bitmap;
+		self->width         = bitmap.width();
+		self->height        = bitmap.height();
+		self->color_space   = bitmap.color_space();
+		self->pixel_density = pixel_density;
+	}
+
+	Image::~Image ()
+	{
+	}
 
 	Image
-	load_image (const char* path, bool alphatex)
+	Image::dup () const
 	{
-		return Image(load_bitmap(path), alphatex);
+		return Image(bitmap().dup(), pixel_density());
 	}
 
-	void
-	save_image (const Image& image, const char* path)
+	coord
+	Image::width () const
 	{
-		if (!image)
-			argument_error(__FILE__, __LINE__);
+		return self->width / self->pixel_density;
+	}
 
-		return save_bitmap(image.bitmap(), path);
+	coord
+	Image::height () const
+	{
+		return self->height / self->pixel_density;
+	}
+
+	const ColorSpace&
+	Image::color_space () const
+	{
+		return self->color_space;
+	}
+
+	float
+	Image::pixel_density () const
+	{
+		return self->pixel_density;
+	}
+
+	Painter
+	Image::painter ()
+	{
+		Painter p;
+		p.bind(*this);
+		return p;
+	}
+
+	Bitmap&
+	Image::bitmap ()
+	{
+		return get_bitmap(*this);
+	}
+
+	const Bitmap&
+	Image::bitmap () const
+	{
+		return get_bitmap(const_cast<Image&>(*this));
+	}
+
+	Image::operator bool () const
+	{
+		return
+			self->width         > 0 &&
+			self->height        > 0 &&
+			self->pixel_density > 0 &&
+			self->color_space;
+	}
+
+	bool
+	Image::operator ! () const
+	{
+		return !operator bool();
 	}
 
 

data/src/image.h

@@ -0,0 +1,25 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_IMAGE_H__
+#define __RAYS_SRC_IMAGE_H__
+
+
+#include <rays/image.h>
+
+
+namespace Rays
+{
+
+
+	class Texture;
+
+
+	      Texture& Image_get_texture (      Image& image);
+
+	const Texture& Image_get_texture (const Image& image);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/ios/bitmap.mm

@@ -1,13 +1,13 @@
 // -*- objc -*-
-#import "rays/bitmap.h"
+#import "../bitmap.h"
 
 
-#include <assert.h>
-#include <boost/scoped_array.hpp>
-#import <ImageIO/ImageIO.h>
+#import <ImageIO/CGImageDestination.h>
 #import <MobileCoreServices/UTCoreTypes.h>
 #include "rays/exception.h"
-#include "rays/texture.h"
+#include "../color_space.h"
+#include "../font.h"
+#include "../texture.h"
 #include "../frame_buffer.h"
 #include "helper.h"
 
@@ -60,14 +60,13 @@ namespace Rays
 
 		ColorSpace color_space;
 
-		void* pixels;
+		void* pixels = NULL;
 
-		CGContextRef context;
+		CGContextRef context = NULL;
 
-		bool dirty;
+		bool modified;
 
 		Data ()
-		:	pixels(NULL), context(NULL)
 		{
 			clear();
 		}
@@ -86,7 +85,7 @@ namespace Rays
 			if (bpc <= 0 || pitch <= 0) return NULL;
 
 			CGColorSpaceRef cgcs = NULL;
-			if (color_space.is_gray())
+			if (color_space.is_gray() || color_space.is_alpha())
 				cgcs = CGColorSpaceCreateDeviceGray();
 			else if (color_space.is_rgb() || color_space.is_bgr())
 				cgcs = CGColorSpaceCreateDeviceRGB();
@@ -115,7 +114,7 @@ namespace Rays
 			color_space = COLORSPACE_UNKNOWN;
 			pixels      = NULL;
 			context     = NULL;
-			dirty       = false;
+			modified    = false;
 		}
 
 	};// Bitmap::Data
@@ -135,7 +134,7 @@ namespace Rays
 		this_->self->width       = w;
 		this_->self->height      = h;
 		this_->self->color_space = cs;
-		this_->self->dirty       = true;
+		this_->self->modified    = true;
 
 		size_t size = w * h * cs.Bpp();
 		this_->self->pixels = new uchar[size];
@@ -152,16 +151,108 @@ namespace Rays
 		if (!this_ || !tex)
 			argument_error(__FILE__, __LINE__);
 
-		setup_bitmap(this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
+		setup_bitmap(
+			this_, tex.width(), tex.height(), tex.color_space(), NULL, false);
 
 		GLenum format, type;
-		tex.color_space().get_gl_enums(&format, &type, tex.alpha_only());
+		ColorSpace_get_gl_format_and_type(&format, &type, tex.color_space());
 
 		FrameBuffer fb(tex);
 		FrameBufferBinder binder(fb.id());
 
 		for (int y = 0; y < this_->height(); ++y)
-			glReadPixels(0, y, this_->width(), 1, format, type, (GLvoid*) this_->at<uchar>(0, y));
+		{
+			GLvoid* ptr = (GLvoid*) this_->at<uchar>(0, y);
+			glReadPixels(0, y, this_->width(), 1, format, type, ptr);
+		}
+	}
+
+	Bitmap
+	Bitmap_from (const Texture& texture)
+	{
+		Bitmap bmp;
+		setup_bitmap(&bmp, texture);
+		return bmp;
+	}
+
+	void
+	Bitmap_draw_string (
+		Bitmap* bitmap, const RawFont& font, const char* str, coord x, coord y)
+	{
+		if (!bitmap || !*bitmap || !font || !str)
+			argument_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return;
+
+		font.draw_string(bitmap->self->get_context(), bitmap->height(), str, x, y);
+		Bitmap_set_modified(bitmap);
+	}
+
+	void
+	Bitmap_set_modified (Bitmap* bitmap, bool modified)
+	{
+		assert(bitmap);
+
+		bitmap->self->modified = modified;
+	}
+
+	bool
+	Bitmap_get_modified (const Bitmap& bitmap)
+	{
+		return bitmap.self->modified;
+	}
+
+	void
+	Bitmap_save (const Bitmap& bmp, const char* path_)
+	{
+		std::shared_ptr<CGImage> img(bmp.self->get_image(), CGImageRelease);
+		if (!img)
+			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		NSURL* url = [NSURL fileURLWithPath: path];
+		if (!url)
+			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
+
+		std::shared_ptr<CGImageDestination> dest(
+			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
+			safe_cfrelease);
+		if (!dest)
+			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
+
+		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
+		if (!CGImageDestinationFinalize(dest.get()))
+			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
+	}
+
+	Bitmap
+	Bitmap_load (const char* path_)
+	{
+		if (!path_ || path_[0] == '\0')
+			argument_error(__FILE__, __LINE__);
+
+		NSString* path = [NSString stringWithUTF8String: path_];
+		UIImage* uiimage = [UIImage imageWithContentsOfFile: path];
+		if (!uiimage)
+			rays_error(__FILE__, __LINE__, "[UIImage imageWithContentsOfFile:] failed.");
+
+		CGImageRef image = [uiimage CGImage];
+		if (!image)
+			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
+
+		size_t width  = CGImageGetWidth(image);
+		size_t height = CGImageGetHeight(image);
+
+		Bitmap bmp((int) width, (int) height, RGBA);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "invalid bitmap.");
+
+		CGContextRef context = bmp.self->get_context();
+		if (!context)
+			rays_error(__FILE__, __LINE__, "creating CGContext failed.");
+
+		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
+		return bmp;
 	}
 
 
@@ -175,17 +266,12 @@ namespace Rays
 		setup_bitmap(this, width, height, color_space, pixels);
 	}
 
-	Bitmap::Bitmap (const Texture& texture)
-	{
-		setup_bitmap(this, texture);
-	}
-
 	Bitmap::~Bitmap ()
 	{
 	}
 
 	Bitmap
-	Bitmap::copy () const
+	Bitmap::dup () const
 	{
 		return Bitmap(width(), height(), color_space(), pixels());
 	}
@@ -240,18 +326,6 @@ namespace Rays
 		return const_cast<This*>(this)->pixels();
 	}
 
-	bool
-	Bitmap::dirty () const
-	{
-		return self->dirty;
-	}
-
-	void
-	Bitmap::set_dirty (bool b)
-	{
-		self->dirty = b;
-	}
-
 	Bitmap::operator bool () const
 	{
 		return
@@ -265,76 +339,4 @@ namespace Rays
 	}
 
 
-	Bitmap
-	load_bitmap (const char* path_)
-	{
-		if (!path_ || path_[0] == '\0')
-			argument_error(__FILE__, __LINE__);
-
-		NSString* path = [NSString stringWithUTF8String: path_];
-		UIImage* uiimage = [UIImage imageWithContentsOfFile: path];
-		if (!uiimage)
-			rays_error(__FILE__, __LINE__, "[UIImage imageWithContentsOfFile:] failed.");
-
-		CGImageRef image = [uiimage CGImage];
-		if (!image)
-			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
-
-		size_t width  = CGImageGetWidth(image);
-		size_t height = CGImageGetHeight(image);
-
-		Bitmap bmp((int) width, (int) height, RGBA);
-		if (!bmp)
-			rays_error(__FILE__, __LINE__, "invalid bitmap.");
-
-		CGContextRef context = bmp.self->get_context();
-		if (!context)
-			rays_error(__FILE__, __LINE__, "creating CGContext failed.");
-
-		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
-		return bmp;
-	}
-
-	void
-	save_bitmap (const Bitmap& bmp, const char* path_)
-	{
-		boost::shared_ptr<CGImage> img(
-			bmp.self->get_image(), CGImageRelease);
-		if (!img)
-			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
-
-		NSString* path = [NSString stringWithUTF8String: path_];
-		NSURL* url = [NSURL fileURLWithPath: path];
-		if (!url)
-			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
-
-		boost::shared_ptr<CGImageDestination> dest(
-			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
-			safe_cfrelease);
-		if (!dest)
-			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
-
-		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
-		if (!CGImageDestinationFinalize(dest.get()))
-			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
-	}
-
-
-	void draw_string (
-		CGContextRef, coord, const char*, coord, coord, const Font&);
-
-	void
-	draw_string (
-		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
-	{
-		if (!bmp || !*bmp || !str || !font)
-			argument_error(__FILE__, __LINE__);
-
-		if (*str == '\0') return;
-
-		draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font);
-		bmp->set_dirty();
-	}
-
-
 }// Rays