rays 0.1.11 → 0.1.16

data/src/osx/rays.mm

@@ -4,6 +4,7 @@
 
 #import <Foundation/Foundation.h>
 #include "rays/exception.h"
+#include "../opengl.h"
 
 
 namespace Rays
@@ -27,6 +28,8 @@ namespace Rays
 			rays_error(__FILE__, __LINE__, "Rays::init(): already initialized.");
 
 		global::pool = [[NSAutoreleasePool alloc] init];
+
+		OpenGL_set_context(get_offscreen_context());
 	}
 
 	void

data/src/painter.cpp

@@ -1,22 +1,28 @@
-#include "rays/painter.h"
+#include "painter.h"
 
 
 #include <math.h>
-#include <list>
+#include <assert.h>
+#include <memory>
+#include <vector>
 #include <algorithm>
-#include <boost/scoped_array.hpp>
+#include <glm/gtc/matrix_transform.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 "rays/debug.h"
+#include "opengl.h"
+#include "matrix.h"
+#include "polygon.h"
+#include "bitmap.h"
+#include "texture.h"
+#include "image.h"
+#include "font.h"
 #include "frame_buffer.h"
-#include "program.h"
+#include "shader.h"
+#include "shader_program.h"
+#include "shader_source.h"
 
 
 namespace Rays
@@ -35,152 +41,528 @@ namespace Rays
 	};// ColorType
 
 
-	static const float PI   = M_PI;
+	struct State
+	{
 
-	static const float PI_2 = PI * 2;
+		Color background, colors[2];
 
+		coord stroke_width;
 
-	struct Attributes
-	{
+		CapType stroke_cap;
 
-		Bounds clip;
+		JoinType stroke_join;
 
-		Color background, colors[2];
+		coord miter_limit;
+
+		uint nsegment;
+
+		Bounds clip;
 
 		Font font;
 
+		Shader shader;
+
 		void init ()
 		{
-			clip           .reset(-1);
 			background     .reset(0, 0);
 			colors[FILL]   .reset(1, 1);
 			colors[STROKE] .reset(1, 0);
+			stroke_width   = 0;
+			stroke_cap     = CAP_DEFAULT;
+			stroke_join    = JOIN_DEFAULT;
+			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
+			nsegment       = 0;
+			clip           .reset(-1);
 			font           = default_font();
+			shader         = Shader();
+		}
+
+		bool has_color ()
+		{
+			return colors[FILL] || colors[STROKE];
 		}
 
-	};// Attributes
+	};// State
 
 
-	struct Painter::Data
+	struct TextureInfo
 	{
 
-		Bounds viewport;
+		const Texture& texture;
 
-		Attributes attrs;
+		Coord2 texcoord_min, texcoord_max;
 
-		Program program;
+		TextureInfo (
+			const Texture& texture,
+			coord x_min, coord y_min,
+			coord x_max, coord y_max)
+		:	texture(texture)
+		{
+			texcoord_min.reset(x_min, y_min);
+			texcoord_max.reset(x_max, y_max);
+		}
 
-		std::list<Attributes> attrs_stack;
+		operator bool () const
+		{
+			return
+				texture &&
+				texcoord_min.x < texcoord_max.x &&
+				texcoord_min.x < texcoord_max.y;
+		}
 
-		bool painting;
+		bool operator ! () const
+		{
+			return !operator bool();
+		}
 
-		GLenum prev_matrix_mode;
+	};// TextureInfo
 
-		GLuint current_texture;
 
-		Image text_image;
+	struct OpenGLState
+	{
+
+		GLint viewport[4];
+
+		GLclampf color_clear[4];
+
+		GLboolean scissor_test;
+		GLint scissor_box[4];
+
+		GLboolean blend;
+		GLint blend_src_factor, blend_dst_factor;
+
+		GLint framebuffer_binding;
+
+		void push ()
+		{
+			glGetIntegerv(GL_VIEWPORT, viewport);
+
+			glGetFloatv(GL_COLOR_CLEAR_VALUE, color_clear);
+
+			glGetBooleanv(GL_SCISSOR_TEST, &scissor_test);
+			glGetIntegerv(GL_SCISSOR_BOX, scissor_box);
+
+			glGetBooleanv(GL_BLEND, &blend);
+			glGetIntegerv(GL_BLEND_SRC_ALPHA, &blend_src_factor);
+			glGetIntegerv(GL_BLEND_DST_ALPHA, &blend_dst_factor);
+
+			glGetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer_binding);
+		}
+
+		void pop ()
+		{
+			glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
+
+			glClearColor(
+				color_clear[0], color_clear[1], color_clear[2], color_clear[3]);
+
+			enable(GL_SCISSOR_TEST, scissor_test);
+			glScissor(scissor_box[0], scissor_box[1], scissor_box[2], scissor_box[3]);
+
+			enable(GL_BLEND, blend);
+			glBlendFunc(blend_src_factor, blend_dst_factor);
+
+			glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_binding);
+		}
+
+		private:
+
+			void enable(GLenum type, GLboolean value)
+			{
+				if (value)
+					glEnable(type);
+				else
+					glDisable(type);
+			}
+
+	};// OpenGLState
+
+
+	class DefaultIndices
+	{
+
+		public:
+
+			void resize (size_t size)
+			{
+				indices.reserve(size);
+				while (indices.size() < size)
+					indices.emplace_back(indices.size());
+			}
+
+			void clear ()
+			{
+				decltype(indices)().swap(indices);
+			}
+
+			const uint* get () const
+			{
+				return &indices[0];
+			}
+
+		private:
+
+			std::vector<uint> indices;
+
+	};// DefaultIndices
+
+
+	template <typename COORD>
+	static GLenum get_gl_type ();
+
+	template <>
+	GLenum
+	get_gl_type<float> ()
+	{
+		return GL_FLOAT;
+	}
+
+	static const Shader&
+	get_default_shader_for_shape ()
+	{
+		static const Shader SHADER(
+			"varying vec4 " VARYING_COLOR ";"
+			"void main ()"
+			"{"
+			"  gl_FragColor = v_Color;"
+			"}");
+		return SHADER;
+	}
+
+	static const Shader&
+	get_default_shader_for_color_texture ()
+	{
+		static const Shader SHADER(
+			"varying vec4 " VARYING_TEXCOORD ";"
+			"varying vec4 " VARYING_COLOR ";"
+			"vec4 sampleTexture(vec2);"
+			"void main ()"
+			"{"
+			"  vec4 color   = sampleTexture(" VARYING_TEXCOORD ".xy);"
+			"  gl_FragColor = v_Color * color;"
+			"}");
+		return SHADER;
+	}
+
+	static const Shader&
+	get_default_shader_for_alpha_texture ()
+	{
+		static const Shader SHADER(
+			"varying vec4 " VARYING_TEXCOORD ";"
+			"varying vec4 " VARYING_COLOR ";"
+			"vec4 sampleTexture(vec2);"
+			"void main ()"
+			"{"
+			"  vec4 color   = sampleTexture(" VARYING_TEXCOORD ".xy);"
+			"  gl_FragColor = vec4(v_Color.rgb, color.a);"
+			"}");
+		return SHADER;
+	}
+
+
+	struct Painter::Data
+	{
+
+		bool painting = false;
+
+		float pixel_density = 1;
+
+		Bounds viewport;
+
+		State              state;
+
+		std::vector<State> state_stack;
+
+		Matrix              position_matrix;
+
+		std::vector<Matrix> position_matrix_stack;
 
 		FrameBuffer frame_buffer;
 
-		float scale_factor;
+		Image text_image;
+
+		OpenGLState opengl_state;
 
-		mutable Matrix matrix_tmp;
+		DefaultIndices default_indices;
 
 		Data ()
-		:	painting(false), prev_matrix_mode(0), current_texture(0),
-			text_image(1, 1, GRAY, true), scale_factor(1)
 		{
-			attrs.init();
+			state.init();
+		}
+
+		void set_pixel_density (float density)
+		{
+			if (density <= 0)
+				argument_error(__FILE__, __LINE__, "invalid pixel_density.");
+
+			this->pixel_density = density;
+			text_image = Image();
 		}
 
 		void update_clip ()
 		{
-			if (attrs.clip)
+			const Bounds& clip = state.clip;
+			if (clip)
 			{
+				coord y = frame_buffer ? clip.y : viewport.h - (clip.y + clip.h);
 				glEnable(GL_SCISSOR_TEST);
 				glScissor(
-					attrs.clip.x,
-					viewport.height - attrs.clip.height - attrs.clip.y,
-					attrs.clip.width,
-					attrs.clip.height);
+					pixel_density * clip.x,
+					pixel_density * y,
+					pixel_density * clip.width,
+					pixel_density * clip.height);
 			}
 			else
 			{
 				glDisable(GL_SCISSOR_TEST);
 			}
 
-			check_error(__FILE__, __LINE__);
+			OpenGL_check_error(__FILE__, __LINE__);
 		}
 
-		bool use_color (ColorType type)
+		bool get_color (Color* color, ColorType type)
 		{
-			const Color& c = attrs.colors[type];
-			if (c.alpha <= 0) return false;
+			const Color& c = state.colors[type];
+			if (!c) return false;
 
-			glColor4f(c.red, c.green, c.blue, c.alpha);
+			*color = c;
 			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)
+		void draw_polygon (
+			GLenum mode, const Color& color,
+			const Coord3* points,           size_t npoints,
+			const uint*   indices   = NULL, size_t nindices = 0,
+			const Coord3* texcoords = NULL,
+			const Shader& default_shader = get_default_shader_for_shape(),
+			const TextureInfo* texinfo = NULL)
 		{
-			if (nindices <= 0 || !indices || !vertices)
+			if (!points || npoints <= 0)
 				argument_error(__FILE__, __LINE__);
 
 			if (!painting)
 				invalid_state_error(__FILE__, __LINE__, "'painting' should be true.");
 
-			bool use_texture = texture && tex_coords;
+			if (!indices || nindices <= 0)
+			{
+				default_indices.resize(npoints);
+				indices  = default_indices.get();
+				nindices = npoints;
+			}
 
-			if (use_texture)
+			if (!texcoords)
+				texcoords = points;
+
+			const ShaderProgram* program = Shader_get_program(state.shader);
+			if (!program || !*program)
 			{
+				program = Shader_get_program(default_shader);
+				if (!program || !*program) return;
+			}
+
+			ShaderProgram_activate(*program);
+			apply_builtin_uniforms(*program, texinfo);
+
+			GLint a_position = glGetAttribLocation(program->id(), ATTRIB_POSITION);
+			GLint a_texcoord = glGetAttribLocation(program->id(), ATTRIB_TEXCOORD);
+			GLint a_color    = glGetAttribLocation(program->id(), ATTRIB_COLOR);
+			if (a_position < 0 || a_texcoord < 0 || a_color < 0)
+				opengl_error(__FILE__, __LINE__);
+
+			setup_vertices(
+				points, npoints, texcoords, color, a_position, a_texcoord, a_color);
+			//activate_texture(texture);
+
+			glDrawElements(mode, (GLsizei) nindices, GL_UNSIGNED_INT, indices);
+			OpenGL_check_error(__FILE__, __LINE__);
+
+			//deactivate_texture(texture);
+			cleanup_vertices(a_position, a_texcoord);
+
+			ShaderProgram_deactivate();
+		}
+
+		private:
+
+			void apply_builtin_uniforms (
+				const ShaderProgram& program, const TextureInfo* texinfo)
+			{
+				GLint pos_matrix_loc =
+					glGetUniformLocation(program.id(), UNIFORM_POSITION_MATRIX);
+				if (pos_matrix_loc >= 0)
+				{
+					glUniformMatrix4fv(
+						pos_matrix_loc, 1, GL_FALSE, position_matrix.array);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				GLint texcoord_matrix_loc =
+					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MATRIX);
+				if (texcoord_matrix_loc >= 0)
+				{
+					static const Matrix TEXCOORD_MATRIX(1);
+					glUniformMatrix4fv(
+						texcoord_matrix_loc, 1, GL_FALSE, TEXCOORD_MATRIX.array);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				apply_texture_uniforms(program, texinfo);
+			}
+
+			void apply_texture_uniforms (
+				const ShaderProgram& program, const TextureInfo* texinfo)
+			{
+				if (!texinfo || !*texinfo) return;
+
+				const Texture& texture = texinfo->texture;
+
+				GLint texture_loc =
+					glGetUniformLocation(program.id(), UNIFORM_TEXTURE);
+				if (texture_loc >= 0)
+				{
+					glActiveTexture(GL_TEXTURE0);
+					glBindTexture(GL_TEXTURE_2D, texture.id());
+
+					glUniform1i(texture_loc, 0);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				GLint size_loc =
+					glGetUniformLocation(program.id(), UNIFORM_TEXTURE_SIZE);
+				if (size_loc >= 0)
+				{
+					glUniform2f(
+						size_loc, texture.reserved_width(), texture.reserved_height());
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				GLint min_loc =
+					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MIN);
+				if (min_loc >= 0)
+				{
+					glUniform2fv(min_loc, 1, texinfo->texcoord_min.array);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+
+				GLint max_loc =
+					glGetUniformLocation(program.id(), UNIFORM_TEXCOORD_MAX);
+				if (max_loc >= 0)
+				{
+					glUniform2fv(max_loc, 1, texinfo->texcoord_max.array);
+					OpenGL_check_error(__FILE__, __LINE__);
+				}
+			}
+
+			void setup_vertices (
+				const Coord3* points, size_t npoints,
+				const Coord3* texcoords, const Color& color,
+				GLuint a_position, GLuint a_texcoord, GLuint a_color)
+			{
+				assert(points && npoints >= 0 && texcoords);
+
+				glEnableVertexAttribArray(a_position);
+				glVertexAttribPointer(
+					a_position, Coord3::SIZE, get_gl_type<coord>(),
+					GL_FALSE, sizeof(Coord3), points);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glEnableVertexAttribArray(a_texcoord);
+				glVertexAttribPointer(
+					a_texcoord, Coord3::SIZE, get_gl_type<coord>(),
+					GL_FALSE, sizeof(Coord3), texcoords);
+				OpenGL_check_error(__FILE__, __LINE__);
+
+				glVertexAttrib4fv(a_color, color.array);
+			}
+
+			void cleanup_vertices (GLint a_position, GLint a_texcoord)
+			{
+				glDisableVertexAttribArray(a_position);
+				glDisableVertexAttribArray(a_texcoord);
+				OpenGL_check_error(__FILE__, __LINE__);
+			}
+
+			void activate_texture (const Texture* texture)
+			{
+				if (!texture)
+				{
+					glDisable(GL_TEXTURE_2D);
+					return;
+				}
+
 				if (!*texture)
 					argument_error(__FILE__, __LINE__, "invalid texture.");
 
 				GLuint id = texture->id();
-				if (id != current_texture)
-				{
+				if (id != get_current_texture_id())
 					glBindTexture(GL_TEXTURE_2D, id);
-					current_texture = id;
-				}
 
 				glEnable(GL_TEXTURE_2D);
+			}
 
-				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-				glTexCoordPointer(2, GL_FLOAT, 0, tex_coords);
+			GLuint get_current_texture_id ()
+			{
+				GLint id = 0;
+				glGetIntegerv(GL_TEXTURE_BINDING_2D, &id);
+				return (GLuint) id;
 			}
-			else
+
+			void deactivate_texture (const Texture* texture)
 			{
+				if (!texture) return;
+
 				glDisable(GL_TEXTURE_2D);
-				glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 			}
 
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glVertexPointer(vertex_size, GL_FLOAT, 0, vertices);
+	};// Painter::Data
 
-			glDrawElements(mode, nindices, GL_UNSIGNED_INT, indices);
 
-			glDisableClientState(GL_VERTEX_ARRAY);
-			if (use_texture)
-			{
-				glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-				glDisable(GL_TEXTURE_2D);
-			}
+	static void
+	draw_polygon (
+		Painter* painter,
+		const GLenum* modes,
+		coord offset_x, coord offset_y,
+		bool nofill, bool nostroke,
+		const Coord3* points,           size_t npoints,
+		const uint*   indices   = NULL, size_t nindices = 0,
+		const Coord3* texcoords = NULL,
+		const Shader& default_shader = get_default_shader_for_shape(),
+		const TextureInfo* texinfo = NULL)
+	{
+		assert(painter);
+
+		bool offset = offset_x != 0 || offset_y != 0;
+		if (offset)
+		{
+			painter->push_matrix();
+			painter->translate(offset_x, offset_y);
 		}
 
-	};// Painter::Data
+		Color color;
+		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
+		{
+			if ((nofill && type == FILL) || (nostroke && type == STROKE))
+				continue;
+
+			if (!painter->self->get_color(&color, (ColorType) type))
+				continue;
+
+			painter->self->draw_polygon(
+				modes[type], color, points, npoints, indices, nindices, texcoords,
+				default_shader, texinfo);
+		}
 
+		if (offset)
+			painter->pop_matrix();
+	}
 
 	void
-	set_painter_scale_factor (Painter* painter, float factor)
+	Painter_draw_polygon (
+		Painter* painter, GLenum mode, const Color& color,
+		const Coord3* points,  size_t npoints,
+		const uint*   indices, size_t nindices)
 	{
-		if (!painter)
-			argument_error(__FILE__, __LINE__, "invalid texture.");
-
-		painter->self->scale_factor = factor;
+		painter->self->draw_polygon(mode, color, points, npoints, indices, nindices);
 	}
 
 
@@ -193,53 +575,57 @@ namespace Rays
 	}
 
 	void
-	Painter::canvas (coord x, coord y, coord width, coord height)
+	Painter::canvas (
+		coord x, coord y, coord width, coord height, float pixel_density)
 	{
-		canvas(Bounds(x, y, -100, width, height, 200));
+		canvas(Bounds(x, y, -100, width, height, 200), pixel_density);
 	}
 
 	void
-	Painter::canvas (coord x, coord y, coord z, coord width, coord height, coord depth)
+	Painter::canvas (
+		coord x, coord y, coord z, coord width, coord height, coord depth,
+		float pixel_density)
 	{
-		canvas(Bounds(x, y, z, width, height, depth));
+		canvas(Bounds(x, y, z, width, height, depth), pixel_density);
 	}
 
 	void
-	Painter::canvas (const Bounds& bounds)
+	Painter::canvas (const Bounds& viewport, float pixel_density)
 	{
-		if (!bounds)
+		if (!viewport)
 			argument_error(__FILE__, __LINE__);
 
 		if (self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be false.");
 
-		self->viewport = bounds;
+		self->viewport = viewport;
+		self->set_pixel_density(pixel_density);
 	}
 
 	void
-	Painter::bind (const Texture& texture)
+	Painter::bind (const Image& image)
 	{
-		if (!texture)
-			argument_error(__FILE__, __LINE__, "invalid texture.");
+		if (!image)
+			argument_error(__FILE__, __LINE__, "invalid image.");
 
 		if (self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be false.");
 
-		FrameBuffer fb(texture);
+		FrameBuffer fb(Image_get_texture(image));
 		if (!fb)
 			rays_error(__FILE__, __LINE__, "invalid frame buffer.");
 
 		unbind();
 
 		self->frame_buffer = fb;
-		canvas(0, 0, fb.width(), fb.height());
+		canvas(0, 0, image.width(), image.height(), image.pixel_density());
 	}
 
 	void
 	Painter::unbind ()
 	{
 		if (self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
 		self->frame_buffer = FrameBuffer();
 	}
@@ -250,104 +636,74 @@ namespace Rays
 		return self->viewport;
 	}
 
+	float
+	Painter::pixel_density () const
+	{
+		return self->pixel_density;
+	}
 
 	void
 	Painter::begin ()
 	{
 		if (self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be false.");
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be false.");
 
-		FrameBuffer& fb = self->frame_buffer;
-		if (fb) bind_frame_buffer(fb.id());
+		self->opengl_state.push();
 
-		push_attr();
-		push_shader();
+		//glEnable(GL_CULL_FACE);
+		glEnable(GL_BLEND);
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+		OpenGL_check_error(__FILE__, __LINE__);
+
+		FrameBuffer& fb = self->frame_buffer;
+		if (fb) FrameBuffer_bind(fb.id());
 
 		const Bounds& vp = self->viewport;
-		float scale      = self->scale_factor;
+		float density    = self->pixel_density;
 		glViewport(
-			(int) vp.x,             (int) vp.y,
-			(int) vp.width * scale, (int) vp.height * scale);
+			(int) (vp.x      * density), (int) (vp.y      * density),
+			(int) (vp.width  * density), (int) (vp.height * density));
+		OpenGL_check_error(__FILE__, __LINE__);
 
 		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)                std::swap(y1, y2);
-
-		glGetIntegerv(GL_MATRIX_MODE, (GLint*) &self->prev_matrix_mode);
-
-		glMatrixMode(GL_PROJECTION);
-		glPushMatrix();
-		glLoadIdentity();
-		glOrtho(x1, x2, y1, y2, z1, z2);
+		if (!fb) std::swap(y1, y2);
 
-		glMatrixMode(GL_MODELVIEW);
-		glPushMatrix();
-		glLoadIdentity();
-		glTranslatef(0.375f, 0.375f, 0);
+		self->position_matrix.reset(1);
+		self->position_matrix *= to_rays(glm::ortho(x1, x2, y1, y2));
+		//self->position_matrix.translate(0.375f, 0.375f);
 
-		glMatrixMode(GL_TEXTURE);
-		glPushMatrix();
-		glLoadIdentity();
-
-	#ifndef IOS
-		glMatrixMode(GL_COLOR);
-		glPushMatrix();
-		glLoadIdentity();
-	#endif
-
-		glMatrixMode(GL_MODELVIEW);
-
-		//glEnable(GL_CULL_FACE);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-		check_error(__FILE__, __LINE__);
+		self->update_clip();
 
 		self->painting = true;
-
-		no_clip();
 	}
 
 	void
 	Painter::end ()
 	{
 		if (!self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		self->painting = false;
-
-		glDisable(GL_BLEND);
-		glDisable(GL_CULL_FACE);
-
-		glMatrixMode(GL_PROJECTION);
-		glPopMatrix();
-
-		glMatrixMode(GL_MODELVIEW);
-		glPopMatrix();
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
-		glMatrixMode(GL_TEXTURE);
-		glPopMatrix();
+		if (!self->state_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "state stack is not empty.");
 
-	#ifndef IOS
-		glMatrixMode(GL_COLOR);
-		glPopMatrix();
-	#endif
+		if (!self->position_matrix_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "position matrix stack is not empty.");
 
-		glMatrixMode(self->prev_matrix_mode);
-
-		pop_shader();
-		pop_attr();
+		self->painting = false;
+		self->opengl_state.pop();
+		self->default_indices.clear();
 
-		//glFinish();
+		glFinish();
 
 		if (self->frame_buffer)
 		{
-			unbind_frame_buffer();
+			FrameBuffer_unbind();
 
 			Texture& tex = self->frame_buffer.texture();
-			if (tex) tex.set_dirty(true);
+			if (tex) tex.set_modified();
 		}
 	}
 
@@ -355,388 +711,243 @@ namespace Rays
 	Painter::clear ()
 	{
 		if (!self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
-		const Color& c = self->attrs.background;
+		const Color& c = self->state.background;
 		glClearColor(c.red, c.green, c.blue, c.alpha);
 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-		check_error(__FILE__, __LINE__);
+		OpenGL_check_error(__FILE__, __LINE__);
 	}
 
-	void
-	Painter::line (coord x1, coord y1, coord x2, coord y2)
+	static inline void
+	debug_draw_triangulation (
+		Painter* painter, const Polygon& polygon, const Color& color)
 	{
-		static const uint INDICES[] =
-		{
-			0, 1
-		};
+#ifdef _DEBUG
+		assert(painter);
 
-		Data* pself = self.get();
+		Color invert_color(
+			1.f - color.red,
+			1.f - color.green,
+			1.f - color.blue);
 
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		if (!pself->use_color(STROKE))
-			return;
-
-		coord vertices[] =
+		Polygon::TrianglePointList triangles;
+		if (Polygon_triangulate(&triangles, polygon))
 		{
-			x1, y1,
-			x2, y2
-		};
-
-		pself->draw_shape(GL_LINES, 2, INDICES, 2, vertices);
-	}
-
-	void
-	Painter::line (const Point& p1, const Point& p2)
-	{
-		line(p1.x, p1.y, p2.x, p2.y);
+			for (size_t i = 0; i < triangles.size(); i += 3)
+			{
+				painter->self->draw_polygon(
+					GL_LINE_LOOP, invert_color, &triangles[i], 3);
+			}
+		}
+#endif
 	}
 
 	void
-	Painter::lines (const Coord2* points, size_t size)
+	Painter::polygon (const Polygon& polygon)
 	{
-		Data* pself = self.get();
-
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
-		if (!pself->use_color(STROKE))
+		if (!self->state.has_color())
 			return;
 
-		boost::scoped_array<uint> indices(new uint[size]);
-		for (size_t i = 0; i < size; ++i)
-			indices[i] = (uint) i;
-
-		pself->draw_shape(GL_LINES, (int) size, indices.get(), 2, (coord*) points);
-	}
-
-	void
-	Painter::lines (const Coord3* points, size_t size)
-	{
-		Data* pself = self.get();
-
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		if (!pself->use_color(STROKE))
-			return;
+		Color color;
 
-		boost::scoped_array<uint>   indices(new uint[size]);
-		boost::scoped_array<Coord2> vertices(new Coord2[size]);
-		for (size_t i = 0; i < size; ++i)
+		if (self->get_color(&color, FILL))
 		{
-			indices[i] = (uint) i;
-			vertices[i].reset(points[i].x, points[i].y);
+			Polygon_fill(polygon, this, color);
+			debug_draw_triangulation(this, polygon, color);
 		}
 
-		pself->draw_shape(
-			GL_LINES, (int) size, indices.get(), 2, (coord*) vertices.get());
+		if (self->get_color(&color, STROKE))
+			Polygon_stroke(polygon, this, color);
 	}
 
 	void
-	Painter::polygon (const Coord2* points, size_t size)
+	Painter::line (coord x1, coord y1, coord x2, coord y2)
 	{
-		Data* pself = self.get();
-
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		GLenum modes[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
-		boost::scoped_array<uint>   indices;
-
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			if (!pself->use_color((ColorType) type)) continue;
-
-			if (!indices.get())
-			{
-				indices.reset(new uint[size]);
-				for (size_t i = 0; i < size; ++i)
-					indices[i] = (uint) i;
-			}
-
-			pself->draw_shape(
-				modes[type], (int) size, indices.get(), 2, (coord*) points);
-		}
+		polygon(create_line(x1, y1, x2, y2));
 	}
 
 	void
-	Painter::polygon (const Coord3* points, size_t size)
+	Painter::line (const Point& p1, const Point& p2)
 	{
-		Data* pself = self.get();
-
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		GLenum modes[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
-		boost::scoped_array<uint>   indices;
-		boost::scoped_array<Coord2> vertices;
-
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			if (!pself->use_color((ColorType) type)) continue;
-
-			if (!indices.get())
-			{
-				indices.reset(new uint[size]);
-				for (size_t i = 0; i < size; ++i)
-					indices[i] = (uint) i;
-			}
+		polygon(create_line(p1, p2));
+	}
 
-			if (!vertices.get())
-			{
-				vertices.reset(new Coord2[size]);
-				for (size_t i = 0; i < size; ++i)
-					vertices[i].reset(points[i].x, points[i].y);
-			}
+	void
+	Painter::line (const Point* points, size_t size, bool loop)
+	{
+		polygon(create_line(points, size, loop));
+	}
 
-			pself->draw_shape(
-				modes[type], (int) size, indices.get(), 2, (coord*) vertices.get());
-		}
+	void
+	Painter::line (const Polyline& polyline)
+	{
+		polygon(create_line(polyline));
 	}
 
 	void
 	Painter::rect (coord x, coord y, coord width, coord height, coord round)
 	{
-		rect(x, y, width, height, round, round);
+		polygon(create_rect(x, y, width, height, round, nsegment()));
 	}
 
 	void
 	Painter::rect (
 		coord x, coord y, coord width, coord height,
-		coord round_width, coord round_height)
+		coord round_left_top,    coord round_right_top,
+		coord round_left_bottom, coord round_right_bottom)
 	{
-		static const GLenum MODES[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
-		static const uint INDICES[] =
-		{
-			0, 1, 2, 3
-		};
-
-		Data* pself = self.get();
-
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
-
-		if (width <= 0 || height <= 0) return;
-
-		coord x2 = x + width  - 1;
-		coord y2 = y + height - 1;
-
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			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
-			};
-
-			pself->draw_shape(MODES[type], 4, INDICES, 2, vertices);
-		}
+		polygon(create_rect(
+			x, y, width, height,
+			round_left_top,    round_right_top,
+			round_left_bottom, round_right_bottom,
+			nsegment()));
 	}
 
 	void
 	Painter::rect (const Bounds& bounds, coord round)
 	{
-		rect(
-			bounds.x, bounds.y, bounds.width, bounds.height,
-			round);
+		polygon(create_rect(bounds, round, nsegment()));
 	}
 
 	void
-	Painter::rect (const Bounds& bounds, coord round_width, coord round_height)
+	Painter::rect (
+		const Bounds& bounds,
+		coord round_left_top,    coord round_right_top,
+		coord round_left_bottom, coord round_right_bottom)
 	{
-		rect(
-			bounds.x, bounds.y, bounds.width, bounds.height,
-			round_width, round_height);
+		polygon(create_rect(
+			bounds,
+			round_left_top,    round_right_top,
+			round_left_bottom, round_right_bottom,
+			nsegment()));
 	}
 
-	static void
-	draw_ellipse (
-		Painter* painter,
+	void
+	Painter::ellipse (
 		coord x, coord y, coord width, coord height,
-		float angle_from, float angle_to, coord radius_min,
-		uint nsegment)
+		const Point& hole_size,
+		float angle_from, float angle_to)
 	{
-		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.");
-
-		if (height   == 0) height   = width;
-		if (nsegment <= 0) nsegment = Painter::ELLIPSE_NSEGMENT;
-
-		coord radius_x     = width  / 2;
-		coord radius_y     = height / 2;
-		coord radius_x_min = radius_x * radius_min;
-		coord radius_y_min = radius_y * radius_min;
-		float from         = angle_from / 360.f;
-		float to           = angle_to   / 360.f;
-		bool hole          = radius_min != 0;
-		int nvertices      = hole ? nsegment * 2 : nsegment;
-		GLenum modes[]     =
-		{
-			(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;
-
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			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]);
-
-			Coord2* vertex = vertices.get();
-			assert(vertex);
-
-			for (uint seg = 0; seg < 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)
-					vertex->reset(x + xx * radius_x_min, y + yy * radius_y_min);
-				vertex  ->reset(x + xx * radius_x,     y + yy * radius_y);
-			}
+		polygon(create_ellipse(
+			x, y, width, height, hole_size, angle_from, angle_to, nsegment()));
+	}
 
-			pself->draw_shape(modes[type], nvertices, indices.get(), 2, (coord*) vertices.get());
-		}
+	void
+	Painter::ellipse (
+		const Bounds& bounds,
+		const Point& hole_size,
+		float angle_from, float angle_to)
+	{
+		polygon(create_ellipse(
+			bounds, hole_size, angle_from, angle_to, nsegment()));
 	}
 
 	void
 	Painter::ellipse (
-		coord x, coord y, coord width, coord height,
-		coord radius_min, uint nsegment)
+		const Point& center, const Point& radius, const Point& hole_radius,
+		float angle_from, float angle_to)
 	{
-		draw_ellipse(this, x, y, width, height, 0, 360, radius_min, nsegment);
+		polygon(create_ellipse(
+			center, radius, hole_radius, angle_from, angle_to, nsegment()));
 	}
 
 	void
-	Painter::ellipse (const Bounds& bounds, coord radius_min, uint nsegment)
+	Painter::curve (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
 	{
-		ellipse(
-			bounds.x, bounds.y, bounds.width, bounds.height, radius_min, nsegment);
+		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop));
 	}
 
 	void
-	Painter::ellipse (
-		const Point& center, coord radius, coord radius_min, uint nsegment)
+	Painter::curve (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
 	{
-		ellipse(
-			center.x - radius, center.y - radius, radius * 2, radius * 2,
-			radius_min, nsegment);
+		polygon(create_curve(p1, p2, p3, p4, loop));
 	}
 
 	void
-	Painter::arc (
-		coord x, coord y, coord width, coord height,
-		float angle_from, float angle_to, coord radius_min, uint nsegment)
+	Painter::curve (const Point* points, size_t size, bool loop)
 	{
-		draw_ellipse(
-			this, x, y, width, height, angle_from, angle_to, radius_min, nsegment);
+		polygon(create_curve(points, size, loop));
 	}
 
 	void
-	Painter::arc (
-		const Bounds& bounds,
-		float angle_from, float angle_to, coord radius_min, uint nsegment)
+	Painter::bezier (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+	}
+
+	void
+	Painter::bezier (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
 	{
-		arc(
-			bounds.x, bounds.y, bounds.width, bounds.height,
-			angle_from, angle_to, radius_min, nsegment);
+		polygon(create_bezier(p1, p2, p3, p4, loop));
 	}
 
 	void
-	Painter::arc (
-		const Point& center, coord radius,
-		float angle_from, float angle_to, coord radius_min, uint nsegment)
+	Painter::bezier (const Point* points, size_t size, bool loop)
 	{
-		arc(
-			center.x, center.y, radius * 2, radius * 2,
-			angle_from, angle_to, radius_min, nsegment);
+		polygon(create_bezier(points, size, loop));
 	}
 
 	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)
+		Painter* painter, const Image& image,
+		coord src_x, coord src_y, coord src_w, coord src_h,
+		coord dst_x, coord dst_y, coord dst_w, coord dst_h,
+		bool nostroke = false, const Shader* shader = NULL)
 	{
 		static const GLenum MODES[] = {GL_TRIANGLE_FAN, GL_LINE_LOOP};
-		static const uint INDICES[] =
-		{
-			0, 1, 2, 3
-		};
 
-		assert(tex);
+		assert(painter && image);
 
-		if (!painter)
-			argument_error(__FILE__, __LINE__);
+		Painter::Data* self = painter->self.get();
 
-		Painter::Data* pself = painter->self.get();
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
-		if (!pself->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+		if (!self->state.has_color())
+			return;
 
-		coord x2 = x + width  - 1;
-		coord y2 = y + height - 1;
-		coord vertices[] =
-		{
-			x,  y,
-			x,  y2,
-			x2, y2,
-			x2, y
-		};
+		const Texture& texture = Image_get_texture(image);
+		if (!texture)
+			invalid_state_error(__FILE__, __LINE__);
 
-		for (int type = COLOR_TYPE_BEGIN; type < COLOR_TYPE_END; ++type)
-		{
-			if (
-				(nostroke && type == STROKE) ||
-				!pself->use_color((ColorType) type))
-			{
-				continue;
-			}
+		float density = image.pixel_density();
+		src_x *= density;
+		src_y *= density;
+		src_w *= density;
+		src_h *= density;
 
-			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);
-		}
+		Point points[4], texcoords[4];
+		points[0]   .reset(dst_x,         dst_y);
+		points[1]   .reset(dst_x,         dst_y + dst_h);
+		points[2]   .reset(dst_x + dst_w, dst_y + dst_h);
+		points[3]   .reset(dst_x + dst_w, dst_y);
+		texcoords[0].reset(src_x,         src_y);
+		texcoords[1].reset(src_x,         src_y + src_h);
+		texcoords[2].reset(src_x + src_w, src_y + src_h);
+		texcoords[3].reset(src_x + src_w, src_y);
+
+		TextureInfo texinfo(texture, src_x, src_y, src_x + src_w, src_y + src_h);
+
+		if (!shader)
+			shader = &get_default_shader_for_color_texture();
+
+		draw_polygon(
+			painter, MODES, 0, 0, false, nostroke, points, 4, NULL, 0, texcoords,
+			*shader, &texinfo);
 	}
 
 	void
@@ -745,14 +956,10 @@ namespace Rays
 		if (!image_)
 			argument_error(__FILE__, __LINE__);
 
-		const Texture& tex = image_.texture();
-		if (!tex)
-			argument_error(__FILE__, __LINE__);
-
 		draw_image(
-			this, tex,
-			0, 0, tex.s_max(), tex.t_max(),
-			x, y, tex.width(), tex.height());
+			this, image_,
+			0, 0, image_.width(), image_.height(),
+			x, y, image_.width(), image_.height());
 	}
 
 	void
@@ -768,14 +975,10 @@ namespace Rays
 		if (!image_)
 			argument_error(__FILE__, __LINE__);
 
-		const Texture& tex = image_.texture();
-		if (!tex)
-			argument_error(__FILE__, __LINE__);
-
 		draw_image(
-			this, tex,
-			0, 0, tex.s_max(), tex.t_max(),
-			x, y, width,       height);
+			this, image_,
+			0, 0, image_.width(), image_.height(),
+			x, y, width,          height);
 	}
 
 	void
@@ -788,191 +991,185 @@ namespace Rays
 	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 src_x, coord src_y, coord src_width, coord src_height,
+		coord dst_x, coord dst_y)
 	{
 		if (!image_)
 			argument_error(__FILE__, __LINE__);
 
-		const Texture& tex = image_.texture();
-		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;
 		draw_image(
-			this, tex,
-			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
-			dest_x,     dest_y,     dest_width,     dest_height);
+			this, image_,
+			src_x, src_y, src_width,      src_height,
+			dst_x, dst_y, image_.width(), image_.height());
 	}
 
 	void
 	Painter::image (
-		const Image& image_, const Bounds& src_bounds, const Point& dest_position)
+		const Image& image_, const Bounds& src_bounds, const Point& dst_position)
 	{
 		image(
 			image_,
 			src_bounds.x, src_bounds.y, src_bounds.width, src_bounds.height,
-			dest_position.x, dest_position.y);
+			dst_position.x, dst_position.y);
 	}
 
 	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)
+		coord src_x, coord src_y, coord src_width, coord src_height,
+		coord dst_x, coord dst_y, coord dst_width, coord dst_height)
 	{
 		if (!image_)
 			argument_error(__FILE__, __LINE__);
 
-		const Texture& tex = image_.texture();
-		if (!tex)
-			argument_error(__FILE__, __LINE__);
-
-		float s = tex.s_max() / tex.width();
-		float t = tex.t_max() / tex.height();
 		draw_image(
-			this, tex,
-			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
-			dest_x,     dest_y,     dest_width,     dest_height);
+			this, image_,
+			src_x, src_y, src_width, src_height,
+			dst_x, dst_y, dst_width, dst_height);
 	}
 
 	void
 	Painter::image (
-		const Image& image_, const Bounds& src_bounds, const Bounds& dest_bounds)
+		const Image& image_, const Bounds& src_bounds, const Bounds& dst_bounds)
 	{
 		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);
+			src_bounds.x, src_bounds.y, src_bounds.width, src_bounds.height,
+			dst_bounds.x, dst_bounds.y, dst_bounds.width, dst_bounds.height);
+	}
+
+	static inline void
+	debug_draw_text (
+		Painter* painter, const Font& font,
+		coord x, coord y, coord str_width, coord str_height)
+	{
+#if 0
+		save_image(painter->self->text_image, "/tmp/font.png");
+
+		painter->push_state();
+		{
+			coord 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);
+			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_state();
+#endif
 	}
 
 	static void
 	draw_text (
-		Painter* painter, const char* str, coord str_width, coord str_height,
-		coord x, coord y, coord width, coord height,
-		const Font& font)
+		Painter* painter, const Font& font,
+		const char* str, coord x, coord y, coord width = 0, coord height = 0)
 	{
-		assert(str && *str != '\0' && font);
+		assert(painter && font && str && *str != '\0');
 
-		if (!painter)
-			argument_error(__FILE__, __LINE__);
+		Painter::Data* self = painter->self.get();
 
-		if (!painter->self->painting)
-			invalid_state_error(__FILE__, __LINE__, "self->painting should be true.");
+		if (!self->painting)
+			invalid_state_error(__FILE__, __LINE__, "painting flag should be true.");
 
-		Painter::Data* self = painter->self.get();
-		int tex_w = ceil(str_width);
-		int tex_h = ceil(str_height);
+		if (!self->state.has_color())
+			return;
 
+		float density = self->pixel_density;
+		coord str_w = Font_get_width(font, density, str);
+		coord str_h = Font_get_height(font, density);
+		int tex_w   = ceil(str_w);
+		int tex_h   = ceil(str_h);
+		const Texture& texture = Image_get_texture(self->text_image);
 		if (
-			self->text_image.width()  < tex_w ||
-			self->text_image.height() < tex_h)
+			texture.width()  < tex_w ||
+			texture.height() < tex_h ||
+			self->text_image.pixel_density() != density)
 		{
-			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());
+			int bmp_w = std::max(texture.width(),  tex_w);
+			int bmp_h = std::max(texture.height(), tex_h);
+			self->text_image = Image(Bitmap(bmp_w, bmp_h, ALPHA), density);
 		}
 
 		if (!self->text_image)
 			invalid_state_error(__FILE__, __LINE__);
 
-		draw_string(&self->text_image.bitmap(), str, 0, 0, font);
+		assert(self->text_image.pixel_density() == density);
 
-		const Texture& tex = self->text_image.texture();
-		if (!tex)
-			rays_error(__FILE__, __LINE__, "text_image's texture is invalid.");
+		Bitmap_draw_string(
+			&self->text_image.bitmap(), Font_get_raw(font, density), str, 0, 0);
 
-		#if 0//def DEBUG
-			save_image(self->text_image, "/Users/snori/font.png");
-
-			painter->push_attr();
-			{
-				coord 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);
-				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_attr();
-		#endif
+		str_w /= density;
+		str_h /= density;
+		if (width  == 0) width  = str_w;
+		if (height == 0) height = str_h;
 
 		draw_image(
-			painter, tex,
-			0, 0, tex.s(str_width - 1), tex.t(str_height - 1),
-			x, y, width,                height,
-			true);
+			painter, self->text_image,
+			0, 0, str_w, str_h,
+			x, y, str_w, str_h,
+			true, &get_default_shader_for_alpha_texture());
+
+		debug_draw_text(painter, font, x, y, str_w / density, str_h / density);
 	}
 
 	void
-	Painter::text (const char* str, coord x, coord y, const Font* font)
+	Painter::text (const char* str, coord x, coord y)
 	{
 		if (!str)
 			argument_error(__FILE__, __LINE__);
 
 		if (*str == '\0') return;
 
-		if (!font) font = &self->attrs.font;
-		if (!*font)
-			argument_error(__FILE__, __LINE__);
+		const Font& font = self->state.font;
+		if (!font)
+			invalid_state_error(__FILE__, __LINE__);
 
-		coord w = font->get_width(str), h = font->get_height();
-		w = ceil(w);
-		h = ceil(h);
-		draw_text(this, str, w, h, x, y, w, h, *font);
+		draw_text(this, font, str, x, y);
 	}
 
 	void
-	Painter::text (const char* str, const Point& position, const Font* font)
+	Painter::text (const char* str, const Point& position)
 	{
-		text(str, position.x, position.y, font);
+		text(str, position.x, position.y);
 	}
 
 	void
-	Painter::text (
-		const char* str, coord x, coord y, coord width, coord height,
-		const Font* font)
+	Painter::text (const char* str, coord x, coord y, coord width, coord height)
 	{
 		if (!str)
 			argument_error(__FILE__, __LINE__);
 
-		if (*str == '\0') return;
+		if (*str == '\0' || width == 0 || height == 0) return;
 
-		if (!font) font = &self->attrs.font;
-		if (!*font)
-			argument_error(__FILE__, __LINE__);
+		const Font& font = self->state.font;
+		if (!font)
+			invalid_state_error(__FILE__, __LINE__);
 
-		coord w = font->get_width(str), h = font->get_height();
-		w = ceil(w);
-		h = ceil(h);
-		draw_text(this, str, w, h, x, y, width, height, *font);
+		draw_text(this, font, str, x, y, width, height);
 	}
 
 	void
-	Painter::text (const char* str, const Bounds& bounds, const Font* font)
+	Painter::text (const char* str, const Bounds& bounds)
 	{
-		text(str, bounds.x, bounds.y, bounds.width, bounds.height, font);
+		text(str, bounds.x, bounds.y, bounds.width, bounds.height);
 	}
 
-
 	void
-	Painter::set_background (float red, float green, float blue, float alpha, bool clear)
+	Painter::set_background (
+		float red, float green, float blue, float alpha, bool clear)
 	{
 		set_background(Color(red, green, blue, alpha), clear);
 	}
@@ -980,7 +1177,7 @@ namespace Rays
 	void
 	Painter::set_background (const Color& color, bool clear)
 	{
-		self->attrs.background = color;
+		self->state.background = color;
 
 		if (self->painting && clear) this->clear();
 	}
@@ -996,7 +1193,7 @@ namespace Rays
 	const Color&
 	Painter::background () const
 	{
-		return self->attrs.background;
+		return self->state.background;
 	}
 
 	void
@@ -1008,19 +1205,19 @@ namespace Rays
 	void
 	Painter::set_fill (const Color& color)
 	{
-		self->attrs.colors[FILL] = color;
+		self->state.colors[FILL] = color;
 	}
 
 	void
 	Painter::no_fill ()
 	{
-		self->attrs.colors[FILL].alpha = 0;
+		self->state.colors[FILL].alpha = 0;
 	}
 
 	const Color&
 	Painter::fill () const
 	{
-		return self->attrs.colors[FILL];
+		return self->state.colors[FILL];
 	}
 
 	void
@@ -1032,217 +1229,200 @@ namespace Rays
 	void
 	Painter::set_stroke (const Color& color)
 	{
-		self->attrs.colors[STROKE] = color;
+		self->state.colors[STROKE] = color;
 	}
 
 	void
 	Painter::no_stroke ()
 	{
-		self->attrs.colors[STROKE].alpha = 0;
+		self->state.colors[STROKE].alpha = 0;
 	}
 
 	const Color&
 	Painter::stroke () const
 	{
-		return self->attrs.colors[STROKE];
+		return self->state.colors[STROKE];
 	}
 
 	void
-	Painter::set_clip (coord x, coord y, coord width, coord height)
+	Painter::set_stroke_width (coord width)
 	{
-		set_clip(Bounds(x, y, width, height));
+		self->state.stroke_width = width;
 	}
 
-	void
-	Painter::set_clip (const Bounds& bounds)
+	coord
+	Painter::stroke_width () const
 	{
-		self->attrs.clip = bounds;
-		self->update_clip();
+		return self->state.stroke_width;
 	}
 
 	void
-	Painter::no_clip ()
-	{
-		set_clip(0, 0, -1, -1);
-	}
-
-	const Bounds&
-	Painter::clip () const
+	Painter::set_stroke_cap (CapType cap)
 	{
-		return self->attrs.clip;
+		self->state.stroke_cap = cap;
 	}
 
-	void
-	Painter::set_font (const char* name, coord size)
+	CapType
+	Painter::stroke_cap () const
 	{
-		set_font(Font(name, size));
+		return self->state.stroke_cap;
 	}
 
 	void
-	Painter::set_font (const Font& font)
+	Painter::set_stroke_join (JoinType join)
 	{
-		self->attrs.font = font;
+		self->state.stroke_join = join;
 	}
 
-	const Font&
-	Painter::font () const
+	JoinType
+	Painter::stroke_join () const
 	{
-		return self->attrs.font;
+		return self->state.stroke_join;
 	}
 
 	void
-	Painter::push_attr ()
+	Painter::set_miter_limit (coord limit)
 	{
-		self->attrs_stack.push_back(self->attrs);
+		self->state.miter_limit = limit;
 	}
 
-	void
-	Painter::pop_attr ()
+	coord
+	Painter::miter_limit () const
 	{
-		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();
+		return self->state.miter_limit;
 	}
 
-
 	void
-	Painter::attach (const Shader& shader)
+	Painter::set_nsegment (int nsegment)
 	{
-		self->program.attach(shader);
+		if (nsegment < 0) nsegment = 0;
+		self->state.nsegment = nsegment;
 	}
 
-	void
-	Painter::detach (const Shader& shader)
+	uint
+	Painter::nsegment () const
 	{
-		self->program.detach(shader);
+		return self->state.nsegment;
 	}
 
 	void
-	Painter::set_uniform (const char* name, int arg1)
+	Painter::set_clip (coord x, coord y, coord width, coord height)
 	{
-		self->program.set_uniform(name, arg1);
+		set_clip(Bounds(x, y, width, height));
 	}
 
 	void
-	Painter::set_uniform (const char* name, int arg1, int arg2)
+	Painter::set_clip (const Bounds& bounds)
 	{
-		self->program.set_uniform(name, arg1, arg2);
+		self->state.clip = bounds;
+		self->update_clip();
 	}
 
 	void
-	Painter::set_uniform (const char* name, int arg1, int arg2, int arg3)
+	Painter::no_clip ()
 	{
-		self->program.set_uniform(name, arg1, arg2, arg3);
+		set_clip(0, 0, -1, -1);
 	}
 
-	void
-	Painter::set_uniform (const char* name, int arg1, int arg2, int arg3, int arg4)
+	const Bounds&
+	Painter::clip () const
 	{
-		self->program.set_uniform(name, arg1, arg2, arg3, arg4);
+		return self->state.clip;
 	}
 
 	void
-	Painter::set_uniform (const char* name, const int* args, size_t size)
+	Painter::set_font (const char* name, coord size)
 	{
-		self->program.set_uniform(name, args, size);
+		set_font(Font(name, size));
 	}
 
 	void
-	Painter::set_uniform (const char* name, float arg1)
+	Painter::set_font (const Font& font)
 	{
-		self->program.set_uniform(name, arg1);
+		self->state.font = font;
 	}
 
-	void
-	Painter::set_uniform (const char* name, float arg1, float arg2)
+	const Font&
+	Painter::font () const
 	{
-		self->program.set_uniform(name, arg1, arg2);
+		return self->state.font;
 	}
 
 	void
-	Painter::set_uniform (const char* name, float arg1, float arg2, float arg3)
+	Painter::set_shader (const Shader& shader)
 	{
-		self->program.set_uniform(name, arg1, arg2, arg3);
+		self->state.shader = shader;
 	}
 
 	void
-	Painter::set_uniform (const char* name, float arg1, float arg2, float arg3, float arg4)
+	Painter::no_shader ()
 	{
-		self->program.set_uniform(name, arg1, arg2, arg3, arg4);
+		self->state.shader = Shader();
 	}
 
-	void
-	Painter::set_uniform (const char* name, const float* args, size_t size)
+	const Shader&
+	Painter::shader () const
 	{
-		self->program.set_uniform(name, args, size);
+		return self->state.shader;
 	}
 
 	void
-	Painter::push_shader ()
+	Painter::push_state ()
 	{
-		self->program.push();
+		self->state_stack.emplace_back(self->state);
 	}
 
 	void
-	Painter::pop_shader ()
+	Painter::pop_state ()
 	{
-		self->program.pop();
-	}
+		if (self->state_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "state stack underflow.");
 
+		self->state = self->state_stack.back();
+		self->state_stack.pop_back();
+		self->update_clip();
+	}
 
 	void
 	Painter::translate (coord x, coord y, coord z)
 	{
-		glTranslatef(x, y, z);
+		self->position_matrix.translate(x, y, z);
 	}
 
 	void
 	Painter::translate (const Point& value)
 	{
-		translate(value.x, value.y, value.z);
+		self->position_matrix.translate(value);
 	}
 
 	void
 	Painter::scale (coord x, coord y, coord z)
 	{
-		glScalef(x, y, z);
+		self->position_matrix.scale(x, y, z);
 	}
 
 	void
 	Painter::scale (const Point& value)
 	{
-		scale(value.x, value.y, value.z);
+		self->position_matrix.scale(value);
 	}
 
 	void
-	Painter::rotate (float angle, coord x, coord y, coord z)
+	Painter::rotate (float degree, coord x, coord y, coord z)
 	{
-		glRotatef(angle, x, y, z);
+		self->position_matrix.rotate(degree, x, y, z);
 	}
 
 	void
-	Painter::rotate (float angle, const Point& axis)
+	Painter::rotate (float angle, const Point& normalized_axis)
 	{
-		rotate(angle, axis.x, axis.y, axis.z);
+		self->position_matrix.rotate(angle, normalized_axis);
 	}
 
 	void
 	Painter::set_matrix (float value)
 	{
-		if (value == 1)
-		{
-			glLoadIdentity();
-			return;
-		}
-
-		set_matrix(
-			value, 0, 0, 0,
-			0, value, 0, 0,
-			0, 0, value, 0,
-			0, 0, 0, value);
+		self->position_matrix.reset(value);
 	}
 
 	void
@@ -1252,52 +1432,46 @@ namespace Rays
 		float c1, float c2, float c3, float c4,
 		float d1, float d2, float d3, float d4)
 	{
-		float array[] = {
+		self->position_matrix.reset(
 			a1, a2, a3, a4,
 			b1, b2, b3, b4,
 			c1, c2, c3, c4,
-			d1, d2, d3, d4
-		};
-		set_matrix(array);
+			d1, d2, d3, d4);
 	}
 
 	void
-	Painter::set_matrix (const float* elements)
+	Painter::set_matrix (const coord* elements, size_t size)
 	{
-		if (!elements)
-			argument_error(__FILE__, __LINE__);
-
-		glLoadMatrixf(elements);
+		self->position_matrix.reset(elements, size);
 	}
 
 	void
 	Painter::set_matrix (const Matrix& matrix)
 	{
-		set_matrix(matrix.array);
+		self->position_matrix = matrix;
 	}
 
 	const Matrix&
 	Painter::matrix () const
 	{
-		glGetFloatv(GL_MODELVIEW_MATRIX, self->matrix_tmp.array);
-		check_error(__FILE__, __LINE__);
-		return self->matrix_tmp;
+		return self->position_matrix;
 	}
 
 	void
 	Painter::push_matrix ()
 	{
-		glPushMatrix();
-		check_error(__FILE__, __LINE__);
+		self->position_matrix_stack.emplace_back(self->position_matrix);
 	}
 
 	void
 	Painter::pop_matrix ()
 	{
-		glPopMatrix();
-		check_error(__FILE__, __LINE__);
-	}
+		if (self->position_matrix_stack.empty())
+			invalid_state_error(__FILE__, __LINE__, "matrix stack underflow.");
 
+		self->position_matrix = self->position_matrix_stack.back();
+		self->position_matrix_stack.pop_back();
+	}
 
 	Painter::operator bool () const
 	{