rays 0.1.11 → 0.1.16

data/src/painter.h

@@ -0,0 +1,24 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RAYS_SRC_PAINTER_H__
+#define __RAYS_SRC_PAINTER_H__
+
+
+#include <rays/painter.h>
+#include "opengl.h"
+
+
+namespace Rays
+{
+
+
+	void Painter_draw_polygon (
+		Painter* painter, GLenum mode, const Color& color,
+		const Coord3* points,         size_t npoints,
+		const uint*   indices = NULL, size_t nindices = 0);
+
+
+}// Rays
+
+
+#endif//EOH

data/src/point.cpp

@@ -2,88 +2,44 @@
 
 
 #include <math.h>
-#include <xot/string.h>
+#include <glm/geometric.hpp>
+#include <glm/gtx/rotate_vector.hpp>
+#include <xot/util.h>
 #include "rays/exception.h"
+#include "coord.h"
 
 
 namespace Rays
 {
 
 
-	Coord2&
-	Coord2::reset (coord value)
-	{
-		return reset(value, value);
-	}
-
-	Coord2&
-	Coord2::reset (coord x, coord y)
-	{
-		this->x = x;
-		this->y = y;
-		return *this;
-	}
-
-	coord&
-	Coord2::operator [] (size_t index)
-	{
-		if (index >= 2)
-			argument_error(__FILE__, __LINE__);
-
-		return array[index];
-	}
-
-	const coord&
-	Coord2::operator [] (size_t index) const
+	Point::Point (coord value)
 	{
-		return const_cast<Coord2*>(this)->operator[](index);
+		reset(value);
 	}
 
-
-	Coord3&
-	Coord3::reset (coord value)
+	Point::Point (coord x, coord y, coord z)
 	{
-		return reset(value, value, 0);
+		reset(x, y, z);
 	}
 
-	Coord3&
-	Coord3::reset (coord x, coord y, coord z)
+	Point
+	Point::dup () const
 	{
-		this->x = x;
-		this->y = y;
-		this->z = z;
 		return *this;
 	}
 
-	coord&
-	Coord3::operator [] (size_t index)
-	{
-		if (index >= 3)
-			argument_error(__FILE__, __LINE__);
-
-		return array[index];
-	}
-
-	const coord&
-	Coord3::operator [] (size_t index) const
-	{
-		return const_cast<Coord3*>(this)->operator[](index);
-	}
-
-
-	Point::Point (coord value)
-	{
-		reset(value);
-	}
-
-	Point::Point (coord x, coord y, coord z)
+	Point&
+	Point::reset (coord value)
 	{
-		reset(x, y, z);
+		Super::reset(value);
+		return *this;
 	}
 
-	Point
-	Point::dup () const
+	Point&
+	Point::reset (coord x, coord y, coord z)
 	{
+		Super::reset(x, y, z);
 		return *this;
 	}
 
@@ -95,7 +51,7 @@ namespace Rays
 	}
 
 	Point&
-	Point::move_to (const Point& point)
+	Point::move_to (const This& point)
 	{
 		reset(point.x, point.y, point.z);
 		return *this;
@@ -109,146 +65,211 @@ namespace Rays
 	}
 
 	Point&
-	Point::move_by (const Point& point)
+	Point::move_by (const This& point)
 	{
 		reset(this->x + point.x, this->y + point.y, this->z + point.z);
 		return *this;
 	}
 
+	void
+	Point::rotate (float degree)
+	{
+		to_glm(*this) = glm::rotateZ(to_glm(*this), (float) Xot::deg2rad(degree));
+	}
+
 	coord
 	Point::length () const
 	{
-		return sqrt(x * x + y * y + z * z);
+		return glm::length(to_glm(*this));
 	}
 
-	void
-	Point::normalize ()
+	Point
+	Point::normal () const
 	{
-		coord len = length();
-		if (len == 0)
+		if (dot(*this, *this) == 0)
 			invalid_state_error(__FILE__, __LINE__);
 
-		*this /= len;
+		return to_rays<Point>(glm::normalize(to_glm(*this)));
+	}
+
+	void
+	Point::normalize ()
+	{
+		*this = normal();
 	}
 
 	Point
-	Point::normal () const
+	Point::operator - () const
 	{
-		Point t = *this;
-		t.normalize();
-		return t;
+		return to_rays<Point>(-to_glm(*this));
 	}
 
-	String
-	Point::inspect () const
+	Point&
+	Point::operator += (coord rhs)
 	{
-		return Xot::stringf("x=%f y=%f z=%f", x, y, z);
+		to_glm(*this) += rhs;
+		return *this;
 	}
 
-	Point
-	Point::operator - () const
+	Point&
+	Point::operator += (const This& rhs)
 	{
-		return Point(-x, -y, -z);
+		to_glm(*this) += to_glm(rhs);
+		return *this;
 	}
 
 	Point&
-	Point::operator += (const Point& rhs)
+	Point::operator -= (coord rhs)
 	{
-		x += rhs.x;
-		y += rhs.y;
-		z += rhs.z;
+		to_glm(*this) -= rhs;
 		return *this;
 	}
 
 	Point&
-	Point::operator -= (const Point& rhs)
+	Point::operator -= (const This& rhs)
 	{
-		x -= rhs.x;
-		y -= rhs.y;
-		z -= rhs.z;
+		to_glm(*this) -= to_glm(rhs);
 		return *this;
 	}
 
 	Point&
-	Point::operator *= (const Point& rhs)
+	Point::operator *= (coord rhs)
 	{
-		x *= rhs.x;
-		y *= rhs.y;
-		z *= rhs.z;
+		to_glm(*this) *= rhs;
 		return *this;
 	}
 
 	Point&
-	Point::operator /= (const Point& rhs)
+	Point::operator *= (const This& rhs)
 	{
-		x /= rhs.x;
-		y /= rhs.y;
-		z /= rhs.z;
+		to_glm(*this) *= to_glm(rhs);
 		return *this;
 	}
 
 	Point&
 	Point::operator /= (coord rhs)
 	{
-		x /= rhs;
-		y /= rhs;
-		z /= rhs;
+		if (rhs == 0)
+			argument_error(__FILE__, __LINE__);
+
+		to_glm(*this) /= rhs;
+		return *this;
+	}
+
+	Point&
+	Point::operator /= (const This& rhs)
+	{
+		if (rhs.x == 0 || rhs.y == 0 || rhs.z == 0)
+			argument_error(__FILE__, __LINE__);
+
+		to_glm(*this) /= to_glm(rhs);
 		return *this;
 	}
 
 	bool
 	operator == (const Point& lhs, const Point& rhs)
 	{
-		return
-			lhs.x == rhs.x &&
-			lhs.y == rhs.y &&
-			lhs.z == rhs.z;
+		return to_glm(lhs) == to_glm(rhs);
 	}
 
 	bool
 	operator != (const Point& lhs, const Point& rhs)
 	{
-		return !operator==(lhs, rhs);
+		return to_glm(lhs) != to_glm(rhs);
+	}
+
+	Point
+	operator + (coord lhs, const Point& rhs)
+	{
+		return to_rays<Point>(lhs + to_glm(rhs));
+	}
+
+	Point
+	operator + (const Point& lhs, coord rhs)
+	{
+		return to_rays<Point>(to_glm(lhs) + rhs);
 	}
 
 	Point
 	operator + (const Point& lhs, const Point& rhs)
 	{
-		Point t = lhs;
-		t += rhs;
-		return t;
+		return to_rays<Point>(to_glm(lhs) + to_glm(rhs));
+	}
+
+	Point
+	operator - (coord lhs, const Point& rhs)
+	{
+		return to_rays<Point>(lhs - to_glm(rhs));
+	}
+
+	Point
+	operator - (const Point& lhs, coord rhs)
+	{
+		return to_rays<Point>(to_glm(lhs) - rhs);
 	}
 
 	Point
 	operator - (const Point& lhs, const Point& rhs)
 	{
-		Point t = lhs;
-		t -= rhs;
-		return t;
+		return to_rays<Point>(to_glm(lhs) - to_glm(rhs));
+	}
+
+	Point
+	operator * (coord lhs, const Point& rhs)
+	{
+		return to_rays<Point>(lhs * to_glm(rhs));
+	}
+
+	Point
+	operator * (const Point& lhs, coord rhs)
+	{
+		return to_rays<Point>(to_glm(lhs) * rhs);
 	}
 
 	Point
 	operator * (const Point& lhs, const Point& rhs)
 	{
-		Point t = lhs;
-		t *= rhs;
-		return t;
+		return to_rays<Point>(to_glm(lhs) * to_glm(rhs));
 	}
 
 	Point
-	operator / (const Point& lhs, const Point& rhs)
+	operator / (coord lhs, const Point& rhs)
 	{
-		Point t = lhs;
-		t /= rhs;
-		return t;
+		if (rhs.x == 0 || rhs.y == 0 || rhs.z == 0)
+			argument_error(__FILE__, __LINE__);
+
+		return to_rays<Point>(lhs / to_glm(rhs));
 	}
 
 	Point
 	operator / (const Point& lhs, coord rhs)
 	{
-		Point t = lhs;
-		t /= rhs;
-		return t;
+		if (rhs == 0)
+			argument_error(__FILE__, __LINE__);
+
+		return to_rays<Point>(to_glm(lhs) / rhs);
+	}
+
+	Point
+	operator / (const Point& lhs, const Point& rhs)
+	{
+		if (rhs.x == 0 || rhs.y == 0 || rhs.z == 0)
+			argument_error(__FILE__, __LINE__);
+
+		return to_rays<Point>(to_glm(lhs) / to_glm(rhs));
+	}
+
+
+	coord
+	dot (const Point& p1, const Point& p2)
+	{
+		return glm::dot(to_glm(p1), to_glm(p2));
+	}
+
+	Point
+	cross (const Point& p1, const Point& p2)
+	{
+		return to_rays<Point>(glm::cross(to_glm(p1), to_glm(p2)));
 	}
 
 

data/src/polygon.cpp

@@ -0,0 +1,1266 @@
+#include "polygon.h"
+
+
+#include <math.h>
+#include <assert.h>
+#include <utility>
+#include <poly2tri.h>
+#include <Splines.h>
+#include "xot/util.h"
+#include "rays/color.h"
+#include "rays/exception.h"
+#include "rays/debug.h"
+#include "polyline.h"
+#include "painter.h"
+
+
+namespace clip = ClipperLib;
+
+
+namespace Rays
+{
+
+
+	static inline p2t::Point
+	to_poly2tri (const Point& point)
+	{
+		return p2t::Point(point.x, point.y);
+	}
+
+	static inline Point
+	from_poly2tri (const p2t::Point& point)
+	{
+		return Point(point.x, point.y);
+	}
+
+
+	struct Polygon::Data
+	{
+
+		LineList lines;
+
+		virtual ~Data ()
+		{
+		}
+
+		void append (const Polyline& polyline, bool hole = false)
+		{
+			if (polyline.empty())
+				return;
+
+			lines.emplace_back(Line(polyline, hole));
+		}
+
+		void append (const Line& line)
+		{
+			if (line.empty())
+				return;
+
+			lines.emplace_back(line);
+		}
+
+		bool triangulate (TrianglePointList* triangles) const
+		{
+			assert(triangles);
+
+			triangles->clear();
+
+			if (!can_triangulate())
+				return false;
+
+			size_t npoint = count_points();
+			if (npoint <= 0)
+				return true;
+
+			std::unique_ptr<p2t::CDT> cdt;
+			std::vector<p2t::Point> points;
+			std::vector<p2t::Point*> pointers;
+
+			points.reserve(npoint);
+			for (const auto& line : lines)
+			{
+				pointers.clear();
+				pointers.reserve(line.size());
+				for (const auto& point : line)
+				{
+					points.emplace_back(to_poly2tri(point));
+					pointers.emplace_back(&points.back());
+				}
+
+				if (!line.hole())
+				{
+					if (cdt) triangulate(triangles, cdt.get());
+					cdt.reset(new p2t::CDT(pointers));
+				}
+				else if (cdt)
+					cdt->AddHole(pointers);
+			}
+
+			if (cdt) triangulate(triangles, cdt.get());
+
+			return true;
+		}
+
+		virtual void fill (Painter* painter, const Color& color) const = 0;
+
+		virtual void stroke (
+			const Polygon& polygon, Painter* painter, const Color& color) const
+		{
+			assert(painter && color);
+
+			coord stroke_width = painter->stroke_width();
+			if (stroke_width > 0)
+				stroke_with_width(polygon, painter, color, stroke_width);
+			else
+				stroke_without_width(painter, color);
+		}
+
+		private:
+
+			bool can_triangulate () const
+			{
+				for (const auto& line : lines)
+				{
+					if (line.loop() && !line.hole() && !line.empty())
+						return true;
+				}
+				return false;
+			}
+
+			size_t count_points () const
+			{
+				size_t count = 0;
+				for (const auto& line : lines)
+					count += line.size();
+				return count;
+			}
+
+			void triangulate (TrianglePointList* triangles, p2t::CDT* cdt) const
+			{
+				assert(triangles && cdt);
+
+				cdt->Triangulate();
+
+				for (auto* triangle : cdt->GetTriangles())
+				{
+					for (int i = 0; i < 3; ++i)
+						triangles->emplace_back(from_poly2tri(*triangle->GetPoint(i)));
+				}
+			}
+
+			void stroke_with_width (
+				const Polygon& polygon, Painter* painter,
+				const Color& color, coord stroke_width) const
+			{
+				assert(painter && color && stroke_width > 0);
+
+				if (!polygon || polygon.empty()) return;
+
+				CapType cap   = painter->stroke_cap();
+				JoinType join = painter->stroke_join();
+				coord ml      = painter->miter_limit();
+
+				bool has_loop = false;
+				for (const auto& polyline : polygon)
+				{
+					if (!polyline || polyline.empty())
+						continue;
+
+					if (polyline.loop())
+					{
+						has_loop = true;
+						continue;
+					}
+
+					Polygon stroke;
+					if (!polyline.expand(&stroke, stroke_width / 2, cap, join, ml))
+						continue;
+
+					Polygon_fill(stroke, painter, color);
+				}
+
+				if (has_loop)
+				{
+					Polygon hole;
+					if (polygon.expand(&hole, -stroke_width, cap, join, ml))
+						Polygon_fill(polygon - hole, painter, color);
+				}
+			}
+
+			void stroke_without_width (Painter* painter, const Color& color) const
+			{
+				assert(painter && color);
+
+				for (const auto& line : lines)
+				{
+					Painter_draw_polygon(
+						painter, line.loop() ? GL_LINE_LOOP : GL_LINE_STRIP, color,
+						&line[0], line.size());
+				}
+			}
+
+	};// Polygon::Data
+
+
+#if 0
+	static String
+	path2str (const Path& path)
+	{
+		String s;
+		for (const auto& point : path)
+		{
+			if (!s.empty()) s += ", ";
+
+			Point p = from_clipper(point);
+			s += Xot::stringf("[%d,%d]", p.x, p.y);
+		}
+		return s;
+	}
+
+	static void
+	dout_node (const PolyNode& node)
+	{
+		doutln(
+			"path(open: %d, hole: %d, Contour: %s)",
+			(int) node.IsOpen(),
+			(int) node.IsHole(),
+			path2str(node.Contour).c_str());
+	}
+
+	static void
+	dout_tree (const PolyNode& node, int level = 0)
+	{
+		for (int i = 0; i < level; ++i) dout("  ");
+		dout_node(node);
+
+		for (const auto* child : node.Childs)
+			dout_tree(*child, level + 1);
+	}
+#endif
+
+	static uint
+	get_nsegment (
+		uint nsegment, uint nsegment_min, float angle_from, float angle_to)
+	{
+		float angle = angle_to - angle_from;
+		assert(0 <= angle && angle <= 360);
+
+		if (nsegment <= 0)
+			nsegment = 32;
+		else if (nsegment < nsegment_min)
+			nsegment = nsegment_min;
+
+		nsegment *= angle / 360;
+		return nsegment > 0 ? nsegment : 1;
+	}
+
+	static void
+	add_polygon_to_clipper (
+		clip::Clipper* clipper, const Polygon& polygon, clip::PolyType type)
+	{
+		assert(clipper);
+
+		clip::Path path;
+		for (const auto& line : polygon)
+		{
+			if (!line) continue;
+
+			Polyline_get_path(&path, line, line.hole());
+			if (path.empty()) continue;
+
+			clipper->AddPath(path, type, line.loop());
+		}
+	}
+
+	static clip::JoinType
+	get_join_type (JoinType join)
+	{
+		switch (join)
+		{
+			case JOIN_MITER:  return clip::jtMiter;
+			case JOIN_ROUND:  return clip::jtRound;
+			case JOIN_SQUARE: return clip::jtSquare;
+			default:
+				argument_error(__FILE__, __LINE__, "invalid join type -- %d", join);
+		}
+
+		return clip::jtMiter;// to avoid compiler warning
+	}
+
+	static clip::EndType
+	get_end_type (const Polyline& polyline, CapType cap, bool fill)
+	{
+		if (polyline.loop())
+			return fill ? clip::etClosedPolygon : clip::etClosedLine;
+		else switch (cap)
+		{
+			case CAP_BUTT:   return clip::etOpenButt;
+			case CAP_ROUND:  return clip::etOpenRound;
+			case CAP_SQUARE: return clip::etOpenSquare;
+			default:
+				argument_error(__FILE__, __LINE__, "invalid cap type -- %d", cap);
+		}
+
+		return clip::etOpenButt;// to avoid compiler warning
+	}
+
+	static bool
+	add_polyline_to_offsetter (
+		clip::ClipperOffset* offsetter, const Polyline& polyline,
+		CapType cap, JoinType join, bool hole, bool fill)
+	{
+		assert(offsetter);
+
+		if (!polyline) return false;
+
+		clip::Path path;
+		Polyline_get_path(&path, polyline, hole);
+		offsetter->AddPath(
+			path, get_join_type(join), get_end_type(polyline, cap, fill));
+		return true;
+	}
+
+	static bool
+	add_polygon_to_offsetter (
+		clip::ClipperOffset* offsetter, const Polygon& polygon,
+		CapType cap, JoinType join)
+	{
+		assert(offsetter);
+
+		bool added = false;
+		for (const auto& line : polygon.self->lines)
+		{
+			added |= add_polyline_to_offsetter(
+				offsetter, line, cap, join, line.hole(), true);
+		}
+		return added;
+	}
+
+	static bool
+	append_outline (Polygon* polygon, const clip::PolyNode& node)
+	{
+		assert(polygon);
+
+		if (node.Contour.empty() || node.IsHole())
+			return false;
+
+		Polyline polyline;
+		Polyline_create(&polyline, node.Contour, !node.IsOpen(), false);
+		if (!polyline)
+			return false;
+
+		polygon->self->append(polyline, false);
+		return true;
+	}
+
+	static void
+	append_hole (Polygon* polygon, const clip::PolyNode& node)
+	{
+		assert(polygon);
+
+		for (const auto* child : node.Childs)
+		{
+			if (!child->IsHole())
+				return;
+
+			Polyline polyline;
+			Polyline_create(&polyline, child->Contour, !child->IsOpen(), true);
+			if (!polyline)
+				continue;
+
+			polygon->self->append(polyline, true);
+		}
+	}
+
+	static void
+	get_polygon (Polygon* polygon, const clip::PolyNode& node)
+	{
+		assert(polygon);
+
+		if (append_outline(polygon, node))
+			append_hole(polygon, node);
+
+		for (const auto* child : node.Childs)
+			get_polygon(polygon, *child);
+	}
+
+	static Polygon
+	clip_polygons (
+		const Polygon& subject, const Polygon& clip, clip::ClipType type)
+	{
+		clip::Clipper c;
+		c.StrictlySimple(true);
+
+		add_polygon_to_clipper(&c, subject, clip::ptSubject);
+		add_polygon_to_clipper(&c, clip,    clip::ptClip);
+
+		clip::PolyTree tree;
+		c.Execute(type, tree);
+		assert(tree.Contour.empty());
+
+		Polygon result;
+		get_polygon(&result, tree);
+
+		return result;
+	}
+
+	static bool
+	expand_polygon (
+		Polygon* result, const Polygon& polygon,
+		coord width, CapType cap, JoinType join, coord miter_limit)
+	{
+		if (width == 0)
+			return false;
+
+		clip::ClipperOffset co;
+		co.MiterLimit = miter_limit;
+		if (!add_polygon_to_offsetter(&co, polygon, cap, join))
+			return false;
+
+		clip::PolyTree tree;
+		co.Execute(tree, to_clipper(width));
+		assert(tree.Contour.empty());
+
+		get_polygon(result, tree);
+		return true;
+	}
+
+	bool
+	Polyline_expand (
+		Polygon* result, const Polyline& polyline,
+		coord width, CapType cap, JoinType join, coord miter_limit)
+	{
+		if (width == 0)
+			return false;
+
+		clip::ClipperOffset co;
+		co.MiterLimit = miter_limit;
+		if (!add_polyline_to_offsetter(&co, polyline, cap, join, false, false))
+			return false;
+
+		clip::PolyTree tree;
+		co.Execute(tree, to_clipper(width));
+		assert(tree.Contour.empty());
+
+		get_polygon(result, tree);
+		return true;
+	}
+
+
+	struct PolygonData : public Polygon::Data
+	{
+
+		mutable Polygon::TrianglePointList triangles;
+
+		void fill (Painter* painter, const Color& color) const
+		{
+			if (triangles.empty())
+			{
+				if (!triangulate(&triangles))
+					return;
+			}
+
+			Painter_draw_polygon(
+				painter, GL_TRIANGLES, color, &triangles[0], triangles.size());
+		}
+
+	};// PolygonData
+
+
+	struct RectData : public Polygon::Data
+	{
+
+		RectData (
+			coord x, coord y, coord width, coord height,
+			coord round_left_top,    coord round_right_top,
+			coord round_left_bottom, coord round_right_bottom,
+			uint nsegment)
+		{
+			if (
+				round_left_top    == 0 && round_right_top    == 0 &&
+				round_left_bottom == 0 && round_right_bottom == 0)
+			{
+				setup_rect(x, y, width, height, nsegment);
+			}
+			else
+			{
+				setup_round_rect(
+					x, y, width, height,
+					round_left_top,    round_right_top,
+					round_left_bottom, round_right_bottom,
+					nsegment);
+			}
+		}
+
+		void fill (Painter* painter, const Color& color) const
+		{
+			if (lines.size() != 1)
+				invalid_state_error(__FILE__, __LINE__);
+
+			const auto& outline = lines[0];
+			Painter_draw_polygon(
+				painter, GL_TRIANGLE_FAN, color, &outline[0], outline.size());
+		}
+
+		private:
+
+			struct RoundedCorner
+			{
+				coord x, y, offset_sign_x, offset_sign_y, round;
+			};
+
+			void setup_rect (
+				coord x, coord y, coord width, coord height,
+				uint nsegment)
+			{
+				const Point points[] = {
+					Point(x,         y),
+					Point(x,         y + height),
+					Point(x + width, y + height),
+					Point(x + width, y),
+				};
+				append(Polyline(points, 4, true));
+			}
+
+			void setup_round_rect (
+				coord x, coord y, coord width, coord height,
+				coord left_top, coord right_top, coord left_bottom, coord right_bottom,
+				uint nsegment)
+			{
+				assert(width != 0 && height != 0);
+				assert(
+					left_top    != 0 || right_top    != 0 ||
+					left_bottom != 0 || right_bottom != 0);
+
+				nsegment = get_nsegment(nsegment, 1, 0, 90);
+
+				fix_rounds(
+					&left_top,    &right_top,
+					&left_bottom, &right_bottom,
+					width, height);
+
+				coord sign_x            = width  >= 0 ? +1 : -1;
+				coord sign_y            = height >= 0 ? +1 : -1;
+				RoundedCorner corners[] =
+				{
+					{width,      0, -1, +1, right_top},
+					{    0,      0, +1, +1,  left_top},
+					{    0, height, +1, -1,  left_bottom},
+					{width, height, -1, -1, right_bottom}
+				};
+
+				size_t npoints = 0;
+				for (size_t i = 0; i < 4; ++i)
+					npoints += corners[i].round > 0 ? nsegment + 1 : 1;
+
+				std::unique_ptr<Point[]> points(new Point[npoints]);
+				Point* point = points.get();
+
+				for (size_t i = 0; i < 4; ++i)
+				{
+					point += setup_round(
+						point, x, y, corners[i], sign_x, sign_y, (M_PI / 2) * i, nsegment);
+				}
+
+				append(Polyline(points.get(), npoints, true));
+			}
+
+			void fix_rounds (
+				coord* left_top,    coord* right_top,
+				coord* left_bottom, coord* right_bottom,
+				coord width, coord height)
+			{
+				assert(
+					left_top    && right_top &&
+					left_bottom && right_bottom);
+
+				if (width  < 0) width  = -width;
+				if (height < 0) height = -height;
+
+				coord* rounds[] = {
+					 left_top,
+					right_top,
+					right_bottom,
+					 left_bottom,
+					 left_top};
+				coord sizes[]   = {width, height, width, height};
+
+				for (size_t i = 0; i < 4; ++i)
+				{
+					const coord& size = sizes[i];
+
+					coord* a = rounds[i];
+					coord* b = rounds[i + 1];
+					if (*a + *b <= size)
+						continue;
+
+					if (*a > *b)
+						std::swap(a, b);
+
+					if (*a * 2 > size)
+						*a = *b = size / 2;
+					else
+						*b = size - *a;
+				}
+			}
+
+			int setup_round (
+				Point* point, coord x, coord y, const RoundedCorner& corner,
+				coord sign_x, coord sign_y, float radian_offset, uint nsegment)
+			{
+				if (corner.round <= 0)
+				{
+					point->reset(x + corner.x, y + corner.y);
+					return 1;
+				}
+
+				coord offset_x = corner.x + corner.round * corner.offset_sign_x * sign_x;
+				coord offset_y = corner.y + corner.round * corner.offset_sign_y * sign_y;
+
+				for (uint seg = 0; seg <= nsegment; ++seg, ++point)
+				{
+					float pos    = (float) seg / (float) nsegment;
+					float radian = radian_offset + pos * (M_PI / 2);
+					point->reset(
+						x + offset_x + cos(radian) * corner.round * sign_x,
+						y + offset_y - sin(radian) * corner.round * sign_y);
+				}
+				return nsegment + 1;
+			}
+
+	};// RectData
+
+
+	struct EllipseData : public PolygonData
+	{
+
+		typedef PolygonData Super;
+
+		GLenum mode = 0;
+
+		EllipseData (
+			coord x, coord y, coord width, coord height,
+			const Point& hole_size,
+			float angle_from, float angle_to,
+			uint nsegment)
+		{
+			normalize_angle(&angle_from, &angle_to);
+
+			if ((angle_to - angle_from) >= 360)
+				setup_ellipse(x, y, width, height, hole_size, nsegment);
+			else
+			{
+				setup_arc(
+					x, y, width, height, hole_size, angle_from, angle_to, nsegment);
+			}
+		}
+
+		void fill (Painter* painter, const Color& color) const
+		{
+			if (lines.size() <= 0)
+				invalid_state_error(__FILE__, __LINE__);
+
+			if (mode == 0)
+			{
+				Super::fill(painter, color);
+				return;
+			}
+
+			if (lines.size() >= 2)
+				invalid_state_error(__FILE__, __LINE__);
+
+			const auto& outline = lines[0];
+			Painter_draw_polygon(painter, mode, color, &outline[0], outline.size());
+		}
+
+		private:
+
+			void normalize_angle (float* angle_from, float* angle_to)
+			{
+				assert(angle_from && angle_to);
+
+				float& from = *angle_from;
+				float& to   = *angle_to;
+
+				if (from > to)
+					std::swap(from, to);
+
+				if (to - from > 360)
+					to = from + 360;
+			}
+
+			void setup_ellipse (
+				coord x, coord y, coord width, coord height,
+				const Point& hole_size, uint nsegment)
+			{
+				assert(width != 0 && height != 0);
+
+				nsegment = get_nsegment(nsegment, 3, 0, 360);
+
+				bool has_hole     = hole_size != 0;
+				float radian_from = Xot::deg2rad(0);
+				float radian_to   = Xot::deg2rad(360);
+
+				if (!has_hole) mode = GL_TRIANGLE_FAN;
+
+				std::vector<Point> points;
+				points.reserve(nsegment);
+
+				for (uint seg = 0; seg < nsegment; ++seg)
+				{
+					points.emplace_back(make_ellipse_point(
+						x, y, width, height, radian_from, radian_to, nsegment, seg));
+				}
+				append(Polyline(&points[0], points.size(), true));
+
+				if (has_hole)
+				{
+					points.clear();
+
+					coord hole_x = x + (width  - hole_size.x) / 2;
+					coord hole_y = y + (height - hole_size.y) / 2;
+					for (uint seg = 0; seg < nsegment; ++seg)
+					{
+						points.emplace_back(make_ellipse_point(
+							hole_x, hole_y, hole_size.x, hole_size.y,
+							radian_from, radian_to, nsegment, seg));
+					}
+					append(Polyline(&points[0], points.size(), true), true);
+				}
+			}
+
+			void setup_arc (
+				coord x, coord y, coord width, coord height,
+				const Point& hole_size, float angle_from, float angle_to,
+				uint nsegment)
+			{
+				assert(width != 0 && height != 0 && angle_from != angle_to);
+
+				nsegment = get_nsegment(nsegment, 3, angle_from, angle_to);
+
+				bool has_hole     = hole_size != 0;
+				float radian_from = Xot::deg2rad(angle_from);
+				float radian_to   = Xot::deg2rad(angle_to);
+				uint npoint       = nsegment + 1;
+
+				std::vector<Point> points;
+				points.reserve(has_hole ? npoint * 2 : npoint + 1);
+
+				if (!has_hole)
+				{
+					points.emplace_back(Point(x + width / 2, y + height / 2));
+					mode = GL_TRIANGLE_FAN;
+				}
+
+				for (uint seg = 0; seg <= nsegment; ++seg)
+				{
+					points.emplace_back(make_ellipse_point(
+						x, y, width, height, radian_from, radian_to, nsegment, seg));
+				}
+
+				if (has_hole)
+				{
+					coord hole_x = x + (width  - hole_size.x) / 2;
+					coord hole_y = y + (height - hole_size.y) / 2;
+					for (uint seg = 0; seg <= nsegment; ++seg)
+					{
+						points.emplace_back(make_ellipse_point(
+							hole_x, hole_y, hole_size.x, hole_size.y,
+							radian_from, radian_to, nsegment, nsegment - seg));
+					}
+				}
+
+				append(Polyline(&points[0], points.size(), true));
+			}
+
+			Point make_ellipse_point (
+				coord x, coord y, coord width, coord height,
+				float radian_from, float radian_to,
+				uint segment_max, uint segment_index)
+			{
+				float pos    = (float) segment_index / (float) segment_max;
+				float radian = radian_from + (radian_to - radian_from) * pos;
+				float cos_   = (cos(radian)  + 1) / 2.;
+				float sin_   = (-sin(radian) + 1) / 2.;
+				return Point(
+					x + width  * cos_,
+					y + height * sin_);
+			}
+
+	};// EllipseData
+
+
+	Polygon
+	create_line (coord x1, coord y1, coord x2, coord y2)
+	{
+		const Point points[] = {
+			Point(x1, y1),
+			Point(x2, y2)
+		};
+		return create_line(points, 2);
+	}
+
+	Polygon
+	create_line (const Point& p1, const Point& p2)
+	{
+		const Point points[] = {p1, p2};
+		return create_line(points, 2);
+	}
+
+	Polygon
+	create_line (const Point* points, size_t size, bool loop)
+	{
+		return Polygon(points, size, loop);
+	}
+
+	Polygon
+	create_line (const Polyline& polyline)
+	{
+		return Polygon(polyline);
+	}
+
+	Polygon
+	create_rect (
+		coord x, coord y, coord width, coord height,
+		coord round, uint nsegment)
+	{
+		return create_rect(
+			x, y, width, height, round, round, round, round, nsegment);
+	}
+
+	Polygon
+	create_rect (
+		coord x, coord y, coord width, coord height,
+		coord round_left_top,    coord round_right_top,
+		coord round_left_bottom, coord round_right_bottom,
+		uint nsegment)
+	{
+		if (width == 0 || height == 0)
+			return Polygon();
+
+		return Polygon(new RectData(
+			x, y, width, height,
+			round_left_top,    round_right_top,
+			round_left_bottom, round_right_bottom,
+			nsegment));
+	}
+
+	Polygon
+	create_rect(const Bounds& bounds, coord round, uint nsegment)
+	{
+		return create_rect(
+			bounds.x, bounds.y, bounds.width, bounds.height,
+			round, round, round, round,
+			nsegment);
+	}
+
+	Polygon
+	create_rect (
+		const Bounds& bounds,
+		coord round_left_top,    coord round_right_top,
+		coord round_left_bottom, coord round_right_bottom,
+		uint nsegment)
+	{
+		return create_rect(
+			bounds.x, bounds.y, bounds.width, bounds.height,
+			round_left_top,    round_right_top,
+			round_left_bottom, round_right_bottom,
+			nsegment);
+	}
+
+	Polygon
+	create_ellipse (
+		coord x, coord y, coord width, coord height,
+		const Point& hole_size,
+		float angle_from, float angle_to,
+		uint nsegment)
+	{
+		if (width == 0 || height == 0 || angle_from == angle_to)
+			return Polygon();
+
+		return Polygon(new EllipseData(
+			x, y, width, height, hole_size, angle_from, angle_to, nsegment));
+	}
+
+	Polygon
+	create_ellipse (
+		const Bounds& bounds,
+		const Point& hole_size,
+		float angle_from, float angle_to,
+		uint nsegment)
+	{
+		return create_ellipse(
+			bounds.x, bounds.y, bounds.width, bounds.height,
+			hole_size, angle_from, angle_to, nsegment);
+	}
+
+	Polygon
+	create_ellipse (
+		const Point& center, const Point& radius,
+		const Point& hole_radius,
+		float angle_from, float angle_to,
+		uint nsegment)
+	{
+		return create_ellipse(
+			center.x - radius.x, center.y - radius.y,
+			radius.x * 2,        radius.y * 2,
+			hole_radius * 2, angle_from, angle_to, nsegment);
+	}
+
+	static inline const SplineLib::Vec3f&
+	to_splinelib (const Point& val)
+	{
+		return *(const SplineLib::Vec3f*) &val;
+	}
+
+	static inline const Point&
+	to_rays (const SplineLib::Vec3f& val)
+	{
+		return *(const Point*) &val;
+	}
+
+	enum SplineType {BEZIER, HERMITE, CATMULLROM};
+
+	typedef SplineLib::cSpline3 (*SplineFun) (
+		const SplineLib::Vec3f&, const SplineLib::Vec3f&,
+		const SplineLib::Vec3f&, const SplineLib::Vec3f&);
+
+	static SplineFun
+	get_spline_fun (SplineType type)
+	{
+		switch (type)
+		{
+			case BEZIER:     return SplineLib::BezierSpline;
+			case HERMITE:    return SplineLib::HermiteSpline;
+			case CATMULLROM: return SplineLib::CatmullRomSpline;
+			default:
+				argument_error(__FILE__, __LINE__, "unknown spline type %d.", type);
+		}
+	}
+
+	static Polygon
+	create_spline (
+		SplineType type,
+		const Point* points, size_t size, bool loop,
+		uint nsegment = 16)
+	{
+		if (size % 4 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		size_t count = size / 4;
+		auto spline_fun = get_spline_fun(type);
+
+		std::vector<Point> result;
+		result.reserve(nsegment * count);
+		for (size_t i = 0; i < count; ++i)
+		{
+			SplineLib::cSpline3 spline = spline_fun(
+				to_splinelib(points[i * 4 + 0]),
+				to_splinelib(points[i * 4 + 1]),
+				to_splinelib(points[i * 4 + 2]),
+				to_splinelib(points[i * 4 + 3]));
+			for (uint j = 0; j <= nsegment; ++j)
+			{
+				float t = (float) j / nsegment;
+				result.emplace_back(to_rays(SplineLib::Position(spline, t)));
+			}
+		}
+
+		return create_line(&result[0], result.size(), loop);
+	}
+
+	Polygon
+	create_curve (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		const Point points[] = {
+			Point(x1, y1),
+			Point(x2, y2),
+			Point(x3, y3),
+			Point(x4, y4)
+		};
+		return create_spline(CATMULLROM, points, 4, loop);
+	}
+
+	Polygon
+	create_curve (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
+	{
+		const Point points[] = {p1, p2, p3, p4};
+		return create_spline(CATMULLROM, points, 4, loop);
+	}
+
+	Polygon
+	create_curve (const Point* points, size_t size, bool loop)
+	{
+		return create_spline(CATMULLROM, points, size, loop);
+	}
+
+	Polygon
+	create_bezier (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		const Point points[] = {
+			Point(x1, y1),
+			Point(x2, y2),
+			Point(x3, y3),
+			Point(x4, y4)
+		};
+		return create_spline(BEZIER, points, 4, loop);
+	}
+
+	Polygon
+	create_bezier (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
+	{
+		const Point points[] = {p1, p2, p3, p4};
+		return create_spline(BEZIER, points, 4, loop);
+	}
+
+	Polygon
+	create_bezier (const Point* points, size_t size, bool loop)
+	{
+		return create_spline(BEZIER, points, size, loop);
+	}
+
+	void
+	Polygon_fill (const Polygon& polygon, Painter* painter, const Color& color)
+	{
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
+
+		if (!color || !polygon || polygon.empty())
+			return;
+
+		polygon.self->fill(painter, color);
+	}
+
+	void
+	Polygon_stroke (const Polygon& polygon, Painter* painter, const Color& color)
+	{
+		if (!painter)
+			argument_error(__FILE__, __LINE__);
+
+		if (!color || !polygon || polygon.empty())
+			return;
+
+		polygon.self->stroke(polygon, painter, color);
+	}
+
+	bool
+	Polygon_triangulate (
+		Polygon::TrianglePointList* triangles, const Polygon& polygon)
+	{
+		return polygon.self->triangulate(triangles);
+	}
+
+
+	Polygon::Polygon ()
+	:	self(new PolygonData())
+	{
+	}
+
+	Polygon::Polygon (const Point* points, size_t size, bool loop)
+	:	self(new PolygonData())
+	{
+		if (!points || size <= 0) return;
+
+		self->append(Polyline(points, size, loop));
+	}
+
+	Polygon::Polygon (const Polyline& polyline)
+	:	self(new PolygonData())
+	{
+		self->append(polyline);
+	}
+
+	Polygon::Polygon (const Line* lines, size_t size)
+	:	self(new PolygonData())
+	{
+		if (!lines || size <= 0) return;
+
+		for (size_t i = 0; i < size; ++i)
+			self->append(lines[i]);
+	}
+
+	Polygon::Polygon (Data* data)
+	:	self(data)
+	{
+	}
+
+	Polygon::~Polygon ()
+	{
+	}
+
+	bool
+	Polygon::expand (
+		Polygon* result,
+		coord width, CapType cap, JoinType join, coord miter_limit) const
+	{
+		return expand_polygon(result, *this, width, cap, join, miter_limit);
+	}
+
+	Bounds
+	Polygon::bounds () const
+	{
+		if (empty()) return Bounds(-1, -1, -1);
+
+		Bounds b(self->lines[0][0], 0);
+		for (const auto& line : *this)
+		{
+			for (const auto& point : line)
+				b |= point;
+		}
+		return b;
+	}
+
+	size_t
+	Polygon::size () const
+	{
+		return self->lines.size();
+	}
+
+	bool
+	Polygon::empty (bool deep) const
+	{
+		if (deep)
+		{
+			for (const auto& line : self->lines)
+			{
+				if (!line.empty())
+					return false;
+			}
+		}
+
+		return size() <= 0;
+	}
+
+	Polygon::const_iterator
+	Polygon::begin () const
+	{
+		return self->lines.begin();
+	}
+
+	Polygon::const_iterator
+	Polygon::end () const
+	{
+		return self->lines.end();
+	}
+
+	const Polygon::Line&
+	Polygon::operator [] (size_t index) const
+	{
+		return self->lines[index];
+	}
+
+	Polygon::operator bool () const
+	{
+		if (self->lines.empty())
+			return true;
+
+		for (const auto& line : self->lines)
+		{
+			if (line) return true;
+		}
+
+		return false;
+	}
+
+	bool
+	Polygon::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	bool
+	Polygon::triangulate (TrianglePointList* triangles) const
+	{
+		return self->triangulate(triangles);
+	}
+
+	Polygon
+	operator + (const Polygon& lhs, const Polygon& rhs)
+	{
+		return lhs | rhs;
+	}
+
+	Polygon
+	operator - (const Polygon& lhs, const Polygon& rhs)
+	{
+		if (lhs.self == rhs.self) return Polygon();
+
+		return clip_polygons(lhs, rhs, clip::ctDifference);
+	}
+
+	Polygon
+	operator & (const Polygon& lhs, const Polygon& rhs)
+	{
+		if (lhs.self == rhs.self) return lhs;
+
+		return clip_polygons(lhs, rhs, clip::ctIntersection);
+	}
+
+	Polygon
+	operator | (const Polygon& lhs, const Polygon& rhs)
+	{
+		if (lhs.self == rhs.self) return lhs;
+
+		return clip_polygons(lhs, rhs, clip::ctUnion);
+	}
+
+	Polygon
+	operator ^ (const Polygon& lhs, const Polygon& rhs)
+	{
+		if (lhs.self == rhs.self) return Polygon();
+
+		return clip_polygons(lhs, rhs, clip::ctXor);
+	}
+
+
+	Polygon::Line::Line ()
+	:	Super(), hole_(false)
+	{
+	}
+
+	Polygon::Line::Line (const Point* points, size_t size, bool loop, bool hole)
+	:	Super(points, size, loop), hole_(hole)
+	{
+		if (!*this)
+			argument_error(__FILE__, __LINE__);
+	}
+
+	Polygon::Line::Line (const Polyline& polyline, bool hole)
+	:	Super(polyline), hole_(hole)
+	{
+		if (!*this)
+			argument_error(__FILE__, __LINE__);
+	}
+
+	bool
+	Polygon::Line::hole () const
+	{
+		return hole_;
+	}
+
+	Polygon::Line::operator bool () const
+	{
+		if (!Super::operator bool())
+			return false;
+
+		return loop() || !hole();
+	}
+
+	bool
+	Polygon::Line::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rays