rays 0.1.11 → 0.1.16

data/src/font.h

@@ -0,0 +1,64 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_FONT_H__
+#define __RAYS_SRC_FONT_H__
+
+
+#include <rays/defs.h>
+#include <rays/font.h>
+
+
+namespace Rays
+{
+
+
+	class RawFont
+	{
+
+		public:
+
+			RawFont ();
+
+			RawFont (const char* name, coord size = 0);
+
+			~RawFont ();
+
+			void draw_string (
+				void* context, coord context_height,
+				const char* str, coord x, coord y) const;
+
+			String name () const;
+
+			coord size () const;
+
+			coord get_width (const char* str) const;
+
+			coord get_height (
+				coord* ascent  = NULL,
+				coord* descent = NULL,
+				coord* leading = NULL) const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// RawFont
+
+
+	const RawFont& Font_get_raw (const Font& font, float pixel_density);
+
+	coord Font_get_width (const Font& font, float pixel_density, const char* str);
+
+	coord Font_get_height (
+		const Font& font, float pixel_density,
+		coord* ascent = NULL, coord* descent = NULL, coord* leading = NULL);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/frame_buffer.cpp

@@ -3,8 +3,8 @@
 
 #include <vector>
 #include "rays/exception.h"
-#include "rays/texture.h"
-#include "rays/opengl.h"
+#include "rays/debug.h"
+#include "texture.h"
 #include "render_buffer.h"
 
 
@@ -15,17 +15,12 @@ namespace Rays
 	struct FrameBuffer::Data
 	{
 
-		int id;
+		int id = -1;
 
 		Texture texture;
 
 		RenderBuffer render_buffer;
 
-		Data ()
-		:	id(-1)
-		{
-		}
-
 		~Data ()
 		{
 			clear();
@@ -37,7 +32,7 @@ namespace Rays
 
 			GLuint id_ = 0;
 			glGenFramebuffers(1, &id_);
-			check_error(__FILE__, __LINE__);
+			OpenGL_check_error(__FILE__, __LINE__);
 
 			id = id_;
 		}
@@ -51,7 +46,7 @@ namespace Rays
 			{
 				GLuint id_ = id;
 				glDeleteFramebuffers(1, &id_);
-				check_error(__FILE__, __LINE__);
+				OpenGL_check_error(__FILE__, __LINE__);
 			}
 
 			id = -1;
@@ -83,21 +78,17 @@ namespace Rays
 	{
 		switch (status)
 		{
+			case GL_FRAMEBUFFER_UNSUPPORTED:                   return "GL_FRAMEBUFFER_UNSUPPORTED";
+			case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:         return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+			case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+			case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:        return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
 			#ifdef IOS
-				case GL_FRAMEBUFFER_UNSUPPORTED_OES:                   return "GL_FRAMEBUFFER_UNSUPPORTED_OES";
-				case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES:         return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES";
-				case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES";
-				case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES:         return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES";
-				case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES:            return "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES";
+				case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
 			#else
-				case GL_FRAMEBUFFER_UNDEFINED:                     return "GL_FRAMEBUFFER_UNDEFINED";
-				case GL_FRAMEBUFFER_UNSUPPORTED:                   return "GL_FRAMEBUFFER_UNSUPPORTED";
-				case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:         return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
-				case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
-				case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:        return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
-				case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:        return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
-				case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:        return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
-				//case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:      return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS";
+				case GL_FRAMEBUFFER_UNDEFINED:                  return "GL_FRAMEBUFFER_UNDEFINED";
+				case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:     return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
+				case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:     return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
+				//case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:   return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS";
 			#endif
 		}
 		return "UNKNOWN STATUS";
@@ -114,14 +105,13 @@ namespace Rays
 		FrameBufferBinder binder(id());
 
 		glFramebufferTexture2D(
-			GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-			GL_TEXTURE_2D, texture.id(), 0);
-		check_error(__FILE__, __LINE__);
+			GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture.id(), 0);
+		OpenGL_check_error(__FILE__, __LINE__);
 
 		self->texture = texture;
 
 #if 0
-		int w = texture.width(), h = texture.height();
+		int w = texture.reserved_width(), h = texture.reserved_height();
 		if (
 			w != self->render_buffer.width() ||
 			h != self->render_buffer.height())
@@ -131,7 +121,7 @@ namespace Rays
 			glFramebufferRenderbuffer(
 				GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
 				GL_RENDERBUFFER, rb.id());
-			check_error(__FILE__, __LINE__);
+			OpenGL_check_error(__FILE__, __LINE__);
 
 			self->render_buffer = rb;
 		}
@@ -185,7 +175,9 @@ namespace Rays
 			return false;
 
 		const RenderBuffer& r = self->render_buffer;
-		if (r && (t.width() != r.width() || t.height() != r.height()))
+		int w                 = t.reserved_width();
+		int h                 = t.reserved_height();
+		if (r && (r.width() != w || r.height() != h))
 			return false;
 
 		return true;
@@ -201,12 +193,12 @@ namespace Rays
 	FrameBufferBinder::FrameBufferBinder (GLuint id)
 	:	id(id)
 	{
-		bind_frame_buffer(id);
+		FrameBuffer_bind(id);
 	}
 
 	FrameBufferBinder::~FrameBufferBinder ()
 	{
-		unbind_frame_buffer();
+		FrameBuffer_unbind();
 	}
 
 	GLuint
@@ -216,59 +208,33 @@ namespace Rays
 	}
 
 
-	struct FrameBufferID
-	{
-
-		GLuint draw, read;
-
-		FrameBufferID ()
-		:	draw(0), read(0)
-		{
-		}
-
-		FrameBufferID (GLuint draw, GLuint read)
-		:	draw(draw), read(read)
-		{
-		}
-
-	};// FrameBufferID
+	static std::vector<GLuint> frame_buffer_bind_stack;
 
-	static std::vector<FrameBufferID> frame_buffer_bind_stack;
 
-
-	static void
-	bind_frame_buffer (GLuint draw, GLuint read)
+	void
+	FrameBuffer_bind (GLuint id)
 	{
-		FrameBufferID id;
-		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*) &id.draw);
-		glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*) &id.read);
-		check_error(__FILE__, __LINE__);
+		GLuint current = 0;
+		glGetIntegerv(GL_FRAMEBUFFER_BINDING, (GLint*) &current);
+		OpenGL_check_error(__FILE__, __LINE__);
 
-		frame_buffer_bind_stack.push_back(id);
+		frame_buffer_bind_stack.push_back(current);
 
-		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw);
-		glBindFramebuffer(GL_READ_FRAMEBUFFER, read);
-		check_error(__FILE__, __LINE__);
-	}
-
-	void
-	bind_frame_buffer (GLuint id)
-	{
-		bind_frame_buffer(id, id);
+		glBindFramebuffer(GL_FRAMEBUFFER, id);
+		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
 	void
-	unbind_frame_buffer ()
+	FrameBuffer_unbind ()
 	{
 		if (frame_buffer_bind_stack.empty())
-			rays_error(__FILE__, __LINE__, "frame_buffer_bind_stack is empty.");
+			rays_error(__FILE__, __LINE__, "frame_buffer_bind_stack underflow.");
 
-		FrameBufferID id = frame_buffer_bind_stack.back();
+		GLuint id = frame_buffer_bind_stack.back();
 		frame_buffer_bind_stack.pop_back();
 
-		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, id.draw);
-		glBindFramebuffer(GL_READ_FRAMEBUFFER, id.read);
-		check_error(__FILE__, __LINE__);
+		glBindFramebuffer(GL_FRAMEBUFFER, id);
+		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
 

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 "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();
 	}