rays 0.1.46 → 0.1.48

data/src/polygon.cpp

@@ -4,7 +4,7 @@
 #include <math.h>
 #include <assert.h>
 #include <utility>
-#include <poly2tri.h>
+#include <earcut.hpp>
 #include <Splines.h>
 #include <xot/util.h>
 #include "rays/color.h"
@@ -17,91 +17,269 @@
 namespace clip = ClipperLib;
 
 
-namespace Rays
+namespace mapbox
 {
 
-
-	static inline p2t::Point
-	to_poly2tri (const Point& point)
+	namespace util
 	{
-		return p2t::Point(point.x, point.y);
-	}
 
-	static inline Point
-	from_poly2tri (const p2t::Point& point)
-	{
-		return Point(point.x, point.y);
-	}
+		template<>
+		struct nth<0, Rays::Point>
+		{
+			inline static auto get (const Rays::Point& p)
+			{
+				return p.x;
+			}
+		};
 
+		template<>
+		struct nth<1, Rays::Point>
+		{
+			inline static auto get (const Rays::Point& p)
+			{
+				return p.y;
+			}
+		};
 
-	struct Polygon::Data
+	}// util
+
+}// mapbox
+
+
+namespace Rays
+{
+
+
+	class Triangles
 	{
 
-		LineList lines;
+		public:
 
-		virtual ~Data ()
-		{
-		}
+			Triangles (size_t npoints)
+			{
+				points.reserve(npoints);
+			}
 
-		void append (const Polyline& polyline, bool hole = false)
-		{
-			if (polyline.empty())
-				return;
+			void append (const Polyline& polyline)
+			{
+				if (polyline.empty()) return;
 
-			lines.emplace_back(Line(polyline, hole));
-		}
+				const Point* points_     = polyline.points();
+				const Color* colors_     = polyline.colors();
+				const Coord3* texcoords_ = polyline.texcoords();
+				if (!points_)
+					argument_error(__FILE__, __LINE__);
 
-		void append (const Line& line)
-		{
-			if (line.empty())
-				return;
+				if (
+					!points.empty() &&
+					(!colors_ != !pcolors || !texcoords_ != !ptexcoords))
+				{
+					argument_error(__FILE__, __LINE__);
+				}
 
-			lines.emplace_back(line);
-		}
+				segments.emplace_back(points.size(), 0, polyline.hole());
+				points.insert(points.end(), points_, points_ + polyline.size());
+				segments.back().end = points.size();
 
-		bool triangulate (TrianglePointList* triangles) const
-		{
-			assert(triangles);
+				if (colors_)
+				{
+					if (!pcolors)
+					{
+						pcolors.reset(new decltype(pcolors)::element_type());
+						pcolors->reserve(points.capacity());
+					}
+					pcolors->insert(pcolors->end(), colors_, colors_ + polyline.size());
+				}
 
-			triangles->clear();
+				if (texcoords_)
+				{
+					if (!ptexcoords)
+					{
+						ptexcoords.reset(new decltype(ptexcoords)::element_type());
+						ptexcoords->reserve(points.capacity());
+					}
+					ptexcoords->insert(
+						ptexcoords->end(), texcoords_, texcoords_ + polyline.size());
+				}
+			}
 
-			if (!can_triangulate())
-				return false;
+			bool get (Polygon::TrianglePointList* triangles) const
+			{
+				triangulate();
+				if (indices.empty()) return false;
 
-			size_t npoint = count_points();
-			if (npoint <= 0)
+				triangles->reserve(triangles->size() + indices.size());
+				for (const auto& index : indices)
+					triangles->emplace_back(points[index]);
 				return true;
+			}
+
+			void draw (Painter* painter, const Color& color) const
+			{
+				triangulate();
+				if (indices.empty()) return;
+
+				if (pcolors)
+				{
+					Painter_draw(
+						painter, GL_TRIANGLES,
+						&points[0],  points.size(),
+						&indices[0], indices.size(),
+						&(*pcolors)[0],
+						ptexcoords ? &(*ptexcoords)[0] : NULL);
+				}
+				else
+				{
+					Painter_draw(
+						painter, GL_TRIANGLES, color,
+						&points[0],  points.size(),
+						&indices[0], indices.size(),
+						ptexcoords ? &(*ptexcoords)[0] : NULL);
+				}
+			}
 
-			std::unique_ptr<p2t::CDT> cdt;
-			std::vector<p2t::Point> points;
-			std::vector<p2t::Point*> pointers;
+		private:
 
-			points.reserve(npoint);
-			for (const auto& line : lines)
+			struct Segment
 			{
-				pointers.clear();
-				pointers.reserve(line.size());
-				for (const auto& point : line)
+
+				size_t begin, end;
+
+				bool hole;
+
+				Segment (size_t begin, size_t end, bool hole = false)
+				:	begin(begin), end(end), hole(hole)
 				{
-					points.emplace_back(to_poly2tri(point));
-					pointers.emplace_back(&points.back());
 				}
 
-				if (!line.hole())
+				bool empty () const
 				{
-					if (cdt) triangulate(triangles, cdt.get());
-					cdt.reset(new p2t::CDT(pointers));
+					return begin == end;
 				}
-				else if (cdt)
-					cdt->AddHole(pointers);
+
+			};// Segment
+
+			class Polyline
+			{
+
+				const Point* points;
+
+				size_t size_;
+
+				public:
+
+					typedef Point value_type;
+
+					Polyline (const Point* points, size_t size)
+					:	points(points), size_(size)
+					{
+					}
+
+					size_t size () const {return size_;}
+
+					bool empty () const {return size_ == 0;}
+
+					const Point& operator [] (size_t i) const {return points[i];}
+
+			};// Polyline
+
+			typedef std::vector<Polyline> PolylineList;
+
+			std::vector<Point> points;
+
+			std::unique_ptr<std::vector<Color>> pcolors;
+
+			std::unique_ptr<std::vector<Coord3>> ptexcoords;
+
+			mutable std::vector<Segment> segments;
+
+			mutable std::vector<uint32_t> indices;
+
+			void triangulate () const
+			{
+				if (segments.empty()) return;
+
+				PolylineList polylines;
+				size_t index_offset = 0;
+				for (const auto& seg : segments)
+				{
+					Polyline polyline(&points[0] + seg.begin, seg.end - seg.begin);
+					if (!seg.hole)
+					{
+						triangulate(polylines, index_offset);
+						polylines.clear();
+						index_offset = seg.begin;
+					}
+					polylines.emplace_back(polyline);
+				}
+				triangulate(polylines, index_offset);
+
+				segments.clear();
+				segments.shrink_to_fit();
 			}
 
-			if (cdt) triangulate(triangles, cdt.get());
+			void triangulate (const PolylineList& polylines, size_t index_offset) const
+			{
+				if (polylines.empty()) return;
 
-			return true;
+				auto result = mapbox::earcut<uint32_t>(polylines);
+				for (const auto& index : result)
+					indices.emplace_back(index_offset + index);
+			}
+
+	};// Triangles
+
+
+	struct Polygon::Data
+	{
+
+		PolylineList polylines;
+
+		mutable std::unique_ptr<Bounds>    pbounds;
+
+		mutable std::unique_ptr<Triangles> ptriangles;
+
+		virtual ~Data ()
+		{
 		}
 
-		virtual void fill (Painter* painter, const Color& color) const = 0;
+		const Bounds& bounds () const
+		{
+			if (!pbounds)
+			{
+				if (polylines.empty())
+					pbounds.reset(new Bounds(-1, -1, -1));
+				else
+				{
+					pbounds.reset(new Bounds(polylines[0][0], 0));
+					for (const auto& polyline : polylines)
+					{
+						for (const auto& point : polyline)
+							*pbounds |= point;
+					}
+				}
+			}
+			return *pbounds;
+		}
+
+		void append (const Polyline& polyline)
+		{
+			if (polyline.empty())
+				return;
+
+			polylines.emplace_back(polyline);
+		}
+
+		bool triangulate (TrianglePointList* triangles) const
+		{
+			triangles->clear();
+			return this->triangles().get(triangles);
+		}
+
+		virtual void fill (Painter* painter, const Color& color) const
+		{
+			triangles().draw(painter, color);
+		}
 
 		virtual void stroke (
 			const Polygon& polygon, Painter* painter, const Color& color) const
@@ -110,47 +288,46 @@ namespace Rays
 
 			coord stroke_width = painter->stroke_width();
 			if (stroke_width > 0)
-				stroke_with_width(polygon, painter, color, stroke_width);
+			{
+				stroke_with_width(
+					polygon, painter, color, stroke_width, painter->stroke_outset());
+			}
 			else
 				stroke_without_width(painter, color);
 		}
 
 		private:
 
-			bool can_triangulate () const
+			Triangles& triangles () const
 			{
-				for (const auto& line : lines)
+				if (!ptriangles)
 				{
-					if (line.loop() && !line.hole() && !line.empty())
-						return true;
+					ptriangles.reset(new Triangles(count_points_for_triangulation()));
+					for (const auto& polyline : polylines)
+						ptriangles->append(polyline);
 				}
-				return false;
+				return *ptriangles;
 			}
 
-			size_t count_points () const
+			size_t count_points_for_triangulation () const
 			{
 				size_t count = 0;
-				for (const auto& line : lines)
-					count += line.size();
+				for (const auto& polyline : polylines)
+				{
+					if (can_triangulate(polyline))
+						count += polyline.size();
+				}
 				return count;
 			}
 
-			void triangulate (TrianglePointList* triangles, p2t::CDT* cdt) const
+			bool can_triangulate (const Polyline& polyline) 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)));
-				}
+				return (polyline.fill() || polyline.hole()) && polyline.size() >= 3;
 			}
 
 			void stroke_with_width (
 				const Polygon& polygon, Painter* painter,
-				const Color& color, coord stroke_width) const
+				const Color& color, coord stroke_width, float stroke_outset) const
 			{
 				assert(painter && color && stroke_width > 0);
 
@@ -163,39 +340,54 @@ namespace Rays
 				bool has_loop = false;
 				for (const auto& polyline : polygon)
 				{
-					if (!polyline || polyline.empty())
-						continue;
-
 					if (polyline.loop())
 					{
 						has_loop = true;
 						continue;
 					}
+					stroke_polyline(polyline, painter, color, stroke_width, cap, join, ml);
+				}
 
-					Polygon stroke;
-					if (!polyline.expand(&stroke, stroke_width / 2, cap, join, ml))
-						continue;
+				if (!has_loop) return;
 
-					Polygon_fill(stroke, painter, color);
-				}
+				coord inset = (-0.5 + stroke_outset) * stroke_width;
+				Polygon outline;
+				if (inset == 0)
+					outline = polygon;
+				else if (!polygon.expand(&outline, inset, cap, join, ml))
+					return;
 
-				if (has_loop)
+				for (const auto& polyline : outline)
 				{
-					Polygon hole;
-					if (polygon.expand(&hole, -stroke_width, cap, join, ml))
-						Polygon_fill(polygon - hole, painter, color);
+					if (polyline.loop())
+						stroke_polyline(polyline, painter, color, stroke_width, cap, join, ml);
 				}
 			}
 
+			void stroke_polyline (
+				const Polyline& polyline, Painter* painter,
+				const Color& color, coord stroke_width,
+				CapType cap, JoinType join, coord miter_limit) const
+			{
+				assert(stroke_width > 0);
+
+				if (!polyline || polyline.empty())
+					return;
+
+				Polygon stroke;
+				if (polyline.expand(&stroke, stroke_width / 2, cap, join, miter_limit))
+					Polygon_fill(stroke, painter, color);
+			}
+
 			void stroke_without_width (Painter* painter, const Color& color) const
 			{
 				assert(painter && color);
 
-				for (const auto& line : lines)
+				for (const auto& polyline : polylines)
 				{
-					Painter_draw_polygon(
-						painter, line.loop() ? GL_LINE_LOOP : GL_LINE_STRIP, color,
-						&line[0], line.size());
+					Painter_draw(
+						painter, polyline.loop() ? GL_LINE_LOOP : GL_LINE_STRIP, color,
+						&polyline[0], polyline.size());
 				}
 			}
 
@@ -261,14 +453,14 @@ namespace Rays
 		assert(clipper);
 
 		clip::Path path;
-		for (const auto& line : polygon)
+		for (const auto& polyline : polygon)
 		{
-			if (!line) continue;
+			if (!polyline) continue;
 
-			Polyline_get_path(&path, line, line.hole());
+			Polyline_get_path(&path, polyline, polyline.hole());
 			if (path.empty()) continue;
 
-			clipper->AddPath(path, type, line.loop());
+			clipper->AddPath(path, type, polyline.loop());
 		}
 	}
 
@@ -307,7 +499,7 @@ namespace Rays
 	static bool
 	add_polyline_to_offsetter (
 		clip::ClipperOffset* offsetter, const Polyline& polyline,
-		CapType cap, JoinType join, bool hole, bool fill)
+		CapType cap, JoinType join, bool fill, bool hole)
 	{
 		assert(offsetter);
 
@@ -328,10 +520,10 @@ namespace Rays
 		assert(offsetter);
 
 		bool added = false;
-		for (const auto& line : polygon.self->lines)
+		for (const auto& polyline : polygon.self->polylines)
 		{
 			added |= add_polyline_to_offsetter(
-				offsetter, line, cap, join, line.hole(), true);
+				offsetter, polyline, cap, join, true, polyline.hole());
 		}
 		return added;
 	}
@@ -344,12 +536,11 @@ namespace Rays
 		if (node.Contour.empty() || node.IsHole())
 			return false;
 
-		Polyline polyline;
-		Polyline_create(&polyline, node.Contour, !node.IsOpen(), false);
+		Polyline polyline = Polyline_create(node.Contour, !node.IsOpen());
 		if (!polyline)
 			return false;
 
-		polygon->self->append(polyline, false);
+		polygon->self->append(polyline);
 		return true;
 	}
 
@@ -363,12 +554,11 @@ namespace Rays
 			if (!child->IsHole())
 				return;
 
-			Polyline polyline;
-			Polyline_create(&polyline, child->Contour, !child->IsOpen(), true);
+			Polyline polyline = Polyline_create(child->Contour, !child->IsOpen(), true);
 			if (!polyline)
 				continue;
 
-			polygon->self->append(polyline, true);
+			polygon->self->append(polyline);
 		}
 	}
 
@@ -447,26 +637,6 @@ namespace Rays
 	}
 
 
-	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
 	{
 
@@ -494,11 +664,11 @@ namespace Rays
 
 		void fill (Painter* painter, const Color& color) const
 		{
-			if (lines.size() != 1)
+			if (polylines.size() != 1)
 				invalid_state_error(__FILE__, __LINE__);
 
-			const auto& outline = lines[0];
-			Painter_draw_polygon(
+			const auto& outline = polylines[0];
+			Painter_draw(
 				painter, GL_TRIANGLE_FAN, color, &outline[0], outline.size());
 		}
 
@@ -629,10 +799,10 @@ namespace Rays
 	};// RectData
 
 
-	struct EllipseData : public PolygonData
+	struct EllipseData : public Polygon::Data
 	{
 
-		typedef PolygonData Super;
+		typedef Polygon::Data Super;
 
 		GLenum mode = 0;
 
@@ -655,7 +825,7 @@ namespace Rays
 
 		void fill (Painter* painter, const Color& color) const
 		{
-			if (lines.size() <= 0)
+			if (polylines.size() <= 0)
 				invalid_state_error(__FILE__, __LINE__);
 
 			if (mode == 0)
@@ -664,11 +834,11 @@ namespace Rays
 				return;
 			}
 
-			if (lines.size() >= 2)
+			if (polylines.size() >= 2)
 				invalid_state_error(__FILE__, __LINE__);
 
-			const auto& outline = lines[0];
-			Painter_draw_polygon(painter, mode, color, &outline[0], outline.size());
+			const auto& outline = polylines[0];
+			Painter_draw(painter, mode, color, &outline[0], outline.size());
 		}
 
 		private:
@@ -723,7 +893,7 @@ namespace Rays
 							hole_x, hole_y, hole_size.x, hole_size.y,
 							radian_from, radian_to, nsegment, seg));
 					}
-					append(Polyline(&points[0], points.size(), true), true);
+					append(Polyline(&points[0], points.size(), true, NULL, NULL, true));
 				}
 			}
 
@@ -746,7 +916,7 @@ namespace Rays
 
 				if (!has_hole)
 				{
-					points.emplace_back(Point(x + width / 2, y + height / 2));
+					points.emplace_back(x + width / 2, y + height / 2);
 					mode = GL_TRIANGLE_FAN;
 				}
 
@@ -788,6 +958,27 @@ namespace Rays
 	};// EllipseData
 
 
+	Polygon
+	create_point (coord x, coord y)
+	{
+		return create_point(Point(x, y));
+	}
+
+	Polygon
+	create_point (const Point& point)
+	{
+		return create_points(&point, 1);
+	}
+
+	Polygon
+	create_points (const Point* points, size_t size)
+	{
+		Polygon p;
+		for (size_t i = 0; i < size; ++i)
+			p.self->append(Polyline(&points[i], 1, false, false));
+		return p;
+	}
+
 	Polygon
 	create_line (coord x1, coord y1, coord x2, coord y2)
 	{
@@ -808,7 +999,20 @@ namespace Rays
 	Polygon
 	create_line (const Point* points, size_t size, bool loop)
 	{
-		return Polygon(points, size, loop);
+		Polygon p;(points, size, loop);
+		//if (!loop || size < 3)
+			p.self->append(Polyline(points, size, loop, false));
+#if 0
+		else
+		{
+			std::vector<Point> array;
+			array.reserve(size + 1);
+			array.insert(array.begin(), points, points + size);
+			array.emplace_back(points[0]);
+			polygon->self->append(Polyline(&array[0], array.size(), true, false));
+		}
+#endif
+		return p;
 	}
 
 	Polygon
@@ -817,6 +1021,125 @@ namespace Rays
 		return Polygon(polyline);
 	}
 
+	Polygon
+	create_lines (const Point* points, size_t size)
+	{
+		Polygon p;
+		for (size_t i = 0; i + 1 < size; i += 2)
+			p.self->append(Polyline(&points[i], 2, false, false));
+		return p;
+	}
+
+	Polygon
+	create_triangle (
+		coord x1, coord y1, coord x2, coord y2, coord x3, coord y3, bool loop)
+	{
+		const Point points[] = {Point(x1, y1), Point(x2, y2), Point(x3, y3)};
+		return create_triangles(points, 3, loop);
+	}
+
+	Polygon
+	create_triangle (
+		const Point& p1, const Point& p2, const Point& p3, bool loop)
+	{
+		const Point points[] = {p1, p2, p3};
+		return create_triangles(points, 3, loop);
+	}
+
+	Polygon
+	create_triangles (
+		const Point* points, size_t size, bool loop,
+		const Color* colors, const Coord3* texcoords)
+	{
+		Polygon p;
+		for (size_t i = 0; i + 2 < size; i += 3)
+		{
+			p.self->append(Polyline(
+				&points[i], 3, loop, true,
+				colors    ? &colors[i]    : NULL,
+				texcoords ? &texcoords[i] : NULL));
+		}
+		return p;
+	}
+
+	Polygon
+	create_triangle_strip (
+		const Point* points, size_t size,
+		const Color* colors, const Coord3* texcoords)
+	{
+		Polygon p;
+		if (size < 3) return p;
+
+		size_t     last = size - 1;
+		size_t  in_last = last % 2 == 0 ? last - 1 : last;
+		size_t out_last = last % 2 == 0 ? last     : last - 1;
+
+		std::vector<Point> points_;
+		points_.reserve(size);
+		points_.emplace_back(points[0]);
+		for (size_t i = 1; i <= in_last; i += 2)
+			points_.emplace_back(points[i]);
+		for (size_t i = out_last; i >= 2; i -= 2)
+			points_.emplace_back(points[i]);
+
+		std::unique_ptr<std::vector<Color>> pcolors_;
+		if (colors)
+		{
+			pcolors_.reset(new decltype(pcolors_)::element_type());
+			pcolors_->reserve(size);
+			pcolors_->emplace_back(colors[0]);
+			for (size_t i = 1; i <= in_last; i += 2)
+				pcolors_->emplace_back(colors[i]);
+			for (size_t i = out_last; i >= 2; i -= 2)
+				pcolors_->emplace_back(colors[i]);
+		}
+
+		std::unique_ptr<std::vector<Coord3>> ptexcoords_;
+		if (texcoords)
+		{
+			ptexcoords_.reset(new decltype(ptexcoords_)::element_type());
+			ptexcoords_->reserve(size);
+			ptexcoords_->emplace_back(texcoords[0]);
+			for (size_t i = 1; i <= in_last; i += 2)
+				ptexcoords_->emplace_back(texcoords[i]);
+			for (size_t i = out_last; i >= 2; i -= 2)
+				ptexcoords_->emplace_back(texcoords[i]);
+		}
+
+		p.self->append(Polyline(
+			&points_[0], points_.size(), true,
+			pcolors_    ? &(*pcolors_)[0]    : NULL,
+			ptexcoords_ ? &(*ptexcoords_)[0] : NULL));
+		if (size >= 4)
+		{
+			p.self->append(Polyline(
+				&points[1], size - 2, false,
+				colors    ? &colors[1]    : NULL,
+				texcoords ? &texcoords[1] : NULL));
+		}
+		return p;
+	}
+
+	Polygon
+	create_triangle_fan (
+		const Point* points, size_t size,
+		const Color* colors, const Coord3* texcoords)
+	{
+		Polygon p(points, size, true, colors, texcoords);
+
+		Point array[2];
+		array[0] = points[0];
+		for (size_t i = 2; i < size - 1; ++i)
+		{
+			array[1] = points[i];
+			p.self->append(Polyline(
+				&array[0], 2, false,
+				colors    ? &colors[0]    : NULL,
+				texcoords ? &texcoords[0] : NULL));
+		}
+		return p;
+	}
+
 	Polygon
 	create_rect (
 		coord x, coord y, coord width, coord height,
@@ -866,6 +1189,96 @@ namespace Rays
 			nsegment);
 	}
 
+	Polygon
+	create_quad (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		Point points[] = {Point(x1, y1), Point(x2, y2), Point(x3, y3), Point(x4, y4)};
+		return create_quads(points, 4, loop);
+	}
+
+	Polygon
+	create_quad (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
+	{
+		Point points[] = {p1, p2, p3, p4};
+		return create_quads(points, 4, loop);
+	}
+
+	Polygon
+	create_quads (
+		const Point* points, size_t size, bool loop,
+		const Color* colors, const Coord3* texcoords)
+	{
+		Polygon p;
+		for (size_t i = 0; i + 3 < size; i += 4)
+		{
+			p.self->append(Polyline(
+				&points[i], 4, loop, true,
+				colors    ? &colors[i]    : NULL,
+				texcoords ? &texcoords[i] : NULL));
+		}
+		return p;
+	}
+
+	Polygon
+	create_quad_strip (
+		const Point* points, size_t size,
+		const Color* colors, const Coord3* texcoords)
+	{
+		Polygon p;
+		if (size < 4) return p;
+
+		if (size % 2 != 0) --size;
+		size_t  in_last = size - 2;
+		size_t out_last = size - 1;
+
+		std::vector<Point> points_;
+		points_.reserve(size);
+		for (size_t i = 0; i <= in_last; i += 2)
+			points_.emplace_back(points[i]);
+		for (int i = (int) out_last; i >= 1; i -= 2)
+			points_.emplace_back(points[i]);
+
+		std::unique_ptr<std::vector<Color>> pcolors_;
+		if (colors)
+		{
+			pcolors_.reset(new decltype(pcolors_)::element_type());
+			pcolors_->reserve(size);
+			for (size_t i = 0; i <= in_last; i += 2)
+				pcolors_->emplace_back(colors[i]);
+			for (int i = (int) out_last; i >= 1; i -= 2)
+				pcolors_->emplace_back(colors[i]);
+		}
+
+		std::unique_ptr<std::vector<Coord3>> ptexcoords_;
+		if (texcoords)
+		{
+			ptexcoords_.reset(new decltype(ptexcoords_)::element_type());
+			ptexcoords_->reserve(size);
+			for (size_t i = 0; i <= in_last; i += 2)
+				ptexcoords_->emplace_back(texcoords[i]);
+			for (int i = (int) out_last; i >= 1; i -= 2)
+				ptexcoords_->emplace_back(texcoords[i]);
+		}
+
+		p.self->append(Polyline(
+			&points_[0], points_.size(), true,
+			pcolors_    ? &(*pcolors_)[0]    : NULL,
+			ptexcoords_ ? &(*ptexcoords_)[0] : NULL));
+		for (size_t i = 2; i < in_last; i += 2)
+		{
+			p.self->append(Polyline(
+				&points[i], 2, false,
+				colors    ? &colors[i]    : NULL,
+				texcoords ? &texcoords[i] : NULL));
+		}
+		return p;
+	}
+
 	Polygon
 	create_ellipse (
 		coord x, coord y, coord width, coord height,
@@ -1060,31 +1473,36 @@ namespace Rays
 
 
 	Polygon::Polygon ()
-	:	self(new PolygonData())
 	{
 	}
 
-	Polygon::Polygon (const Point* points, size_t size, bool loop)
-	:	self(new PolygonData())
+	Polygon::Polygon (
+		const Point* points, size_t size, bool loop,
+		const Color* colors, const Coord3* texcoords)
 	{
 		if (!points || size <= 0) return;
 
-		self->append(Polyline(points, size, loop));
+		self->append(Polyline(points, size, loop, true, colors, texcoords));
 	}
 
 	Polygon::Polygon (const Polyline& polyline)
-	:	self(new PolygonData())
 	{
+		if (polyline.hole())
+			argument_error(__FILE__, __LINE__);
+
 		self->append(polyline);
 	}
 
-	Polygon::Polygon (const Line* lines, size_t size)
-	:	self(new PolygonData())
+	Polygon::Polygon (const Polyline* polylines, size_t size)
 	{
-		if (!lines || size <= 0) return;
+		if (!polylines || size <= 0)
+			return;
+
+		if (polylines[0].hole())
+			argument_error(__FILE__, __LINE__);
 
 		for (size_t i = 0; i < size; ++i)
-			self->append(lines[i]);
+			self->append(polylines[i]);
 	}
 
 	Polygon::Polygon (Data* data)
@@ -1107,21 +1525,13 @@ namespace Rays
 	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;
+		return self->bounds();
 	}
 
 	size_t
 	Polygon::size () const
 	{
-		return self->lines.size();
+		return self->polylines.size();
 	}
 
 	bool
@@ -1129,9 +1539,9 @@ namespace Rays
 	{
 		if (deep)
 		{
-			for (const auto& line : self->lines)
+			for (const auto& polyline : self->polylines)
 			{
-				if (!line.empty())
+				if (!polyline.empty())
 					return false;
 			}
 		}
@@ -1142,29 +1552,29 @@ namespace Rays
 	Polygon::const_iterator
 	Polygon::begin () const
 	{
-		return self->lines.begin();
+		return self->polylines.begin();
 	}
 
 	Polygon::const_iterator
 	Polygon::end () const
 	{
-		return self->lines.end();
+		return self->polylines.end();
 	}
 
-	const Polygon::Line&
+	const Polyline&
 	Polygon::operator [] (size_t index) const
 	{
-		return self->lines[index];
+		return self->polylines[index];
 	}
 
 	Polygon::operator bool () const
 	{
-		if (self->lines.empty())
+		if (self->polylines.empty())
 			return true;
 
-		for (const auto& line : self->lines)
+		for (const auto& polyline : self->polylines)
 		{
-			if (line) return true;
+			if (polyline) return true;
 		}
 
 		return false;
@@ -1182,10 +1592,23 @@ namespace Rays
 		return self->triangulate(triangles);
 	}
 
+	Polygon
+	operator + (const Polygon& lhs, const Polyline& rhs)
+	{
+		std::vector<Polyline> polylines;
+		for (const auto& polyline : lhs)
+			polylines.emplace_back(polyline);
+		polylines.emplace_back(rhs);
+		return Polygon(&polylines[0], polylines.size());
+	}
+
 	Polygon
 	operator + (const Polygon& lhs, const Polygon& rhs)
 	{
-		return lhs | rhs;
+		std::vector<Polyline> polylines;
+		for (const auto& polyline : lhs) polylines.emplace_back(polyline);
+		for (const auto& polyline : rhs) polylines.emplace_back(polyline);
+		return Polygon(&polylines[0], polylines.size());
 	}
 
 	Polygon
@@ -1221,44 +1644,4 @@ namespace Rays
 	}
 
 
-	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