rays 0.1.1

data/src/cocoa/helpers.h

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

data/src/cocoa/helpers.mm

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

data/src/cocoa/rays.mm

@@ -0,0 +1,40 @@
+// -*- objc -*-
+#include "rays/rays.h"
+
+
+#import <Cocoa/Cocoa.h>
+
+
+namespace Rays
+{
+
+
+	namespace global
+	{
+
+
+		static NSAutoreleasePool* pool = nil;
+
+
+	}// global
+
+
+	bool
+	init ()
+	{
+		if (global::pool) return false;
+		global::pool = [[NSAutoreleasePool alloc] init];
+		return true;
+	}
+
+	bool
+	fin ()
+	{
+		if (!global::pool) return false;
+		[global::pool release];
+		global::pool = nil;
+		return true;
+	}
+
+
+}// Rays

data/src/colorspace.cpp

@@ -0,0 +1,183 @@
+#include "rays/colorspace.h"
+
+
+#include <rays/helpers.h>
+
+
+namespace Rays
+{
+
+
+	enum
+	{
+
+		FIRST        = GRAY_8,    LAST       = ABGR_float,
+
+		GRAY_FIRST   = GRAY_8,    GRAY_LAST  = GRAY_float,
+
+		RGB_FIRST    = RGB_888,   RGB_LAST   = ABGR_float,
+
+		FLOAT_SECOND = RGB_float, FLOAT_LAST = ABGR_float,
+
+	};
+
+
+	ColorSpace::ColorSpace ()
+	:	type_(COLORSPACE_UNKNOWN), premult(false)
+	{
+	}
+
+	ColorSpace::ColorSpace (ColorSpaceType type, bool premultiplied)
+	:	type_(type), premult(premultiplied)
+	{
+	}
+
+	ColorSpaceType
+	ColorSpace::type () const
+	{
+		return type_;
+	}
+
+	int
+	ColorSpace::bpc () const
+	{
+		static const int BPPS[] =
+		{
+			0,                            // UNKNOWN
+			8, 16, 24, 32, 32,            // GRAY
+			8, 8, 8, 8, 8, 8, 8, 8, 8, 8, // RGB(A), BGR(A)
+			32, 32, 32, 32, 32, 32,       // RGB(A), BGR(A) float
+		};
+		if (type_ < 0 || COLORSPACE_LAST <= type_) return BPPS[UNKNOWN];
+		return BPPS[type_];
+	}
+
+	int
+	ColorSpace::Bpc () const
+	{
+		return bit2byte(bpc());
+	}
+
+	int
+	ColorSpace::bpp () const
+	{
+		static const int BPPS[] =
+		{
+			0,                     // UNKNOWN
+			8,  16, 24,  32,  32,  // GRAY
+			24, 32,  32,  32,  32, // RGB(A)
+			24, 32,  32,  32,  32, // BGR(A)
+			96, 128, 128,          // RGB(A) float
+			96, 128, 128,          // BGR(A) float
+		};
+		if (type_ < 0 || COLORSPACE_LAST <= type_) return BPPS[UNKNOWN];
+		return BPPS[type_];
+	}
+
+	int
+	ColorSpace::Bpp () const
+	{
+		return bit2byte(bpp());
+	}
+
+	int
+	ColorSpace::alpha_pos () const
+	{
+		return is_alpha_last() ? 3 : 0;
+	}
+
+	bool
+	ColorSpace::is_gray () const
+	{
+		return GRAY_FIRST <= (int) type_ && (int) type_ <= GRAY_LAST;
+	}
+
+	bool
+	ColorSpace::is_rgb () const
+	{
+		return
+			(RGB_888   <= type_ && type_ <= XRGB_8888) ||
+			(RGB_float <= type_ && type_ <= ARGB_float);
+	}
+
+	bool
+	ColorSpace::is_bgr () const
+	{
+		return
+			(BGR_888   <= type_ && type_ <= XBGR_8888) ||
+			(BGR_float <= type_ && type_ <= ABGR_float);
+	}
+
+	bool
+	ColorSpace::is_float () const
+	{
+		return
+			type_ == GRAY_float ||
+			(FLOAT_SECOND <= (int) type_ && (int) type_ <= FLOAT_LAST);
+	}
+
+	bool
+	ColorSpace::has_alpha () const
+	{
+		return
+			type_ == RGBA_8888  || type_ == ARGB_8888  ||
+			type_ == BGRA_8888  || type_ == ABGR_8888  ||
+			type_ == RGBA_float || type_ == ARGB_float ||
+			type_ == BGRA_float || type_ == ABGR_float;
+	}
+
+	bool
+	ColorSpace::has_skip () const
+	{
+		return
+			type_ == RGBX_8888  || type_ == XRGB_8888 ||
+			type_ == BGRX_8888  || type_ == XBGR_8888;
+	}
+
+	bool
+	ColorSpace::is_alpha_first () const
+	{
+		return
+			type_ == ARGB_8888  || type_ == ABGR_8888 ||
+			type_ == ARGB_float || type_ == ABGR_float;
+	}
+
+	bool
+	ColorSpace::is_alpha_last () const
+	{
+		return
+			type_ == RGBA_8888  || type_ == BGRA_8888 ||
+			type_ == RGBA_float || type_ == BGRA_float;
+	}
+
+	bool
+	ColorSpace::is_skip_first () const
+	{
+		return type_ == XRGB_8888  || type_ == XBGR_8888;
+	}
+
+	bool
+	ColorSpace::is_skip_last () const
+	{
+		return type_ == RGBX_8888  || type_ == BGRX_8888;
+	}
+
+	bool
+	ColorSpace::is_premult () const
+	{
+		return premult;
+	}
+
+	ColorSpace::operator bool () const
+	{
+		return FIRST <= (int) type_ && (int) type_ <= LAST;
+	}
+
+	bool
+	ColorSpace::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays

data/src/helpers.cpp

@@ -0,0 +1,22 @@
+#include "rays/helpers.h"
+
+
+namespace Rays
+{
+
+
+	int
+	bit2byte (int bits)
+	{
+		if ((bits % 8) != 0) return -1;
+		return bits / 8;
+	}
+
+	int
+	byte2bit (int bytes)
+	{
+		return bytes * 8;
+	}
+
+
+}// Rays

data/src/image.cpp

@@ -0,0 +1,133 @@
+#include "rays/image.h"
+
+
+#include <rays/bitmap.h>
+#include <rays/texture.h>
+
+
+namespace Rays
+{
+
+
+	struct Image::Data
+	{
+
+		Bitmap bitmap;
+
+		bool alphatex;
+
+		mutable Texture texture;
+
+		Data ()
+		:	alphatex(false)
+		{
+		}
+
+	};// Image::Data
+
+
+	Image::Image ()
+	{
+	}
+
+	Image::Image (
+		int width, int height, const ColorSpace& cs,
+		bool alphatex)
+	{
+		self->bitmap   = Bitmap(width, height, cs);
+		self->alphatex = alphatex;
+	}
+
+	Image::Image (const Bitmap& bitmap, bool alphatex)
+	{
+		self->bitmap   = bitmap;
+		self->alphatex = alphatex;
+	}
+
+	Image::~Image ()
+	{
+	}
+
+	int
+	Image::width () const
+	{
+		return self->bitmap.width();
+	}
+
+	int
+	Image::height () const
+	{
+		return self->bitmap.height();
+	}
+
+	const ColorSpace&
+	Image::color_space () const
+	{
+		return self->bitmap.color_space();
+	}
+
+	bool
+	Image::alpha_texture () const
+	{
+		return self->alphatex;
+	}
+
+	Bitmap&
+	Image::bitmap ()
+	{
+		return self->bitmap;
+	}
+
+	const Bitmap&
+	Image::bitmap () const
+	{
+		return const_cast<Image*>(this)->bitmap();
+	}
+
+	Texture&
+	Image::texture ()
+	{
+		if (
+			self->bitmap &&
+			(!self->texture || self->bitmap.dirty()))
+		{
+			self->texture = Texture(self->bitmap, self->alphatex);
+			self->bitmap.set_dirty(false);
+		}
+
+		return self->texture;
+	}
+
+	const Texture&
+	Image::texture () const
+	{
+		return const_cast<Image*>(this)->texture();
+	}
+
+	Image::operator bool () const
+	{
+		return !!self->bitmap;
+	}
+
+	bool
+	Image::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+	bool
+	load_image (Image* image, const char* path, bool alphatex)
+	{
+		if (!image || !path) return false;
+
+		Bitmap bitmap;
+		if (!load_bitmap(&bitmap, path))
+			return false;
+
+		*image = Image(bitmap, alphatex);
+		return *image;
+	}
+
+
+}// Rays

data/src/painter.cpp

@@ -0,0 +1,769 @@
+#include "rays/painter.h"
+
+
+#include <math.h>
+#include <algorithm>
+#include <rays/bitmap.h>
+#include <rays/texture.h>
+#include <rays/image.h>
+
+
+namespace Rays
+{
+
+
+	static const float PI = 3.141592653589793238462643383279f;
+
+	static const float PI_2 = PI * 2;
+
+
+	static void
+	gl_clear_error ()
+	{
+		glGetError();
+	}
+
+	static bool
+	gl_no_error ()
+	{
+		return glGetError() == GL_NO_ERROR;
+	}
+
+
+	struct Rect
+	{
+
+		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 - 1;
+		}
+
+		coord bottom () const
+		{
+			return y + height - 1;
+		}
+
+		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
+
+
+	struct Color
+	{
+
+		float red, green, blue, alpha;
+
+		Color ()
+		:	red(0), green(0), blue(0), alpha(0)
+		{
+		}
+
+		void set (float red, float green, float blue, float alpha)
+		{
+			this->red   = red;
+			this->green = green;
+			this->blue  = blue;
+			this->alpha = alpha;
+		}
+
+		bool 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* array () const {return (float*) this;}
+
+	};// Color
+
+
+	struct Painter::Data
+	{
+
+		Rect viewport, clip;
+
+		Color clear, colors[2];
+
+		bool painting, drawing, clipping;
+
+		Image textimage;
+
+		Data ()
+		:	painting(false), drawing(false), clipping(false),
+			textimage(1, 1, GRAY, true)
+		{
+		}
+
+		bool use_color (size_t i) const
+		{
+			gl_clear_error();
+
+			const Color& c = colors[i];
+			if (c.alpha <= 0) return false;
+
+			glColor4fv(c.array());
+			return gl_no_error();
+		}
+
+		bool update_clip ()
+		{
+			gl_clear_error();
+
+			if (clip)
+			{
+				if (clipping) return true;
+				glEnable(GL_SCISSOR_TEST);
+				clipping = true;
+			}
+			else
+			{
+				if (!clipping) return true;
+				glDisable(GL_SCISSOR_TEST);
+				clipping = false;
+			}
+
+			return gl_no_error();
+		}
+
+	};// Painter::Data
+
+
+	enum ColorOrder
+	{
+
+		FILL = 0, STROKE
+
+	};// ColorOrder
+
+
+	Painter::Painter ()
+	{
+	}
+
+	Painter::~Painter ()
+	{
+	}
+
+	bool
+	Painter::canvas (coord x, coord y, coord width, coord height)
+	{
+		if (self->painting || width < 0 || height < 0)
+			return false;
+
+		self->viewport.set(x, y, width, height);
+
+		glViewport(
+			(int) self->viewport.x,     (int) self->viewport.y,
+			(int) self->viewport.width, (int) self->viewport.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);
+
+		glMatrixMode(GL_MODELVIEW);
+		glLoadIdentity();
+
+		return true;
+	}
+
+	bool
+	Painter::begin ()
+	{
+		if (self->painting) return false;
+
+		glEnable(GL_CULL_FACE);
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		self->painting = true;
+
+		no_clip();
+		clear();
+
+		return push();
+	}
+
+	bool
+	Painter::end ()
+	{
+		if (!self->painting) return false;
+
+		pop();
+
+		self->painting = false;
+
+		glDisable(GL_BLEND);
+		glDisable(GL_CULL_FACE);
+
+		return true;
+	}
+
+	bool
+	Painter::push ()
+	{
+		glPushMatrix();
+		return true;
+	}
+
+	bool
+	Painter::pop ()
+	{
+		glPopMatrix();
+		return true;
+	}
+
+
+	bool
+	Painter::line (coord x1, coord y1, coord x2, coord y2)
+	{
+		if (!self->painting || !self->use_color(STROKE))
+			return true;
+
+		if (!begin_shape(LINES)) return false;
+		bool ret =
+			vertex(x1, y1) &&
+			vertex(x2, y2);
+		if (!end_shape()) return false;
+
+		return ret;
+	}
+
+	bool
+	Painter::rect (coord x, coord y, coord width, coord height)
+	{
+		static const ShapeType TYPES[] = {QUADS, LINE_LOOP};
+
+		if (!self->painting) return false;
+
+		coord x2 = x + width;
+		coord y2 = y + height;
+
+		bool ret = true;
+		for (int i = 0; i < 2; ++i)
+		{
+			if (!self->use_color(i)) continue;
+
+			if (!begin_shape(TYPES[i])) return false;
+			ret &=
+				vertex(x,  y)  &&
+				vertex(x,  y2) &&
+				vertex(x2, y2) &&
+				vertex(x2, y);
+			if (!end_shape()) return false;
+		}
+
+		return ret;
+	}
+
+	static bool
+	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 (height == 0) height = width;
+
+		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;
+		ShapeType types[]  =
+		{
+			hole ? TRIANGLE_STRIP : TRIANGLE_FAN,
+			LINE_LOOP
+		};
+
+		x += radius_x;
+		y += radius_y;
+
+		bool ret = true;
+		for (int i = 0; i < 2; ++i)
+		{
+			if (!painter->self->use_color(i)) continue;
+
+			if (!painter->begin_shape(types[i])) return false;
+
+			if (!hole)
+				ret &= painter->vertex(x, y);
+
+			for (int seg = 0; seg <= (int) nsegment; ++seg)
+			{
+				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->vertex(x + xx * radius_x_min, y + yy * radius_y_min);
+				ret &=   painter->vertex(x + xx * radius_x,     y + yy * radius_y);
+			}
+
+			if (!painter->end_shape()) return false;
+		}
+
+		return ret;
+	}
+
+	static const uint ELLIPSE_NSEGMENT = 32;
+
+	bool
+	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);
+	}
+
+	bool
+	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(
+			this, x, y, width, height, angle_from, angle_to, radius_min, nsegment);
+	}
+
+	static bool
+	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};
+
+		assert(tex);
+
+		if (!painter || !painter->self->painting)
+			return false;
+
+		coord x2 = x + width;
+		coord y2 = y + height;
+
+		glEnable(GL_TEXTURE_2D);
+		painter->texture(tex);
+
+		bool ret = true;
+		for (int i = 0; i < 2; ++i)
+		{
+			if (
+				(nostroke && TYPES[i] == LINE_LOOP) ||
+				!painter->self->use_color(i))
+			{
+				continue;
+			}
+
+			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);
+			if (!painter->end_shape()) return false;
+		}
+
+		painter->no_texture();
+		glDisable(GL_TEXTURE_2D);
+
+		return ret;
+	}
+
+	bool
+	Painter::image (const Image& image_, coord x, coord y)
+	{
+		if (!image_) return false;
+
+		const Texture& tex = image_.texture();
+		if (!tex) return false;
+
+		return draw_image(
+			this, tex,
+			0, 0, tex.s_max(), tex.t_max(),
+			x, y, tex.width(), tex.height());
+	}
+
+	bool
+	Painter::image (
+		const Image& image_, coord x, coord y, coord width, coord height)
+	{
+		if (!image_) return false;
+
+		const Texture& tex = image_.texture();
+		if (!tex) return false;
+
+		return draw_image(
+			this, tex,
+			0, 0, tex.s_max(), tex.t_max(),
+			x, y, width,       height);
+	}
+
+	bool
+	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;
+
+		const Texture& tex = image_.texture();
+		if (!tex) return false;
+
+		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(
+			this, tex,
+			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
+			dest_x,     dest_y,     dest_width,     dest_height);
+	}
+
+	bool
+	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;
+
+		const Texture& tex = image_.texture();
+		if (!tex) return false;
+
+		float s = tex.s_max() / tex.width();
+		float t = tex.t_max() / tex.height();
+		return draw_image(
+			this, tex,
+			 src_x * s,  src_y * t,  src_width * s,  src_height * t,
+			dest_x,     dest_y,     dest_width,     dest_height);
+	}
+
+	static bool
+	draw_text (
+		Painter* painter, const char* str, coord str_width, coord str_height,
+		coord x, coord y, coord width, coord height,
+		const Font& font)
+	{
+		assert(str && *str != '\0' && font);
+
+		if (!painter || !painter->self->painting)
+			return false;
+
+		Painter::Data* self = painter->self.get();
+
+		if (
+			self->textimage.width()  < str_width ||
+			self->textimage.height() < str_height)
+		{
+			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(),
+				self->textimage.alpha_texture());
+		}
+
+		if (!self->textimage) return false;
+
+		if (!draw_string(&self->textimage.bitmap(), str, 0, 0, font))
+			return false;
+
+		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(
+			painter, tex,
+			0, 0, str_width * s, str_height * t,
+			x, y, width,         height,
+			true);
+	}
+
+	bool
+	Painter::text (const char* str, coord x, coord y, const Font& font)
+	{
+		if (!str || !font) return false;
+
+		if (*str == '\0') return true;
+
+		coord w = 0, h = 0;
+		if (!font.get_extent(&w, &h, str))
+			return false;
+
+		return draw_text(
+			this, str, w, h, x, y, w, h, font);
+	}
+
+	bool
+	Painter::text (
+		const char* str, coord x, coord y, coord width, coord height,
+		const Font& font)
+	{
+		if (!str || !font) return false;
+
+		if (*str == '\0') return true;
+
+		coord w = 0, h = 0;
+		if (!font.get_extent(&w, &h, str))
+			return false;
+
+		return draw_text(this, str, w, h, x, y, width, height, font);
+	}
+
+	bool
+	Painter::clear ()
+	{
+		if (!self->painting) return false;
+
+		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+		return true;
+	}
+
+	bool
+	Painter::get_clear (float* red, float* green, float* blue, float* alpha)
+	{
+		return self->clear.get(red, green, blue, alpha);
+	}
+
+	bool
+	Painter::set_clear (float red, float green, float blue, float alpha)
+	{
+		self->clear.set(red, green, blue, alpha);
+		glClearColor(red, green, blue, alpha);
+		return true;
+	}
+
+	bool
+	Painter::no_clear ()
+	{
+		return set_clear(
+			self->clear.red, self->clear.green, self->clear.blue, 0);
+	}
+
+	bool
+	Painter::get_fill (float* red, float* green, float* blue, float* alpha)
+	{
+		return self->colors[FILL].get(red, green, blue, alpha);
+	}
+
+	bool
+	Painter::set_fill (float red, float green, float blue, float alpha)
+	{
+		self->colors[FILL].set(red, green, blue, alpha);
+		return true;
+	}
+
+	bool
+	Painter::no_fill ()
+	{
+		self->colors[FILL].alpha = 0;
+		return true;
+	}
+
+	bool
+	Painter::get_stroke (float* red, float* green, float* blue, float* alpha)
+	{
+		return self->colors[STROKE].get(red, green, blue, alpha);
+	}
+
+	bool
+	Painter::set_stroke (float red, float green, float blue, float alpha)
+	{
+		self->colors[STROKE].set(red, green, blue, alpha);
+		return true;
+	}
+
+	bool
+	Painter::no_stroke ()
+	{
+		self->colors[STROKE].alpha = 0;
+		return true;
+	}
+
+	bool
+	Painter::get_clip (coord* x, coord* y, coord* width, coord* height)
+	{
+		return self->clip.get(x, y, width, height);
+	}
+
+	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;
+
+		if (self->clip)
+		{
+			glScissor(
+				self->clip.x, -self->clip.y, self->clip.width, self->clip.height);
+		}
+
+		return true;
+	}
+
+	bool
+	Painter::no_clip ()
+	{
+		return set_clip(0, 0, -1, -1);
+	}
+
+
+	bool
+	Painter::begin_shape (ShapeType type)
+	{
+		if (!self->painting || self->drawing)
+			return false;
+
+		glBegin(type);
+
+		self->drawing = true;
+		return true;
+	}
+
+	bool
+	Painter::end_shape ()
+	{
+		if (!self->painting || !self->drawing)
+			return false;
+
+		glEnd();
+
+		self->drawing = false;
+		return true;
+	}
+
+	bool
+	Painter::color (float red, float green, float blue, float alpha)
+	{
+		if (!self->drawing) return false;
+
+		glColor4f(red, green, blue, alpha);
+		return true;
+	}
+
+	bool
+	Painter::texture (const Texture& tex)
+	{
+		if (!self->drawing) return false;
+
+		glBindTexture(GL_TEXTURE_2D, tex ? tex.id() : 0);
+		return true;
+	}
+
+	bool
+	Painter::no_texture ()
+	{
+		if (!self->drawing) return false;
+
+		glBindTexture(GL_TEXTURE_2D, 0);
+		return true;
+	}
+
+	bool
+	Painter::vertex (coord x, coord y)
+	{
+		return vertex(x, y, 0);
+	}
+
+	bool
+	Painter::vertex (coord x, coord y, coord z)
+	{
+		if (!self->drawing) return false;
+
+		glVertex3f(x, y, z);
+		return true;
+	}
+
+	bool
+	Painter::vertex (coord x, coord y, coord texcoord_s, coord texcoord_t)
+	{
+		return vertex(x, y, 0, texcoord_s, texcoord_t);
+	}
+
+	bool
+	Painter::vertex (coord x, coord y, coord z, coord texcoord_s, coord texcoord_t)
+	{
+		if (!self->drawing) return false;
+
+		glTexCoord2f(texcoord_s, texcoord_t);
+		return vertex(x, y, z);
+	}
+
+	Painter::operator bool () const
+	{
+		return self->viewport;
+	}
+
+	bool
+	Painter::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays