rays 0.1.47 → 0.1.48

data/src/polygon.cpp

@@ -50,66 +50,62 @@ namespace Rays
 {
 
 
-	class Triangulator
+	class Triangles
 	{
 
 		public:
 
-			Triangulator (size_t npoints)
+			Triangles (size_t npoints)
 			{
 				points.reserve(npoints);
 			}
 
-			size_t begin (bool hole = false)
+			void append (const Polyline& polyline)
 			{
-				segments.emplace_back(points.size(), 0, hole);
-				return segments.back().begin;
-			}
-
-			void end (size_t n)
-			{
-				if (segments.empty())
-					invalid_state_error(__FILE__, __LINE__);
+				if (polyline.empty()) return;
 
-				auto& seg = segments.back();
-				if (n != seg.begin)
+				const Point* points_     = polyline.points();
+				const Color* colors_     = polyline.colors();
+				const Coord3* texcoords_ = polyline.texcoords();
+				if (!points_)
 					argument_error(__FILE__, __LINE__);
 
-				seg.end = points.size();
-
-				if (seg.empty()) segments.pop_back();
-			}
-
-			void append (const Point& point)
-			{
-				points.emplace_back(point);
-			}
+				if (
+					!points.empty() &&
+					(!colors_ != !pcolors || !texcoords_ != !ptexcoords))
+				{
+					argument_error(__FILE__, __LINE__);
+				}
 
-			void triangulate ()
-			{
-				if (segments.empty()) return;
+				segments.emplace_back(points.size(), 0, polyline.hole());
+				points.insert(points.end(), points_, points_ + polyline.size());
+				segments.back().end = points.size();
 
-				PolylineList polylines;
-				size_t index_offset = 0;
-				for (const auto& seg : segments)
+				if (colors_)
 				{
-					Polyline polyline(&points[0] + seg.begin, seg.end - seg.begin);
-					if (!seg.hole)
+					if (!pcolors)
 					{
-						triangulate(polylines, index_offset);
-						polylines.clear();
-						index_offset = seg.begin;
+						pcolors.reset(new decltype(pcolors)::element_type());
+						pcolors->reserve(points.capacity());
 					}
-					polylines.emplace_back(polyline);
+					pcolors->insert(pcolors->end(), colors_, colors_ + polyline.size());
 				}
-				triangulate(polylines, index_offset);
 
-				segments.clear();
-				segments.shrink_to_fit();
+				if (texcoords_)
+				{
+					if (!ptexcoords)
+					{
+						ptexcoords.reset(new decltype(ptexcoords)::element_type());
+						ptexcoords->reserve(points.capacity());
+					}
+					ptexcoords->insert(
+						ptexcoords->end(), texcoords_, texcoords_ + polyline.size());
+				}
 			}
 
-			bool get_triangles (Polygon::TrianglePointList* triangles) const
+			bool get (Polygon::TrianglePointList* triangles) const
 			{
+				triangulate();
 				if (indices.empty()) return false;
 
 				triangles->reserve(triangles->size() + indices.size());
@@ -118,6 +114,30 @@ namespace Rays
 				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);
+				}
+			}
+
 		private:
 
 			struct Segment
@@ -165,13 +185,40 @@ namespace Rays
 
 			typedef std::vector<Polyline> PolylineList;
 
-			std::vector<Segment> segments;
-
 			std::vector<Point> points;
 
-			std::vector<uint32_t> indices;
+			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();
+			}
 
-			void triangulate (const PolylineList& polylines, size_t index_offset)
+			void triangulate (const PolylineList& polylines, size_t index_offset) const
 			{
 				if (polylines.empty()) return;
 
@@ -180,17 +227,17 @@ namespace Rays
 					indices.emplace_back(index_offset + index);
 			}
 
-	};// Triangulator
+	};// Triangles
 
 
 	struct Polygon::Data
 	{
 
-		LineList lines;
+		PolylineList polylines;
 
-		mutable std::unique_ptr<Bounds> pbounds;
+		mutable std::unique_ptr<Bounds>    pbounds;
 
-		mutable std::unique_ptr<Triangulator> ptriangulator;
+		mutable std::unique_ptr<Triangles> ptriangles;
 
 		virtual ~Data ()
 		{
@@ -200,14 +247,14 @@ namespace Rays
 		{
 			if (!pbounds)
 			{
-				if (lines.empty())
+				if (polylines.empty())
 					pbounds.reset(new Bounds(-1, -1, -1));
 				else
 				{
-					pbounds.reset(new Bounds(lines[0][0], 0));
-					for (const auto& line : lines)
+					pbounds.reset(new Bounds(polylines[0][0], 0));
+					for (const auto& polyline : polylines)
 					{
-						for (const auto& point : line)
+						for (const auto& point : polyline)
 							*pbounds |= point;
 					}
 				}
@@ -215,48 +262,24 @@ namespace Rays
 			return *pbounds;
 		}
 
-		void append (const Polyline& polyline, bool hole = false)
+		void append (const Polyline& polyline)
 		{
 			if (polyline.empty())
 				return;
 
-			lines.emplace_back(polyline, hole);
-			pbounds.reset();
-		}
-
-		void append (const Line& line)
-		{
-			if (line.empty())
-				return;
-
-			lines.emplace_back(line);
-			pbounds.reset();
+			polylines.emplace_back(polyline);
 		}
 
 		bool triangulate (TrianglePointList* triangles) const
 		{
-			assert(triangles);
-
-			if (!ptriangulator)
-			{
-				ptriangulator.reset(new Triangulator(count_points_for_triangulation()));
-				auto& t = *ptriangulator;
-
-				for (const auto& line : lines)
-				{
-					size_t n = t.begin(line.hole());
-					for (const auto& point : line)
-						t.append(point);
-					t.end(n);
-				}
-				t.triangulate();
-			}
-
 			triangles->clear();
-			return ptriangulator->get_triangles(triangles);
+			return this->triangles().get(triangles);
 		}
 
-		virtual void fill (Painter* painter, const Color& color) const = 0;
+		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
@@ -275,20 +298,31 @@ namespace Rays
 
 		private:
 
+			Triangles& triangles () const
+			{
+				if (!ptriangles)
+				{
+					ptriangles.reset(new Triangles(count_points_for_triangulation()));
+					for (const auto& polyline : polylines)
+						ptriangles->append(polyline);
+				}
+				return *ptriangles;
+			}
+
 			size_t count_points_for_triangulation () const
 			{
 				size_t count = 0;
-				for (const auto& line : lines)
+				for (const auto& polyline : polylines)
 				{
-					if (can_triangulate(line))
-						count += line.size();
+					if (can_triangulate(polyline))
+						count += polyline.size();
 				}
 				return count;
 			}
 
-			bool can_triangulate (const Line& line) const
+			bool can_triangulate (const Polyline& polyline) const
 			{
-				return (line.fill() || line.hole()) && line.size() >= 3;
+				return (polyline.fill() || polyline.hole()) && polyline.size() >= 3;
 			}
 
 			void stroke_with_width (
@@ -349,11 +383,11 @@ namespace Rays
 			{
 				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());
 				}
 			}
 
@@ -419,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());
 		}
 	}
 
@@ -465,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);
 
@@ -486,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;
 	}
@@ -502,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;
 	}
 
@@ -521,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);
 		}
 	}
 
@@ -605,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
 	{
 
@@ -652,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());
 		}
 
@@ -787,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;
 
@@ -813,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)
@@ -822,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:
@@ -881,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));
 				}
 			}
 
@@ -946,50 +958,51 @@ namespace Rays
 	};// EllipseData
 
 
-	static const char*
-	get_draw_mode_name (DrawMode mode)
+	Polygon
+	create_point (coord x, coord y)
 	{
-		switch (mode)
-		{
-			case DRAW_POINTS:         return "DRAW_POINTS";
-			case DRAW_LINES:          return "DRAW_LINES";
-			case DRAW_LINE_STRIP:     return "DRAW_LINE_STRIP";
-			case DRAW_TRIANGLES:      return "DRAW_TRIANGLES";
-			case DRAW_TRIANGLE_STRIP: return "DRAW_TRIANGLE_STRIP";
-			case DRAW_TRIANGLE_FAN:   return "DRAW_TRIANGLE_FAN";
-			case DRAW_QUADS:          return "DRAW_QUADS";
-			case DRAW_QUAD_STRIP:     return "DRAW_QUAD_STRIP";
-			case DRAW_POLYGON:        return "DRAW_POLYGON";
-			default: argument_error(__FILE__, __LINE__, "unknown draw mode");
-		}
+		return create_point(Point(x, y));
 	}
 
-	static void
-	create_polygon (Polygon* polygon, const Point* points, size_t size, bool loop)
+	Polygon
+	create_point (const Point& point)
 	{
-		polygon->self->append(Polyline(points, size, loop, true));
+		return create_points(&point, 1);
 	}
 
-	static void
-	create_points (Polygon* polygon, const Point* points, size_t size)
+	Polygon
+	create_points (const Point* points, size_t size)
 	{
+		Polygon p;
 		for (size_t i = 0; i < size; ++i)
-			polygon->self->append(Polyline(&points[i], 1, false, false));
+			p.self->append(Polyline(&points[i], 1, false, false));
+		return p;
 	}
 
-	static void
-	create_lines (Polygon* polygon, const Point* points, size_t size)
+	Polygon
+	create_line (coord x1, coord y1, coord x2, coord y2)
 	{
-		for (size_t i = 0; i + 1 < size; i += 2)
-			polygon->self->append(Polyline(&points[i], 2, false, false));
+		const Point points[] = {
+			Point(x1, y1),
+			Point(x2, y2)
+		};
+		return create_line(points, 2);
 	}
 
-	static void
-	create_line_strip (
-		Polygon* polygon, const Point* points, size_t size, bool loop)
+	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)
 	{
-		if (!loop || size < 3)
-			polygon->self->append(Polyline(points, size, loop, false));
+		Polygon p;(points, size, loop);
+		//if (!loop || size < 3)
+			p.self->append(Polyline(points, size, loop, false));
+#if 0
 		else
 		{
 			std::vector<Point> array;
@@ -998,105 +1011,133 @@ namespace Rays
 			array.emplace_back(points[0]);
 			polygon->self->append(Polyline(&array[0], array.size(), true, false));
 		}
+#endif
+		return p;
 	}
 
-	static void
+	Polygon
+	create_line (const Polyline& polyline)
+	{
+		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 (
-		Polygon* polygon, const Point* points, size_t size, bool loop)
+		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)
-			polygon->self->append(Polyline(&points[i], 3, loop, true));
+		{
+			p.self->append(Polyline(
+				&points[i], 3, loop, true,
+				colors    ? &colors[i]    : NULL,
+				texcoords ? &texcoords[i] : NULL));
+		}
+		return p;
 	}
 
-	static void
-	create_triangle_strip (Polygon* polygon, const Point* points, size_t size)
+	Polygon
+	create_triangle_strip (
+		const Point* points, size_t size,
+		const Color* colors, const Coord3* texcoords)
 	{
-		if (size < 3) return;
+		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> array;
-		array.emplace_back(points[0]);
+		std::vector<Point> points_;
+		points_.reserve(size);
+		points_.emplace_back(points[0]);
 		for (size_t i = 1; i <= in_last; i += 2)
-			array.emplace_back(points[i]);
+			points_.emplace_back(points[i]);
 		for (size_t i = out_last; i >= 2; i -= 2)
-			array.emplace_back(points[i]);
+			points_.emplace_back(points[i]);
 
-		polygon->self->append(Polyline(&array[0], array.size(), true));
+		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)
-			polygon->self->append(Polyline(&points[1], size - 2));
+		{
+			p.self->append(Polyline(
+				&points[1], size - 2, false,
+				colors    ? &colors[1]    : NULL,
+				texcoords ? &texcoords[1] : NULL));
+		}
+		return p;
 	}
 
-	static void
-	create_triangle_fan (Polygon* polygon, const Point* points, size_t size)
+	Polygon
+	create_triangle_fan (
+		const Point* points, size_t size,
+		const Color* colors, const Coord3* texcoords)
 	{
-		create_polygon(polygon, points, size, true);
+		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];
-			polygon->self->append(Polyline(&array[0], 2));
+			p.self->append(Polyline(
+				&array[0], 2, false,
+				colors    ? &colors[0]    : NULL,
+				texcoords ? &texcoords[0] : NULL));
 		}
-	}
-
-	static void
-	create_quads (Polygon* polygon, const Point* points, size_t size, bool loop)
-	{
-		for (size_t i = 0; i + 3 < size; i += 4)
-			polygon->self->append(Polyline(&points[i], 4, loop, true));
-	}
-
-	static void
-	create_quad_strip (Polygon* polygon, const Point* points, size_t size)
-	{
-		if (size < 4) return;
-
-		if (size % 2 != 0) --size;
-		size_t  in_last = size - 2;
-		size_t out_last = size - 1;
-
-		std::vector<Point> array;
-		for (size_t i = 0; i <= in_last; i += 2)
-			array.emplace_back(points[i]);
-		for (int i = (int) out_last; i >= 1; i -= 2)
-			array.emplace_back(points[i]);
-
-		polygon->self->append(Polyline(&array[0], array.size(), true));
-		for (size_t i = 2; i < in_last; i += 2)
-			polygon->self->append(Polyline(&points[i], 2));
-	}
-
-	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);
+		return p;
 	}
 
 	Polygon
@@ -1148,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,
@@ -1342,54 +1473,36 @@ namespace Rays
 
 
 	Polygon::Polygon ()
-	:	self(new PolygonData())
 	{
 	}
 
-	Polygon::Polygon (const Point* points, size_t size, bool loop)
-	:	self(new PolygonData())
-	{
-		if (!points || size <= 0) return;
-
-		create_polygon(this, points, size, loop);
-	}
-
-	Polygon::Polygon (DrawMode mode, 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;
 
-		switch (mode)
-		{
-			case DRAW_POINTS:         create_points(        this, points, size);       break;
-			case DRAW_LINES:          create_lines(         this, points, size);       break;
-			case DRAW_LINE_STRIP:     create_line_strip(    this, points, size, loop); break;
-			case DRAW_TRIANGLES:      create_triangles(     this, points, size, loop); break;
-			case DRAW_TRIANGLE_STRIP: create_triangle_strip(this, points, size);       break;
-			case DRAW_TRIANGLE_FAN:   create_triangle_fan(  this, points, size);       break;
-			case DRAW_QUADS:          create_quads(         this, points, size, loop); break;
-			case DRAW_QUAD_STRIP:     create_quad_strip(    this, points, size);       break;
-			case DRAW_POLYGON:        create_polygon(       this, points, size, loop); break;
-			default:
-				argument_error(
-					__FILE__, __LINE__,
-					Xot::stringf("unknown draw mode '%s'", get_draw_mode_name(mode)));
-		}
+		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)
@@ -1418,7 +1531,7 @@ namespace Rays
 	size_t
 	Polygon::size () const
 	{
-		return self->lines.size();
+		return self->polylines.size();
 	}
 
 	bool
@@ -1426,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;
 			}
 		}
@@ -1439,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;
@@ -1479,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
@@ -1518,41 +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
-	{
-		return Super::operator bool() && (loop() || !hole());
-	}
-
-	bool
-	Polygon::Line::operator ! () const
-	{
-		return !operator bool();
-	}
-
-
 }// Rays