rays 0.1.3 → 0.1.4

data/src/cocoa/bitmap.mm

@@ -204,7 +204,7 @@ namespace Rays
 	const void*
 	Bitmap::data () const
 	{
-		return const_cast<Bitmap*>(this)->data();
+		return const_cast<This*>(this)->data();
 	}
 
 	Bitmap::operator bool () const
@@ -233,10 +233,10 @@ namespace Rays
 		CGImageRef image = [imagerep CGImage];
 		if (!image) return false;
 
-		int width  = CGImageGetWidth(image);
-		int height = CGImageGetHeight(image);
+		size_t width  = CGImageGetWidth(image);
+		size_t height = CGImageGetHeight(image);
 
-		*bmp = Bitmap(width, height, ColorSpace(RGBA, true));
+		*bmp = Bitmap((int) width, (int) height, ColorSpace(RGBA, true));
 		if (!*bmp) return false;
 
 		CGContextRef context = bmp->self->get_context();

data/src/cocoa/font.mm

@@ -102,35 +102,39 @@ namespace Rays
 	}
 
 	bool
-	Font::get_extent (coord* width, coord* height, const char* str) const
+	Font::get_width (coord* width, const char* str) const
 	{
-		if (!*this) return false;
+		if (!width || !str || !*this) return false;
 
-		if (width)  *width  = 0;
-		if (height) *height = 0;
-
-		CGFloat ascent = 0, descent = 0, leading = 0;
-		if (width)
+		if (*str == '\0')
 		{
-			CTLineRef line = make_line(self->font, str);
-			if (!line) return false;
-
-			*width = CTLineGetTypographicBounds(line, &ascent, &descent, &leading);
-			CFRelease(line);
+			*width = 0;
+			return true;
 		}
 
-		if (height)
-		{
-			if (width)
-				*height = ascent + descent + leading;
-			else
-			{
-				*height =
-					CTFontGetAscent(self->font) +
-					CTFontGetDescent(self->font) +
-					CTFontGetLeading(self->font);
-			}
-		}
+		CTLineRef line = make_line(self->font, str);
+		if (!line) return false;
+
+		*width = CTLineGetTypographicBounds(line, NULL, NULL, NULL);
+		CFRelease(line);
+
+		return true;
+	}
+
+	bool
+	Font::get_height (
+		coord* height, coord* ascent, coord* descent, coord* leading) const
+	{
+		if ((!height && !ascent && !descent && !leading) || !*this) return false;
+
+		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;
 	}
@@ -167,12 +171,14 @@ namespace Rays
 		CTLineRef line = make_line(font.self->font, str);
 		if (!line) return false;
 
-		coord width = 0, height = 0;
-		if (!font.get_extent(&width, &height, str))
+		coord width = 0, height = 0, ascent = 0;
+		if (!font.get_width(&width, str) || !font.get_height(&height, &ascent))
 			return false;
 
-		CGRect rect = CGRectMake(
-			x, context_height - height - y, width, height);
+		height = ceil(height);
+		ascent = floor(ascent);
+
+		CGRect rect = CGRectMake(x, context_height - height - y, width, height);
 		CGContextClearRect(context, rect);
 		//CGContextSetRGBFillColor(context, 0, 0, 0, 1);
 		//CGContextFillRect(context, rect);
@@ -180,8 +186,7 @@ namespace Rays
 
 		CGContextSaveGState(context);
 		CGContextSetTextMatrix(context, CGAffineTransformIdentity);
-		CGContextSetTextPosition(
-			context, x, context_height - CTFontGetAscent(font.self->font) - y);
+		CGContextSetTextPosition(context, x, context_height - ascent - y);
 		CTLineDraw(line, context);
 		CGContextRestoreGState(context);
 

data/src/cocoa/rays.mm

@@ -23,6 +23,7 @@ namespace Rays
 	init ()
 	{
 		if (global::pool) return false;
+
 		global::pool = [[NSAutoreleasePool alloc] init];
 		return true;
 	}
@@ -31,6 +32,7 @@ namespace Rays
 	fin ()
 	{
 		if (!global::pool) return false;
+
 		[global::pool release];
 		global::pool = nil;
 		return true;

data/src/color.cpp

@@ -0,0 +1,77 @@
+#include "rays/color.h"
+
+
+namespace Rays
+{
+
+
+	Color::Color (float value, float alpha)
+	{
+		set(value, alpha);
+	}
+
+	Color::Color (float red, float green, float blue, float alpha)
+	{
+		set(red, green, blue, alpha);
+	}
+
+	Color
+	Color::dup () const
+	{
+		return *this;
+	}
+
+	Color&
+	Color::set (float value, float alpha)
+	{
+		return set(value, value, value, alpha);
+	}
+
+	Color&
+	Color::set (float red, float green, float blue, float alpha)
+	{
+		this->red   = red;
+		this->green = green;
+		this->blue  = blue;
+		this->alpha = alpha;
+		return *this;
+	}
+
+	bool
+	Color::get (float* red, float* green, float* blue, float* alpha) const
+	{
+		if (!red && !green && !blue && !alpha)
+			return false;
+
+		if (red)   *red   = this->red;
+		if (green) *green = this->green;
+		if (blue)  *blue  = this->blue;
+		if (alpha) *alpha = this->alpha;
+		return true;
+	}
+
+	float*
+	Color::array ()
+	{
+		return (float*) this;
+	}
+
+	const float*
+	Color::array () const
+	{
+		return const_cast<Color*>(this)->array();
+	}
+
+	Color::operator bool () const
+	{
+		return red >= 0 && green >= 0 && blue >= 0 && alpha >= 0;
+	}
+
+	bool
+	Color::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

data/src/colorspace.cpp

@@ -1,7 +1,7 @@
 #include "rays/colorspace.h"
 
 
-#include <rays/helpers.h>
+#include <xot/util.h>
 
 
 namespace Rays
@@ -55,7 +55,7 @@ namespace Rays
 	int
 	ColorSpace::Bpc () const
 	{
-		return bit2byte(bpc());
+		return Xot::bit2byte(bpc());
 	}
 
 	int
@@ -77,7 +77,7 @@ namespace Rays
 	int
 	ColorSpace::Bpp () const
 	{
-		return bit2byte(bpp());
+		return Xot::bit2byte(bpp());
 	}
 
 	int

data/src/exception.cpp

@@ -1,21 +1,6 @@
 #include "rays/exception.h"
 
 
-#define VA_STRING(format, result) \
-	String result; \
-	do \
-	{ \
-		if (format) \
-		{ \
-			va_list args; \
-			va_start(args, format); \
-			result = Xot::stringf(format, args); \
-			va_end(args); \
-		} \
-	} \
-	while (false)
-
-
 namespace Rays
 {
 
@@ -23,7 +8,7 @@ namespace Rays
 	RaysException::RaysException (const char* format, ...)
 	:	Super("")
 	{
-		VA_STRING(format, s);
+		XOT_STRINGF(format, s);
 		text = s;
 	}
 
@@ -39,9 +24,9 @@ namespace Rays
 
 
 	void
-	error (const char* format, ...)
+	rays_error (const char* format, ...)
 	{
-		VA_STRING(format, s);
+		XOT_STRINGF(format, s);
 		throw RaysException(s.c_str());
 	}
 

data/src/image.cpp

@@ -81,7 +81,7 @@ namespace Rays
 	const Bitmap&
 	Image::bitmap () const
 	{
-		return const_cast<Image*>(this)->bitmap();
+		return const_cast<This*>(this)->bitmap();
 	}
 
 	Texture&
@@ -101,7 +101,7 @@ namespace Rays
 	const Texture&
 	Image::texture () const
 	{
-		return const_cast<Image*>(this)->texture();
+		return const_cast<This*>(this)->texture();
 	}
 
 	Image::operator bool () const
@@ -129,5 +129,12 @@ namespace Rays
 		return *image;
 	}
 
+	bool
+	save_image (const Image& image, const char* path)
+	{
+		if (!image || !path) return false;
+		return save_bitmap(image.bitmap(), path);
+	}
+
 
 }// Rays

data/src/matrix.cpp

@@ -0,0 +1,103 @@
+#include "rays/matrix.h"
+
+
+namespace Rays
+{
+
+
+	Matrix::Matrix (float value)
+	{
+		set(value);
+	}
+
+	Matrix::Matrix (
+		float a1, float a2, float a3, float a4,
+		float b1, float b2, float b3, float b4,
+		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);
+	}
+
+	Matrix::Matrix (const float* elements, size_t size)
+	{
+		set(elements, size);
+	}
+
+	Matrix
+	Matrix::dup () const
+	{
+		return *this;
+	}
+
+	Matrix&
+	Matrix::set (float value)
+	{
+		return set(
+			value, 0, 0, 0,
+			0, value, 0, 0,
+			0, 0, value, 0,
+			0, 0, 0, value);
+	}
+
+	Matrix&
+	Matrix::set (
+		float a1, float a2, float a3, float a4,
+		float b1, float b2, float b3, float b4,
+		float c1, float c2, float c3, float c4,
+		float d1, float d2, float d3, float d4)
+	{
+		this->a1 = a1; this->a2 = a2; this->a3 = a3; this->a4 = a4;
+		this->b1 = b1; this->b2 = b2; this->b3 = b3; this->b4 = b4;
+		this->c1 = c1; this->c2 = c2; this->c3 = c3; this->c4 = c4;
+		this->d1 = d1; this->d2 = d2; this->d3 = d3; this->d4 = d4;
+		return *this;
+	}
+
+	Matrix&
+	Matrix::set (const float* elements, size_t size)
+	{
+		if (size != 16) return *this;
+		float* e = array();
+		for (int i = 0; i < 16; ++i) *e++ = *elements++;
+		return *this;
+	}
+
+	float&
+	Matrix::at (int row, int column)
+	{
+		return array()[column * 4 + row];
+	}
+
+	float
+	Matrix::at (int row, int column) const
+	{
+		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];
+	}
+
+	float
+	Matrix::operator [] (int index) const
+	{
+		return const_cast<Matrix*>(this)->operator[](index);
+	}
+
+
+}// Rays

data/src/painter.cpp

@@ -2,7 +2,13 @@
 
 
 #include <math.h>
+#include <list>
 #include <algorithm>
+#include <rays/point.h>
+#include <rays/bounds.h>
+#include <rays/color.h>
+#include <rays/matrix.h>
+#include <rays/font.h>
 #include <rays/bitmap.h>
 #include <rays/texture.h>
 #include <rays/image.h>
@@ -12,181 +18,115 @@ namespace Rays
 {
 
 
+	enum ColorOrder
+	{
+
+		FILL = 0, STROKE
+
+	};// ColorOrder
+
+
 	static const float PI = 3.141592653589793238462643383279f;
 
 	static const float PI_2 = PI * 2;
 
 
 	static void
-	gl_clear_error ()
+	clear_error ()
 	{
 		glGetError();
 	}
 
 	static bool
-	gl_no_error ()
+	is_error ()
 	{
-		return glGetError() == GL_NO_ERROR;
+		return glGetError() != GL_NO_ERROR;
 	}
 
-
-	struct Rect
+	static bool
+	is_error (GLenum error)
 	{
-
-		coord x, y, width, height;
-
-		Rect ()
-		:	x(0), y(0), width(0), height(0)
-		{
-		}
-
-		coord left () const
-		{
-			return x;
-		}
-
-		coord top () const
-		{
-			return y;
-		}
-
-		coord right () const
-		{
-			return x + width;
-		}
-
-		coord bottom () const
-		{
-			return y + height;
-		}
-
-		void set (coord x, coord y, coord width, coord height)
-		{
-			this->x      = x;
-			this->y      = y;
-			this->width  = width;
-			this->height = height;
-		}
-
-		bool get (coord* x, coord* y, coord* width, coord* height)
-		{
-			if (!x && !y && !width && !height)
-				return false;
-
-			if (x)      *x      = this->x;
-			if (y)      *y      = this->y;
-			if (width)  *width  = this->width;
-			if (height) *height = this->height;
-			return true;
-		}
-
-		coord* array () const {return (coord*) this;}
-
-		operator bool () const
-		{
-			return width >= 0 && height >= 0;
-		}
-
-		bool operator ! () const
-		{
-			return !operator bool();
-		}
-
-	};// Rect
+		return glGetError() == error;
+	}
 
 
-	struct Color
+	struct Attributes
 	{
 
-		float red, green, blue, alpha;
+		Bounds clip;
 
-		Color ()
-		:	red(0), green(0), blue(0), alpha(0)
-		{
-		}
+		Color background, colors[2];
 
-		void set (float red, float green, float blue, float alpha)
-		{
-			this->red   = red;
-			this->green = green;
-			this->blue  = blue;
-			this->alpha = alpha;
-		}
+		Font font;
 
-		bool get (float* red, float* green, float* blue, float* alpha) const
+		void init ()
 		{
-			if (!red && !green && !blue && !alpha) return false;
-			if (red)   *red   = this->red;
-			if (green) *green = this->green;
-			if (blue)  *blue  = this->blue;
-			if (alpha) *alpha = this->alpha;
-			return true;
+			clip           .set(-1);
+			background     .set(0, 0);
+			colors[FILL]   .set(0, 0);
+			colors[STROKE] .set(0, 0);
+			font           = default_font();
 		}
 
-		float* array () const {return (float*) this;}
-
-	};// Color
+	};// Attributes
 
 
 	struct Painter::Data
 	{
 
-		Rect viewport, clip;
+		Bounds viewport;
+
+		Attributes attrs;
 
-		Color clear, colors[2];
+		std::list<Attributes> attrs_stack;
 
-		bool painting, drawing, clipping;
+		bool painting, drawing;
 
 		Image textimage;
 
+		mutable Matrix matrix_tmp;
+
 		Data ()
-		:	painting(false), drawing(false), clipping(false),
-			textimage(1, 1, GRAY, true)
+		:	painting(false), drawing(false), textimage(1, 1, GRAY, true)
 		{
+			attrs.init();
 		}
 
-		bool use_color (size_t i) const
+		bool use_color (size_t i)
 		{
-			gl_clear_error();
+			clear_error();
 
-			const Color& c = colors[i];
-			if (c.alpha <= 0) return false;
+			const Color& col = attrs.colors[i];
+			if (col.alpha <= 0) return false;
 
-			glColor4fv(c.array());
-			return gl_no_error();
+			glColor4fv(col.array());
+			return !is_error();
 		}
 
 		bool update_clip ()
 		{
-			gl_clear_error();
+			clear_error();
 
-			if (clip)
+			if (attrs.clip)
 			{
-				if (clipping) return true;
 				glEnable(GL_SCISSOR_TEST);
-				clipping = true;
+				glScissor(
+					attrs.clip.x,
+					viewport.height - attrs.clip.height - attrs.clip.y,
+					attrs.clip.width,
+					attrs.clip.height);
 			}
 			else
 			{
-				if (!clipping) return true;
 				glDisable(GL_SCISSOR_TEST);
-				clipping = false;
 			}
 
-			return gl_no_error();
+			return !is_error();
 		}
 
 	};// Painter::Data
 
 
-	enum ColorOrder
-	{
-
-		FILL = 0, STROKE
-
-	};// ColorOrder
-
-
 	Painter::Painter ()
 	{
 	}
@@ -198,27 +138,31 @@ namespace Rays
 	bool
 	Painter::canvas (coord x, coord y, coord width, coord height)
 	{
-		if (self->painting || width < 0 || height < 0)
-			return false;
+		return canvas(Bounds(x, y, -100, width, height, 200));
+	}
 
-		self->viewport.set(x, y, width, height);
+	bool
+	Painter::canvas (coord x, coord y, coord z, coord width, coord height, coord depth)
+	{
+		return canvas(Bounds(x, y, z, width, height, depth));
+	}
+
+	bool
+	Painter::canvas (const Bounds& bounds)
+	{
+		if (self->painting || !bounds) return false;
 
-		glViewport(
-			(int) self->viewport.x,     (int) self->viewport.y,
-			(int) self->viewport.width, (int) self->viewport.height);
+		const Bounds& b = self->viewport = bounds;
+
+		glViewport((int) b.x, (int) b.y, (int) b.width, (int) b.height);
 
 		glMatrixMode(GL_PROJECTION);
 		glLoadIdentity();
-
-		glOrtho(
-			self->viewport.left(), self->viewport.right(),
-			self->viewport.top(),  self->viewport.bottom(),
-			-100, 100);
-		glRotatef(180, 1, 0, 0);
-		glTranslatef(0, -self->viewport.height, 0);
+		glOrtho(b.x, b.x + b.width, b.y + b.height, b.y, b.z, b.z + b.depth);
 
 		glMatrixMode(GL_MODELVIEW);
 		glLoadIdentity();
+		glTranslatef(0.375f, 0.375f, 0);
 
 		return true;
 	}
@@ -228,6 +172,8 @@ namespace Rays
 	{
 		if (self->painting) return false;
 
+		push_attrs();
+
 		glEnable(GL_CULL_FACE);
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -252,21 +198,7 @@ namespace Rays
 		glDisable(GL_BLEND);
 		glDisable(GL_CULL_FACE);
 
-		return true;
-	}
-
-	bool
-	Painter::push_matrix ()
-	{
-		glPushMatrix();
-		return true;
-	}
-
-	bool
-	Painter::pop_matrix ()
-	{
-		glPopMatrix();
-		return true;
+		return pop_attrs();
 	}
 
 
@@ -278,13 +210,19 @@ namespace Rays
 
 		if (!begin_shape(LINES)) return false;
 		bool ret =
-			vertex(x1, y1) &&
-			vertex(x2, y2);
+			add_vertex(x1, y1) &&
+			add_vertex(x2, y2);
 		if (!end_shape()) return false;
 
 		return ret;
 	}
 
+	bool
+	Painter::line (const Point& p1, const Point& p2)
+	{
+		return line(p1.x, p1.y, p2.x, p2.y);
+	}
+
 	bool
 	Painter::rect (coord x, coord y, coord width, coord height)
 	{
@@ -292,8 +230,10 @@ namespace Rays
 
 		if (!self->painting) return false;
 
-		coord x2 = x + width;
-		coord y2 = y + height;
+		if (width <= 0 || height <= 0) return true;
+
+		coord x2 = x + width  - 1;
+		coord y2 = y + height - 1;
 
 		bool ret = true;
 		for (int i = 0; i < 2; ++i)
@@ -301,17 +241,25 @@ namespace Rays
 			if (!self->use_color(i)) continue;
 
 			if (!begin_shape(TYPES[i])) return false;
+			coord xx = x2 + 1 - i;
+			coord yy = y2 + 1 - i;
 			ret &=
-				vertex(x,  y)  &&
-				vertex(x,  y2) &&
-				vertex(x2, y2) &&
-				vertex(x2, y);
+				add_vertex(x,  y)  &&
+				add_vertex(x,  yy) &&
+				add_vertex(xx, yy) &&
+				add_vertex(xx, y);
 			if (!end_shape()) return false;
 		}
 
 		return ret;
 	}
 
+	bool
+	Painter::rect (const Bounds& bounds)
+	{
+		return rect(bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
 	static bool
 	draw_ellipse (
 		Painter* painter,
@@ -348,7 +296,7 @@ namespace Rays
 			if (!painter->begin_shape(types[i])) return false;
 
 			if (!hole)
-				ret &= painter->vertex(x, y);
+				ret &= painter->add_vertex(x, y);
 
 			for (int seg = 0; seg <= (int) nsegment; ++seg)
 			{
@@ -357,8 +305,8 @@ namespace Rays
 				float xx     = cos(radian);
 				float yy     = -sin(radian);
 				if (hole)
-					ret &= painter->vertex(x + xx * radius_x_min, y + yy * radius_y_min);
-				ret &=   painter->vertex(x + xx * radius_x,     y + yy * radius_y);
+					ret &= painter->add_vertex(x + xx * radius_x_min, y + yy * radius_y_min);
+				ret &=   painter->add_vertex(x + xx * radius_x,     y + yy * radius_y);
 			}
 
 			if (!painter->end_shape()) return false;
@@ -371,25 +319,59 @@ namespace Rays
 
 	bool
 	Painter::ellipse (
-		coord x, coord y, coord width, coord height, coord radius_min,
-		uint nsegment)
+		coord x, coord y, coord width, coord height,
+		coord radius_min, uint nsegment)
 	{
 		if (nsegment <= 0) nsegment = ELLIPSE_NSEGMENT;
 		return draw_ellipse(
 			this, x, y, width, height, 0, 360, radius_min, nsegment);
 	}
 
+	bool
+	Painter::ellipse (const Bounds& bounds, coord radius_min, uint nsegment)
+	{
+		return ellipse(
+			bounds.x, bounds.y, bounds.width, bounds.height, radius_min, nsegment);
+	}
+
+	bool
+	Painter::ellipse (
+		const Point& center, coord radius, coord radius_min, uint nsegment)
+	{
+		return ellipse(
+			center.x, center.y, radius * 2, radius * 2, radius_min, nsegment);
+	}
+
 	bool
 	Painter::arc (
 		coord x, coord y, coord width, coord height,
-		float angle_from, float angle_to, coord radius_min,
-		uint nsegment)
+		float angle_from, float angle_to, coord radius_min, uint nsegment)
 	{
 		if (nsegment <= 0) nsegment = ELLIPSE_NSEGMENT;
 		return draw_ellipse(
 			this, x, y, width, height, angle_from, angle_to, radius_min, nsegment);
 	}
 
+	bool
+	Painter::arc (
+		const Bounds& bounds,
+		float angle_from, float angle_to, coord radius_min, uint nsegment)
+	{
+		return arc(
+			bounds.x, bounds.y, bounds.width, bounds.height,
+			angle_from, angle_to, radius_min, nsegment);
+	}
+
+	bool
+	Painter::arc (
+		const Point& center, coord radius,
+		float angle_from, float angle_to, coord radius_min, uint nsegment)
+	{
+		return arc(
+			center.x, center.y, radius * 2, radius * 2,
+			angle_from, angle_to, radius_min, nsegment);
+	}
+
 	static bool
 	draw_image (
 		Painter* painter, const Texture& tex,
@@ -404,11 +386,11 @@ namespace Rays
 		if (!painter || !painter->self->painting)
 			return false;
 
-		coord x2 = x + width;
-		coord y2 = y + height;
+		coord x2 = x + width  - 1;
+		coord y2 = y + height - 1;
 
 		glEnable(GL_TEXTURE_2D);
-		painter->texture(tex);
+		painter->set_texture(tex);
 
 		bool ret = true;
 		for (int i = 0; i < 2; ++i)
@@ -422,10 +404,10 @@ namespace Rays
 
 			if (!painter->begin_shape(TYPES[i])) return false;
 			ret &=
-				painter->vertex(x,  y,  s_min, t_min) &&
-				painter->vertex(x,  y2, s_min, t_max) &&
-				painter->vertex(x2, y2, s_max, t_max) &&
-				painter->vertex(x2, y,  s_max, t_min);
+				painter->add_vertex(x,  y,  s_min, t_min) &&
+				painter->add_vertex(x,  y2, s_min, t_max) &&
+				painter->add_vertex(x2, y2, s_max, t_max) &&
+				painter->add_vertex(x2, y,  s_max, t_min);
 			if (!painter->end_shape()) return false;
 		}
 
@@ -449,6 +431,12 @@ namespace Rays
 			x, y, tex.width(), tex.height());
 	}
 
+	bool
+	Painter::image (const Image& image_, const Point& position)
+	{
+		return image(image_, position.x, position.y);
+	}
+
 	bool
 	Painter::image (
 		const Image& image_, coord x, coord y, coord width, coord height)
@@ -464,6 +452,13 @@ namespace Rays
 			x, y, width,       height);
 	}
 
+	bool
+	Painter::image (
+		const Image& image_, const Bounds& bounds)
+	{
+		return image(image_, bounds.x, bounds.y, bounds.width, bounds.height);
+	}
+
 	bool
 	Painter::image (
 		const Image& image_,
@@ -483,6 +478,16 @@ namespace Rays
 			dest_x,     dest_y,     dest_width,     dest_height);
 	}
 
+	bool
+	Painter::image (
+		const Image& image_, const Bounds& src_bounds, const Point& dest_position)
+	{
+		return image(
+			image_,
+			src_bounds.x, src_bounds.y, src_bounds.width, src_bounds.height,
+			dest_position.x, dest_position.y);
+	}
+
 	bool
 	Painter::image (
 		const Image& image_,
@@ -502,6 +507,16 @@ namespace Rays
 			dest_x,     dest_y,     dest_width,     dest_height);
 	}
 
+	bool
+	Painter::image (
+		const Image& image_, const Bounds& src_bounds, const Bounds& dest_bounds)
+	{
+		return image(
+			image_,
+			 src_bounds.x,  src_bounds.y,  src_bounds.width,  src_bounds.height,
+			dest_bounds.x, dest_bounds.y, dest_bounds.width, dest_bounds.height);
+	}
+
 	static bool
 	draw_text (
 		Painter* painter, const char* str, coord str_width, coord str_height,
@@ -514,15 +529,17 @@ namespace Rays
 			return false;
 
 		Painter::Data* self = painter->self.get();
+		int tex_w = ceil(str_width);
+		int tex_h = ceil(str_height);
 
 		if (
-			self->textimage.width()  < str_width ||
-			self->textimage.height() < str_height)
+			self->textimage.width()  < tex_w ||
+			self->textimage.height() < tex_h)
 		{
-			coord w = std::max((coord) self->textimage.width(),  str_width);
-			coord h = std::max((coord) self->textimage.height(), str_height);
 			self->textimage = Image(
-				w + 1, h + 1, self->textimage.color_space(),
+				std::max(self->textimage.width(),  tex_w),
+				std::max(self->textimage.height(), tex_h),
+				self->textimage.color_space(),
 				self->textimage.alpha_texture());
 		}
 
@@ -534,44 +551,93 @@ namespace Rays
 		const Texture& tex = self->textimage.texture();
 		if (!tex) return false;
 
-		float s = tex.s_max() / tex.width();
-		float t = tex.t_max() / tex.height();
-		return draw_image(
+		#ifdef DEBUG
+			save_image(self->textimage, "/Users/snori/font.png");
+
+			painter->push_attrs();
+			{
+				coord asc, desc, lead;
+				font.get_height(NULL, &asc, &desc, &lead);
+				//printf("%f %f %f %f \n", str_height, asc, desc, lead);
+
+				painter->set_stroke(0.5, 0.5, 1);
+				painter->no_fill();
+				painter->rect(x - 1, y - 1, str_width + 2, str_height + 2);
+
+				coord yy = y;
+				painter->set_stroke(1, 0.5, 0.5, 0.4);
+				painter->rect(x, yy, str_width, asc);//str_height);
+
+				yy += asc;
+				painter->set_stroke(1, 1, 0.5, 0.4);
+				painter->rect(x, yy, str_width, desc);
+
+				yy += desc;
+				painter->set_stroke(1, 0.5, 1, 0.4);
+				painter->rect(x, yy, str_width, lead);
+			}
+			painter->pop_attrs();
+		#endif
+
+		bool ret = draw_image(
 			painter, tex,
-			0, 0, str_width * s, str_height * t,
-			x, y, width,         height,
+			0, 0, tex.s(str_width - 1), tex.t(str_height - 1),
+			x, y, width,                height,
 			true);
+
+		return ret;
 	}
 
 	bool
-	Painter::text (const char* str, coord x, coord y, const Font& font)
+	Painter::text (const char* str, coord x, coord y, const Font* font)
 	{
-		if (!str || !font) return false;
+		if (!str) return false;
 
 		if (*str == '\0') return true;
 
+		if (!font) font = &self->attrs.font;
+		if (!*font) return false;
+
 		coord w = 0, h = 0;
-		if (!font.get_extent(&w, &h, str))
+		if (!font->get_width(&w, str) || !font->get_height(&h))
 			return false;
 
-		return draw_text(
-			this, str, w, h, x, y, w, h, font);
+		w = ceil(w);
+		h = ceil(h);
+		return draw_text(this, str, w, h, x, y, w, h, *font);
+	}
+
+	bool
+	Painter::text (const char* str, const Point& position, const Font* font)
+	{
+		return text(str, position.x, position.y, font);
 	}
 
 	bool
 	Painter::text (
 		const char* str, coord x, coord y, coord width, coord height,
-		const Font& font)
+		const Font* font)
 	{
-		if (!str || !font) return false;
+		if (!str) return false;
 
 		if (*str == '\0') return true;
 
+		if (!font) font = &self->attrs.font;
+		if (!*font) return false;
+
 		coord w = 0, h = 0;
-		if (!font.get_extent(&w, &h, str))
+		if (!font->get_width(&w, str) || !font->get_height(&h))
 			return false;
 
-		return draw_text(this, str, w, h, x, y, width, height, font);
+		w = ceil(w);
+		h = ceil(h);
+		return draw_text(this, str, w, h, x, y, width, height, *font);
+	}
+
+	bool
+	Painter::text (const char* str, const Bounds& bounds, const Font* font)
+	{
+		return text(str, bounds.x, bounds.y, bounds.width, bounds.height, font);
 	}
 
 	bool
@@ -579,91 +645,106 @@ namespace Rays
 	{
 		if (!self->painting) return false;
 
+		const Color& c = self->attrs.background;
+		glClearColor(c.red, c.green, c.blue, c.alpha);
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 		return true;
 	}
 
 	bool
-	Painter::get_clear (float* red, float* green, float* blue, float* alpha)
+	Painter::set_background (float red, float green, float blue, float alpha)
 	{
-		return self->clear.get(red, green, blue, alpha);
+		self->attrs.background.set(red, green, blue, alpha);
+		return true;
 	}
 
 	bool
-	Painter::set_clear (float red, float green, float blue, float alpha)
+	Painter::set_background (const Color& color)
 	{
-		self->clear.set(red, green, blue, alpha);
-		glClearColor(red, green, blue, alpha);
+		self->attrs.background = color;
 		return true;
 	}
 
 	bool
-	Painter::no_clear ()
+	Painter::no_background ()
 	{
-		return set_clear(
-			self->clear.red, self->clear.green, self->clear.blue, 0);
+		self->attrs.background.alpha = 0;
+		return true;
 	}
 
-	bool
-	Painter::get_fill (float* red, float* green, float* blue, float* alpha)
+	const Color&
+	Painter::background () const
 	{
-		return self->colors[FILL].get(red, green, blue, alpha);
+		return self->attrs.background;
 	}
 
 	bool
 	Painter::set_fill (float red, float green, float blue, float alpha)
 	{
-		self->colors[FILL].set(red, green, blue, alpha);
+		self->attrs.colors[FILL].set(red, green, blue, alpha);
 		return true;
 	}
 
 	bool
-	Painter::no_fill ()
+	Painter::set_fill (const Color& color)
 	{
-		self->colors[FILL].alpha = 0;
+		self->attrs.colors[FILL] = color;
 		return true;
 	}
 
 	bool
-	Painter::get_stroke (float* red, float* green, float* blue, float* alpha)
+	Painter::no_fill ()
 	{
-		return self->colors[STROKE].get(red, green, blue, alpha);
+		self->attrs.colors[FILL].alpha = 0;
+		return true;
+	}
+
+	const Color&
+	Painter::fill () const
+	{
+		return self->attrs.colors[FILL];
 	}
 
 	bool
 	Painter::set_stroke (float red, float green, float blue, float alpha)
 	{
-		self->colors[STROKE].set(red, green, blue, alpha);
+		self->attrs.colors[STROKE].set(red, green, blue, alpha);
 		return true;
 	}
 
 	bool
-	Painter::no_stroke ()
+	Painter::set_stroke (const Color& color)
 	{
-		self->colors[STROKE].alpha = 0;
+		self->attrs.colors[STROKE] = color;
 		return true;
 	}
 
 	bool
-	Painter::get_clip (coord* x, coord* y, coord* width, coord* height)
+	Painter::no_stroke ()
+	{
+		self->attrs.colors[STROKE].alpha = 0;
+		return true;
+	}
+
+	const Color&
+	Painter::stroke () const
 	{
-		return self->clip.get(x, y, width, height);
+		return self->attrs.colors[STROKE];
 	}
 
 	bool
 	Painter::set_clip (coord x, coord y, coord width, coord height)
 	{
-		self->clip.set(x, y, width, height);
-		if (!self->update_clip())
-			return false;
+		return set_clip(Bounds(x, y, width, height));
+	}
 
-		if (self->clip)
-		{
-			glScissor(
-				self->clip.x, -self->clip.y, self->clip.width, self->clip.height);
-		}
+	bool
+	Painter::set_clip (const Bounds& bounds)
+	{
+		if (bounds == self->attrs.clip) return true;
 
-		return true;
+		self->attrs.clip = bounds;
+		return self->update_clip();
 	}
 
 	bool
@@ -672,6 +753,154 @@ namespace Rays
 		return set_clip(0, 0, -1, -1);
 	}
 
+	const Bounds&
+	Painter::clip () const
+	{
+		return self->attrs.clip;
+	}
+
+	bool
+	Painter::set_font (const Font& font)
+	{
+		self->attrs.font = font;
+		return true;
+	}
+
+	const Font&
+	Painter::font () const
+	{
+		return self->attrs.font;
+	}
+
+	bool
+	Painter::push_attrs ()
+	{
+		//glPushAttrib(GL_ALL_ATTRIB_BITS);
+		self->attrs_stack.push_back(self->attrs);
+		return true;
+	}
+
+	bool
+	Painter::pop_attrs ()
+	{
+		if (self->attrs_stack.empty()) return false;
+
+		self->attrs = self->attrs_stack.back();
+		self->attrs_stack.pop_back();
+		self->update_clip();
+
+		//glPopAttrib();
+		return true;
+	}
+
+
+	bool
+	Painter::translate (coord x, coord y, coord z)
+	{
+		glTranslatef(x, y, z);
+		return !is_error();
+	}
+
+	bool
+	Painter::translate (const Point& value)
+	{
+		return translate(value.x, value.y, value.z);
+	}
+
+	bool
+	Painter::scale (coord x, coord y, coord z)
+	{
+		glScalef(x, y, z);
+		return !is_error();
+	}
+
+	bool
+	Painter::scale (const Point& value)
+	{
+		return scale(value.x, value.y, value.z);
+	}
+
+	bool
+	Painter::rotate (float angle, coord x, coord y, coord z)
+	{
+		glRotatef(angle, x, y, z);
+		return !is_error();
+	}
+
+	bool
+	Painter::rotate (float angle, const Point& center)
+	{
+		return rotate(angle, center.x, center.y, center.z);
+	}
+
+	bool
+	Painter::set_matrix (float value)
+	{
+		if (value == 1)
+		{
+			glLoadIdentity();
+			return !is_error();
+		}
+
+		return set_matrix(
+			value, 0, 0, 0,
+			0, value, 0, 0,
+			0, 0, value, 0,
+			0, 0, 0, value);
+	}
+
+	bool
+	Painter::set_matrix (
+		float a1, float a2, float a3, float a4,
+		float b1, float b2, float b3, float b4,
+		float c1, float c2, float c3, float c4,
+		float d1, float d2, float d3, float d4)
+	{
+		float array[] = {
+			a1, a2, a3, a4,
+			b1, b2, b3, b4,
+			c1, c2, c3, c4,
+			d1, d2, d3, d4
+		};
+		return set_matrix(array);
+	}
+
+	bool
+	Painter::set_matrix (const float* elements)
+	{
+		if (!elements) return false;
+		glLoadMatrixf(elements);
+		return !is_error();
+	}
+
+	bool
+	Painter::set_matrix (const Matrix& matrix)
+	{
+		return set_matrix(matrix.array());
+	}
+
+	const Matrix&
+	Painter::matrix () const
+	{
+		glGetFloatv(GL_MODELVIEW_MATRIX, self->matrix_tmp.array());
+		if (is_error(GL_INVALID_ENUM)) self->matrix_tmp.set(0);
+		return self->matrix_tmp;
+	}
+
+	bool
+	Painter::push_matrix ()
+	{
+		glPushMatrix();
+		return !is_error(GL_STACK_OVERFLOW);
+	}
+
+	bool
+	Painter::pop_matrix ()
+	{
+		glPopMatrix();
+		return !is_error(GL_STACK_UNDERFLOW);
+	}
+
 
 	bool
 	Painter::begin_shape (ShapeType type)
@@ -698,7 +927,7 @@ namespace Rays
 	}
 
 	bool
-	Painter::color (float red, float green, float blue, float alpha)
+	Painter::set_color (float red, float green, float blue, float alpha)
 	{
 		if (!self->drawing) return false;
 
@@ -707,7 +936,16 @@ namespace Rays
 	}
 
 	bool
-	Painter::texture (const Texture& tex)
+	Painter::set_color (const Color& color)
+	{
+		if (!self->drawing) return false;
+
+		glColor4fv(color.array());
+		return true;
+	}
+
+	bool
+	Painter::set_texture (const Texture& tex)
 	{
 		if (!self->drawing) return false;
 
@@ -725,13 +963,13 @@ namespace Rays
 	}
 
 	bool
-	Painter::vertex (coord x, coord y)
+	Painter::add_vertex (coord x, coord y)
 	{
-		return vertex(x, y, 0);
+		return add_vertex(x, y, 0);
 	}
 
 	bool
-	Painter::vertex (coord x, coord y, coord z)
+	Painter::add_vertex (coord x, coord y, coord z)
 	{
 		if (!self->drawing) return false;
 
@@ -740,20 +978,33 @@ namespace Rays
 	}
 
 	bool
-	Painter::vertex (coord x, coord y, coord texcoord_s, coord texcoord_t)
+	Painter::add_vertex (const Point& pos)
 	{
-		return vertex(x, y, 0, texcoord_s, texcoord_t);
+		return add_vertex(pos.x, pos.y, pos.z);
 	}
 
 	bool
-	Painter::vertex (coord x, coord y, coord z, coord texcoord_s, coord texcoord_t)
+	Painter::add_vertex (coord x, coord y, coord tex_s, coord tex_t)
+	{
+		return add_vertex(x, y, 0, tex_s, tex_t);
+	}
+
+	bool
+	Painter::add_vertex (coord x, coord y, coord z, coord tex_s, coord tex_t)
 	{
 		if (!self->drawing) return false;
 
-		glTexCoord2f(texcoord_s, texcoord_t);
-		return vertex(x, y, z);
+		glTexCoord2f(tex_s, tex_t);
+		return add_vertex(x, y, z);
+	}
+
+	bool
+	Painter::add_vertex (const Point& pos, coord tex_s, coord tex_t)
+	{
+		return add_vertex(pos.x, pos.y, pos.z, tex_s, tex_t);
 	}
 
+
 	Painter::operator bool () const
 	{
 		return self->viewport;