CUGL 2.3
Cornell University Game Library

#include <CUPath2.h>
Public Member Functions  
Path2 ()  
Path2 (const std::vector< Vec2 > &vertices)  
Path2 (const Vec2 *vertices, size_t vertsize)  
Path2 (const Path2 &path)  
Path2 (Path2 &&path)  
Path2 (const Rect rect)  
Path2 (const std::shared_ptr< JsonValue > &data)  
~Path2 ()  
Path2 &  operator= (const Path2 &other) 
Path2 &  operator= (Path2 &&other) 
Path2 &  operator= (const Rect rect) 
Path2 &  operator= (const std::shared_ptr< JsonValue > &data) 
Path2 &  set (const std::vector< Vec2 > &vertices) 
Path2 &  set (const Vec2 *vertices, size_t vertsize) 
Path2 &  set (const Path2 &path) 
Path2 &  set (const Rect rect) 
Path2 &  set (const std::shared_ptr< JsonValue > &data) 
Path2 &  clear () 
bool  empty () const 
size_t  size () const 
bool  isClosed () const 
Vec2 &  at (size_t index) 
const Vec2 &  at (size_t index) const 
bool  isCorner (size_t index) const 
const std::vector< Vec2 > &  getVertices () const 
const Rect  getBounds () const 
std::vector< Uint32 >  getIndices () const 
size_t  getIndices (std::vector< Uint32 > &buffer) const 
Vec2  pop () 
void  push (Vec2 point, bool corner=false) 
void  push (float x, float y, bool corner=false) 
Vec2  remove (size_t index) 
void  add (size_t index, Vec2 point, bool corner=false) 
void  add (size_t index, float x, float y, bool corner=false) 
void  reserve (size_t size) 
std::vector< Uint32 >  convexHull () const 
bool  contains (Vec2 point) const 
bool  contains (float x, float y) const 
bool  incident (Vec2 point, float err=CU_MATH_EPSILON) const 
bool  incident (float x, float y, float err=CU_MATH_EPSILON) const 
Uint32  leftTurns () const 
bool  isConvex () const 
float  area () const 
int  orientation () const 
Path2 &  reverse () 
Path2  reversed () const 
Path2 &  operator*= (float scale) 
Path2 &  operator*= (const Vec2 scale) 
Path2 &  operator*= (const Affine2 &transform) 
Path2 &  operator*= (const Mat4 &transform) 
Path2 &  operator/= (float scale) 
Path2 &  operator/= (const Vec2 scale) 
Path2 &  operator+= (const Vec2 offset) 
Path2 &  operator= (const Vec2 offset) 
Path2  operator* (float scale) const 
Path2  operator* (const Vec2 scale) const 
Path2  operator* (const Affine2 &transform) const 
Path2  operator* (const Mat4 &transform) const 
Path2  operator/ (float scale) const 
Path2  operator/ (const Vec2 scale) const 
Path2  operator+ (const Vec2 offset) const 
Path2  operator (const Vec2 offset) 
Path2 &  operator+= (const Path2 &extra) 
Path2  operator+ (const Path2 &extra) const 
Path2  slice (size_t start, size_t end) const 
Path2  sliceFrom (size_t start) const 
Path2  sliceTo (size_t end) const 
std::string  toString (bool verbose=false) const 
operator std::string () const  
operator Rect () const  
Static Public Member Functions  
static std::vector< Uint32 >  convexHull (const std::vector< Vec2 > &vertices) 
static int  orientation (const Vec2 &a, const Vec2 &b, const Vec2 &c) 
static int  orientation (const std::vector< Vec2 > &path) 
static int  orientation (const Vec2 *path, size_t size) 
Public Attributes  
std::vector< Vec2 >  vertices 
std::unordered_set< size_t >  corners 
bool  closed 
Friends  
class  PathSmoother 
class  PathFactory 
class  SplinePather 
class  SimpleExtruder 
class  ComplexExtruder 
class  EarclipTriangulator 
class  DelaunayTriangulator 
Path2  operator* (float scale, const Path2 &path) 
Path2  operator* (const Vec2 scale, const Path2 &path) 
Class to represent a flattened polyline.
This class is intended to represent any continuous polyline. While it may be either open or closed, it should not have any gaps between vertices. If you need a path with gaps, that should be represented by multiple Path2 objects.
It is possible to draw a path object directly to a SpriteBatch
. However, in most applications you will want to convert a path object to a Poly2
for width and texturing. In particular, you will often want to either extrude (give stroke width) or triangulate (fill) a path.
We have provided several factories for converting a path to a Poly2
. These factories allow for delegating index computation to a separate thread, if it takes too long. These factories are as follows:
EarclipTriangulator
: This is a simple earclippingtriangulator for tesselating paths into polygons. It supports holes, but does not support selfintersections. While it produces better (e.g. less thin) triangles than MonotoneTriangulator, this comes at a cost. This triangulator has worst case O(n^2). With that said, it has low overhead and so is very efficient on small polygons.
DelaunayTriangulator
: This is a Delaunay Triangular that gives a more uniform triangulation in accordance to the Vornoi diagram. This triangulator uses an advancingfront algorithm that is the fastest in practice (though worst case O(n log n) is not guaranteed). However, it has a lot of overhead that is unnecessary for small polygons. As with EarclipTriangulator, it supports holes, but does not support selfintersections.
PathFactory
: This is a tool is used to generate several basic path shapes, such as rounded rectangles or arcs. It also allows you construct wireframe traversals of polygon meshes.
SimpleExtruder
: This is a tool can take a path and convert it into a solid polygon. This solid polygon is the same as the path, except that the path now has a width and a mitre at the joints. This algorithm is quite fast, but the resulting polygon may overlap itself. This is ideal for strokes that only need to be drawn and do not need accurate geometric information.
ComplexExtruder
: Like SimpleExtruder
, this is a tool can take a path polygon and convert it into a solid polygon. However it is much more powerful and guarantees that the resulting polygon has no overlaps. Unforunately, it is extremely slow (in the 10s of milliseconds) and is unsuitable for calcuations at framerate.

inline 
Creates an empty path.
The created path has no vertices. The bounding box is trivial.

inline 
Creates a path with the given vertices
No vertices are marked are as corner vertices. The path will be open.
vertices  The vector of vertices (as Vec2) in this path 

inline 
Creates a path with the given vertices
No vertices are marked are as corner vertices. The path will be open.
vertices  The array of vertices in this path 
vertsize  The number of elements to use from vertices 

inline 
Creates a copy of the given path.
Both the vertices and the annotations are copied. No references to the original path are kept.
path  The path to copy 

inline 
Creates a copy with the resource of the given path.
As a move constructor, this will invalidate the original path
path  The path to take from 

inline 
Creates a path for the given rectangle.
The path will have four vertices, one for each corner of the rectangle. It will be closed.
rect  The rectangle to copy 

inline 
Creates a path from the given JsonValue
The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.
On the other hand, if it is a JSON object, it supports the following attributes:
"vertices": An (even) list of floats, representing the vertices "corners": A list of integers representing corner positions "closed": A boolean value, representing if the path is closed
All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.
data  The JSON object specifying the path 

inline 
Deletes the given path, freeing all resources.
void cugl::Path2::add  (  size_t  index, 
float  x,  
float  y,  
bool  corner = false 

) 
Adds a point at the given index
index  The index to add the point 
x  The xcoordinate to add 
y  The ycoordinate to add 
corner  Whether this point is a corner 
void cugl::Path2::add  (  size_t  index, 
Vec2  point,  
bool  corner = false 

) 
Adds a point at the given index
index  The index to add the point 
point  The point to add 
corner  Whether this point is a corner 
float cugl::Path2::area  (  )  const 
Returns the area enclosed by this path.
The area is defined as the sum of oriented triangles in a triangle fan from a point on the convex hull. Counterclockwise triangles have positive area, while clockwise triangles have negative area. The result agrees with the traditional concept of area for counter clockwise paths.
The area can be used to determine the orientation. It the area is negative, that means this path essentially represents a hole (e.g. is clockwise instead of counterclockwise).

inline 
Returns a reference to the point at the given index.
This accessor will allow you to change the (singular) point. It is intended to allow minor distortions to the path without changing the underlying geometry.
index  The path index 

inline 
Returns a reference to the point at the given index.
This accessor will allow you to change the (singular) point. It is intended to allow minor distortions to the path without changing the underlying geometry.
index  The path index 
Path2 & cugl::Path2::clear  (  ) 
Clears the contents of this path
bool cugl::Path2::contains  (  float  x, 
float  y  
)  const 
Returns true if the interior of this path contains the given point.
This mehtod returns false if the path is open. Otherwise, it uses an evenodd crossing rule to determine containment. Containment is not strict. Points on the boundary are contained within this polygon.
x  The xcoordinate to test 
y  The ycoordinate to test 

inline 
Returns true if the interior of this path contains the given point.
This mehtod returns false if the path is open. Otherwise, it uses an evenodd crossing rule to determine containment. Containment is not strict. Points on the boundary are contained within this polygon.
point  The point to test 
std::vector< Uint32 > cugl::Path2::convexHull  (  )  const 
Returns the set of points forming the convex hull of this path.
The returned set of points is guaranteed to be a counterclockwise traversal of the hull.
The points on the convex hull define the "border" of the shape. In addition to minimizing the number of vertices, this is useful for determining whether or not a point lies on the boundary.
This implementation is adapted from the example at
http://www.geeksforgeeks.org/convexhullset2grahamscan/

static 
Returns the set of points forming the convex hull of the given points.
The returned set of points is guaranteed to be a counterclockwise traversal of the hull.
The points on the convex hull define the "border" of the shape. In addition to minimizing the number of vertices, this is useful for determining whether or not a point lies on the boundary.
This implementation is adapted from the example at
http://www.geeksforgeeks.org/convexhullset2grahamscan/
vertices  The points for the computation 

inline 
Returns true if the path is empty.
const Rect cugl::Path2::getBounds  (  )  const 
Returns the bounding box for the path
The bounding box is the minimal rectangle that contains all of the vertices in this path. This method will recompute the bounds and is hence O(n).
std::vector< Uint32 > cugl::Path2::getIndices  (  )  const 
Returns a list of vertex indices representing this path.
The indices are intended to be used in a drawing mesh to display this path. The number of indices will be a multiple of two.
size_t cugl::Path2::getIndices  (  std::vector< Uint32 > &  buffer  )  const 
Stores a list of vertex indices in the given buffer.
The indices are intended to be used in a drawing mesh to display this path. The number of indices will be a multiple of two.
The indices will be appended to the provided vector. You should clear the vector first if you do not want to preserve the original data. If the calculation is not yet performed, this method will do nothing.
buffer  a buffer to store the list of indices. 

inline 
Returns the list of vertices
This accessor will not permit any changes to the vertex array. To change the array, you must change the path via a set() method.
bool cugl::Path2::incident  (  float  x, 
float  y,  
float  err = CU_MATH_EPSILON 

)  const 
Returns true if the given point is on the path.
This method returns true if the point is within margin of error of a line segment.
x  The xcoordinate to test 
y  The ycoordinate to test 
err  The distance tolerance 

inline 
Returns true if the given point is on the path.
This method returns true if the point is within margin of error of a line segment.
point  The point to check 
err  The distance tolerance 

inline 
Returns whether the path is closed.
bool cugl::Path2::isConvex  (  )  const 
Returns true if this path defines a convex shape.
This method returns false if the path is open.
bool cugl::Path2::isCorner  (  size_t  index  )  const 
Returns true if the point at the given index is a corner
Corner points will be assigned a joint style when extruded. Points that are not corners will be extruded smoothly (typically because they are the result of a bezier expansion).
index  The attribute index 
Uint32 cugl::Path2::leftTurns  (  )  const 
Returns the number of left turns in this path.
Left turns are determined by looking at the interior angle generated at each point (assuming that the path is intended to be counterclockwise). In the case of an open path, the first and last vertexes are not counted.
This method is a generalization of isConvex
that can be used to analyze the convexity of a path.

inline 
Cast from Path2 to a string.
Returns a new path by transforming all of the vertices of this path.
Note: This method does not modify the path.
transform  The affine transform 
Returns a new path by transforming all of the vertices of this path.
The vertices are transformed as 3d points. The zvalue is 0.
Note: This method does not modify the path.
transform  The transform matrix 
Returns a new path by scaling the vertices nonuniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
Note: This method does not modify the path.
scale  The nonuniform scaling factor 

inline 
Returns a new path by scaling the vertices uniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
Note: This method does not modify the path.
scale  The uniform scaling factor 
Transforms all of the vertices of this path.
transform  The affine transform 
Transforms all of the vertices of this path.
The vertices are transformed as 3d points. The zvalue is 0.
transform  The transform matrix 
Nonuniformly scales all of the vertices of this path.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The nonuniform scaling factor 
Path2 & cugl::Path2::operator*=  (  float  scale  ) 
Uniformly scales all of the vertices of this path.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The uniform scaling factor 
Returns a new path by appending extra to the end of this path
The vertices are appended in order to the end of the path. If the original path was closed, the copy is open (regardless of whether or not extra is closed)
Note: This method does not modify the original path.
extra  The path to add 
Returns a new path by translating the vertices
Note: This method does not modify the path.
offset  The translation amount 
Appends the given path to the end of this one
The vertices are appended in order to the end of the path. If the original path was closed, it is now open (regardless of whether or not extra is closed)
extra  The path to append 
Translates all of the vertices of this path.
offset  The translation amount 
Returns a new path by translating the vertices
Note: This method does not modify the path.
offset  The inverse of the translation amount 
Translates all of the vertices of this path.
offset  The inverse of the translation amount 
Returns a new path by scaling the vertices nonuniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
Note: This method does not modify the path.
scale  The inverse of the nonuniform scaling factor 

inline 
Returns a new path by scaling the vertices uniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
Note: This method does not modify the path.
scale  The inverse of the uniform scaling factor 
Nonuniformly scales all of the vertices of this path.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The inverse of the nonuniform scaling factor 
Path2 & cugl::Path2::operator/=  (  float  scale  ) 
Uniformly scales all of the vertices of this path.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The inverse of the uniform scaling factor 
Sets this path to be a copy of the given one.
All of the contents are copied, so that this path does not hold any references to elements of the other path.
This method returns a reference to this path for chaining.
other  The path to copy 
Sets this path to be a copy of the given rectangle.
The path will have four vertices, one for each corner of the rectangle. The path will be closed.
This method returns a reference to this path for chaining.
rect  The rectangle to copy 
Sets this path from the data in the given JsonValue
The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.
On the other hand, if it is a JSON object, it supports the following attributes:
"vertices": An (even) list of floats, representing the vertices "corners": A list of integers representing corner positions "closed": A boolean value, representing if the path is closed
All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.
data  The JSON object specifying the path 
Sets this path to be have the resources of the given one.
This method returns a reference to this path for chaining.
other  The path to take from 
int cugl::Path2::orientation  (  )  const 
Returns 1, 0, or 1 indicating the path orientation.
If the method returns 1, this is a counterclockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.

static 
Returns 1, 0, or 1 indicating the path orientation.
If the method returns 1, this is a counterclockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.
path  The path to check 
Returns 1, 0, or 1 indicating the orientation of a > b > c
If the function returns 1, this is a counterclockwise turn. If 1, it is a clockwise turn. If 0, it is colinear.
a  The first point 
b  The second point 
c  The third point 

static 
Returns 1, 0, or 1 indicating the path orientation.
If the method returns 1, this is a counterclockwise path. If 1, it is a clockwise path. If 0, that means it is undefined. The orientation can be undefined if all the points are colinear.
path  The path to check 
size  The path size 
Vec2 cugl::Path2::pop  (  ) 
Returns the former end point in the path, after removing it
If this path is empty, this will return the zero vector.
void cugl::Path2::push  (  float  x, 
float  y,  
bool  corner = false 

) 
Adds a point to the end of this path
x  The xcoordinate to add 
y  The ycoordinate to add 
corner  Whether this point is a corner 
void cugl::Path2::push  (  Vec2  point, 
bool  corner = false 

) 
Adds a point to the end of this path
point  The point to add 
corner  Whether this point is a corner 
Vec2 cugl::Path2::remove  (  size_t  index  ) 
Returns the former point at the given index, after removing it
If this path is empty, this will return the zero vector.
void cugl::Path2::reserve  (  size_t  size  ) 
Allocates space in this path for the given number of points.
This method can help performance when a path is being constructed piecemeal.
size  The number of spots allocated for future points. 
Path2 & cugl::Path2::reverse  (  ) 
Reverses the orientation of this path in place
The path will have all of its vertices in the reverse order from the original. This path will not be affected.
Path2 cugl::Path2::reversed  (  )  const 
Returns a path with the reverse orientation of this one.
The path will have all of its vertices in the reverse order from the original. This path will not be affected.
Sets this path to be a copy of the given one.
All of the contents are copied, so that this path does not hold any references to elements of the other path.
This method returns a reference to this path for chaining.
path  The path to copy 
Sets the path to represent the given rectangle.
The path will have four vertices, one for each corner of the rectangle. The path will be closed.
This method returns a reference to this path for chaining.
rect  The rectangle to copy 
Sets this path from the data in the given JsonValue
The JsonValue should either be an array of floats or an JSON object. If it is an array of floats, then it interprets those floats as the vertices. All points are corners and the path is closed.
On the other hand, if it is a JSON object, it supports the following attributes:
"vertices": An (even) list of floats, representing the vertices "corners": A list of integers representing corner positions "closed": A boolean value, representing if the path is closed
All attributes are optional. If "vertices" are missing, then the path will be empty. If "corners" is missing, then all vertices are corners. If "closed" is missing, then the path is closed by default.
data  The JSON object specifying the path 
Sets the path to have the given vertices
No vertices are marked are as corner vertices. The path will be open.
This method returns a reference to this path for chaining.
vertices  The vector of vertices (as Vec2) in this path 
Sets the path to have the given vertices.
No vertices are marked are as corner vertices. The path will be open.
This method returns a reference to this path for chaining.
vertices  The array of vertices in this path 
vertsize  The number of elements to use from vertices 

inline 
Returns the number of vertices in a path.
Path2 cugl::Path2::slice  (  size_t  start, 
size_t  end  
)  const 
Returns the slice of this path between start and end.
The sliced path will use the indices from start to end (not including end). It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.
start  The start index 
end  The end index 

inline 
Returns the slice of this mesh from the start index to the end.
The sliced mesh will use the indices from start to the end. It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.
start  The start index 

inline 
Returns the slice of this mesh from the begining to end.
The sliced mesh will use the indices up to (but not including) end. It will include the vertices referenced by those indices, and only those vertices. The resulting path is open.
end  The end index 
std::string cugl::Path2::toString  (  bool  verbose = false  )  const 
Returns a string representation of this path for debugging purposes.
If verbose is true, the string will include class information. This allows us to unambiguously identify the class.
verbose  Whether to include class information 
Returns a new path by scaling the vertices nonuniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The nonuniform scaling factor 
path  The path to scale 
Returns a new path by scaling the vertices uniformly.
The vertices are scaled from the origin of the coordinate space. This means that if the origin is not path of this path, then the path will be effectively translated by the scaling.
scale  The uniform scaling factor 
path  The path to scale 

friend 
Friend classes
bool cugl::Path2::closed 
Whether or not this path is closed
std::unordered_set<size_t> cugl::Path2::corners 
The corner points of this path (used for extrusion).
std::vector<Vec2> cugl::Path2::vertices 
The vector of vertices in this path