rays 0.1.6 → 0.1.7

data/src/{colorspace.cpp → color_space.cpp}

@@ -1,7 +1,9 @@
-#include "rays/colorspace.h"
+#include "rays/color_space.h"
 
 
+#include <assert.h>
 #include <xot/util.h>
+#include "rays/exception.h"
 
 
 namespace Rays
@@ -168,6 +170,41 @@ namespace Rays
 		return premult;
 	}
 
+	void
+	ColorSpace::get_gl_enums (GLenum* format, GLenum* type, bool alpha_only) const
+	{
+		if (!format && !type)
+			argument_error(__FILE__, __LINE__);
+
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (format)
+		{
+			     if (is_rgb())  *format = has_alpha() ? GL_RGBA  : GL_RGB;
+		#ifndef IOS
+			else if (is_bgr())  *format = has_alpha() ? GL_BGRA  : GL_BGR;
+		#endif
+			else if (is_gray()) *format = alpha_only  ? GL_ALPHA : GL_LUMINANCE;
+			else rays_error(__FILE__, __LINE__, "invalid color space.");
+		}
+
+		if (type)
+		{
+			if (is_float())
+				*type = GL_FLOAT;
+			else switch (bpc())
+			{
+				case 8:  *type = GL_UNSIGNED_BYTE; break;
+				case 16: *type = GL_UNSIGNED_SHORT; break;
+			#ifndef IOS
+				case 32: *type = GL_UNSIGNED_INT; break;
+			#endif
+				default: rays_error(__FILE__, __LINE__, "invalid bpc.");
+			}
+		}
+	}
+
 	ColorSpace::operator bool () const
 	{
 		return FIRST <= (int) type_ && (int) type_ <= LAST;

data/src/exception.cpp

@@ -1,34 +1,43 @@
 #include "rays/exception.h"
 
 
+#include "xot/string.h"
+
+
 namespace Rays
 {
 
 
-	RaysException::RaysException (const char* format, ...)
-	:	Super("")
+	RaysError::RaysError (const char* str)
+	:	Super(str)
 	{
-		XOT_STRINGF(format, s);
-		text = s;
 	}
 
-	RaysException::~RaysException () throw()
-	{
-	}
 
-	const char*
-	RaysException::what () const throw()
+	OpenGLError::OpenGLError (const char* str)
+	:	Super(str)
 	{
-		return text.c_str();
 	}
 
 
-	void
-	rays_error (const char* format, ...)
+	namespace ErrorFunctions
 	{
-		XOT_STRINGF(format, s);
-		throw RaysException(s.c_str());
-	}
+
+		void
+		rays_error (const char* file, int line, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw RaysError(Xot::error_text(file, line, s));
+		}
+
+		void
+		opengl_error (const char* file, int line, const char* format, ...)
+		{
+			XOT_STRINGF(format, s);
+			throw OpenGLError(Xot::error_text(file, line, s));
+		}
+
+	}// ErrorFunctions
 
 
 }// Rays

data/src/frame_buffer.cpp

@@ -0,0 +1,275 @@
+#include "frame_buffer.h"
+
+
+#include <vector>
+#include "rays/exception.h"
+#include "rays/texture.h"
+#include "rays/opengl.h"
+#include "render_buffer.h"
+
+
+namespace Rays
+{
+
+
+	struct FrameBuffer::Data
+	{
+
+		int id;
+
+		Texture texture;
+
+		RenderBuffer render_buffer;
+
+		Data ()
+		:	id(-1)
+		{
+		}
+
+		~Data ()
+		{
+			clear();
+		}
+
+		void create ()
+		{
+			if (is_valid()) return;
+
+			GLuint id_ = 0;
+			glGenFramebuffers(1, &id_);
+			check_error(__FILE__, __LINE__);
+
+			id = id_;
+		}
+
+		void clear ()
+		{
+			texture       = Texture();
+			render_buffer = RenderBuffer();
+
+			if (id >= 0)
+			{
+				GLenum id_ = id;
+				glDeleteFramebuffers(1, &id_);
+				check_error(__FILE__, __LINE__);
+			}
+
+			id = -1;
+		}
+
+		bool is_valid () const
+		{
+			return id >= 0;
+		}
+
+	};// FrameBuffer::Data
+
+
+	FrameBuffer::FrameBuffer ()
+	{
+	}
+
+	FrameBuffer::FrameBuffer (const Texture& texture)
+	{
+		attach(texture);
+	}
+
+	FrameBuffer::~FrameBuffer ()
+	{
+	}
+
+	static String
+	get_error_status_name (GLenum status)
+	{
+		switch (status)
+		{
+			#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";
+			#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";
+			#endif
+		}
+		return "UNKNOWN STATUS";
+	}
+
+	void
+	FrameBuffer::attach (const Texture& texture)
+	{
+		if (!texture)
+			argument_error(__FILE__, __LINE__, "FrameBuffer::attach(): invalid texture.");
+
+		self->create();
+
+		FrameBufferBinder binder(id());
+
+		glFramebufferTexture2D(
+			GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+			GL_TEXTURE_2D, texture.id(), 0);
+		check_error(__FILE__, __LINE__);
+
+		self->texture = texture;
+
+#if 0
+		int w = texture.width(), h = texture.height();
+		if (
+			w != self->render_buffer.width() ||
+			h != self->render_buffer.height())
+		{
+			RenderBuffer rb = RenderBuffer(w, h);
+
+			glFramebufferRenderbuffer(
+				GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+				GL_RENDERBUFFER, rb.id());
+			check_error(__FILE__, __LINE__);
+
+			self->render_buffer = rb;
+		}
+#endif
+
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		if (status != GL_FRAMEBUFFER_COMPLETE)
+		{
+			opengl_error(__FILE__, __LINE__,
+				"frame buffer status is %s", get_error_status_name(status).c_str());
+		}
+	}
+
+	GLuint
+	FrameBuffer::id () const
+	{
+		return self->id;
+	}
+
+	int
+	FrameBuffer::width () const
+	{
+		return self->texture.width();
+	}
+
+	int
+	FrameBuffer::height () const
+	{
+		return self->texture.height();
+	}
+
+	Texture&
+	FrameBuffer::texture ()
+	{
+		return self->texture;
+	}
+
+	const Texture&
+	FrameBuffer::texture () const
+	{
+		return const_cast<FrameBuffer*>(this)->texture();
+	}
+
+	FrameBuffer::operator bool () const
+	{
+		if (!self || !self->is_valid())
+			return false;
+
+		const Texture& t = self->texture;
+		if (!t)
+			return false;
+
+		const RenderBuffer& r = self->render_buffer;
+		if (r && (t.width() != r.width() || t.height() != r.height()))
+			return false;
+
+		return true;
+	}
+
+	bool
+	FrameBuffer::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	FrameBufferBinder::FrameBufferBinder (GLuint id)
+	:	id(id)
+	{
+		bind_frame_buffer(id);
+	}
+
+	FrameBufferBinder::~FrameBufferBinder ()
+	{
+		unbind_frame_buffer();
+	}
+
+	GLuint
+	FrameBufferBinder::current () const
+	{
+		return id;
+	}
+
+
+	struct FrameBufferID
+	{
+
+		GLuint draw, read;
+
+		FrameBufferID ()
+		:	draw(0), read(0)
+		{
+		}
+
+		FrameBufferID (GLuint draw, GLuint read)
+		:	draw(draw), read(read)
+		{
+		}
+
+	};// FrameBufferID
+
+	static std::vector<FrameBufferID> frame_buffer_bind_stack;
+
+
+	static void
+	bind_frame_buffer (GLuint draw, GLuint read)
+	{
+		FrameBufferID id;
+		glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*) &id.draw);
+		glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, (GLint*) &id.read);
+		check_error(__FILE__, __LINE__);
+
+		frame_buffer_bind_stack.push_back(id);
+
+		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);
+	}
+
+	void
+	unbind_frame_buffer ()
+	{
+		if (frame_buffer_bind_stack.empty())
+			rays_error(__FILE__, __LINE__, "frame_buffer_bind_stack is empty.");
+
+		FrameBufferID 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__);
+	}
+
+
+}// Rays

data/src/frame_buffer.h

@@ -0,0 +1,79 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_FRAME_BUFFER_H__
+#define __RAYS_FRAME_BUFFER_H__
+
+
+#include <xot/pimpl.h>
+#include <rays/defs.h>
+#include <rays/opengl.h>
+
+
+namespace Rays
+{
+
+
+	class Texture;
+
+
+	class FrameBuffer
+	{
+
+		public:
+
+			FrameBuffer ();
+
+			FrameBuffer (const Texture& texture);
+
+			~FrameBuffer ();
+
+			void attach (const Texture& texture);
+
+			GLuint id () const;
+
+			int width () const;
+
+			int height () const;
+
+			      Texture& texture ();
+
+			const Texture& texture () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PImpl<Data, true> self;
+
+	};// FrameBuffer
+
+
+	class FrameBufferBinder
+	{
+
+		public:
+
+			FrameBufferBinder (GLuint id);
+
+			~FrameBufferBinder ();
+
+			GLuint current () const;
+
+		private:
+
+			GLuint id;
+
+	};// FrameBufferBinder
+
+
+	void bind_frame_buffer (GLuint id);
+
+	void unbind_frame_buffer ();
+
+
+}// Rays
+
+
+#endif//EOH

data/src/image.cpp

@@ -1,8 +1,9 @@
 #include "rays/image.h"
 
 
-#include <rays/bitmap.h>
-#include <rays/texture.h>
+#include "rays/exception.h"
+#include "rays/bitmap.h"
+#include "rays/texture.h"
 
 
 namespace Rays
@@ -12,14 +13,18 @@ namespace Rays
 	struct Image::Data
 	{
 
-		Bitmap bitmap;
+		int width, height;
 
-		bool alphatex;
+		ColorSpace color_space;
+
+		bool alpha_only;
+
+		mutable Bitmap bitmap;
 
 		mutable Texture texture;
 
 		Data ()
-		:	alphatex(false)
+		:	width(0), height(0), alpha_only(false)
 		{
 		}
 
@@ -30,51 +35,81 @@ namespace Rays
 	{
 	}
 
-	Image::Image (
-		int width, int height, const ColorSpace& cs,
-		bool alphatex)
+	Image::Image (int width, int height, const ColorSpace& cs, bool alpha_only)
 	{
-		self->bitmap   = Bitmap(width, height, cs);
-		self->alphatex = alphatex;
+		self->width       = width;
+		self->height      = height;
+		self->color_space = cs;
+		self->alpha_only  = alpha_only;
 	}
 
-	Image::Image (const Bitmap& bitmap, bool alphatex)
+	Image::Image (const Bitmap& bitmap, bool alpha_only)
 	{
-		self->bitmap   = bitmap;
-		self->alphatex = alphatex;
+		self->width       = bitmap.width();
+		self->height      = bitmap.height();
+		self->color_space = bitmap.color_space();
+		self->alpha_only  = alpha_only;
+		self->bitmap      = bitmap;
 	}
 
 	Image::~Image ()
 	{
 	}
 
+	Image
+	Image::copy () const
+	{
+		return Image(width(), height(), color_space(), alpha_only());
+	}
+
+	Painter
+	Image::painter ()
+	{
+		Painter p;
+		p.bind(texture());
+		return p;
+	}
+
 	int
 	Image::width () const
 	{
-		return self->bitmap.width();
+		return self->width;
 	}
 
 	int
 	Image::height () const
 	{
-		return self->bitmap.height();
+		return self->height;
 	}
 
 	const ColorSpace&
 	Image::color_space () const
 	{
-		return self->bitmap.color_space();
+		return self->color_space;
 	}
 
 	bool
-	Image::alpha_texture () const
+	Image::alpha_only () const
 	{
-		return self->alphatex;
+		return self->alpha_only;
 	}
 
 	Bitmap&
 	Image::bitmap ()
 	{
+		if (!self->bitmap)
+		{
+			if (self->texture)
+				self->bitmap = Bitmap(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);
+
+		if (self->bitmap)  self->bitmap.set_dirty(false);
+		if (self->texture) self->texture.set_dirty(false);
+
 		return self->bitmap;
 	}
 
@@ -87,13 +122,27 @@ namespace Rays
 	Texture&
 	Image::texture ()
 	{
-		if (
-			self->bitmap &&
-			(!self->texture || self->bitmap.dirty()))
+		if (!self->texture)
 		{
-			self->texture = Texture(self->bitmap, self->alphatex);
-			self->bitmap.set_dirty(false);
+			if (self->bitmap)
+				self->texture = Texture(self->bitmap, self->alpha_only);
+			else
+			{
+				self->texture = Texture(
+					self->width, self->height, self->color_space, self->alpha_only);
+
+				Painter p;
+				p.bind(self->texture);
+				p.begin();
+				p.clear();
+				p.end();
+			}
 		}
+		else if (self->bitmap && !self->texture.dirty() && self->bitmap.dirty())
+			self->texture = Texture(self->bitmap, self->alpha_only);
+
+		if (self->bitmap)  self->bitmap.set_dirty(false);
+		if (self->texture) self->texture.set_dirty(false);
 
 		return self->texture;
 	}
@@ -106,7 +155,7 @@ namespace Rays
 
 	Image::operator bool () const
 	{
-		return !!self->bitmap;
+		return self->width > 0 && self->height > 0 && self->color_space;
 	}
 
 	bool
@@ -116,23 +165,18 @@ namespace Rays
 	}
 
 
-	bool
-	load_image (Image* image, const char* path, bool alphatex)
+	Image
+	load_image (const char* path, bool alphatex)
 	{
-		if (!image || !path) return false;
-
-		Bitmap bitmap;
-		if (!load_bitmap(&bitmap, path))
-			return false;
-
-		*image = Image(bitmap, alphatex);
-		return *image;
+		return Image(load_bitmap(path), alphatex);
 	}
 
-	bool
+	void
 	save_image (const Image& image, const char* path)
 	{
-		if (!image || !path) return false;
+		if (!image)
+			argument_error(__FILE__, __LINE__);
+
 		return save_bitmap(image.bitmap(), path);
 	}