rays 0.1.6 → 0.1.7

data/src/{cocoa → ios}/rays.mm

@@ -2,7 +2,8 @@
 #include "rays/rays.h"
 
 
-#import <Cocoa/Cocoa.h>
+#import <Foundation/Foundation.h>
+#include "rays/exception.h"
 
 
 namespace Rays
@@ -19,23 +20,23 @@ namespace Rays
 	}// global
 
 
-	bool
+	void
 	init ()
 	{
-		if (global::pool) return false;
+		if (global::pool)
+			rays_error(__FILE__, __LINE__, "Rays::init(): already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
-		return true;
 	}
 
-	bool
+	void
 	fin ()
 	{
-		if (!global::pool) return false;
+		if (!global::pool)
+			rays_error(__FILE__, __LINE__, "Rays::fin(): not initialized.");
 
 		[global::pool release];
 		global::pool = nil;
-		return true;
 	}
 
 

data/src/matrix.cpp

@@ -7,7 +7,7 @@ namespace Rays
 
 	Matrix::Matrix (float value)
 	{
-		set(value);
+		reset(value);
 	}
 
 	Matrix::Matrix (
@@ -16,12 +16,12 @@ namespace Rays
 		float c1, float c2, float c3, float c4,
 		float d1, float d2, float d3, float d4)
 	{
-		set(a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4);
+		reset(a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4);
 	}
 
 	Matrix::Matrix (const float* elements, size_t size)
 	{
-		set(elements, size);
+		reset(elements, size);
 	}
 
 	Matrix
@@ -31,9 +31,9 @@ namespace Rays
 	}
 
 	Matrix&
-	Matrix::set (float value)
+	Matrix::reset (float value)
 	{
-		return set(
+		return reset(
 			value, 0, 0, 0,
 			0, value, 0, 0,
 			0, 0, value, 0,
@@ -41,7 +41,7 @@ namespace Rays
 	}
 
 	Matrix&
-	Matrix::set (
+	Matrix::reset (
 		float a1, float a2, float a3, float a4,
 		float b1, float b2, float b3, float b4,
 		float c1, float c2, float c3, float c4,
@@ -55,10 +55,10 @@ namespace Rays
 	}
 
 	Matrix&
-	Matrix::set (const float* elements, size_t size)
+	Matrix::reset (const float* elements, size_t size)
 	{
 		if (size != 16) return *this;
-		float* e = array();
+		float* e = array;
 		for (int i = 0; i < 16; ++i) *e++ = *elements++;
 		return *this;
 	}
@@ -66,7 +66,7 @@ namespace Rays
 	float&
 	Matrix::at (int row, int column)
 	{
-		return array()[column * 4 + row];
+		return array[column * 4 + row];
 	}
 
 	float
@@ -75,22 +75,10 @@ namespace Rays
 		return const_cast<Matrix*>(this)->at(row, column);
 	}
 
-	float*
-	Matrix::array ()
-	{
-		return (float*) this;
-	}
-
-	const float*
-	Matrix::array () const
-	{
-		return const_cast<Matrix*>(this)->array();
-	}
-
 	float&
 	Matrix::operator [] (int index)
 	{
-		return array()[index];
+		return array[index];
 	}
 
 	float

data/src/opengl.cpp

@@ -0,0 +1,64 @@
+#include "rays/opengl.h"
+
+
+#include "rays/exception.h"
+
+
+namespace Rays
+{
+
+
+	GLenum
+	get_error ()
+	{
+		return glGetError();
+	}
+
+	bool
+	no_error ()
+	{
+		return get_error() == GL_NO_ERROR;
+	}
+
+	bool
+	is_error (GLenum err)
+	{
+		return get_error() == err;
+	}
+
+	static String
+	get_error_name (GLenum error)
+	{
+		switch (error)
+		{
+			case GL_NO_ERROR:          return "GL_NO_ERROR";
+			case GL_INVALID_ENUM:      return "GL_INVALID_ENUM";
+			case GL_INVALID_VALUE:     return "GL_INVALID_VALUE";
+			case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION";
+		#ifndef IOS
+			case GL_STACK_OVERFLOW:    return "GL_STACK_OVERFLOW";
+			case GL_STACK_UNDERFLOW:   return "GL_STACK_UNDERFLOW";
+		#endif
+			case GL_OUT_OF_MEMORY:     return "GL_OUT_OF_MEMORY";
+			case 0x506:                return "GL_INVALID_FRAMEBUFFER_OPERATION";
+			case 0x8031:               return "GL_TABLE_TOO_LARGE";
+		}
+		return "UNKNOWN ERROR";
+	}
+
+	void
+	check_error (const char* file, int line)
+	{
+		GLenum e = get_error();
+		if (e != GL_NO_ERROR)
+			opengl_error(file, line, "OpenGL error %s", get_error_name(e).c_str());
+	}
+
+	void
+	clear_error ()
+	{
+		get_error();
+	}
+
+
+}// Rays

data/src/{cocoa → osx}/bitmap.mm

@@ -1,9 +1,13 @@
 // -*- objc -*-
-#import <rays/bitmap.h>
+#import "rays/bitmap.h"
 
 
 #include <assert.h>
+#include <boost/scoped_array.hpp>
 #import <Cocoa/Cocoa.h>
+#include "rays/exception.h"
+#include "rays/texture.h"
+#include "../frame_buffer.h"
 #include "helper.h"
 
 
@@ -53,7 +57,7 @@ namespace Rays
 
 		int width, height;
 
-		ColorSpace colorspace;
+		ColorSpace color_space;
 
 		void* pixels;
 
@@ -62,50 +66,34 @@ namespace Rays
 		bool dirty;
 
 		Data ()
-		:	width(0), height(0), pixels(NULL), context(NULL), dirty(true)
-		{
-		}
-
-		~Data ()
+		:	pixels(NULL), context(NULL)
 		{
 			clear();
 		}
 
-		bool setup (int w, int h, const ColorSpace& cs)
+		~Data ()
 		{
-			if (w <= 0 || h <= 0 || !cs) return false;
-
 			clear();
-
-			width      = w;
-			height     = h;
-			colorspace = cs;
-
-			size_t size = w * h * cs.Bpp();
-			pixels = new uchar[size];
-			memset(pixels, 0, size);
-
-			return true;
 		}
 
 		CGContextRef get_context ()
 		{
 			if (context) return context;
 
-			int bpc   = colorspace.bpc();
-			int pitch = width * colorspace.Bpp();
+			int bpc   = color_space.bpc();
+			int pitch = width * color_space.Bpp();
 			if (bpc <= 0 || pitch <= 0) return NULL;
 
 			CGColorSpaceRef cgcs = NULL;
-			if (colorspace.is_gray())
+			if (color_space.is_gray())
 				cgcs = CGColorSpaceCreateDeviceGray();
-			else if (colorspace.is_rgb() || colorspace.is_bgr())
+			else if (color_space.is_rgb() || color_space.is_bgr())
 				cgcs = CGColorSpaceCreateDeviceRGB();
 			else
 				return NULL;
 
 			context = CGBitmapContextCreate(
-				pixels, width, height, bpc, pitch, cgcs, make_bitmapinfo(colorspace));
+				pixels, width, height, bpc, pitch, cgcs, make_bitmapinfo(color_space));
 			CGColorSpaceRelease(cgcs);
 			return context;
 		}
@@ -123,28 +111,84 @@ namespace Rays
 			if (pixels) delete [] (uchar*) pixels;
 
 			width = height = 0;
-			colorspace = COLORSPACE_UNKNOWN;
-			pixels     = NULL;
-			context    = NULL;
-			dirty      = true;
+			color_space = COLORSPACE_UNKNOWN;
+			pixels      = NULL;
+			context     = NULL;
+			dirty       = false;
 		}
 
 	};// Bitmap::Data
 
 
+	static void
+	setup_bitmap (
+		Bitmap* this_,
+		int w, int h, const ColorSpace& cs,
+		const void* pixels_ = NULL, bool clear_pixels = true)
+	{
+		if (!this_ || w <= 0 || h <= 0 || !cs)
+			argument_error(__FILE__, __LINE__);
+
+		this_->self->clear();
+
+		this_->self->width       = w;
+		this_->self->height      = h;
+		this_->self->color_space = cs;
+		this_->self->dirty       = true;
+
+		size_t size = w * h * cs.Bpp();
+		this_->self->pixels = new uchar[size];
+
+		if (pixels_)
+			memcpy(this_->self->pixels, pixels_, size);
+		else if (clear_pixels)
+			memset(this_->self->pixels, 0, size);
+	}
+
+	static void
+	setup_bitmap (Bitmap* this_, const Texture& tex)
+	{
+		if (!this_ || !tex)
+			argument_error(__FILE__, __LINE__);
+
+		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());
+
+		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));
+	}
+
+
 	Bitmap::Bitmap ()
 	{
 	}
 
-	Bitmap::Bitmap (int width, int height, const ColorSpace& colorspace)
+	Bitmap::Bitmap (
+		int width, int height, const ColorSpace& color_space, const void* pixels)
 	{
-		self->setup(width, height, colorspace);
+		setup_bitmap(this, width, height, color_space, pixels);
+	}
+
+	Bitmap::Bitmap (const Texture& texture)
+	{
+		setup_bitmap(this, texture);
 	}
 
 	Bitmap::~Bitmap ()
 	{
 	}
 
+	Bitmap
+	Bitmap::copy () const
+	{
+		return Bitmap(width(), height(), color_space(), pixels());
+	}
+
 	int
 	Bitmap::width () const
 	{
@@ -167,13 +211,13 @@ namespace Rays
 			static const ColorSpace UNKNOWN = COLORSPACE_UNKNOWN;
 			return UNKNOWN;
 		}
-		return self->colorspace;
+		return self->color_space;
 	}
 
 	int
 	Bitmap::pitch () const
 	{
-		return width() * self->colorspace.Bpp();
+		return width() * self->color_space.Bpp();
 	}
 
 	size_t
@@ -182,35 +226,35 @@ namespace Rays
 		return pitch() * height();
 	}
 
-	bool
-	Bitmap::dirty () const
+	void*
+	Bitmap::pixels ()
 	{
-		return self->dirty;
+		if (!*this) return NULL;
+		return self->pixels;
 	}
 
-	void
-	Bitmap::set_dirty (bool b)
+	const void*
+	Bitmap::pixels () const
 	{
-		self->dirty = b;
+		return const_cast<This*>(this)->pixels();
 	}
 
-	void*
-	Bitmap::data ()
+	bool
+	Bitmap::dirty () const
 	{
-		if (!*this) return NULL;
-		return self->pixels;
+		return self->dirty;
 	}
 
-	const void*
-	Bitmap::data () const
+	void
+	Bitmap::set_dirty (bool b)
 	{
-		return const_cast<This*>(this)->data();
+		self->dirty = b;
 	}
 
 	Bitmap::operator bool () const
 	{
 		return
-			self->width > 0 && self->height > 0 && self->colorspace && self->pixels;
+			self->width > 0 && self->height > 0 && self->color_space && self->pixels;
 	}
 
 	bool
@@ -220,69 +264,76 @@ namespace Rays
 	}
 
 
-	bool
-	load_bitmap (Bitmap* bmp, const char* path_)
+	Bitmap
+	load_bitmap (const char* path_)
 	{
-		if (!bmp || !path_) return false;
+		if (!path_ || path_[0] == '\0')
+			argument_error(__FILE__, __LINE__);
 
 		NSString* path = [NSString stringWithUTF8String: path_];
 		NSBitmapImageRep* imagerep =
 			[NSBitmapImageRep imageRepWithContentsOfFile: path];
-		if (!imagerep) return false;
+		if (!imagerep)
+			rays_error(__FILE__, __LINE__, "[NSBitmapImageRep imageRepWithContentsOfFile] failed.");
 
 		CGImageRef image = [imagerep CGImage];
-		if (!image) return false;
+		if (!image)
+			rays_error(__FILE__, __LINE__, "[imagerep CGImage] failed.");
 
 		size_t width  = CGImageGetWidth(image);
 		size_t height = CGImageGetHeight(image);
 
-		*bmp = Bitmap((int) width, (int) height, ColorSpace(RGBA, true));
-		if (!*bmp) return false;
+		Bitmap bmp((int) width, (int) height, RGBA);
+		if (!bmp)
+			rays_error(__FILE__, __LINE__, "invalid bitmap.");
 
-		CGContextRef context = bmp->self->get_context();
-		if (!context) return false;
+		CGContextRef context = bmp.self->get_context();
+		if (!context)
+			rays_error(__FILE__, __LINE__, "creating CGContext failed.");
 
 		CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);
-		return true;
+		return bmp;
 	}
 
-	bool
+	void
 	save_bitmap (const Bitmap& bmp, const char* path_)
 	{
 		boost::shared_ptr<CGImage> img(
 			bmp.self->get_image(), CGImageRelease);
-		if (!img) return false;
+		if (!img)
+			rays_error(__FILE__, __LINE__, "getting CGImage failed.");
 
 		NSString* path = [NSString stringWithUTF8String: path_];
 		NSURL* url = [NSURL fileURLWithPath: path];
-		if (!url) return false;
+		if (!url)
+			rays_error(__FILE__, __LINE__, "creating NSURL failed.");
 
 		boost::shared_ptr<CGImageDestination> dest(
 			CGImageDestinationCreateWithURL((CFURLRef) url, kUTTypePNG, 1, NULL),
 			safe_cfrelease);
-		if (!dest) return false;
+		if (!dest)
+			rays_error(__FILE__, __LINE__, "CGImageDestinationCreateWithURL() failed.");
 
 		CGImageDestinationAddImage(dest.get(), img.get(), NULL);
-		return CGImageDestinationFinalize(dest.get());
+		if (!CGImageDestinationFinalize(dest.get()))
+			rays_error(__FILE__, __LINE__, "CGImageDestinationFinalize() failed.");
 	}
 
 
-	bool draw_string (
+	void draw_string (
 		CGContextRef, coord, const char*, coord, coord, const Font&);
 
-	bool
+	void
 	draw_string (
 		Bitmap* bmp, const char* str, coord x, coord y, const Font& font)
 	{
-		if (!bmp || !*bmp || !str || !font) return false;
-
-		if (*str == '\0') return true;
+		if (!bmp || !*bmp || !str || !font)
+			argument_error(__FILE__, __LINE__);
 
-		if (!draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font))
-			return false;
+		if (*str == '\0') return;
 
+		draw_string(bmp->self->get_context(), bmp->height(), str, x, y, font);
 		bmp->set_dirty();
-		return true;
 	}
 
 

data/src/{cocoa → osx}/font.mm

@@ -3,6 +3,7 @@
 
 
 #include <ApplicationServices/ApplicationServices.h>
+#include "rays/exception.h"
 #include "helper.h"
 
 
@@ -78,6 +79,12 @@ namespace Rays
 	{
 	}
 
+	Font
+	Font::copy () const
+	{
+		return Font(name(), size());
+	}
+
 	String
 	Font::name () const
 	{
@@ -101,42 +108,42 @@ namespace Rays
 		return CTFontGetSize(self->font);
 	}
 
-	bool
-	Font::get_width (coord* width, const char* str) const
+	coord
+	Font::get_width (const char* str) const
 	{
-		if (!width || !str || !*this) return false;
+		if (!str)
+			argument_error(__FILE__, __LINE__);
 
-		if (*str == '\0')
-		{
-			*width = 0;
-			return true;
-		}
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (*str == '\0') return 0;
 
 		CTLineRef line = make_line(self->font, str);
-		if (!line) return false;
+		if (!line)
+			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
 
-		*width = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
+		coord w = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
 		CFRelease(line);
 
-		return true;
+		return w;
 	}
 
-	bool
-	Font::get_height (
-		coord* height, coord* ascent, coord* descent, coord* leading) const
+	coord
+	Font::get_height (coord* ascent, coord* descent, coord* leading) const
 	{
-		if ((!height && !ascent && !descent && !leading) || !*this) return false;
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
 
 		CGFloat asc  = CTFontGetAscent(self->font);
 		CGFloat desc = CTFontGetDescent(self->font);
 		CGFloat lead = CTFontGetLeading(self->font);
 
-		if (height)  *height  = asc + desc + lead;
 		if (ascent)  *ascent  = asc;
 		if (descent) *descent = desc;
 		if (leading) *leading = lead;
 
-		return true;
+		return asc + desc + lead;
 	}
 
 	Font::operator bool () const
@@ -159,21 +166,23 @@ namespace Rays
 	}
 
 
-	bool
+	void
 	draw_string (
 		CGContextRef context, coord context_height,
 		const char* str, coord x, coord y, const Font& font)
 	{
-		if (!context || !str || !font) return false;
+		if (!context || !str || !font)
+			argument_error(__FILE__, __LINE__);
 
-		if (*str == '\0') return true;
+		if (*str == '\0') return;
 
 		CTLineRef line = make_line(font.self->font, str);
-		if (!line) return false;
+		if (!line)
+			rays_error(__FILE__, __LINE__, "creating CTLineRef failed.");
 
 		coord width = 0, height = 0, ascent = 0;
-		if (!font.get_width(&width, str) || !font.get_height(&height, &ascent))
-			return false;
+		width  = font.get_width(str);
+		height = font.get_height(&ascent);
 
 		height = ceil(height);
 		ascent = floor(ascent);
@@ -191,7 +200,6 @@ namespace Rays
 		CGContextRestoreGState(context);
 
 		CFRelease(line);
-		return true;
 	}
 
 

data/src/osx/helper.h

@@ -0,0 +1,26 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_OSX_HELPER_H__
+#define __RAYS_OSX_HELPER_H__
+
+
+#include <boost/shared_ptr.hpp>
+#include <CoreFoundation/CoreFoundation.h>
+
+
+namespace Rays
+{
+
+
+	void safe_cfrelease (CFTypeRef ref);
+
+
+	typedef boost::shared_ptr<const __CFString> CFString;
+
+	CFString cfstring (const char* str);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/osx/helper.mm

@@ -0,0 +1,25 @@
+// -*- objc -*-
+#include "helper.h"
+
+
+namespace Rays
+{
+
+
+	void
+	safe_cfrelease (CFTypeRef ref)
+	{
+		if (ref) CFRelease(ref);
+	}
+
+
+	CFString
+	cfstring (const char* str)
+	{
+		CFStringRef ref = CFStringCreateWithCString(
+			kCFAllocatorDefault, str, kCFStringEncodingUTF8);
+		return CFString(ref, safe_cfrelease);
+	}
+
+
+}// Rays