rays 0.1.12 → 0.1.13

data/src/color_space.h

@@ -0,0 +1,22 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_COLOR_SPACE_H__
+#define __RAYS_SRC_COLOR_SPACE_H__
+
+
+#include <rays/color_space.h>
+#include "opengl.h"
+
+
+namespace Rays
+{
+
+
+	void ColorSpace_get_gl_format_and_type (
+		GLenum* format, GLenum* type, const ColorSpace& cs);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/coord.cpp

@@ -0,0 +1,170 @@
+#include "coord.h"
+
+
+#include <xot/string.h>
+#include "rays/exception.h"
+
+
+namespace Rays
+{
+
+
+	Coord2&
+	Coord2::reset (coord value)
+	{
+		return reset(value, value);
+	}
+
+	Coord2&
+	Coord2::reset (coord x, coord y)
+	{
+		this->x = x;
+		this->y = y;
+		return *this;
+	}
+
+	size_t
+	Coord2::size () const
+	{
+		return SIZE;
+	}
+
+	String
+	Coord2::inspect () const
+	{
+		return Xot::stringf("x=%f y=%f", x, y);
+	}
+
+	coord&
+	Coord2::operator [] (size_t index)
+	{
+		if (index >= 2)
+			argument_error(__FILE__, __LINE__);
+
+		return array[index];
+	}
+
+	const coord&
+	Coord2::operator [] (size_t index) const
+	{
+		return const_cast<Coord2*>(this)->operator[](index);
+	}
+
+
+	Coord3&
+	Coord3::operator = (const Coord2& rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = 0;
+		return *this;
+	}
+
+	Coord3&
+	Coord3::reset (coord value)
+	{
+		return reset(value, value);
+	}
+
+	Coord3&
+	Coord3::reset (coord x, coord y, coord z)
+	{
+		this->x = x;
+		this->y = y;
+		this->z = z;
+		return *this;
+	}
+
+	size_t
+	Coord3::size () const
+	{
+		return SIZE;
+	}
+
+	String
+	Coord3::inspect () const
+	{
+		return Xot::stringf("x=%f y=%f z=%f", x, y, z);
+	}
+
+	coord&
+	Coord3::operator [] (size_t index)
+	{
+		if (index >= 3)
+			argument_error(__FILE__, __LINE__);
+
+		return array[index];
+	}
+
+	const coord&
+	Coord3::operator [] (size_t index) const
+	{
+		return const_cast<Coord3*>(this)->operator[](index);
+	}
+
+
+	Coord4&
+	Coord4::operator = (const Coord2& rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = 0;
+		w = 1;
+		return *this;
+	}
+
+	Coord4&
+	Coord4::operator = (const Coord3& rhs)
+	{
+		x = rhs.x;
+		y = rhs.y;
+		z = rhs.z;
+		w = 1;
+		return *this;
+	}
+
+	Coord4&
+	Coord4::reset (coord value)
+	{
+		return reset(value, value, value);
+	}
+
+	Coord4&
+	Coord4::reset (coord x, coord y, coord z, coord w)
+	{
+		this->x = x;
+		this->y = y;
+		this->z = z;
+		this->w = w;
+		return *this;
+	}
+
+	size_t
+	Coord4::size () const
+	{
+		return SIZE;
+	}
+
+	String
+	Coord4::inspect () const
+	{
+		return Xot::stringf("x=%f y=%f z=%f w=%f", x, y, z, w);
+	}
+
+	coord&
+	Coord4::operator [] (size_t index)
+	{
+		if (index >= 4)
+			argument_error(__FILE__, __LINE__);
+
+		return array[index];
+	}
+
+	const coord&
+	Coord4::operator [] (size_t index) const
+	{
+		return const_cast<Coord4*>(this)->operator[](index);
+	}
+
+
+}// Rays

data/src/coord.h

@@ -0,0 +1,35 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_COORD_H__
+#define __RAYS_SRC_COORD_H__
+
+
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
+#include <rays/coord.h>
+
+
+namespace Rays
+{
+
+
+	typedef glm::tvec3<coord, glm::defaultp> Vec3;
+
+	typedef glm::tvec4<coord, glm::defaultp> Vec4;
+
+
+	inline       Vec3& to_glm (      Coord3& val) {return *(      Vec3*) &val;}
+
+	inline const Vec3& to_glm (const Coord3& val) {return *(const Vec3*) &val;}
+
+	template <typename T>
+	inline       T&    to_rays (      Vec3&  val) {return *(      T*)    &val;}
+
+	template <typename T>
+	inline const T&    to_rays (const Vec3&  val) {return *(const T*)    &val;}
+
+
+}// Rays
+
+
+#endif//EOH

data/src/font.cpp

@@ -0,0 +1,118 @@
+#include "font.h"
+
+
+#include <assert.h>
+
+
+namespace Rays
+{
+
+
+	struct Font::Data
+	{
+
+		RawFont rawfont;
+
+		mutable RawFont rawfont_for_pixel_density;
+
+		mutable float for_pixel_density = 1;
+
+		const RawFont& get_raw (float pixel_density) const
+		{
+			assert(pixel_density > 0);
+
+			if (!rawfont || pixel_density == 1)
+				return rawfont;
+
+			if (pixel_density != for_pixel_density)
+			{
+				rawfont_for_pixel_density =
+					RawFont(rawfont.name(), rawfont.size() * pixel_density);
+				for_pixel_density = pixel_density;
+			}
+
+			return rawfont_for_pixel_density;
+		}
+
+	};// Font::Data
+
+
+	const Font&
+	default_font ()
+	{
+		static const Font FONT(NULL);
+		return FONT;
+	}
+
+	const RawFont&
+	Font_get_raw (const Font& font, float pixel_density)
+	{
+		return font.self->get_raw(pixel_density);
+	}
+
+	coord
+	Font_get_width (const Font& font, float pixel_density, const char* str)
+	{
+		return Font_get_raw(font, pixel_density).get_width(str);
+	}
+
+	coord
+	Font_get_height (
+		const Font& font, float pixel_density,
+		coord* ascent, coord* descent, coord* leading)
+	{
+		return Font_get_raw(font, pixel_density)
+			.get_height(ascent, descent, leading);
+	}
+
+
+	Font::Font ()
+	{
+	}
+
+	Font::Font (const char* name, coord size)
+	{
+		self->rawfont = RawFont(name, size);
+	}
+
+	Font::~Font ()
+	{
+	}
+
+	String
+	Font::name () const
+	{
+		return self->rawfont.name();
+	}
+
+	coord
+	Font::size () const
+	{
+		return self->rawfont.size();
+	}
+
+	coord
+	Font::get_width (const char* str) const
+	{
+		return self->rawfont.get_width(str);
+	}
+
+	coord
+	Font::get_height (coord* ascent, coord* descent, coord* leading) const
+	{
+		return self->rawfont.get_height(ascent, descent, leading);
+	}
+
+	Font::operator bool () const
+	{
+		return !!self->rawfont;
+	}
+
+	bool
+	Font::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

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__);
 	}