rays 0.1.13 → 0.1.18

data/src/osx/font.mm

@@ -71,8 +71,8 @@ namespace Rays
 	RawFont::RawFont (const char* name, coord size)
 	{
 		self->font = name
-			? CTFontCreateWithName(cfstring(name).get(), size, NULL)
-			: CTFontCreateUIFontForLanguage(kCTFontUIFontSystem, size, NULL);
+			?	CTFontCreateWithName(cfstring(name).get(), size, NULL)
+			:	CTFontCreateUIFontForLanguage(kCTFontUIFontSystem, size, NULL);
 	}
 
 	RawFont::~RawFont ()

data/src/painter.cpp

@@ -48,6 +48,12 @@ namespace Rays
 
 		coord stroke_width;
 
+		CapType stroke_cap;
+
+		JoinType stroke_join;
+
+		coord miter_limit;
+
 		uint nsegment;
 
 		Bounds clip;
@@ -62,6 +68,9 @@ namespace Rays
 			colors[FILL]   .reset(1, 1);
 			colors[STROKE] .reset(1, 0);
 			stroke_width   = 0;
+			stroke_cap     = CAP_DEFAULT;
+			stroke_join    = JOIN_DEFAULT;
+			miter_limit    = JOIN_DEFAULT_MITER_LIMIT;
 			nsegment       = 0;
 			clip           .reset(-1);
 			font           = default_font();
@@ -641,6 +650,11 @@ namespace Rays
 
 		self->opengl_state.push();
 
+		//glEnable(GL_CULL_FACE);
+		glEnable(GL_BLEND);
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE);
+		OpenGL_check_error(__FILE__, __LINE__);
+
 		FrameBuffer& fb = self->frame_buffer;
 		if (fb) FrameBuffer_bind(fb.id());
 
@@ -649,6 +663,7 @@ namespace Rays
 		glViewport(
 			(int) (vp.x      * density), (int) (vp.y      * density),
 			(int) (vp.width  * density), (int) (vp.height * density));
+		OpenGL_check_error(__FILE__, __LINE__);
 
 		coord x1 = vp.x, x2 = vp.x + vp.width;
 		coord y1 = vp.y, y2 = vp.y + vp.height;
@@ -656,20 +671,13 @@ namespace Rays
 		if (z1 == 0 && z2 == 0) {z1 = -100; z2 = 200;}
 		if (!fb) std::swap(y1, y2);
 
-		self->state.init();
-
 		self->position_matrix.reset(1);
 		self->position_matrix *= to_rays(glm::ortho(x1, x2, y1, y2));
 		//self->position_matrix.translate(0.375f, 0.375f);
 
-		//glEnable(GL_CULL_FACE);
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		OpenGL_check_error(__FILE__, __LINE__);
+		self->update_clip();
 
 		self->painting = true;
-
-		no_clip();
 	}
 
 	void
@@ -847,6 +855,52 @@ namespace Rays
 			center, radius, hole_radius, angle_from, angle_to, nsegment()));
 	}
 
+	void
+	Painter::curve (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		polygon(create_curve(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+	}
+
+	void
+	Painter::curve (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
+	{
+		polygon(create_curve(p1, p2, p3, p4, loop));
+	}
+
+	void
+	Painter::curve (const Point* points, size_t size, bool loop)
+	{
+		polygon(create_curve(points, size, loop));
+	}
+
+	void
+	Painter::bezier (
+		coord x1, coord y1, coord x2, coord y2,
+		coord x3, coord y3, coord x4, coord y4,
+		bool loop)
+	{
+		polygon(create_bezier(x1, y1, x2, y2, x3, y3, x4, y4, loop));
+	}
+
+	void
+	Painter::bezier (
+		const Point& p1, const Point& p2, const Point& p3, const Point& p4,
+		bool loop)
+	{
+		polygon(create_bezier(p1, p2, p3, p4, loop));
+	}
+
+	void
+	Painter::bezier (const Point* points, size_t size, bool loop)
+	{
+		polygon(create_bezier(points, size, loop));
+	}
+
 	static void
 	draw_image (
 		Painter* painter, const Image& image,
@@ -1202,6 +1256,42 @@ namespace Rays
 		return self->state.stroke_width;
 	}
 
+	void
+	Painter::set_stroke_cap (CapType cap)
+	{
+		self->state.stroke_cap = cap;
+	}
+
+	CapType
+	Painter::stroke_cap () const
+	{
+		return self->state.stroke_cap;
+	}
+
+	void
+	Painter::set_stroke_join (JoinType join)
+	{
+		self->state.stroke_join = join;
+	}
+
+	JoinType
+	Painter::stroke_join () const
+	{
+		return self->state.stroke_join;
+	}
+
+	void
+	Painter::set_miter_limit (coord limit)
+	{
+		self->state.miter_limit = limit;
+	}
+
+	coord
+	Painter::miter_limit () const
+	{
+		return self->state.miter_limit;
+	}
+
 	void
 	Painter::set_nsegment (int nsegment)
 	{
@@ -1279,7 +1369,7 @@ namespace Rays
 	void
 	Painter::push_state ()
 	{
-		self->state_stack.push_back(self->state);
+		self->state_stack.emplace_back(self->state);
 	}
 
 	void
@@ -1370,7 +1460,7 @@ namespace Rays
 	void
 	Painter::push_matrix ()
 	{
-		self->position_matrix_stack.push_back(self->position_matrix);
+		self->position_matrix_stack.emplace_back(self->position_matrix);
 	}
 
 	void

data/src/polygon.cpp

@@ -5,6 +5,7 @@
 #include <assert.h>
 #include <utility>
 #include <poly2tri.h>
+#include <Splines.h>
 #include "xot/util.h"
 #include "rays/color.h"
 #include "rays/exception.h"
@@ -13,7 +14,7 @@
 #include "painter.h"
 
 
-using namespace ClipperLib;
+namespace clip = ClipperLib;
 
 
 namespace Rays
@@ -155,6 +156,10 @@ namespace Rays
 
 				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)
 				{
@@ -168,7 +173,7 @@ namespace Rays
 					}
 
 					Polygon stroke;
-					if (!polyline.expand(&stroke, stroke_width / 2))
+					if (!polyline.expand(&stroke, stroke_width / 2, cap, join, ml))
 						continue;
 
 					Polygon_fill(stroke, painter, color);
@@ -177,7 +182,7 @@ namespace Rays
 				if (has_loop)
 				{
 					Polygon hole;
-					if (polygon.expand(&hole, -stroke_width))
+					if (polygon.expand(&hole, -stroke_width, cap, join, ml))
 						Polygon_fill(polygon - hole, painter, color);
 				}
 			}
@@ -251,11 +256,11 @@ namespace Rays
 
 	static void
 	add_polygon_to_clipper (
-		Clipper* clipper, const Polygon& polygon, PolyType type)
+		clip::Clipper* clipper, const Polygon& polygon, clip::PolyType type)
 	{
 		assert(clipper);
 
-		Path path;
+		clip::Path path;
 		for (const auto& line : polygon)
 		{
 			if (!line) continue;
@@ -267,42 +272,72 @@ namespace Rays
 		}
 	}
 
-	static EndType
-	get_end_type (const Polyline& polyline, bool fill)
+	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 ? etClosedPolygon : etClosedLine;
-		else
-			return etOpenButt;
+			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 (
-		ClipperOffset* offsetter, const Polyline& polyline, bool hole, bool fill)
+		clip::ClipperOffset* offsetter, const Polyline& polyline,
+		CapType cap, JoinType join, bool hole, bool fill)
 	{
 		assert(offsetter);
 
 		if (!polyline) return false;
 
-		Path path;
+		clip::Path path;
 		Polyline_get_path(&path, polyline, hole);
-		offsetter->AddPath(path, jtMiter, get_end_type(polyline, fill));
+		offsetter->AddPath(
+			path, get_join_type(join), get_end_type(polyline, cap, fill));
 		return true;
 	}
 
 	static bool
-	add_polygon_to_offsetter (ClipperOffset* offsetter, const Polygon& polygon)
+	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, line.hole(), true);
+		{
+			added |= add_polyline_to_offsetter(
+				offsetter, line, cap, join, line.hole(), true);
+		}
 		return added;
 	}
 
 	static bool
-	append_outline (Polygon* polygon, const PolyNode& node)
+	append_outline (Polygon* polygon, const clip::PolyNode& node)
 	{
 		assert(polygon);
 
@@ -319,7 +354,7 @@ namespace Rays
 	}
 
 	static void
-	append_hole (Polygon* polygon, const PolyNode& node)
+	append_hole (Polygon* polygon, const clip::PolyNode& node)
 	{
 		assert(polygon);
 
@@ -338,7 +373,7 @@ namespace Rays
 	}
 
 	static void
-	get_polygon (Polygon* polygon, const PolyNode& node)
+	get_polygon (Polygon* polygon, const clip::PolyNode& node)
 	{
 		assert(polygon);
 
@@ -350,15 +385,16 @@ namespace Rays
 	}
 
 	static Polygon
-	clip_polygons (const Polygon& subject, const Polygon& clip, ClipType type)
+	clip_polygons (
+		const Polygon& subject, const Polygon& clip, clip::ClipType type)
 	{
-		Clipper c;
+		clip::Clipper c;
 		c.StrictlySimple(true);
 
-		add_polygon_to_clipper(&c, subject, ptSubject);
-		add_polygon_to_clipper(&c, clip,    ptClip);
+		add_polygon_to_clipper(&c, subject, clip::ptSubject);
+		add_polygon_to_clipper(&c, clip,    clip::ptClip);
 
-		PolyTree tree;
+		clip::PolyTree tree;
 		c.Execute(type, tree);
 		assert(tree.Contour.empty());
 
@@ -369,16 +405,19 @@ namespace Rays
 	}
 
 	static bool
-	expand_polygon (Polygon* result, const Polygon& polygon, coord width)
+	expand_polygon (
+		Polygon* result, const Polygon& polygon,
+		coord width, CapType cap, JoinType join, coord miter_limit)
 	{
 		if (width == 0)
 			return false;
 
-		ClipperOffset co;
-		if (!add_polygon_to_offsetter(&co, polygon))
+		clip::ClipperOffset co;
+		co.MiterLimit = miter_limit;
+		if (!add_polygon_to_offsetter(&co, polygon, cap, join))
 			return false;
 
-		PolyTree tree;
+		clip::PolyTree tree;
 		co.Execute(tree, to_clipper(width));
 		assert(tree.Contour.empty());
 
@@ -387,16 +426,19 @@ namespace Rays
 	}
 
 	bool
-	Polyline_expand (Polygon* result, const Polyline& polyline, coord width)
+	Polyline_expand (
+		Polygon* result, const Polyline& polyline,
+		coord width, CapType cap, JoinType join, coord miter_limit)
 	{
 		if (width == 0)
 			return false;
 
-		ClipperOffset co;
-		if (!add_polyline_to_offsetter(&co, polyline, false, false))
+		clip::ClipperOffset co;
+		co.MiterLimit = miter_limit;
+		if (!add_polyline_to_offsetter(&co, polyline, cap, join, false, false))
 			return false;
 
-		PolyTree tree;
+		clip::PolyTree tree;
 		co.Execute(tree, to_clipper(width));
 		assert(tree.Contour.empty());
 
@@ -865,6 +907,128 @@ namespace Rays
 			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)
 	{
@@ -935,9 +1099,11 @@ namespace Rays
 	}
 
 	bool
-	Polygon::expand (Polygon* result, coord width) const
+	Polygon::expand (
+		Polygon* result,
+		coord width, CapType cap, JoinType join, coord miter_limit) const
 	{
-		return expand_polygon(result, *this, width);
+		return expand_polygon(result, *this, width, cap, join, miter_limit);
 	}
 
 	Bounds
@@ -1029,7 +1195,7 @@ namespace Rays
 	{
 		if (lhs.self == rhs.self) return Polygon();
 
-		return clip_polygons(lhs, rhs, ctDifference);
+		return clip_polygons(lhs, rhs, clip::ctDifference);
 	}
 
 	Polygon
@@ -1037,7 +1203,7 @@ namespace Rays
 	{
 		if (lhs.self == rhs.self) return lhs;
 
-		return clip_polygons(lhs, rhs, ctIntersection);
+		return clip_polygons(lhs, rhs, clip::ctIntersection);
 	}
 
 	Polygon
@@ -1045,7 +1211,7 @@ namespace Rays
 	{
 		if (lhs.self == rhs.self) return lhs;
 
-		return clip_polygons(lhs, rhs, ctUnion);
+		return clip_polygons(lhs, rhs, clip::ctUnion);
 	}
 
 	Polygon
@@ -1053,7 +1219,7 @@ namespace Rays
 	{
 		if (lhs.self == rhs.self) return Polygon();
 
-		return clip_polygons(lhs, rhs, ctXor);
+		return clip_polygons(lhs, rhs, clip::ctXor);
 	}