CUGL 2.1
Cornell University Game Library
Public Member Functions | List of all members
cugl::PolyFactory Class Reference

#include <CUPolyFactory.h>

Public Member Functions

 PolyFactory ()
 
 PolyFactory (float tol)
 
float getTolerance () const
 
void setTolerance (float tol)
 
Poly2 makeTriangle (const Vec2 a, const Vec2 b, const Vec2 c) const
 
Poly2 makeTriangle (float ax, float ay, float bx, float by, float cx, float cy) const
 
Poly2makeTriangle (Poly2 *poly, const Vec2 a, const Vec2 b, const Vec2 c) const
 
Poly2makeTriangle (Poly2 *poly, float ax, float ay, float bx, float by, float cx, float cy) const
 
Poly2 makeRect (const Vec2 origin, const Vec2 size) const
 
Poly2 makeRect (const Rect rect) const
 
Poly2 makeRect (float x, float y, float w, float h) const
 
Poly2makeRect (Poly2 *poly, const Vec2 origin, const Vec2 size) const
 
Poly2makeRect (Poly2 *poly, const Rect rect) const
 
Poly2makeRect (Poly2 *poly, float x, float y, float w, float h) const
 
Poly2 makeNgon (const Vec2 center, float radius, Uint32 sides) const
 
Poly2 makeNgon (float cx, float cy, float radius, Uint32 sides) const
 
Poly2makeNgon (Poly2 *poly, const Vec2 center, float radius, Uint32 sides) const
 
Poly2makeNgon (Poly2 *poly, float cx, float cy, float radius, Uint32 sides) const
 
Poly2 makeEllipse (const Vec2 center, const Vec2 size) const
 
Poly2 makeEllipse (float cx, float cy, float sx, float sy) const
 
Poly2makeEllipse (Poly2 *poly, const Vec2 center, const Vec2 size) const
 
Poly2makeEllipse (Poly2 *poly, float cx, float cy, float sx, float sy) const
 
Poly2 makeCircle (const Vec2 center, float radius) const
 
Poly2 makeCircle (float cx, float cy, float radius) const
 
Poly2makeCircle (Poly2 *poly, const Vec2 center, float radius) const
 
Poly2makeCircle (Poly2 *poly, float cx, float cy, float radius) const
 
Poly2 makeArc (const Vec2 center, float radius, float start, float degrees) const
 
Poly2 makeArc (float cx, float cy, float radius, float start, float degrees) const
 
Poly2makeArc (Poly2 *poly, const Vec2 center, float radius, float start, float degrees) const
 
Poly2makeArc (Poly2 *poly, float cx, float cy, float radius, float start, float degrees) const
 
Poly2 makeRoundedRect (const Vec2 origin, const Size size, float radius) const
 
Poly2 makeRoundedRect (const Rect rect, float radius) const
 
Poly2 makeRoundedRect (float x, float y, float w, float h, float r) const
 
Poly2makeRoundedRect (Poly2 *poly, const Vec2 origin, const Size size, float radius) const
 
Poly2makeRoundedRect (Poly2 *poly, const Rect rect, float radius) const
 
Poly2makeRoundedRect (Poly2 *poly, float x, float y, float w, float h, float r) const
 
Poly2 makeCapsule (const Vec2 origin, const Size size) const
 
Poly2 makeCapsule (const Rect rect) const
 
Poly2 makeCapsule (float x, float y, float w, float h) const
 
Poly2makeCapsule (Poly2 *poly, const Vec2 origin, const Size size) const
 
Poly2makeCapsule (Poly2 *poly, const Rect rect) const
 
Poly2makeCapsule (Poly2 *poly, float x, float y, float w, float h) const
 
Poly2 makeCapsule (poly2::Capsule shape, const Vec2 origin, const Size size) const
 
Poly2 makeCapsule (poly2::Capsule shape, const Rect rect) const
 
Poly2 makeCapsule (poly2::Capsule shape, float x, float y, float w, float h) const
 
Poly2makeCapsule (Poly2 *poly, poly2::Capsule shape, const Vec2 origin, const Size size) const
 
Poly2makeCapsule (Poly2 *poly, poly2::Capsule shape, const Rect rect) const
 
Poly2makeCapsule (Poly2 *poly, poly2::Capsule shape, float x, float y, float w, float h) const
 

Detailed Description

This class is a factory for generating common Poly2 objects.

Most of the time that we create a solid polygon, we are using it to approximate a common shape, like a circle, or a rounded rectangle. Instead of embedding all of this functionality into Poly2 (which already has enough to do on its own), we have factored this out into a a separate factory class. This factory can generate new polygons or reset existing ones (conserving memory).

This factory is much lighter weight than the triangulation or extrusion factories. In this factory, the calculation step and the materialization step are one in the same. That is because the calculations are short and do not need to be refactored for multithread calculation. Indeed, the only reason this factory is not a collection of simple functions is because that we have have some settings (like precision and geometry) that we want to set separately.

Constructor & Destructor Documentation

◆ PolyFactory() [1/2]

cugl::PolyFactory::PolyFactory ( )

Creates a PolyFactory for generating solid polygons.

This factory will use the default tolerance.

◆ PolyFactory() [2/2]

cugl::PolyFactory::PolyFactory ( float  tol)

Creates a factory for generating solid polygons with the given tolerance.

Parameters
tolThe curve tolerance for rounded shapes

Member Function Documentation

◆ getTolerance()

float cugl::PolyFactory::getTolerance ( ) const
inline

Returns the curve tolerance for rounded shapes.

The tolerance guarantees that curved shapes have enough segments so that any points on the true shape are always within tolerance of the segmented approximation.

Rounded shapes include makeEllipse, makeCircle, makeArc, and makeRoundedRect.

Returns
the curve tolerance for rounded shapes.

◆ makeArc() [1/4]

Poly2 cugl::PolyFactory::makeArc ( const Vec2  center,
float  radius,
float  start,
float  degrees 
) const
inline

Returns a solid polygon that represents an arc of the given dimensions.

All arc measurements are in degrees, not radians.

Parameters
centerThe arc center point (of the defining circle
radiusThe radius from the center point
startThe starting angle in degrees
degreesThe number of degrees to generate
Returns
a solid polygon that represents an arc of the given dimensions.

◆ makeArc() [2/4]

Poly2 cugl::PolyFactory::makeArc ( float  cx,
float  cy,
float  radius,
float  start,
float  degrees 
) const

Returns a solid polygon that represents an arc of the given dimensions.

All arc measurements are in degrees, not radians.

Parameters
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe radius from the center point
startThe starting angle in degrees
degreesThe number of degrees to generate
Returns
a solid polygon that represents an arc of the given dimensions.

◆ makeArc() [3/4]

Poly2* cugl::PolyFactory::makeArc ( Poly2 poly,
const Vec2  center,
float  radius,
float  start,
float  degrees 
) const
inline

Stores an arc in the provided buffer.

All arc measurements are in degrees, not radians.

The arc will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
centerThe arc center point (of the defining circle
radiusThe radius from the center point
startThe starting angle in degrees
degreesThe number of degrees to generate
Returns
a reference to the buffer for chaining.

◆ makeArc() [4/4]

Poly2* cugl::PolyFactory::makeArc ( Poly2 poly,
float  cx,
float  cy,
float  radius,
float  start,
float  degrees 
) const

Stores an arc in the provided buffer.

All arc measurements are in degrees, not radians.

The arc will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe radius from the center point
startThe starting angle in degrees
degreesThe number of degrees to generate
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [1/12]

Poly2 cugl::PolyFactory::makeCapsule ( const Rect  rect) const
inline

Returns a solid polygon that represents a (full) capsule of the given dimensions.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

Parameters
rectThe enclosing rectangle
Returns
a solid polygon that represents a (full) capsule of the given dimensions.

◆ makeCapsule() [2/12]

Poly2 cugl::PolyFactory::makeCapsule ( const Vec2  origin,
const Size  size 
) const
inline

Returns a solid polygon that represents a (full) capsule of the given dimensions.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

Parameters
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
Returns
a solid polygon that represents a (full) capsule of the given dimensions.

◆ makeCapsule() [3/12]

Poly2 cugl::PolyFactory::makeCapsule ( float  x,
float  y,
float  w,
float  h 
) const

Returns a solid polygon that represents a (full) capsule of the given dimensions.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

Parameters
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe capsule width
hThe capsule height
Returns
a solid polygon that represents a (full) capsule of the given dimensions.

◆ makeCapsule() [4/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
const Rect  rect 
) const
inline

Stores a (full) capsule in the provided buffer.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
rectThe enclosing rectangle
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [5/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
const Vec2  origin,
const Size  size 
) const
inline

Stores a (full) capsule in the provided buffer.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [6/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
float  x,
float  y,
float  w,
float  h 
) const

Stores a (full) capsule in the provided buffer.

A capsule is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom.Otherwise it will be oriented horizontally.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe capsule width
hThe capsule height
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [7/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
poly2::Capsule  shape,
const Rect  rect 
) const
inline

Stores a capsule in the provided buffer.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
shapeThe capsule shape
rectThe enclosing rectangle
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [8/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
poly2::Capsule  shape,
const Vec2  origin,
const Size  size 
) const
inline

Stores a capsule in the provided buffer.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
shapeThe capsule shape
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [9/12]

Poly2* cugl::PolyFactory::makeCapsule ( Poly2 poly,
poly2::Capsule  shape,
float  x,
float  y,
float  w,
float  h 
) const

Stores a capsule in the provided buffer.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

The capsule will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
shapeThe capsule shape
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe capsule width
hThe capsule height
Returns
a reference to the buffer for chaining.

◆ makeCapsule() [10/12]

Poly2 cugl::PolyFactory::makeCapsule ( poly2::Capsule  shape,
const Rect  rect 
) const
inline

Returns a solid polygon that represents a capsule of the given dimensions.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

Parameters
shapeThe capsule shape
rectThe enclosing rectangle
Returns
a solid polygon that represents a capsule of the given dimensions.

◆ makeCapsule() [11/12]

Poly2 cugl::PolyFactory::makeCapsule ( poly2::Capsule  shape,
const Vec2  origin,
const Size  size 
) const
inline

Returns a solid polygon that represents a capsule of the given dimensions.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

Parameters
shapeThe capsule shape
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
Returns
a solid polygon that represents a capsule of the given dimensions.

◆ makeCapsule() [12/12]

Poly2 cugl::PolyFactory::makeCapsule ( poly2::Capsule  shape,
float  x,
float  y,
float  w,
float  h 
) const

Returns a solid polygon that represents a (full) capsule of the given dimensions.

A capsule typically is a pill-like shape that fits inside of given rectangle. If width < height, the capsule will be oriented vertically with the rounded portions at the top and bottom. Otherwise it will be oriented horizontally.

This method allows for the creation of half-capsules, simply by using the enumeration poly2::Capsule. The enumeration specifies which side should be rounded in case of a half-capsule. Half-capsules are sized so that the corresponding full capsule would fit in the bounding box.

Parameters
shapeThe capsule shape
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe capsule width
hThe capsule height
Returns
a solid polygon that represents a capsule of the given dimensions.

◆ makeCircle() [1/4]

Poly2 cugl::PolyFactory::makeCircle ( const Vec2  center,
float  radius 
) const
inline

Returns a solid polygon that represents a circle of the given dimensions.

Parameters
centerThe circle center point
radiusThe circle radius
Returns
a solid polygon that represents an circle of the given dimensions.

◆ makeCircle() [2/4]

Poly2 cugl::PolyFactory::makeCircle ( float  cx,
float  cy,
float  radius 
) const

Returns a solid polygon that represents a circle of the given dimensions.

Parameters
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe circle radius
Returns
a solid polygon that represents an circle of the given dimensions.

◆ makeCircle() [3/4]

Poly2* cugl::PolyFactory::makeCircle ( Poly2 poly,
const Vec2  center,
float  radius 
) const
inline

Stores a circle in the provided buffer.

The circle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
centerThe circle center point
radiusThe circle radius
Returns
a reference to the buffer for chaining.

◆ makeCircle() [4/4]

Poly2* cugl::PolyFactory::makeCircle ( Poly2 poly,
float  cx,
float  cy,
float  radius 
) const

Stores a circle in the provided buffer.

The circle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe circle radius
Returns
a reference to the buffer for chaining.

◆ makeEllipse() [1/4]

Poly2 cugl::PolyFactory::makeEllipse ( const Vec2  center,
const Vec2  size 
) const
inline

Returns a solid polygon that represents an ellipse of the given dimensions.

Parameters
centerThe ellipse center point
sizeThe size of the ellipse
Returns
a solid polygon that represents an ellipse of the given dimensions.

◆ makeEllipse() [2/4]

Poly2 cugl::PolyFactory::makeEllipse ( float  cx,
float  cy,
float  sx,
float  sy 
) const

Returns a solid polygon that represents an ellipse of the given dimensions.

Parameters
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
sxThe size (diameter) along the x-axis
syThe size (diameter) along the y-axis
Returns
a solid polygon that represents an ellipse of the given dimensions.

◆ makeEllipse() [3/4]

Poly2* cugl::PolyFactory::makeEllipse ( Poly2 poly,
const Vec2  center,
const Vec2  size 
) const
inline

Stores an ellipse in the provided buffer.

The ellipse will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
centerThe ellipse center point
sizeThe size of the ellipse
Returns
a reference to the buffer for chaining.

◆ makeEllipse() [4/4]

Poly2* cugl::PolyFactory::makeEllipse ( Poly2 poly,
float  cx,
float  cy,
float  sx,
float  sy 
) const

Stores an ellipse in the provided buffer.

The ellipse will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
sxThe size (diameter) along the x-axis
syThe size (diameter) along the y-axis
Returns
a reference to the buffer for chaining.

◆ makeNgon() [1/4]

Poly2 cugl::PolyFactory::makeNgon ( const Vec2  center,
float  radius,
Uint32  sides 
) const
inline

Returns a solid polygon that represents a regular, many-sided polygon.

The polygon will be centered at the given origin with the given radius. A regular polygon is essentially a circle where the number of segments is explicit (instead of implicit from the curve tolerance).

Parameters
centerThe polygon center point
radiusThe polygon radius
sidesThe number of sides
Returns
a solid polygon that represents a regular, many-sided polygon.

◆ makeNgon() [2/4]

Poly2 cugl::PolyFactory::makeNgon ( float  cx,
float  cy,
float  radius,
Uint32  sides 
) const

Returns a solid polygon that represents a regular, many-sided polygon.

The polygon will be centered at the given origin with the given radius. A regular polygon is essentially a circle where the number of segments is explicit (instead of implicit from the curve tolerance).

Parameters
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe polygon radius
sidesThe number of sides
Returns
a solid polygon that represents a regular, many-sided polygon.

◆ makeNgon() [3/4]

Poly2* cugl::PolyFactory::makeNgon ( Poly2 poly,
const Vec2  center,
float  radius,
Uint32  sides 
) const
inline

Stores a regular, many-sided polygon in the provided buffer.

The polygon will be centered at the given origin with the given radius. A regular polygon is essentially a circle where the number of segments is explicit (instead of implicit from the curve tolerance).

The polygon will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
centerThe polygon center point
radiusThe polygon radius
sidesThe number of sides
Returns
a reference to the buffer for chaining.

◆ makeNgon() [4/4]

Poly2* cugl::PolyFactory::makeNgon ( Poly2 poly,
float  cx,
float  cy,
float  radius,
Uint32  sides 
) const

Stores a regular, many-sided polygon in the provided buffer.

The polygon will be centered at the given origin with the given radius. A regular polygon is essentially a circle where the number of segments is explicit (instead of implicit from the curve tolerance).

The polygon will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
cxThe x-coordinate of the center point
cyThe y-coordinate of the center point
radiusThe polygon radius
sidesThe number of sides
Returns
a reference to the buffer for chaining.

◆ makeRect() [1/6]

Poly2 cugl::PolyFactory::makeRect ( const Rect  rect) const
inline

Returns a solid polygon that represents a rectangle

Parameters
rectThe rectangle
Returns
a solid polygon that represents a rectangle

◆ makeRect() [2/6]

Poly2 cugl::PolyFactory::makeRect ( const Vec2  origin,
const Vec2  size 
) const
inline

Returns a solid polygon that represents a rectangle

Parameters
originThe rectangle origin
sizeThe rectangle size
Returns
a solid polygon that represents a rectangle

◆ makeRect() [3/6]

Poly2 cugl::PolyFactory::makeRect ( float  x,
float  y,
float  w,
float  h 
) const

Returns a solid polygon that represents a rectangle

Parameters
xThe x-coordinate of the bottom left corner
yThe y-coordinate of the bottom left corner
wThe rectangle width
hThe rectangle height
Returns
a solid polygon that represents a rectangle

◆ makeRect() [4/6]

Poly2* cugl::PolyFactory::makeRect ( Poly2 poly,
const Rect  rect 
) const
inline

Stores a rectangle in the provided buffer.

The rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
rectThe rectangle to create
Returns
a reference to the buffer for chaining.

◆ makeRect() [5/6]

Poly2* cugl::PolyFactory::makeRect ( Poly2 poly,
const Vec2  origin,
const Vec2  size 
) const
inline

Stores a rectangle in the provided buffer.

The rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
originThe rectangle origin
sizeThe rectangle size
Returns
a reference to the buffer for chaining.

◆ makeRect() [6/6]

Poly2* cugl::PolyFactory::makeRect ( Poly2 poly,
float  x,
float  y,
float  w,
float  h 
) const

Stores a rectangle in the provided buffer.

The rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
xThe x-coordinate of the bottom left corner
yThe y-coordinate of the bottom left corner
wThe rectangle width
hThe rectangle height
Returns
a reference to the buffer for chaining.

◆ makeRoundedRect() [1/6]

Poly2 cugl::PolyFactory::makeRoundedRect ( const Rect  rect,
float  radius 
) const
inline

Returns a solid polygon that represents a rounded rectangle of the given dimensions.

The radius should not exceed either half the width or half the height.

Parameters
rectThe enclosing rectangle
radiusThe radius of each corner
Returns
a solid polygon that represents a rounded rectangle of the given dimensions.

◆ makeRoundedRect() [2/6]

Poly2 cugl::PolyFactory::makeRoundedRect ( const Vec2  origin,
const Size  size,
float  radius 
) const
inline

Returns a solid polygon that represents a rounded rectangle of the given dimensions.

The radius should not exceed either half the width or half the height.

Parameters
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
radiusThe radius of each corner
Returns
a solid polygon that represents a rounded rectangle of the given dimensions.

◆ makeRoundedRect() [3/6]

Poly2 cugl::PolyFactory::makeRoundedRect ( float  x,
float  y,
float  w,
float  h,
float  r 
) const

Returns a solid polygon that represents a rounded rectangle of the given dimensions.

The radius should not exceed either half the width or half the height.

Parameters
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe rectangle width
hThe rectangle height
rThe radius of each corner
Returns
a solid polygon that represents a rounded rectangle of the given dimensions.

◆ makeRoundedRect() [4/6]

Poly2* cugl::PolyFactory::makeRoundedRect ( Poly2 poly,
const Rect  rect,
float  radius 
) const
inline

Stores a rounded rectangle in the provided buffer.

The radius should not exceed either half the width or half the height.

The rounded rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
rectThe enclosing rectangle
radiusThe radius of each corner
Returns
a reference to the buffer for chaining.

◆ makeRoundedRect() [5/6]

Poly2* cugl::PolyFactory::makeRoundedRect ( Poly2 poly,
const Vec2  origin,
const Size  size,
float  radius 
) const
inline

Stores a rounded rectangle in the provided buffer.

The radius should not exceed either half the width or half the height.

The rounded rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
originThe enclosing rectangle origin
sizeThe enclosing rectangle size
radiusThe radius of each corner
Returns
a reference to the buffer for chaining.

◆ makeRoundedRect() [6/6]

Poly2* cugl::PolyFactory::makeRoundedRect ( Poly2 poly,
float  x,
float  y,
float  w,
float  h,
float  r 
) const

Stores a rounded rectangle in the provided buffer.

The radius should not exceed either half the width or half the height.

The rounded rectangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
xThe x-coordinate of the bottom left corner of the bounding box
yThe y-coordinate of the bottom left corner of the bounding box
wThe rectangle width
hThe rectangle height
rThe radius of each corner
Returns
a reference to the buffer for chaining.

◆ makeTriangle() [1/4]

Poly2 cugl::PolyFactory::makeTriangle ( const Vec2  a,
const Vec2  b,
const Vec2  c 
) const
inline

Returns a solid polygon that represents a simple triangle.

Parameters
aThe first vertex.
bThe second vertex.
cThe third vertex.
Returns
a solid polygon that represents a simple triangle.

◆ makeTriangle() [2/4]

Poly2 cugl::PolyFactory::makeTriangle ( float  ax,
float  ay,
float  bx,
float  by,
float  cx,
float  cy 
) const

Returns a solid polygon that represents a simple triangle.

Parameters
axThe x-coordinate of the first vertex.
ayThe y-coordinate of the first vertex.
bxThe x-coordinate of the second vertex.
byThe y-coordinate of the second vertex.
cxThe x-coordinate of the third vertex.
cyThe y-coordinate of the third vertex.
Returns
a solid polygon that represents a simple triangle.

◆ makeTriangle() [3/4]

Poly2* cugl::PolyFactory::makeTriangle ( Poly2 poly,
const Vec2  a,
const Vec2  b,
const Vec2  c 
) const
inline

Stores a simple triangle in the provided buffer.

The triangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
aThe first vertex
bThe second vertex
cThe third vertex
Returns
a reference to the buffer for chaining.

◆ makeTriangle() [4/4]

Poly2* cugl::PolyFactory::makeTriangle ( Poly2 poly,
float  ax,
float  ay,
float  bx,
float  by,
float  cx,
float  cy 
) const

Stores a simple triangle in the provided buffer.

The triangle will be appended to the buffer. You should clear the buffer first if you do not want to preserve the original data.

Parameters
polyThe polygon to store the result
axThe x-coordinate of the first vertex
ayThe y-coordinate of the first vertex
bxThe x-coordinate of the second vertex
byThe y-coordinate of the second vertex
cxThe x-coordinate of the third vertex
cyThe y-coordinate of the third vertex
Returns
a reference to the buffer for chaining.

◆ setTolerance()

void cugl::PolyFactory::setTolerance ( float  tol)
inline

Sets the curve tolerance for rounded shapes.

The tolerance guarantees that curved shapes have enough segments so that any points on the true shape are always within tolerance of the segmented approximation.

Rounded shapes include makeEllipse, makeCircle, makeArc, and makeRoundedRect.

Parameters
tolThe curve tolerance for rounded shapes.

The documentation for this class was generated from the following file: