rays 0.1.6 → 0.1.7

data/src/painter.cpp

@@ -1,53 +1,45 @@
+
+
 #include "rays/painter.h"
 
 
 #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>
+#include <boost/scoped_array.hpp>
+#include "rays/exception.h"
+#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"
+#include "rays/shader.h"
+#include "frame_buffer.h"
+#include "program.h"
 
 
 namespace Rays
 {
 
 
-	enum ColorOrder
+	enum ColorType
 	{
 
-		FILL = 0, STROKE
-
-	};// ColorOrder
+		FILL = 0,
+		STROKE,
 
+		COLOR_TYPE_LAST,
+		COLOR_TYPE_FIRST = 0
 
-	static const float PI = 3.141592653589793238462643383279f;
-
-	static const float PI_2 = PI * 2;
+	};// ColorType
 
 
-	static void
-	clear_error ()
-	{
-		glGetError();
-	}
-
-	static bool
-	is_error ()
-	{
-		return glGetError() != GL_NO_ERROR;
-	}
+	static const float PI   = 3.141592653589793238462643383279f;
 
-	static bool
-	is_error (GLenum error)
-	{
-		return glGetError() == error;
-	}
+	static const float PI_2 = PI * 2;
 
 
 	struct Attributes
@@ -61,16 +53,29 @@ namespace Rays
 
 		void init ()
 		{
-			clip           .set(-1);
-			background     .set(0, 0);
-			colors[FILL]   .set(0, 0);
-			colors[STROKE] .set(0, 0);
+			clip           .reset(-1);
+			background     .reset(0, 0);
+			colors[FILL]   .reset(1, 1);
+			colors[STROKE] .reset(1, 0);
 			font           = default_font();
 		}
 
 	};// Attributes
 
 
+	struct coord2 {
+
+		coord x, y;
+
+		void reset (coord x_, coord y_)
+		{
+			x = x_;
+			y = y_;
+		}
+
+	};// coord2
+
+
 	struct Painter::Data
 	{
 
@@ -78,35 +83,28 @@ namespace Rays
 
 		Attributes attrs;
 
+		Program program;
+
 		std::list<Attributes> attrs_stack;
 
-		bool painting, drawing;
+		bool painting;
 
-		Image textimage;
+		GLuint current_texture;
+
+		Image text_image;
+
+		FrameBuffer frame_buffer;
 
 		mutable Matrix matrix_tmp;
 
 		Data ()
-		:	painting(false), drawing(false), textimage(1, 1, GRAY, true)
+		:	painting(false), current_texture(0), text_image(1, 1, GRAY, true)
 		{
 			attrs.init();
 		}
 
-		bool use_color (size_t i)
+		void update_clip ()
 		{
-			clear_error();
-
-			const Color& col = attrs.colors[i];
-			if (col.alpha <= 0) return false;
-
-			glColor4fv(col.array());
-			return !is_error();
-		}
-
-		bool update_clip ()
-		{
-			clear_error();
-
 			if (attrs.clip)
 			{
 				glEnable(GL_SCISSOR_TEST);
@@ -121,7 +119,71 @@ namespace Rays
 				glDisable(GL_SCISSOR_TEST);
 			}
 
-			return !is_error();
+			check_error(__FILE__, __LINE__);
+		}
+
+		GLuint frame_buffer_id () const
+		{
+			return frame_buffer ? frame_buffer.id() : 0;
+		}
+
+		bool use_color (ColorType type)
+		{
+			const Color& c = attrs.colors[type];
+			if (c.alpha <= 0) return false;
+
+			glColor4f(c.red, c.green, c.blue, c.alpha);
+			return true;
+		}
+
+		void draw_shape (
+			GLenum mode,
+			int nindices, const uint* indices,
+			int vertex_size, const coord* vertices,
+			const coord* tex_coords = NULL, const Texture* texture = NULL)
+		{
+			if (nindices <= 0 || !indices || !vertices)
+				argument_error(__FILE__, __LINE__);
+
+			if (!painting)
+				invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
+
+			bool use_texture = texture && tex_coords;
+
+			if (use_texture)
+			{
+				if (!*texture)
+					argument_error(__FILE__, __LINE__, "invalid texture.");
+
+				GLuint id = texture->id();
+				if (id != current_texture)
+				{
+					glBindTexture(GL_TEXTURE_2D, id);
+					current_texture = id;
+				}
+
+				glEnable(GL_TEXTURE_2D);
+
+				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+				glTexCoordPointer(2, GL_FLOAT, 0, tex_coords);
+			}
+			else
+			{
+				glDisable(GL_TEXTURE_2D);
+				glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+			}
+
+			glEnableClientState(GL_VERTEX_ARRAY);
+			glVertexPointer(vertex_size, GL_FLOAT, 0, vertices);
+
+			glDrawElements(mode, nindices, GL_UNSIGNED_INT, indices);
+
+			glDisableClientState(GL_VERTEX_ARRAY);
+			if (use_texture)
+			{
+				glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+				glDisable(GL_TEXTURE_2D);
+			}
 		}
 
 	};// Painter::Data
@@ -135,142 +197,261 @@ namespace Rays
 	{
 	}
 
-	bool
+	void
 	Painter::canvas (coord x, coord y, coord width, coord height)
 	{
-		return canvas(Bounds(x, y, -100, width, height, 200));
+		canvas(Bounds(x, y, -100, width, height, 200));
 	}
 
-	bool
+	void
 	Painter::canvas (coord x, coord y, coord z, coord width, coord height, coord depth)
 	{
-		return canvas(Bounds(x, y, z, width, height, depth));
+		canvas(Bounds(x, y, z, width, height, depth));
 	}
 
-	bool
+	void
 	Painter::canvas (const Bounds& bounds)
 	{
-		if (self->painting || !bounds) return false;
+		if (!bounds)
+			argument_error(__FILE__, __LINE__);
+
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+
+		self->viewport = bounds;
+	}
+
+	void
+	Painter::bind (const Texture& texture)
+	{
+		if (!texture)
+			argument_error(__FILE__, __LINE__, "invalid texture.");
+
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+
+		FrameBuffer fb(texture);
+		if (!fb)
+			rays_error(__FILE__, __LINE__, "invalid frame buffer.");
+
+		unbind();
+
+		self->frame_buffer = fb;
+		canvas(0, 0, fb.width(), fb.height());
+	}
+
+	void
+	Painter::unbind ()
+	{
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+
+		self->frame_buffer = FrameBuffer();
+	}
+
+	const Bounds&
+	Painter::bounds () const
+	{
+		return self->viewport;
+	}
+
+
+	void
+	Painter::begin ()
+	{
+		if (self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+
+		GLuint fb = self->frame_buffer_id();
+		bind_frame_buffer(fb);
+
+		push_attr();
+		push_shader();
 
-		const Bounds& b = self->viewport = bounds;
+		const Bounds& vp = self->viewport;
+		glViewport((int) vp.x, (int)vp.y, (int) vp.width, (int) vp.height);
 
-		glViewport((int) b.x, (int) b.y, (int) b.width, (int) b.height);
+		coord x1 = vp.x, x2 = vp.x + vp.width;
+		coord y1 = vp.y, y2 = vp.y + vp.height;
+		coord z1 = vp.z, z2 = vp.z + vp.depth;
+		if (z1 == 0 && z2 == 0) {z1 = -100; z2 = 200;}
+		if (fb == 0)            std::swap(y1, y2);
 
 		glMatrixMode(GL_PROJECTION);
+		glPushMatrix();
 		glLoadIdentity();
-		glOrtho(b.x, b.x + b.width, b.y + b.height, b.y, b.z, b.z + b.depth);
+		glOrtho(x1, x2, y1, y2, z1, z2);
 
 		glMatrixMode(GL_MODELVIEW);
+		glPushMatrix();
 		glLoadIdentity();
 		glTranslatef(0.375f, 0.375f, 0);
 
-		return true;
-	}
+		glMatrixMode(GL_TEXTURE);
+		glPushMatrix();
+		glLoadIdentity();
 
-	bool
-	Painter::begin ()
-	{
-		if (self->painting) return false;
+	#ifndef IOS
+		glMatrixMode(GL_COLOR);
+		glPushMatrix();
+		glLoadIdentity();
+	#endif
 
-		push_attrs();
+		glMatrixMode(GL_MODELVIEW);
 
-		glEnable(GL_CULL_FACE);
+		//glEnable(GL_CULL_FACE);
 		glEnable(GL_BLEND);
 		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
+		check_error(__FILE__, __LINE__);
+
 		self->painting = true;
 
 		no_clip();
-		clear();
-
-		return push_matrix();
 	}
 
-	bool
+	void
 	Painter::end ()
 	{
-		if (!self->painting) return false;
-
-		pop_matrix();
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
 		self->painting = false;
 
 		glDisable(GL_BLEND);
 		glDisable(GL_CULL_FACE);
 
-		return pop_attrs();
+		glMatrixMode(GL_PROJECTION);
+		glPopMatrix();
+
+		glMatrixMode(GL_MODELVIEW);
+		glPopMatrix();
+
+		glMatrixMode(GL_TEXTURE);
+		glPopMatrix();
+
+	#ifndef IOS
+		glMatrixMode(GL_COLOR);
+		glPopMatrix();
+	#endif
+
+		pop_shader();
+		pop_attr();
+
+		//glFinish();
+
+		unbind_frame_buffer();
+
+		Texture& tex = self->frame_buffer.texture();
+		if (tex) tex.set_dirty(true);
 	}
 
+	void
+	Painter::clear ()
+	{
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
-	bool
+		const Color& c = self->attrs.background;
+		glClearColor(c.red, c.green, c.blue, c.alpha);
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+		check_error(__FILE__, __LINE__);
+	}
+
+	void
 	Painter::line (coord x1, coord y1, coord x2, coord y2)
 	{
-		if (!self->painting || !self->use_color(STROKE))
-			return true;
+		static const uint INDICES[] =
+		{
+			0, 1
+		};
+
+		Data* pself = self.get();
+
+		if (!pself->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
-		if (!begin_shape(LINES)) return false;
-		bool ret =
-			add_vertex(x1, y1) &&
-			add_vertex(x2, y2);
-		if (!end_shape()) return false;
+		if (!pself->use_color(STROKE))
+			return;
 
-		return ret;
+		coord vertices[] =
+		{
+			x1, y1,
+			x2, y2
+		};
+
+		pself->draw_shape(GL_LINES, 2, INDICES, 2, vertices);
 	}
 
-	bool
+	void
 	Painter::line (const Point& p1, const Point& p2)
 	{
-		return line(p1.x, p1.y, p2.x, p2.y);
+		line(p1.x, p1.y, p2.x, p2.y);
 	}
 
-	bool
+	void
 	Painter::rect (coord x, coord y, coord width, coord height)
 	{
-		static const ShapeType TYPES[] = {QUADS, LINE_LOOP};
+		static const GLenum MODES[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
+		static const uint INDICES[] =
+		{
+			0, 1, 2, 3
+		};
+
+		Data* pself = self.get();
 
-		if (!self->painting) return false;
+		if (!pself->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
-		if (width <= 0 || height <= 0) return true;
+		if (width <= 0 || height <= 0) return;
 
 		coord x2 = x + width  - 1;
 		coord y2 = y + height - 1;
 
-		bool ret = true;
-		for (int i = 0; i < 2; ++i)
+		for (int type = COLOR_TYPE_FIRST; type < COLOR_TYPE_LAST; ++type)
 		{
-			if (!self->use_color(i)) continue;
-
-			if (!begin_shape(TYPES[i])) return false;
-			coord xx = x2 + 1 - i;
-			coord yy = y2 + 1 - i;
-			ret &=
-				add_vertex(x,  y)  &&
-				add_vertex(x,  yy) &&
-				add_vertex(xx, yy) &&
-				add_vertex(xx, y);
-			if (!end_shape()) return false;
-		}
+			if (!pself->use_color((ColorType) type)) continue;
+
+			coord xx = x2 + 1 - type;
+			coord yy = y2 + 1 - type;
+			coord vertices[] =
+			{
+				x,  y,
+				x,  yy,
+				xx, yy,
+				xx, y
+			};
 
-		return ret;
+			pself->draw_shape(MODES[type], 4, INDICES, 2, vertices);
+		}
 	}
 
-	bool
+	void
 	Painter::rect (const Bounds& bounds)
 	{
-		return rect(bounds.x, bounds.y, bounds.width, bounds.height);
+		rect(bounds.x, bounds.y, bounds.width, bounds.height);
 	}
 
-	static bool
+	static const uint ELLIPSE_NSEGMENT = 32;
+
+	static void
 	draw_ellipse (
 		Painter* painter,
 		coord x, coord y, coord width, coord height,
 		float angle_from, float angle_to, coord radius_min,
 		uint nsegment)
 	{
-		if (!painter || !painter->self->painting)
-			return false;
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
 
-		if (height == 0) height = width;
+		Painter::Data* pself = painter->self.get();
+
+		if (!pself->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+
+		if (height   == 0) height   = width;
+		if (nsegment <= 0) nsegment = ELLIPSE_NSEGMENT;
 
 		coord radius_x     = width  / 2;
 		coord radius_y     = height / 2;
@@ -279,245 +460,274 @@ namespace Rays
 		float from         = angle_from / 360.f;
 		float to           = angle_to   / 360.f;
 		bool hole          = radius_min != 0;
-		ShapeType types[]  =
+		int nvertices      = hole ? nsegment * 2 : nsegment + 1;
+		GLenum modes[]     =
 		{
-			hole ? TRIANGLE_STRIP : TRIANGLE_FAN,
-			LINE_LOOP
+			(GLenum) (hole ? GL_TRIANGLE_STRIP : GL_TRIANGLE_FAN),
+			GL_LINE_LOOP
 		};
+		boost::scoped_array<uint> indices;
+		boost::scoped_array<coord2> vertices;
 
 		x += radius_x;
 		y += radius_y;
 
-		bool ret = true;
-		for (int i = 0; i < 2; ++i)
+		for (int type = COLOR_TYPE_FIRST; type < COLOR_TYPE_LAST; ++type)
 		{
-			if (!painter->self->use_color(i)) continue;
+			if (!pself->use_color((ColorType) type)) continue;
+
+			if (!indices.get())
+			{
+				indices.reset(new uint[nvertices]);
+				for (int i = 0; i < nvertices; ++i)
+					indices[i] = i;
+			}
+
+			if (!vertices.get())
+				vertices.reset(new coord2[nvertices]);
 
-			if (!painter->begin_shape(types[i])) return false;
+			coord2* vertex = vertices.get();
+			assert(vertex);
 
 			if (!hole)
-				ret &= painter->add_vertex(x, y);
+			{
+				vertex->reset(x, y);
+				++vertex;
+			}
 
-			for (int seg = 0; seg <= (int) nsegment; ++seg)
+			for (int seg = 0; seg <= (int) nsegment; ++seg, ++vertex)
 			{
 				float pos    = (float) seg / (float) nsegment;
 				float radian = (from + (to - from) * pos) * PI_2;
 				float xx     = cos(radian);
 				float yy     = -sin(radian);
+
 				if (hole)
-					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);
+					vertex->reset(x + xx * radius_x_min, y + yy * radius_y_min);
+				vertex  ->reset(x + xx * radius_x,     y + yy * radius_y);
 			}
 
-			if (!painter->end_shape()) return false;
+			pself->draw_shape(modes[type], nvertices, indices.get(), 2, (coord*) vertices.get());
 		}
-
-		return ret;
 	}
 
-	static const uint ELLIPSE_NSEGMENT = 32;
-
-	bool
+	void
 	Painter::ellipse (
 		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);
+		draw_ellipse(this, x, y, width, height, 0, 360, radius_min, nsegment);
 	}
 
-	bool
+	void
 	Painter::ellipse (const Bounds& bounds, coord radius_min, uint nsegment)
 	{
-		return ellipse(
+		ellipse(
 			bounds.x, bounds.y, bounds.width, bounds.height, radius_min, nsegment);
 	}
 
-	bool
+	void
 	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);
+		ellipse(center.x, center.y, radius * 2, radius * 2, radius_min, nsegment);
 	}
 
-	bool
+	void
 	Painter::arc (
 		coord x, coord y, coord width, coord height,
 		float angle_from, float angle_to, coord radius_min, uint nsegment)
 	{
-		if (nsegment <= 0) nsegment = ELLIPSE_NSEGMENT;
-		return draw_ellipse(
+		draw_ellipse(
 			this, x, y, width, height, angle_from, angle_to, radius_min, nsegment);
 	}
 
-	bool
+	void
 	Painter::arc (
 		const Bounds& bounds,
 		float angle_from, float angle_to, coord radius_min, uint nsegment)
 	{
-		return arc(
+		arc(
 			bounds.x, bounds.y, bounds.width, bounds.height,
 			angle_from, angle_to, radius_min, nsegment);
 	}
 
-	bool
+	void
 	Painter::arc (
 		const Point& center, coord radius,
 		float angle_from, float angle_to, coord radius_min, uint nsegment)
 	{
-		return arc(
+		arc(
 			center.x, center.y, radius * 2, radius * 2,
 			angle_from, angle_to, radius_min, nsegment);
 	}
 
-	static bool
+	static void
 	draw_image (
 		Painter* painter, const Texture& tex,
 		float s_min, float t_min, float s_max, float t_max,
 		coord x, coord y, coord width, coord height,
 		bool nostroke = false)
 	{
-		static const ShapeType TYPES[] = {QUADS, LINE_LOOP};
+		static const GLenum MODES[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
+		static const uint INDICES[] =
+		{
+			0, 1, 2, 3
+		};
 
 		assert(tex);
 
-		if (!painter || !painter->self->painting)
-			return false;
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
+
+		Painter::Data* pself = painter->self.get();
+
+		if (!pself->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
 		coord x2 = x + width  - 1;
 		coord y2 = y + height - 1;
+		coord vertices[] =
+		{
+			x,  y,
+			x,  y2,
+			x2, y2,
+			x2, y
+		};
 
-		glEnable(GL_TEXTURE_2D);
-		painter->set_texture(tex);
-
-		bool ret = true;
-		for (int i = 0; i < 2; ++i)
+		for (int type = COLOR_TYPE_FIRST; type < COLOR_TYPE_LAST; ++type)
 		{
 			if (
-				(nostroke && TYPES[i] == LINE_LOOP) ||
-				!painter->self->use_color(i))
+				(nostroke && type == STROKE) ||
+				!pself->use_color((ColorType) type))
 			{
 				continue;
 			}
 
-			if (!painter->begin_shape(TYPES[i])) return false;
-			ret &=
-				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;
+			if (type == FILL)
+			{
+				coord tex_coords[] = {
+					s_min, t_min,
+					s_min, t_max,
+					s_max, t_max,
+					s_max, t_min
+				};
+				pself->draw_shape(MODES[type], 4, INDICES, 2, vertices, tex_coords, &tex);
+			}
+			else
+				pself->draw_shape(MODES[type], 4, INDICES, 2, vertices);
 		}
-
-		painter->no_texture();
-		glDisable(GL_TEXTURE_2D);
-
-		return ret;
 	}
 
-	bool
+	void
 	Painter::image (const Image& image_, coord x, coord y)
 	{
-		if (!image_) return false;
+		if (!image_)
+			argument_error(__FILE__, __LINE__);
 
 		const Texture& tex = image_.texture();
-		if (!tex) return false;
+		if (!tex)
+			argument_error(__FILE__, __LINE__);
 
-		return draw_image(
+		draw_image(
 			this, tex,
 			0, 0, tex.s_max(), tex.t_max(),
 			x, y, tex.width(), tex.height());
 	}
 
-	bool
+	void
 	Painter::image (const Image& image_, const Point& position)
 	{
-		return image(image_, position.x, position.y);
+		image(image_, position.x, position.y);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_, coord x, coord y, coord width, coord height)
 	{
-		if (!image_) return false;
+		if (!image_)
+			argument_error(__FILE__, __LINE__);
 
 		const Texture& tex = image_.texture();
-		if (!tex) return false;
+		if (!tex)
+			argument_error(__FILE__, __LINE__);
 
-		return draw_image(
+		draw_image(
 			this, tex,
 			0, 0, tex.s_max(), tex.t_max(),
 			x, y, width,       height);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_, const Bounds& bounds)
 	{
-		return image(image_, bounds.x, bounds.y, bounds.width, bounds.height);
+		image(image_, bounds.x, bounds.y, bounds.width, bounds.height);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_,
 		coord  src_x, coord  src_y, coord src_width, coord src_height,
 		coord dest_x, coord dest_y)
 	{
-		if (!image_) return false;
+		if (!image_)
+			argument_error(__FILE__, __LINE__);
 
 		const Texture& tex = image_.texture();
-		if (!tex) return false;
+		if (!tex)
+			argument_error(__FILE__, __LINE__);
 
 		coord dest_width = tex.width(), dest_height = tex.height();
 		float s = tex.s_max() / dest_width, t = tex.t_max() / dest_height;
-		return draw_image(
+		draw_image(
 			this, tex,
 			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
 			dest_x,     dest_y,     dest_width,     dest_height);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_, const Bounds& src_bounds, const Point& dest_position)
 	{
-		return image(
+		image(
 			image_,
 			src_bounds.x, src_bounds.y, src_bounds.width, src_bounds.height,
 			dest_position.x, dest_position.y);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_,
 		coord  src_x, coord  src_y, coord  src_width, coord  src_height,
 		coord dest_x, coord dest_y, coord dest_width, coord dest_height)
 	{
-		if (!image_) return false;
+		if (!image_)
+			argument_error(__FILE__, __LINE__);
 
 		const Texture& tex = image_.texture();
-		if (!tex) return false;
+		if (!tex)
+			argument_error(__FILE__, __LINE__);
 
 		float s = tex.s_max() / tex.width();
 		float t = tex.t_max() / tex.height();
-		return draw_image(
+		draw_image(
 			this, tex,
 			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
 			dest_x,     dest_y,     dest_width,     dest_height);
 	}
 
-	bool
+	void
 	Painter::image (
 		const Image& image_, const Bounds& src_bounds, const Bounds& dest_bounds)
 	{
-		return image(
+		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
+	static void
 	draw_text (
 		Painter* painter, const char* str, coord str_width, coord str_height,
 		coord x, coord y, coord width, coord height,
@@ -525,39 +735,43 @@ namespace Rays
 	{
 		assert(str && *str != '\0' && font);
 
-		if (!painter || !painter->self->painting)
-			return false;
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
+
+		if (!painter->self->painting)
+			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
 
 		Painter::Data* self = painter->self.get();
 		int tex_w = ceil(str_width);
 		int tex_h = ceil(str_height);
 
 		if (
-			self->textimage.width()  < tex_w ||
-			self->textimage.height() < tex_h)
+			self->text_image.width()  < tex_w ||
+			self->text_image.height() < tex_h)
 		{
-			self->textimage = Image(
-				std::max(self->textimage.width(),  tex_w),
-				std::max(self->textimage.height(), tex_h),
-				self->textimage.color_space(),
-				self->textimage.alpha_texture());
+			self->text_image = Image(
+				std::max(self->text_image.width(),  tex_w),
+				std::max(self->text_image.height(), tex_h),
+				self->text_image.color_space(),
+				self->text_image.alpha_only());
 		}
 
-		if (!self->textimage) return false;
+		if (!self->text_image)
+			invalid_state_error(__FILE__, __LINE__);
 
-		if (!draw_string(&self->textimage.bitmap(), str, 0, 0, font))
-			return false;
+		draw_string(&self->text_image.bitmap(), str, 0, 0, font);
 
-		const Texture& tex = self->textimage.texture();
-		if (!tex) return false;
+		const Texture& tex = self->text_image.texture();
+		if (!tex)
+			rays_error(__FILE__, __LINE__, "text_image's texture is invalid.");
 
 		#ifdef DEBUG
-			save_image(self->textimage, "/Users/snori/font.png");
+			save_image(self->text_image, "/Users/snori/font.png");
 
-			painter->push_attrs();
+			painter->push_attr();
 			{
 				coord asc, desc, lead;
-				font.get_height(NULL, &asc, &desc, &lead);
+				font.get_height(&asc, &desc, &lead);
 				//printf("%f %f %f %f \n", str_height, asc, desc, lead);
 
 				painter->set_stroke(0.5, 0.5, 1);
@@ -576,100 +790,87 @@ namespace Rays
 				painter->set_stroke(1, 0.5, 1, 0.4);
 				painter->rect(x, yy, str_width, lead);
 			}
-			painter->pop_attrs();
+			painter->pop_attr();
 		#endif
 
-		bool ret = draw_image(
+		draw_image(
 			painter, tex,
 			0, 0, tex.s(str_width - 1), tex.t(str_height - 1),
 			x, y, width,                height,
 			true);
-
-		return ret;
 	}
 
-	bool
+	void
 	Painter::text (const char* str, coord x, coord y, const Font* font)
 	{
-		if (!str) return false;
+		if (!str)
+			argument_error(__FILE__, __LINE__);
 
-		if (*str == '\0') return true;
+		if (*str == '\0') return;
 
 		if (!font) font = &self->attrs.font;
-		if (!*font) return false;
-
-		coord w = 0, h = 0;
-		if (!font->get_width(&w, str) || !font->get_height(&h))
-			return false;
+		if (!*font)
+			argument_error(__FILE__, __LINE__);
 
+		coord w = font->get_width(str), h = font->get_height();
 		w = ceil(w);
 		h = ceil(h);
-		return draw_text(this, str, w, h, x, y, w, h, *font);
+		draw_text(this, str, w, h, x, y, w, h, *font);
 	}
 
-	bool
+	void
 	Painter::text (const char* str, const Point& position, const Font* font)
 	{
-		return text(str, position.x, position.y, font);
+		text(str, position.x, position.y, font);
 	}
 
-	bool
+	void
 	Painter::text (
 		const char* str, coord x, coord y, coord width, coord height,
 		const Font* font)
 	{
-		if (!str) return false;
+		if (!str)
+			argument_error(__FILE__, __LINE__);
 
-		if (*str == '\0') return true;
+		if (*str == '\0') return;
 
 		if (!font) font = &self->attrs.font;
-		if (!*font) return false;
-
-		coord w = 0, h = 0;
-		if (!font->get_width(&w, str) || !font->get_height(&h))
-			return false;
+		if (!*font)
+			argument_error(__FILE__, __LINE__);
 
+		coord w = font->get_width(str), h = font->get_height();
 		w = ceil(w);
 		h = ceil(h);
-		return draw_text(this, str, w, h, x, y, width, height, *font);
+		draw_text(this, str, w, h, x, y, width, height, *font);
 	}
 
-	bool
+	void
 	Painter::text (const char* str, const Bounds& bounds, const Font* font)
 	{
-		return text(str, bounds.x, bounds.y, bounds.width, bounds.height, font);
+		text(str, bounds.x, bounds.y, bounds.width, bounds.height, font);
 	}
 
-	bool
-	Painter::clear ()
-	{
-		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::set_background (float red, float green, float blue, float alpha)
+	void
+	Painter::set_background (float red, float green, float blue, float alpha, bool clear)
 	{
-		self->attrs.background.set(red, green, blue, alpha);
-		return true;
+		set_background(Color(red, green, blue, alpha), clear);
 	}
 
-	bool
-	Painter::set_background (const Color& color)
+	void
+	Painter::set_background (const Color& color, bool clear)
 	{
 		self->attrs.background = color;
-		return true;
+
+		if (self->painting && clear) this->clear();
 	}
 
-	bool
-	Painter::no_background ()
+	void
+	Painter::no_background (bool clear)
 	{
-		self->attrs.background.alpha = 0;
-		return true;
+		Color c = background();
+		c.alpha = 0;
+		set_background(c, clear);
 	}
 
 	const Color&
@@ -678,25 +879,22 @@ namespace Rays
 		return self->attrs.background;
 	}
 
-	bool
+	void
 	Painter::set_fill (float red, float green, float blue, float alpha)
 	{
-		self->attrs.colors[FILL].set(red, green, blue, alpha);
-		return true;
+		set_fill(Color(red, green, blue, alpha));
 	}
 
-	bool
+	void
 	Painter::set_fill (const Color& color)
 	{
 		self->attrs.colors[FILL] = color;
-		return true;
 	}
 
-	bool
+	void
 	Painter::no_fill ()
 	{
 		self->attrs.colors[FILL].alpha = 0;
-		return true;
 	}
 
 	const Color&
@@ -705,25 +903,22 @@ namespace Rays
 		return self->attrs.colors[FILL];
 	}
 
-	bool
+	void
 	Painter::set_stroke (float red, float green, float blue, float alpha)
 	{
-		self->attrs.colors[STROKE].set(red, green, blue, alpha);
-		return true;
+		set_stroke(Color(red, green, blue, alpha));
 	}
 
-	bool
+	void
 	Painter::set_stroke (const Color& color)
 	{
 		self->attrs.colors[STROKE] = color;
-		return true;
 	}
 
-	bool
+	void
 	Painter::no_stroke ()
 	{
 		self->attrs.colors[STROKE].alpha = 0;
-		return true;
 	}
 
 	const Color&
@@ -732,25 +927,23 @@ namespace Rays
 		return self->attrs.colors[STROKE];
 	}
 
-	bool
+	void
 	Painter::set_clip (coord x, coord y, coord width, coord height)
 	{
-		return set_clip(Bounds(x, y, width, height));
+		set_clip(Bounds(x, y, width, height));
 	}
 
-	bool
+	void
 	Painter::set_clip (const Bounds& bounds)
 	{
-		if (bounds == self->attrs.clip) return true;
-
 		self->attrs.clip = bounds;
-		return self->update_clip();
+		self->update_clip();
 	}
 
-	bool
+	void
 	Painter::no_clip ()
 	{
-		return set_clip(0, 0, -1, -1);
+		set_clip(0, 0, -1, -1);
 	}
 
 	const Bounds&
@@ -759,11 +952,16 @@ namespace Rays
 		return self->attrs.clip;
 	}
 
-	bool
+	void
+	Painter::set_font (const char* name, coord size)
+	{
+		set_font(Font(name, size));
+	}
+
+	void
 	Painter::set_font (const Font& font)
 	{
 		self->attrs.font = font;
-		return true;
 	}
 
 	const Font&
@@ -772,236 +970,212 @@ namespace Rays
 		return self->attrs.font;
 	}
 
-	bool
-	Painter::push_attrs ()
+	void
+	Painter::push_attr ()
 	{
-		//glPushAttrib(GL_ALL_ATTRIB_BITS);
 		self->attrs_stack.push_back(self->attrs);
-		return true;
 	}
 
-	bool
-	Painter::pop_attrs ()
+	void
+	Painter::pop_attr ()
 	{
-		if (self->attrs_stack.empty()) return false;
+		if (self->attrs_stack.empty())
+			rays_error(__FILE__, __LINE__, "attrs_stack is empty.");
 
 		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)
+	void
+	Painter::attach (const Shader& shader)
 	{
-		glTranslatef(x, y, z);
-		return !is_error();
+		self->program.attach(shader);
 	}
 
-	bool
-	Painter::translate (const Point& value)
+	void
+	Painter::detach (const Shader& shader)
 	{
-		return translate(value.x, value.y, value.z);
+		self->program.detach(shader);
 	}
 
-	bool
-	Painter::scale (coord x, coord y, coord z)
+	void
+	Painter::set_uniform (const char* name, int arg1)
 	{
-		glScalef(x, y, z);
-		return !is_error();
+		self->program.set_uniform(name, arg1);
 	}
 
-	bool
-	Painter::scale (const Point& value)
+	void
+	Painter::set_uniform (const char* name, int arg1, int arg2)
 	{
-		return scale(value.x, value.y, value.z);
+		self->program.set_uniform(name, arg1, arg2);
 	}
 
-	bool
-	Painter::rotate (float angle, coord x, coord y, coord z)
+	void
+	Painter::set_uniform (const char* name, int arg1, int arg2, int arg3)
 	{
-		glRotatef(angle, x, y, z);
-		return !is_error();
+		self->program.set_uniform(name, arg1, arg2, arg3);
 	}
 
-	bool
-	Painter::rotate (float angle, const Point& center)
+	void
+	Painter::set_uniform (const char* name, int arg1, int arg2, int arg3, int arg4)
 	{
-		return rotate(angle, center.x, center.y, center.z);
+		self->program.set_uniform(name, arg1, arg2, arg3, arg4);
 	}
 
-	bool
-	Painter::set_matrix (float value)
+	void
+	Painter::set_uniform (const char* name, const int* args, size_t size)
 	{
-		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);
+		self->program.set_uniform(name, args, size);
 	}
 
-	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)
+	void
+	Painter::set_uniform (const char* name, float arg1)
 	{
-		float array[] = {
-			a1, a2, a3, a4,
-			b1, b2, b3, b4,
-			c1, c2, c3, c4,
-			d1, d2, d3, d4
-		};
-		return set_matrix(array);
+		self->program.set_uniform(name, arg1);
 	}
 
-	bool
-	Painter::set_matrix (const float* elements)
+	void
+	Painter::set_uniform (const char* name, float arg1, float arg2)
 	{
-		if (!elements) return false;
-		glLoadMatrixf(elements);
-		return !is_error();
+		self->program.set_uniform(name, arg1, arg2);
 	}
 
-	bool
-	Painter::set_matrix (const Matrix& matrix)
+	void
+	Painter::set_uniform (const char* name, float arg1, float arg2, float arg3)
 	{
-		return set_matrix(matrix.array());
+		self->program.set_uniform(name, arg1, arg2, arg3);
 	}
 
-	const Matrix&
-	Painter::matrix () const
+	void
+	Painter::set_uniform (const char* name, float arg1, float arg2, float arg3, float arg4)
 	{
-		glGetFloatv(GL_MODELVIEW_MATRIX, self->matrix_tmp.array());
-		if (is_error(GL_INVALID_ENUM)) self->matrix_tmp.set(0);
-		return self->matrix_tmp;
+		self->program.set_uniform(name, arg1, arg2, arg3, arg4);
 	}
 
-	bool
-	Painter::push_matrix ()
+	void
+	Painter::set_uniform (const char* name, const float* args, size_t size)
 	{
-		glPushMatrix();
-		return !is_error(GL_STACK_OVERFLOW);
+		self->program.set_uniform(name, args, size);
 	}
 
-	bool
-	Painter::pop_matrix ()
+	void
+	Painter::push_shader ()
 	{
-		glPopMatrix();
-		return !is_error(GL_STACK_UNDERFLOW);
+		self->program.push();
 	}
 
-
-	bool
-	Painter::begin_shape (ShapeType type)
+	void
+	Painter::pop_shader ()
 	{
-		if (!self->painting || self->drawing)
-			return false;
+		self->program.pop();
+	}
 
-		glBegin(type);
 
-		self->drawing = true;
-		return true;
+	void
+	Painter::translate (coord x, coord y, coord z)
+	{
+		glTranslatef(x, y, z);
 	}
 
-	bool
-	Painter::end_shape ()
+	void
+	Painter::translate (const Point& value)
 	{
-		if (!self->painting || !self->drawing)
-			return false;
-
-		glEnd();
-
-		self->drawing = false;
-		return true;
+		translate(value.x, value.y, value.z);
 	}
 
-	bool
-	Painter::set_color (float red, float green, float blue, float alpha)
+	void
+	Painter::scale (coord x, coord y, coord z)
 	{
-		if (!self->drawing) return false;
-
-		glColor4f(red, green, blue, alpha);
-		return true;
+		glScalef(x, y, z);
 	}
 
-	bool
-	Painter::set_color (const Color& color)
+	void
+	Painter::scale (const Point& value)
 	{
-		if (!self->drawing) return false;
-
-		glColor4fv(color.array());
-		return true;
+		scale(value.x, value.y, value.z);
 	}
 
-	bool
-	Painter::set_texture (const Texture& tex)
+	void
+	Painter::rotate (float angle, coord x, coord y, coord z)
 	{
-		if (!self->drawing) return false;
+		glRotatef(angle, x, y, z);
+	}
 
-		glBindTexture(GL_TEXTURE_2D, tex ? tex.id() : 0);
-		return true;
+	void
+	Painter::rotate (float angle, const Point& center)
+	{
+		rotate(angle, center.x, center.y, center.z);
 	}
 
-	bool
-	Painter::no_texture ()
+	void
+	Painter::set_matrix (float value)
 	{
-		if (!self->drawing) return false;
+		if (value == 1)
+		{
+			glLoadIdentity();
+			return;
+		}
 
-		glBindTexture(GL_TEXTURE_2D, 0);
-		return true;
+		set_matrix(
+			value, 0, 0, 0,
+			0, value, 0, 0,
+			0, 0, value, 0,
+			0, 0, 0, value);
 	}
 
-	bool
-	Painter::add_vertex (coord x, coord y)
+	void
+	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)
 	{
-		return add_vertex(x, y, 0);
+		float array[] = {
+			a1, a2, a3, a4,
+			b1, b2, b3, b4,
+			c1, c2, c3, c4,
+			d1, d2, d3, d4
+		};
+		set_matrix(array);
 	}
 
-	bool
-	Painter::add_vertex (coord x, coord y, coord z)
+	void
+	Painter::set_matrix (const float* elements)
 	{
-		if (!self->drawing) return false;
+		if (!elements)
+			argument_error(__FILE__, __LINE__);
 
-		glVertex3f(x, y, z);
-		return true;
+		glLoadMatrixf(elements);
 	}
 
-	bool
-	Painter::add_vertex (const Point& pos)
+	void
+	Painter::set_matrix (const Matrix& matrix)
 	{
-		return add_vertex(pos.x, pos.y, pos.z);
+		set_matrix(matrix.array);
 	}
 
-	bool
-	Painter::add_vertex (coord x, coord y, coord tex_s, coord tex_t)
+	const Matrix&
+	Painter::matrix () const
 	{
-		return add_vertex(x, y, 0, tex_s, tex_t);
+		glGetFloatv(GL_MODELVIEW_MATRIX, self->matrix_tmp.array);
+		check_error(__FILE__, __LINE__);
+		return self->matrix_tmp;
 	}
 
-	bool
-	Painter::add_vertex (coord x, coord y, coord z, coord tex_s, coord tex_t)
+	void
+	Painter::push_matrix ()
 	{
-		if (!self->drawing) return false;
-
-		glTexCoord2f(tex_s, tex_t);
-		return add_vertex(x, y, z);
+		glPushMatrix();
+		check_error(__FILE__, __LINE__);
 	}
 
-	bool
-	Painter::add_vertex (const Point& pos, coord tex_s, coord tex_t)
+	void
+	Painter::pop_matrix ()
 	{
-		return add_vertex(pos.x, pos.y, pos.z, tex_s, tex_t);
+		glPopMatrix();
+		check_error(__FILE__, __LINE__);
 	}