rays 0.1.11 → 0.1.16

data/src/color_space.cpp

@@ -1,4 +1,4 @@
-#include "rays/color_space.h"
+#include "color_space.h"
 
 
 #include <assert.h>
@@ -13,13 +13,15 @@ namespace Rays
 	enum
 	{
 
-		FIRST        = GRAY_8,    LAST       = ABGR_float,
+		          FIRST = GRAY_8,              LAST = ABGR_float,
 
-		GRAY_FIRST   = GRAY_8,    GRAY_LAST  = GRAY_float,
+		     GRAY_FIRST = GRAY_8,         GRAY_LAST = GRAY_float,
 
-		RGB_FIRST    = RGB_888,   RGB_LAST   = ABGR_float,
+		    ALPHA_FIRST = ALPHA_8,       ALPHA_LAST = ALPHA_float,
 
-		FLOAT_SECOND = RGB_float, FLOAT_LAST = ABGR_float,
+		      RGB_FIRST = RGB_888,         RGB_LAST = ABGR_float,
+
+		RGB_FLOAT_FIRST = RGB_float, RGB_FLOAT_LAST = ABGR_float,
 
 	};
 
@@ -45,12 +47,15 @@ namespace Rays
 	{
 		static const int BPPS[] =
 		{
-			0,                            // UNKNOWN
-			8, 16, 24, 32, 32,            // GRAY
-			8, 8, 8, 8, 8, 8, 8, 8, 8, 8, // RGB(A), BGR(A)
-			32, 32, 32, 32, 32, 32,       // RGB(A), BGR(A) float
+			0,                 // UNKNOWN
+			8, 16, 24, 32, 32, // GRAY
+			8, 16, 24, 32, 32, // ALPHA
+			8, 8, 8, 8, 8,     // RGB(A),
+			8, 8, 8, 8, 8,     // BGR(A)
+			32, 32, 32,        // RGB(A) float
+			32, 32, 32,        // BGR(A) float
 		};
-		if (type_ < 0 || COLORSPACE_LAST <= type_) return BPPS[COLORSPACE_UNKNOWN];
+		if (type_ < 0 || COLORSPACE_MAX <= type_) return BPPS[COLORSPACE_UNKNOWN];
 		return BPPS[type_];
 	}
 
@@ -67,12 +72,13 @@ namespace Rays
 		{
 			0,                     // UNKNOWN
 			8,  16, 24,  32,  32,  // GRAY
+			8,  16, 24,  32,  32,  // ALPHA
 			24, 32,  32,  32,  32, // RGB(A)
 			24, 32,  32,  32,  32, // BGR(A)
 			96, 128, 128,          // RGB(A) float
 			96, 128, 128,          // BGR(A) float
 		};
-		if (type_ < 0 || COLORSPACE_LAST <= type_) return BPPS[COLORSPACE_UNKNOWN];
+		if (type_ < 0 || COLORSPACE_MAX <= type_) return BPPS[COLORSPACE_UNKNOWN];
 		return BPPS[type_];
 	}
 
@@ -91,7 +97,13 @@ namespace Rays
 	bool
 	ColorSpace::is_gray () const
 	{
-		return GRAY_FIRST <= (int) type_ && (int) type_ <= GRAY_LAST;
+		return GRAY_FIRST  <= (int) type_ && (int) type_ <= GRAY_LAST;
+	}
+
+	bool
+	ColorSpace::is_alpha () const
+	{
+		return ALPHA_FIRST <= (int) type_ && (int) type_ <= ALPHA_LAST;
 	}
 
 	bool
@@ -114,14 +126,15 @@ namespace Rays
 	ColorSpace::is_float () const
 	{
 		return
-			type_ == GRAY_float ||
-			(FLOAT_SECOND <= (int) type_ && (int) type_ <= FLOAT_LAST);
+			type_ == GRAY_float || type_ == ALPHA_float ||
+			(RGB_FLOAT_FIRST <= (int) type_ && (int) type_ <= RGB_FLOAT_LAST);
 	}
 
 	bool
 	ColorSpace::has_alpha () const
 	{
 		return
+			(ALPHA_FIRST <= type_ && type_ <= ALPHA_LAST) ||
 			type_ == RGBA_8888  || type_ == ARGB_8888  ||
 			type_ == BGRA_8888  || type_ == ABGR_8888  ||
 			type_ == RGBA_float || type_ == ARGB_float ||
@@ -170,51 +183,56 @@ namespace Rays
 		return premult;
 	}
 
+	ColorSpace::operator bool () const
+	{
+		return FIRST <= (int) type_ && (int) type_ <= LAST;
+	}
+
+	bool
+	ColorSpace::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
 	void
-	ColorSpace::get_gl_enums (GLenum* format, GLenum* type, bool alpha_only) const
+	ColorSpace_get_gl_format_and_type (
+		GLenum* format, GLenum* type, const ColorSpace& cs)
 	{
 		if (!format && !type)
 			argument_error(__FILE__, __LINE__);
 
-		if (!*this)
+		if (!cs)
 			invalid_state_error(__FILE__, __LINE__);
 
 		if (format)
 		{
-			     if (is_rgb())  *format = has_alpha() ? GL_RGBA  : GL_RGB;
+			     if (cs.is_rgb())   *format = cs.has_alpha() ? GL_RGBA  : GL_RGB;
 		#ifndef IOS
-			else if (is_bgr())  *format = has_alpha() ? GL_BGRA  : GL_BGR;
+			else if (cs.is_bgr())   *format = cs.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.");
+			else if (cs.is_gray())  *format = GL_LUMINANCE;
+			else if (cs.is_alpha()) *format = GL_ALPHA;
+			else
+				rays_error(__FILE__, __LINE__, "invalid color space.");
 		}
 
 		if (type)
 		{
-			if (is_float())
+			if (cs.is_float())
 				*type = GL_FLOAT;
-			else switch (bpc())
+			else switch (cs.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.");
+				default:
+					rays_error(__FILE__, __LINE__, "invalid bpc.");
 			}
 		}
 	}
 
-	ColorSpace::operator bool () const
-	{
-		return FIRST <= (int) type_ && (int) type_ <= LAST;
-	}
-
-	bool
-	ColorSpace::operator ! () const
-	{
-		return !operator bool();
-	}
-
 
 }// Rays

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