All the core generic classes and functions. More...

Classes
class	gf::Index2D< I >
	A two-dimensional array with no data. More...

class	gf::Array2D< T, I >
	A two-dimensional array. More...

class	gf::ArrayRef< T >
	A constant reference to an array and its size. More...

class	gf::BufferRef< T >
	A reference to a modifiable buffer and its size. More...

struct	gf::Circ< T >
	Utility class for manipulating circles. More...

class	gf::Clock
	Utility class that measures the elapsed time. More...

class	gf::Dice
	A set of dice that can be rolled. More...

class	gf::Ease
	Predefined easing functions. More...

class	gf::Flags< E >
	Bitfield relying on an enumeration. More...

class	gf::Bresenham
	State for the Bresenham's line algorithm. More...

class	gf::Heightmap
	A heightmap. More...

struct	gf::Library::Version
	Information about version. More...

class	gf::Library
	A class to represent the library. More...

class	gf::Log
	Logging functions. More...

struct	gf::Matrix< T, ROWS, COLS >
	General purpose math matrix. More...

struct	gf::Matrix< T, 2, 2 >
	A 2x2 matrix. More...

struct	gf::Matrix< T, 3, 3 >
	A 3x3 matrix. More...

struct	gf::Matrix< T, 4, 4 >
	A 4x4 matrix. More...

class	gf::Noise2D
	2D A noise function More...

class	gf::Noise3D
	3D A noise function More...

class	gf::ValueNoise2D
	Value 2D noise. More...

class	gf::GradientNoise2D
	Gradient 2D noise. More...

class	gf::GradientNoise3D
	Gradient 3D noise. More...

class	gf::BetterGradientNoise2D
	Better gradient 2D noise. More...

class	gf::FractalNoise2D
	Fractal 2D noise. More...

class	gf::FractalNoise3D
	Fractal 3D noise. More...

class	gf::PerlinNoise2D
	Perlin 2D noise. More...

class	gf::PerlinNoise3D
	Perlin 3D noise. More...

class	gf::SimplexNoise2D
	Simplex 2D noise. More...

class	gf::OpenSimplexNoise2D
	OpenSimplex 2D noise. More...

class	gf::OpenSimplexNoise3D
	OpenSimplex3D noise. More...

class	gf::WaveletNoise3D
	Wavelet 3D noise. More...

class	gf::WorleyNoise2D
	Worley 2D noise. More...

class	gf::Multifractal2D
	Multi Fractal 2D noise. More...

class	gf::HeteroTerrain2D
	Hetero Terrain 2D noise. More...

class	gf::HybridMultifractal2D
	Hybrid Multifractal 2D noise. More...

class	gf::RidgedMultifractal2D
	Ridged Multifractal 2D noise. More...

class	gf::Noise3DTo2DAdapter
	An adapter that make a 2D noise from a 3D noise. More...

struct	gf::Paths
	Special paths. More...

class	gf::Polygon
	A convex polygon. More...

class	gf::Polyline
	A polyline. More...

class	gf::Queue< T >
	A simple concurrent queue. More...

class	gf::Random
	A random engine. More...

struct	gf::Range< T >::Iterator
	A range iterator. More...

struct	gf::Range< T >
	A half-open range of values. More...

struct	gf::PositionRange< T >::Iterator
	An iterator for a 2D range. More...

struct	gf::PositionRange< T >
	A 2D range. More...

struct	gf::NeighborSquareRange< T >::Iterator
	An iterator for a 2D range. More...

struct	gf::NeighborSquareRange< T >
	A 2D range. More...

struct	gf::NeighborDiamondRange< T >::Iterator
	An iterator for a 2D range. More...

struct	gf::NeighborDiamondRange< T >
	A 2D range. More...

struct	gf::Rect< T >
	Utility class for manipulating 2D axis aligned rectangles. More...

class	gf::Ref< T >
	A reference wrapper. More...

class	gf::Singleton< T >
	A singleton that wraps a pointer provided by a storage. More...

class	gf::SingletonStorage< T >
	A storage for a singleton. More...

struct	gf::RStarTree::Node::Member

class	gf::DynamicTree
	An implementation of dynamic tree. More...

class	gf::Quadtree
	An implementation of quadtree. More...

class	gf::RStarTree
	An implemntation of a R* tree. More...

class	gf::SimpleSpatialIndex
	An very simple spatial index. More...

struct	gf::SpatialStructure
	A spatial structure. More...

class	gf::InputStream
	Abstract class for custom file input streams. More...

class	gf::OutputStream
	Abstract class for custom file output streams. More...

class	gf::FileInputStream
	File based input stream. More...

class	gf::MemoryInputStream
	Memory based input stream. More...

class	gf::CompressedInputStream
	Compressed input stream. More...

class	gf::BufferInputStream
	Buffer input stream. More...

class	gf::FileOutputStream
	File based output stream. More...

class	gf::MemoryOutputStream
	Memory based output stream. More...

class	gf::CompressedOutputStream
	Compressed output stream. More...

class	gf::BufferOutputStream
	Buffer output stream. More...

class	gf::StringRef
	A constant reference to a string and its size. More...

struct	gf::CodepointRange::Iterator

struct	gf::CodepointRange
	A range over a sequence of codepoints in UTF-8. More...

class	gf::SystemInfo
	A class for system info. More...

class	gf::Time
	Represents a time value. More...

class	gf::EdgeRef< T >
	A reference to an edge (two points) More...

class	gf::TriangleRef< T >
	A reference to a triangle (three points) More...

struct	gf::NoneType
	Semantic type to represent "none". More...

struct	gf::AllType
	Semantic type to represent "all". More...

struct	gf::AnyType
	Semantic type to represent "any". More...

struct	gf::ZeroType
	Semantic type to represent "zero". More...

struct	gf::Vector< T, N >
	General purpose math vector. More...

struct	gf::Vector< T, 2 >
	A 2D vector. More...

struct	gf::Vector< T, 3 >
	A 3D vector. More...

struct	gf::Vector< T, 4 >
	A 4D vector. More...

Typedefs
using	gf::CircF = Circ< float >
	A `float` circle. More...

using	gf::CircD = Circ< double >
	A `double` circle. More...

using	gf::CircI = Circ< int >
	A `int` circle. More...

using	gf::CircU = Circ< unsigned >
	A `unsigned` circle. More...

using	gf::CircZ = Circ< std::size_t >
	A `std::size_t` circle. More...

using	gf::Easing = float(*)(float)
	An easing function. More...

using	gf::Id = uint64_t
	An identifier. More...

template<typename T >
using	gf::Step = T(*)(T)
	A step is a function with special features. More...

using	gf::Matrix2f = Matrix< float, 2, 2 >
	A float square matrix of size 2. More...

using	gf::Matrix2d = Matrix< double, 2, 2 >
	A double square matrix of size 2. More...

using	gf::Matrix3f = Matrix< float, 3, 3 >
	A float square matrix of size 3. More...

using	gf::Matrix3d = Matrix< double, 3, 3 >
	A double square matrix of size 3. More...

using	gf::Matrix4f = Matrix< float, 4, 4 >
	A float square matrix of size 4. More...

using	gf::Matrix4d = Matrix< double, 4, 4 >
	A double square matrix of size 4. More...

using	gf::Path = boost::filesystem::path
	A path in the filesystem. More...

using	gf::RangeF = Range< float >
	A float range. More...

using	gf::RangeI = Range< int >
	A int range. More...

using	gf::RangeU = Range< unsigned >
	A unsigned range. More...

using	gf::RangeZ = Range< std::size_t >
	A `std::size_t` range. More...

using	gf::RectF = Rect< float >
	A `float` rectangle. More...

using	gf::RectD = Rect< double >
	A `double` rectangle. More...

using	gf::RectI = Rect< int >
	A `int` rectangle. More...

using	gf::RectU = Rect< unsigned >
	A `unsigned` rectangle. More...

using	gf::RectZ = Rect< std::size_t >
	A `std::size_t` rectangle. More...

using	gf::SpatialQueryCallback = std::function< void(Handle)>
	A callback for spatial query. More...

using	gf::Vector2f = Vector< float, 2 >
	A float vector with 2 components. More...

using	gf::Vector3f = Vector< float, 3 >
	A float vector with 3 components. More...

using	gf::Vector4f = Vector< float, 4 >
	A float vector with 4 components. More...

using	gf::Vector2d = Vector< double, 2 >
	A double vector with 2 components. More...

using	gf::Vector3d = Vector< double, 3 >
	A double vector with 3 components. More...

using	gf::Vector4d = Vector< double, 4 >
	A double vector with 4 components. More...

using	gf::Vector2i = Vector< int, 2 >
	A int vector with 2 components. More...

using	gf::Vector3i = Vector< int, 3 >
	A int vector with 3 components. More...

using	gf::Vector4i = Vector< int, 4 >
	A int vector with 4 components. More...

using	gf::Vector2u = Vector< unsigned, 2 >
	A unsigned vector with 2 components. More...

using	gf::Vector3u = Vector< unsigned, 3 >
	A unsigned vector with 3 components. More...

using	gf::Vector4u = Vector< unsigned, 4 >
	A unsigned vector with 4 components. More...

using	gf::Vector2z = Vector< std::size_t, 2 >
	A std::size_t vector with 2 components. More...

using	gf::Vector3z = Vector< std::size_t, 3 >
	A std::size_t vector with 3 components. More...

using	gf::Vector4z = Vector< std::size_t, 4 >
	A std::size_t vector with 4 components. More...

using	gf::Vector2b = Vector< bool, 2 >
	A bool vector with 2 components. More...

using	gf::Vector3b = Vector< bool, 3 >
	A bool vector with 3 components. More...

using	gf::Vector4b = Vector< bool, 4 >
	A bool vector with 4 components. More...

template<typename T >
using	gf::Color3 = Vector< T, 3 >
	A color vector with 3 components. More...

template<typename T >
using	gf::Color4 = Vector< T, 4 >
	A color vector with 4 components. More...

using	gf::Color3f = Color3< float >
	A float color vector with 3 components. More...

using	gf::Color4f = Color4< float >
	A float color vector with 4 components. More...

using	gf::Color3d = Color3< double >
	A double color vector with 3 components. More...

using	gf::Color4d = Color4< double >
	A double color vector with 4 components. More...

using	gf::Color3u = Color3< uint8_t >
	A uint8_t color vector with 3 components. More...

using	gf::Color4u = Color4< uint8_t >
	A uint8_t color vector with 4 components. More...

template<typename T , std::size_t N>
using	gf::Distance = T(*)(Vector< T, N >, Vector< T, N >)
	A distance function. More...

template<typename T >
using	gf::Distance2 = Distance< T, 2 >
	A distance function for 2D vectors. More...

template<typename T >
using	gf::Distance3 = Distance< T, 3 >
	A distance function for 3D vectors. More...

Enumerations
enum	gf::Direction : int { gf::Direction::Center = -1, gf::Direction::Up = 0, gf::Direction::Right = 1, gf::Direction::Down = 2, gf::Direction::Left = 3 }
	Main four directions. More...

enum	gf::PixelFormat { gf::Rgba32, gf::Rgb24 }
	Pixel format. More...

enum	gf::AngularMove : uint8_t { gf::AngularMove::None, gf::AngularMove::Left, gf::AngularMove::Right }
	An angular move. More...

enum	gf::LinearMove : uint8_t { gf::LinearMove::None, gf::LinearMove::Forward, gf::LinearMove::Backward }
	A linear move. More...

enum	gf::Orientation : int { gf::Orientation::Center = -1, gf::Orientation::North = 0, gf::Orientation::NorthEast = 1, gf::Orientation::East = 2, gf::Orientation::SouthEast = 3, gf::Orientation::South = 4, gf::Orientation::SouthWest = 5, gf::Orientation::West = 6, gf::Orientation::NorthWest = 7 }
	Cardinal and ordinal orientation. More...

enum	gf::Quarter { gf::UpperLeft, gf::UpperRight, gf::LowerRight, gf::LowerLeft }
	A quarter in a square. More...

enum	gf::SpatialId : std::size_t
	A spatial id. More...

enum	gf::SpatialStructureType { gf::SpatialStructureType::Object, gf::SpatialStructureType::Node }
	A type of spatial structure. More...

enum	gf::SpatialQuery { gf::SpatialQuery::Contain, gf::SpatialQuery::Intersect }
	A kind of spatial query. More...

enum	gf::Winding { gf::Winding::Clockwise, gf::Winding::Counterclockwise }
	The direction of a polygon's rotation. More...

Functions
template<typename T >
constexpr ArrayRef< T >	gf::array (const T *data, std::size_t size)
	Create a constant reference to an array. More...

template<typename T >
constexpr BufferRef< T >	gf::buffer (T *data, std::size_t size)
	Create a reference to a buffer. More...

Vector2f	gf::unit (Direction direction)
	Get a unit vector from a direction. More...

Vector2i	gf::displacement (Direction direction)
	Get a vector from a direction. More...

float	gf::angle (Direction direction)
	Get an angle from a direction. More...

Direction	gf::opposite (Direction direction)
	Get the opposite direction. More...

Direction	gf::orthogonalCW (Direction direction)
	Get the orthogonal direction clockwise. More...

Direction	gf::orthogonalCCW (Direction direction)
	Get the orthogonal direction counter-clockwise. More...

Direction	gf::nextCW (Direction direction)
	Get the next direction clockwise. More...

Direction	gf::nextCCW (Direction direction)
	Get the next direction counter-clockwise. More...

std::vector< Vector2i >	gf::generateLine (Vector2i p0, Vector2i p1)
	Generate a line between two positions. More...

std::vector< Vector2f >	gf::midpointDisplacement1D (Vector2f p0, Vector2f p1, Random &random, unsigned iterations, Vector2f direction, float initialFactor=1.0f, float reductionFactor=0.5f)
	1D midpoint displacement More...

std::vector< Vector2f >	gf::midpointDisplacement1D (Vector2f p0, Vector2f p1, Random &random, unsigned iterations, float initialFactor=1.0f, float reductionFactor=0.5f)
	1D midpoint displacement More...

Heightmap	gf::midpointDisplacement2D (Vector2i size, Random &random, ArrayRef< double > initialValues=nullptr)
	2D midpoint displacement More...

Heightmap	gf::diamondSquare2D (Vector2i size, Random &random, ArrayRef< double > initialValues=nullptr)
	2D diamond square More...

Polygon	gf::convexHull (ArrayRef< Vector2f > points)
	Compute the convex hull of a set of points. More...

std::vector< Vector2f >	gf::simplifyPoints (ArrayRef< Vector2f > points, float distance=Epsilon)
	Simplify a sequence of points. More...

std::vector< Polyline >	gf::buildLines (ArrayRef< SegmentI > segments)
	Build a set of lines from a set of segments. More...

constexpr Id	gf::hash (const char *str, std::size_t sz)
	Get an identifier from a string. More...

constexpr Id	gf::hash (StringRef str)
	Get an idenfitier from a string. More...

constexpr gf::Id	gf::literals::operator"" _id (const char *str, std::size_t sz)
	User defined operator for creating compile time ids from strings. More...

template<typename T >
constexpr T	gf::pi ()
	Templated value of \( \pi \). More...

template<typename T >
constexpr bool	gf::almostEquals (T a, T b, T epsilon=std::numeric_limits< T >::epsilon())
	Compare two floats. More...

template<typename T >
constexpr T	gf::degreesToRadians (T degrees)
	Convert degrees to radians. More...

template<typename T >
constexpr T	gf::radiansToDegrees (T radians)
	Convert radians to degrees. More...

template<typename T >
constexpr T	gf::linearStep (T t)
	Linear step. More...

template<typename T >
constexpr T	gf::cubicStep (T t)
	Cubic step (smoothstep) More...

template<typename T >
constexpr T	gf::quinticStep (T t)
	Quintic step (smootherstep) More...

template<typename T >
T	gf::cosineStep (T t)
	Cosine step. More...

template<typename T , typename U >
constexpr T	gf::lerp (T lhs, T rhs, U t)
	Linear interpolation function. More...

template<typename T >
constexpr T	gf::clamp (T val, T lo, T hi)
	Clamping function. More...

template<typename T >
constexpr T	gf::square (T val)
	Square function. More...

template<typename T >
constexpr T	gf::cube (T val)
	Cube function. More...

template<typename T >
constexpr int	gf::sign (T val)
	Sign function. More...

template<typename T >
constexpr T	gf::absdiff (T lhs, T rhs)
	Absolute difference of two values. More...

float	gf::angularFactor (AngularMove move)
	Get the angular factor from the angular move. More...

float	gf::linearFactor (LinearMove move)
	Get the linear factor from the linear move. More...

Vector2f	gf::unit (Orientation orientation)
	Get a unit vector from an orientation. More...

Vector2i	gf::displacement (Orientation orientation)
	Get a vector from an orientation. More...

float	gf::angle (Orientation orientation)
	Get an angle from a orientation. More...

Orientation	gf::orientation (float angle)
	Get an orientation from an angle. More...

Orientation	gf::opposite (Orientation orientation)
	Get the opposite orientation. More...

Orientation	gf::orthogonalCW (Orientation orientation)
	Get the orthogonal orientation clockwise. More...

Orientation	gf::orthogonalCCW (Orientation orientation)
	Get the orthogonal orientation counter-clockwise. More...

Orientation	gf::nextCW (Orientation orientation)
	Get the next orientation clockwise. More...

Orientation	gf::nextCCW (Orientation orientation)
	Get the next orientation counter-clockwise. More...

template<typename T >
constexpr Rect< T >	gf::computeBoxQuarter (const Rect< T > &other, Quarter quarter)
	Divide a rectangle in quarters. More...

void	gf::sleep (Time duration)
	Make the current thread sleep for a given duration. More...

std::string	gf::niceNum (float num, float precision)
	Create a string representation of a floating point number. More...

std::string	gf::formatString (const char *fmt,...)
	Format a string like printf. More...

std::string	gf::formatString (const char *fmt, va_list ap)
	Format a string like vprintf. More...

std::string	gf::escapeString (StringRef str)
	Escape a string. More...

std::vector< StringRef >	gf::splitInParagraphs (StringRef str)
	Split a string in multiples paragraphs. More...

std::vector< StringRef >	gf::splitInWords (StringRef str)
	Split a string in multiples words. More...

constexpr CodepointRange	gf::codepoints (StringRef ref)
	Create a range over codepoints from a string. More...

constexpr gf::Time	gf::literals::operator"" _seconds (long double amount)
	User defined operator for creating times in seconds. More...

constexpr gf::Time	gf::literals::operator"" _milliseconds (unsigned long long int amount)
	User defined operator for creating times in milliseconds. More...

constexpr gf::Time	gf::literals::operator"" _microseconds (unsigned long long int amount)
	User defined operator for creating times in microseconds. More...

constexpr Vector2f	gf::transform (const Matrix3f &mat, Vector2f point)
	Apply an affine transformation to a 2D point. More...

RectF	gf::transform (const Matrix3f &mat, const RectF &rect)
	Apply an affine transformaton to a rectangle. More...

constexpr Matrix3f	gf::identityTransform ()
	Identity transform. More...

Matrix3f	gf::translation (Vector2f offset)
	Get a translation matrix. More...

void	gf::translate (Matrix3f &mat, Vector2f offset)
	Combine the current transform with a translation. More...

Matrix3f	gf::rotation (float angle)
	Get a rotation matrix. More...

Matrix3f	gf::rotation (float angle, Vector2f center)
	Get a rotation matrix. More...

void	gf::rotate (Matrix3f &mat, float angle)
	Combine the current transform with a rotation. More...

void	gf::rotate (Matrix3f &mat, float angle, Vector2f center)
	Combine the current transform with a rotation. More...

Matrix3f	gf::scaling (Vector2f factor)
	Get a scaling matrix. More...

Matrix3f	gf::scaling (Vector2f factor, Vector2f center)
	Get a scaling matrix. More...

void	gf::scale (Matrix3f &mat, Vector2f factor)
	Combine the current transform with a scaling. More...

void	gf::scale (Matrix3f &mat, Vector2f factor, Vector2f center)
	Combine the current transform with a scaling. More...

std::vector< TriangleRef< const Vector2f > >	gf::triangulation (ArrayRef< Vector2f > points)
	Compute a Delaunay triangulation of a set of points. More...

template<typename... Args>
constexpr void	gf::unused (Args &&...)
	A simple way to avoid warnings about unused variables. More...

Variables
constexpr Id	gf::InvalidId = 0
	The invalid id (which is 0) More...

constexpr float	gf::Pi = pi<float>()
	The \( \pi \) constant. More...

constexpr float	gf::Pi2 = Pi / 2
	The \( \frac{\pi}{2} \) constant. More...

constexpr float	gf::Pi3 = Pi / 3
	The \( \frac{\pi}{3} \) constant. More...

constexpr float	gf::Pi4 = Pi / 4
	The \( \frac{\pi}{4} \) constant. More...

constexpr float	gf::Pi6 = Pi / 6
	The \( \frac{\pi}{6} \) constant. More...

constexpr float	gf::Sqrt2 = 1.41421356237309504880f
	The \( \sqrt{2} \) constant. More...

constexpr float	gf::InvSqrt2 = 1 / Sqrt2
	The \( \frac{1}{\sqrt{2}} \) constant. More...

constexpr float	gf::Sqrt3 = 1.7320508075688772935f
	The \( \sqrt{3} \) constant. More...

constexpr float	gf::Epsilon = std::numeric_limits<float>::epsilon()
	Machine epsilon. More...

constexpr NoneType	gf::None = { }
	Constant to represent "none". More...

constexpr AllType	gf::All = { }
	Constant to represent "all". More...

constexpr AnyType	gf::Any = { }
	Constant to represent "any". More...

constexpr ZeroType	gf::Zero = { }
	Constant to represent "zero". More...

Detailed Description

All the core generic classes and functions.

Math: gf::Vector, gf::Matrix, gf::Range, gf::Direction, gf::Orientation, gf::Array2D
Geometry: gf::Rect, gf::Circ, gf::Polygon, gf::Polyline
Stream: gf::InputStream, gf::FileInputStream, gf::MemoryInputStream
Utility: gf::Clock, gf::Time, gf::Random, gf::SystemInfo, gf::Singleton, gf::Flags
Noise: gf::Noise2D / gf::Noise3D, gf::GradientNoise2D / gf::GradientNoise3D, gf::FractalNoise2D / gf::FractalNoise3D, gf::PerlinNoise2D / gf::PerlinNoise3D, gf::SimplexNoise2D, gf::OpenSimplexNoise2D / gf::OpenSimplexNoise3D, gf::WorleyNoise2D

Typedef Documentation

◆ CircD

using gf::CircD = typedef Circ<double>

A double circle.

See also: gf::Circ

◆ CircF

using gf::CircF = typedef Circ<float>

A float circle.

See also: gf::Circ

◆ CircI

using gf::CircI = typedef Circ<int>

A int circle.

See also: gf::Circ

◆ CircU

using gf::CircU = typedef Circ<unsigned>

A unsigned circle.

See also: gf::Circ

◆ CircZ

using gf::CircZ = typedef Circ<std::size_t>

A std::size_t circle.

See also: gf::Circ

◆ Color3

template<typename T >

using gf::Color3 = typedef Vector<T, 3>

A color vector with 3 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Color3d

using gf::Color3d = typedef Color3<double>

A double color vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Color3f

using gf::Color3f = typedef Color3<float>

A float color vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Color3u

using gf::Color3u = typedef Color3<uint8_t>

A uint8_t color vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Color4

template<typename T >

using gf::Color4 = typedef Vector<T, 4>

A color vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Color4d

using gf::Color4d = typedef Color4<double>

A double color vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Color4f

using gf::Color4f = typedef Color4<float>

A float color vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Color4u

using gf::Color4u = typedef Color4<uint8_t>

A uint8_t color vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Distance

template<typename T , std::size_t N>

using gf::Distance = typedef T (*)(Vector<T, N>, Vector<T, N>)

A distance function.

A distance function is a function that gives the distance between two vectors.

gf::Distance<float, 3> distFn = gf::manhattanDistance<float, 3>;
Vector3f vec1 = ...;
Vector3f vec2 = ...;
float distance = distFn(vec1, vec2);

See also: manhattanDistance(), squareDistance(), euclideanDistance(), chebyshevDistance(); gf::Distance2, gf::Distance3

◆ Distance2

template<typename T >

using gf::Distance2 = typedef Distance<T, 2>

A distance function for 2D vectors.

See also: gf::Distance

◆ Distance3

template<typename T >

using gf::Distance3 = typedef Distance<T, 3>

A distance function for 3D vectors.

See also: gf::Distance

◆ Easing

using gf::Easing = typedef float (*)(float)

An easing function.

An easing function is a function that specifies how a value changes over time. A normalized easing function has the following properties:

\( f(0) = 0 \)
\( f(1) = 1 \)

Usual easing functions are provided in gf::Ease.

See also: gf::Ease, gf::Step

◆ Id

using gf::Id = typedef uint64_t

An identifier.

◆ Matrix2d

using gf::Matrix2d = typedef Matrix<double, 2, 2>

A double square matrix of size 2.

See also: gf::Matrix, gf::Matrix<T, 2, 2>

◆ Matrix2f

using gf::Matrix2f = typedef Matrix<float, 2, 2>

A float square matrix of size 2.

See also: gf::Matrix, gf::Matrix<T, 2, 2>

◆ Matrix3d

using gf::Matrix3d = typedef Matrix<double, 3, 3>

A double square matrix of size 3.

See also: gf::Matrix, gf::Matrix<T, 3, 3>

◆ Matrix3f

using gf::Matrix3f = typedef Matrix<float, 3, 3>

A float square matrix of size 3.

See also: gf::Matrix, gf::Matrix<T, 3, 3>

◆ Matrix4d

using gf::Matrix4d = typedef Matrix<double, 4, 4>

A double square matrix of size 4.

See also: gf::Matrix, gf::Matrix<T, 4, 4>

◆ Matrix4f

using gf::Matrix4f = typedef Matrix<float, 4, 4>

A float square matrix of size 4.

See also: gf::Matrix, gf::Matrix<T, 4, 4>

◆ Path

using gf::Path = typedef boost::filesystem::path

A path in the filesystem.

gf::Path is a simple typedef for boost::filesystem::path. Boost.Filesystem will eventually be part of the C++17 standard. So, in the future, gf::Path will be a typedef for std::path.

◆ RangeF

using gf::RangeF = typedef Range<float>

A float range.

See also: gf::Range

◆ RangeI

using gf::RangeI = typedef Range<int>

A int range.

See also: gf::Range

◆ RangeU

using gf::RangeU = typedef Range<unsigned>

A unsigned range.

See also: gf::Range

◆ RangeZ

using gf::RangeZ = typedef Range<std::size_t>

A std::size_t range.

See also: gf::Range

◆ RectD

using gf::RectD = typedef Rect<double>

A double rectangle.

See also: gf::Rect

◆ RectF

using gf::RectF = typedef Rect<float>

A float rectangle.

See also: gf::Rect

◆ RectI

using gf::RectI = typedef Rect<int>

A int rectangle.

See also: gf::Rect

◆ RectU

using gf::RectU = typedef Rect<unsigned>

A unsigned rectangle.

See also: gf::Rect

◆ RectZ

using gf::RectZ = typedef Rect<std::size_t>

A std::size_t rectangle.

See also: gf::Rect

◆ SpatialQueryCallback

using gf::SpatialQueryCallback = typedef std::function<void(Handle)>

A callback for spatial query.

◆ Step

template<typename T >

using gf::Step = typedef T (*)(T)

A step is a function with special features.

A step \( f \) is a (mathematical) function which has the following properties:

\( f(0) = 0 \)
\( f(1) = 1 \)

It can be used to smooth a linear interpolation.

gf::Vector2f point1 = ...;
gf::Vector2f point2 = ...;
float t = ...;
gf::Step<float> step = gf::cubicStep<float>;
gf::Vector2f interpolatedPoint = gf::lerp(point1, point2, t);
gf::Vector2f smoothedInterpolatedPoint = gf::lerp(point1, point2, step(t));

See also: linearStep(), cubicStep(), quinticStep(), cosineStep()

◆ Vector2b

using gf::Vector2b = typedef Vector<bool, 2>

A bool vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector2d

using gf::Vector2d = typedef Vector<double, 2>

A double vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector2f

using gf::Vector2f = typedef Vector<float, 2>

A float vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector2i

using gf::Vector2i = typedef Vector<int, 2>

A int vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector2u

using gf::Vector2u = typedef Vector<unsigned, 2>

A unsigned vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector2z

using gf::Vector2z = typedef Vector<std::size_t, 2>

A std::size_t vector with 2 components.

See also: gf::Vector, gf::Vector<T, 2>

◆ Vector3b

using gf::Vector3b = typedef Vector<bool, 3>

A bool vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector3d

using gf::Vector3d = typedef Vector<double, 3>

A double vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector3f

using gf::Vector3f = typedef Vector<float, 3>

A float vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector3i

using gf::Vector3i = typedef Vector<int, 3>

A int vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector3u

using gf::Vector3u = typedef Vector<unsigned, 3>

A unsigned vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector3z

using gf::Vector3z = typedef Vector<std::size_t, 3>

A std::size_t vector with 3 components.

See also: gf::Vector, gf::Vector<T, 3>

◆ Vector4b

using gf::Vector4b = typedef Vector<bool, 4>

A bool vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Vector4d

using gf::Vector4d = typedef Vector<double, 4>

A double vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Vector4f

using gf::Vector4f = typedef Vector<float, 4>

A float vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Vector4i

using gf::Vector4i = typedef Vector<int, 4>

A int vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Vector4u

using gf::Vector4u = typedef Vector<unsigned, 4>

A unsigned vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

◆ Vector4z

using gf::Vector4z = typedef Vector<std::size_t, 4>

A std::size_t vector with 4 components.

See also: gf::Vector, gf::Vector<T, 4>

Enumeration Type Documentation

◆ AngularMove

enum gf::AngularMove : uint8_t

strong

An angular move.

An angular move represents a rotation move to the right or to the left.

See also: gf::LinearMove

Enumerator
None	No angular move.
Left	Move to the left (i.e. counter-clockwise)
Right	Move to the right (i.e. clockwise)

◆ Direction

enum gf::Direction : int

strong

Main four directions.

gf::Direction represents one of the four main directions. A special value is added to represent the center, it indicates no direction.

See also: gf::Orientation

Enumerator
Center	The center, indicates no direction.
Up	The up direction.
Right	The right direction.
Down	The down direction.
Left	The left direction.

◆ LinearMove

enum gf::LinearMove : uint8_t

strong

A linear move.

A linear move represents a translation move forward or backward.

See also: gf::AngularMove

Enumerator
None	No linear move.
Forward	Move forward.
Backward	Move backward.

◆ Orientation

enum gf::Orientation : int

strong

Cardinal and ordinal orientation.

gf::Orientation represents one the four cardinal orientations and the four ordinal (or intercardinal) orientations. A special value is added to represent the center, it indicates no orientation.

See also: gf::Direction

Enumerator
Center	The center, indicates no orientation.
North	The north orientation.
NorthEast	The north-east orientation.
East	The east orientation.
SouthEast	The south-east orientation.
South	The south orientation.
SouthWest	The south-west orientation.
West	The west orientation.
NorthWest	The north-west orientation.

◆ PixelFormat

enum gf::PixelFormat

Pixel format.

Enumerator
Rgba32	Four 8-bit channels.
Rgb24	Three 8-bit channels.

◆ Quarter

enum gf::Quarter

A quarter in a square.

Enumerator
UpperLeft	Upper-left quarter.
UpperRight	Upper-right quarter.
LowerRight	Lower-right quarter.
LowerLeft	Lower-left quarter.

◆ SpatialId

enum gf::SpatialId : std::size_t

A spatial id.

A spatial id refers to an object in a spatial index.

◆ SpatialQuery

enum gf::SpatialQuery

strong

A kind of spatial query.

Enumerator
Contain	Search for all objects that contain the given bounds.
Intersect	Search for all objects that intersect the given bounds.

◆ SpatialStructureType

enum gf::SpatialStructureType

strong

A type of spatial structure.

See also: gf::SpatialStructure

Enumerator
Object	The structure represents an actuel object.
Node	The structure represents an internal node.

◆ Winding

enum gf::Winding

strong

The direction of a polygon's rotation.

Enumerator
Clockwise	Same direction as a clock's hands.
Counterclockwise	Opposite direction of a clock's hands.

Function Documentation

◆ absdiff()

template<typename T >

constexpr T gf::absdiff	(	T	lhs,
		T	rhs
	)

Absolute difference of two values.

This function is defined as:

\[ \text{absdiff}(a, b) = | a - b | \]

Parameters

lhs	The first value
rhs	The second value

Returns: The absolute difference between the two values

◆ almostEquals()

template<typename T >

constexpr bool gf::almostEquals	(	T	a,
		T	b,
		T	epsilon = `std::numeric_limits<T>::epsilon()`
	)

Compare two floats.

Parameters

a	The first float
b	The second float
epsilon	A small value that controls the equality comparison

See also: Comparison - The Floating-Point Guide

◆ angle() [1/2]

float gf::angle ( Direction direction )

Get an angle from a direction.

Up is at angle 0 and angle grows clockwise.

Parameters

direction The direction

Returns: an angle (in radians) representing the direction

◆ angle() [2/2]

float gf::angle ( Orientation orientation )

Get an angle from a orientation.

East is at angle 0 and angle grows clockwise.

Parameters

orientation The orientation

Returns: An angle (in radians) representing the orientation

See also: gf::orientation()

◆ angularFactor()

float gf::angularFactor ( AngularMove move )

Get the angular factor from the angular move.

Returns: \( -1 \), \( 0 \) or \( 1 \) with respect to the move

◆ array()

template<typename T >

constexpr ArrayRef<T> gf::array	(	const T *	data,
		std::size_t	size
	)

Create a constant reference to an array.

Parameters

data	A pointer to the elements in the array
size	The number of elements in the array

Returns: A constant reference to an array

◆ buffer()

template<typename T >

constexpr BufferRef<T> gf::buffer	(	T *	data,
		std::size_t	size
	)

Create a reference to a buffer.

Parameters

data	A pointer to the elements in the buffer
size	The number of elements in the buffer

Returns: A reference to a buffer

◆ buildLines()

std::vector<Polyline> gf::buildLines ( ArrayRef< SegmentI > segments )

Build a set of lines from a set of segments.

Parameters

segments A set of segments

Returns: An array of polylines representing the lines

◆ clamp()

template<typename T >

constexpr T gf::clamp	(	T	val,
		T	lo,
		T	hi
	)

Clamping function.

This function takes a value and returns it if it is in a specified range. If not, the returned value is the nearest value in the range.

Parameters

val	The value to clamp
lo	The minimum accepted value
hi	The maximum accepted value

Returns: The clamped value

◆ codepoints()

constexpr CodepointRange gf::codepoints ( StringRef ref )

inline

Create a range over codepoints from a string.

◆ computeBoxQuarter()

template<typename T >

constexpr Rect<T> gf::computeBoxQuarter	(	const Rect< T > &	other,
		Quarter	quarter
	)

Divide a rectangle in quarters.

Parameters

other	The rectangle to divide
quarter	The quarter to compute

◆ convexHull()

Polygon gf::convexHull ( ArrayRef< Vector2f > points )

Compute the convex hull of a set of points.

This function uses the Quickhull algorithm.

Complexity: \( O(n \log n)\) on average, \( O(n^2) \) on worst case

Parameters

points The set of points

Returns: A (convex) polygon that contains the points

◆ cosineStep()

template<typename T >

T gf::cosineStep ( T t )

inline

Cosine step.

\[ f(t) = (1 - \cos(\pi * t)) * 0.5 \]

See also: gf::Step

◆ cube()

template<typename T >

constexpr T gf::cube ( T val )

Cube function.

For a value \( x \), the cube value is \( x^3 \).

Parameters

val A value

Returns: The cube of the value

◆ cubicStep()

template<typename T >

constexpr T gf::cubicStep ( T t )

Cubic step (smoothstep)

\[ f(t) = -2 * t^3 + 3 * t^2 \]

Compared to a step, it has the following properties:

\( f'(0) = 0 \)
\( f'(1) = 0 \)

This function is also known as smoothstep

See also: gf::Step

◆ degreesToRadians()

template<typename T >

constexpr T gf::degreesToRadians ( T degrees )

Convert degrees to radians.

Parameters

degrees An angle in degrees

Returns: The angle in radians

See also: radiansToDegrees()

◆ diamondSquare2D()

Heightmap gf::diamondSquare2D	(	Vector2i	size,
		Random &	random,
		ArrayRef< double >	initialValues = `nullptr`
	)

2D diamond square

The size can be anything. If the size is not a power of two plus one, then a greater heightmap is generated and a submap of the right size is returned (in the middle of the generated map).

The function takes initial values. If there are less than three values, only the first one is used to initialize the four corners. If there are more than four, only the first four are used to initialize the four corners in that order: north-west, north-east, south-east, south-west. If no values are given, the four corners are initialized to \( 0.0 \).

Parameters

size	The size of the map
random	A random engine
initialValues	The initial values of the four corners

See also: gf::midpointDisplacement2D()

◆ displacement() [1/2]

Vector2i gf::displacement ( Direction direction )

Get a vector from a direction.

The vector has its coordinates at -1, 0 or 1 depending on the direction. It can be used to represent the displacement on a grid in the given direction.

Parameters

direction The direction

Returns: A vector representing the direction

◆ displacement() [2/2]

Vector2i gf::displacement ( Orientation orientation )

Get a vector from an orientation.

The vector has its coordinates at -1, 0 or 1 depending on the orientation. It can be used to represent the displacement on a grid in the given orientation.

Parameters

orientation The orientation

Returns: A vector representing the orientation

◆ escapeString()

std::string gf::escapeString ( StringRef str )

Escape a string.

This function replaces characters with their escaped equivalent. For example, a '\n' character is replaced with "\\\\n". This function can be used to display strings.

Parameters

str	The input string

Returns: An escaped string

◆ formatString() [1/2]

std::string gf::formatString	(	const char *	fmt,
			...
	)

Format a string like printf.

Parameters

fmt	The format string

◆ formatString() [2/2]

std::string gf::formatString	(	const char *	fmt,
		va_list	ap
	)

Format a string like vprintf.

Parameters

fmt	The format string
ap	The arguments of the format string

◆ generateLine()

std::vector<Vector2i> gf::generateLine	(	Vector2i	p0,
		Vector2i	p1
	)

Generate a line between two positions.

This function uses Bresenham's line algorithm.

Parameters

p0	The first point of the line
p1	The last point of the line

Returns: A series of point beginning at the first point and ending just before the last point

See also: gf::Bresenham

◆ hash() [1/2]

constexpr Id gf::hash	(	const char *	str,
		std::size_t	sz
	)

Get an identifier from a string.

The hash is a Fowler–Noll–Vo 1a hash. This function is mainly for internal use. You should instead use the user-defined literal _id.

Example:

gf::Id id = "A string"_id; // computed at compile time

Parameters

str	The string
sz	The size of the string

◆ hash() [2/2]

constexpr Id gf::hash ( StringRef str )

Get an idenfitier from a string.

The hash is a Fowler–Noll–Vo 1a hash. This function can be used for computing an id at runtime. For computing an id from a string at compile time, you should use the the user-defined literal _id.

Parameters

str	The string

Returns: The hash of the string

◆ identityTransform()

constexpr Matrix3f gf::identityTransform ( )

Identity transform.

Returns: The identity matrix

◆ lerp()

template<typename T , typename U >

constexpr T gf::lerp	(	T	lhs,
		T	rhs,
		U	t
	)

Linear interpolation function.

This functions returns an interpolated value between two values lhs and rhs according to a parameter \( t \). When \( t = 0 \) then lhs is returned, and when \( t = 1 \) then rhs is returned.

Parameters

lhs	The first value
rhs	The second value
t	The interpolation parameter, generally in the interval \( [0,1] \)

Returns: A value between the first and second value

◆ linearFactor()

float gf::linearFactor ( LinearMove move )

Get the linear factor from the linear move.

Returns: \( -1 \), \( 0 \) or \( 1 \) with respect to the move

◆ linearStep()

template<typename T >

constexpr T gf::linearStep ( T t )

Linear step.

\[ f(t) = t \]

See also: gf::Step

◆ midpointDisplacement1D() [1/2]

std::vector<Vector2f> gf::midpointDisplacement1D	(	Vector2f	p0,
		Vector2f	p1,
		Random &	random,
		unsigned	iterations,
		Vector2f	direction,
		float	initialFactor = `1.0f`,
		float	reductionFactor = `0.5f`
	)

1D midpoint displacement

Parameters

p0	The first end point
p1	The second end point
random	A random engine
iterations	The number of iterations
direction	The direction to make a displacement
initialFactor	The initial factor to apply to the displacement
reductionFactor	The factor to apply at each iteration

◆ midpointDisplacement1D() [2/2]

std::vector<Vector2f> gf::midpointDisplacement1D	(	Vector2f	p0,
		Vector2f	p1,
		Random &	random,
		unsigned	iterations,
		float	initialFactor = `1.0f`,
		float	reductionFactor = `0.5f`
	)

1D midpoint displacement

The direction is perpendicular to the segment \( [P_0 P_1] \)

Parameters

p0	The first end point
p1	The second end point
random	A random engine
iterations	The number of iterations
initialFactor	The initial factor to apply to the displacement
reductionFactor	The factor to apply at each iteration

◆ midpointDisplacement2D()

Heightmap gf::midpointDisplacement2D	(	Vector2i	size,
		Random &	random,
		ArrayRef< double >	initialValues = `nullptr`
	)

2D midpoint displacement

The size can be anything. If the size is not a power of two plus one, then a greater heightmap is generated and a submap of the right size is returned (in the middle of the generated map).

The function takes initial values. If there are less than three values, only the first one is used to initialize the four corners. If there are more than four, only the first four are used to initialize the four corners in that order: north-west, north-east, south-east, south-west. If no values are given, the four corners are initialized to \( 0.0 \).

Parameters

size	The size of the map
random	A random engine
initialValues	The initial values of the four corners

See also: gf::diamondSquare2D()

◆ nextCCW() [1/2]

Direction gf::nextCCW ( Direction direction )

Get the next direction counter-clockwise.

Parameters

direction The direction

Returns: The next direction counter-clockwise

◆ nextCCW() [2/2]

Orientation gf::nextCCW ( Orientation orientation )

Get the next orientation counter-clockwise.

Parameters

orientation The orientation

Returns: The next orientation counter-clockwise

◆ nextCW() [1/2]

Direction gf::nextCW ( Direction direction )

Get the next direction clockwise.

Parameters

direction The direction

Returns: The next direction clockwise

◆ nextCW() [2/2]

Orientation gf::nextCW ( Orientation orientation )

Get the next orientation clockwise.

Parameters

orientation The orientation

Returns: The next orientation clockwise

◆ niceNum()

std::string gf::niceNum	(	float	num,
		float	precision
	)

Create a string representation of a floating point number.

It is based on Python niceNum.

Parameters

num	The number to display
precision	The precision to use for display

Returns: A string representing the number

◆ operator"" _id()

constexpr gf::Id gf::literals::operator"" _id	(	const char *	str,
		std::size_t	sz
	)

User defined operator for creating compile time ids from strings.

To use it, you have to use the gf::literals namespace:

using namespace gf::literals;
Id id = "FooBar"_id;

◆ operator"" _microseconds()

constexpr gf::Time gf::literals::operator"" _microseconds ( unsigned long long int amount )

User defined operator for creating times in microseconds.

To use it, you have to use the gf::literals namespace:

  using namespace gf::literals;
  gf::Time time = 13_microseconds;

See also: gf::microseconds()

◆ operator"" _milliseconds()

constexpr gf::Time gf::literals::operator"" _milliseconds ( unsigned long long int amount )

User defined operator for creating times in milliseconds.

To use it, you have to use the gf::literals namespace:

  using namespace gf::literals;
  gf::Time time = 42_milliseconds;

See also: gf::milliseconds()

◆ operator"" _seconds()

constexpr gf::Time gf::literals::operator"" _seconds ( long double amount )

User defined operator for creating times in seconds.

To use it, you have to use the gf::literals namespace:

  using namespace gf::literals;
  gf::Time time = 66.6_seconds;

See also: gf::seconds()

◆ opposite() [1/2]

Direction gf::opposite ( Direction direction )

Get the opposite direction.

Parameters

direction The direction

Returns: The opposite direction

◆ opposite() [2/2]

Orientation gf::opposite ( Orientation orientation )

Get the opposite orientation.

Parameters

orientation The orientation

Returns: The opposite orientation

◆ orientation()

Orientation gf::orientation ( float angle )

Get an orientation from an angle.

East is at angle 0 and angle grows clockwise.

Parameters

angle The angle

Returns: An orientation for the angle

See also: gf::angle()

◆ orthogonalCCW() [1/2]

Direction gf::orthogonalCCW ( Direction direction )

Get the orthogonal direction counter-clockwise.

Parameters

direction The direction

Returns: The orthogonal direction counter-clockwise

◆ orthogonalCCW() [2/2]

Orientation gf::orthogonalCCW ( Orientation orientation )

Get the orthogonal orientation counter-clockwise.

Parameters

orientation The orientation

Returns: The orthogonal orientation counter-clockwise

◆ orthogonalCW() [1/2]

Direction gf::orthogonalCW ( Direction direction )

Get the orthogonal direction clockwise.

Parameters

direction The direction

Returns: The orthogonal direction clockwise

◆ orthogonalCW() [2/2]

Orientation gf::orthogonalCW ( Orientation orientation )

Get the orthogonal orientation clockwise.

Parameters

orientation The orientation

Returns: The orthogonal orientation clockwise

◆ pi()

template<typename T >

constexpr T gf::pi ( )

Templated value of \( \pi \).

◆ quinticStep()

template<typename T >

constexpr T gf::quinticStep ( T t )

Quintic step (smootherstep)

\[ f(t) = 6 * t^5 - 15 * t^4 + 10 * t^3 \]

Compared to a step, it has the following properties:

\( f'(0) = 0 \)
\( f'(1) = 0 \)
\( f''(0) = 0 \)
\( f''(1) = 0 \)

This function is also known as smootherstep

See also: gf::Step

◆ radiansToDegrees()

template<typename T >

constexpr T gf::radiansToDegrees ( T radians )

Convert radians to degrees.

Parameters

radians An angle in radians

Returns: The angle in degrees

See also: degreesToRadians()

◆ rotate() [1/2]

void gf::rotate	(	Matrix3f &	mat,
		float	angle
	)

Combine the current transform with a rotation.

Parameters

mat	The current transform
angle	The angle of the rotation (in radians)

◆ rotate() [2/2]

void gf::rotate	(	Matrix3f &	mat,
		float	angle,
		Vector2f	center
	)

Combine the current transform with a rotation.

Parameters

mat	The current transform
angle	The angle of the rotation (in radians)
center	The center of the rotation

◆ rotation() [1/2]

Matrix3f gf::rotation ( float angle )

inline

Get a rotation matrix.

Parameters

angle The angle of the rotation (in radians)

Returns: A rotation of angle radians

◆ rotation() [2/2]

Matrix3f gf::rotation	(	float	angle,
		Vector2f	center
	)

inline

Get a rotation matrix.

Parameters

angle	The angle of the rotation (in radians)
center	The center of the rotation

Returns: A rotation of angle radians of origin center

◆ scale() [1/2]

void gf::scale	(	Matrix3f &	mat,
		Vector2f	factor
	)

Combine the current transform with a scaling.

Parameters

mat	The current transform
factor	The scaling factor

◆ scale() [2/2]

void gf::scale	(	Matrix3f &	mat,
		Vector2f	factor,
		Vector2f	center
	)

Combine the current transform with a scaling.

Parameters

mat	The current transform
factor	The scaling factor
center	The center of the scaling

◆ scaling() [1/2]

Matrix3f gf::scaling ( Vector2f factor )

inline

Get a scaling matrix.

Parameters

factor The scaling factor

Returns: A scaling by factor

◆ scaling() [2/2]

Matrix3f gf::scaling	(	Vector2f	factor,
		Vector2f	center
	)

inline

Get a scaling matrix.

Parameters

factor	The scaling factor
center	The center of the scaling

Returns: A scaling by factor of origin center

◆ sign()

template<typename T >

constexpr int gf::sign ( T val )

Sign function.

The sign function of \( x \) is:

\( -1 \) if \( x < 0 \)
\( 0 \) if \( x = 0 \)
\( 1 \) if \( x > 0 \)

Parameters

val A value

Returns: The sign of the value

See also: Sign function

◆ simplifyPoints()

std::vector<Vector2f> gf::simplifyPoints	(	ArrayRef< Vector2f >	points,
		float	distance = `Epsilon`
	)

Simplify a sequence of points.

This function uses the Douglas–Peucker algorithm.

Parameters

points	The sequence of points
distance	The maximum authorized distance between the original points and the simplified points

Returns: A new simplified sequence of points

◆ sleep()

void gf::sleep ( Time duration )

Make the current thread sleep for a given duration.

gf::sleep is the best way to block a program or one of its threads, as it doesn't consume any CPU power.

Parameters

duration The time to sleep

◆ splitInParagraphs()

std::vector<StringRef> gf::splitInParagraphs ( StringRef str )

Split a string in multiples paragraphs.

The paragraphs are separated by '\n'.

Parameters

str	The input string

Returns: A vector of strings containing the paragraphs

◆ splitInWords()

std::vector<StringRef> gf::splitInWords ( StringRef str )

Split a string in multiples words.

The words are separated by ' ' (space) or '\t' (tabulation).

Parameters

str	The input string

Returns: A vector of strings containing the words

◆ square()

template<typename T >

constexpr T gf::square ( T val )

Square function.

For a value \( x \), the square value is \( x^2 \).

Parameters

val A value

Returns: The square of the value

◆ transform() [1/2]

constexpr Vector2f gf::transform	(	const Matrix3f &	mat,
		Vector2f	point
	)

Apply an affine transformation to a 2D point.

Parameters

mat	The transformation matrix
point	The point to transform

Returns: The transformed point

◆ transform() [2/2]

RectF gf::transform	(	const Matrix3f &	mat,
		const RectF &	rect
	)

Apply an affine transformaton to a rectangle.

The resulting rectangle is axis-aligned

Parameters

mat	The transformation matrix
rect	The rectangle to transform

Returns: The transformed rectangle

◆ translate()

void gf::translate	(	Matrix3f &	mat,
		Vector2f	offset
	)

Combine the current transform with a translation.

Parameters

mat	The current transform
offset	The offset of the translation

◆ translation()

Matrix3f gf::translation ( Vector2f offset )

inline

Get a translation matrix.

Parameters

offset The offset of the translation

Returns: A translation by offset

◆ triangulation()

std::vector<TriangleRef<const Vector2f> > gf::triangulation ( ArrayRef< Vector2f > points )

Compute a Delaunay triangulation of a set of points.

Parameters

points The set of points

Returns: A set of triangles refering to the original points

◆ unit() [1/2]

Vector2f gf::unit ( Direction direction )

Get a unit vector from a direction.

Parameters

direction The direction

Returns: A unit vector representing the direction

◆ unit() [2/2]

Vector2f gf::unit ( Orientation orientation )

Get a unit vector from an orientation.

Parameters

orientation The orientation

Returns: A unit vector representing the orientation

◆ unused()

template<typename... Args>

constexpr void gf::unused ( Args && ... )

A simple way to avoid warnings about unused variables.

Variable Documentation

◆ All

constexpr AllType gf::All = { }

Constant to represent "all".

See also: gf::AllType, gf::None

◆ Any

constexpr AnyType gf::Any = { }

Constant to represent "any".

See also: gf::AnyType, gf::All, gf::None

◆ Epsilon

constexpr float gf::Epsilon = std::numeric_limits<float>::epsilon()

Machine epsilon.

◆ InvalidId

constexpr Id gf::InvalidId = 0

The invalid id (which is 0)

◆ InvSqrt2

constexpr float gf::InvSqrt2 = 1 / Sqrt2

The \( \frac{1}{\sqrt{2}} \) constant.

◆ None

constexpr NoneType gf::None = { }

Constant to represent "none".

See also: gf::NoneType, gf::All

◆ Pi

constexpr float gf::Pi = pi<float>()

The \( \pi \) constant.

◆ Pi2

constexpr float gf::Pi2 = Pi / 2

The \( \frac{\pi}{2} \) constant.

◆ Pi3

constexpr float gf::Pi3 = Pi / 3

The \( \frac{\pi}{3} \) constant.

◆ Pi4

constexpr float gf::Pi4 = Pi / 4

The \( \frac{\pi}{4} \) constant.

◆ Pi6

constexpr float gf::Pi6 = Pi / 6

The \( \frac{\pi}{6} \) constant.

◆ Sqrt2

constexpr float gf::Sqrt2 = 1.41421356237309504880f

The \( \sqrt{2} \) constant.

◆ Sqrt3

constexpr float gf::Sqrt3 = 1.7320508075688772935f

The \( \sqrt{3} \) constant.

◆ Zero

constexpr ZeroType gf::Zero = { }

Constant to represent "zero".

See also: gf::ZeroType

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ CircD

◆ CircF

◆ CircI

◆ CircU

◆ CircZ

◆ Color3

◆ Color3d

◆ Color3f

◆ Color3u

◆ Color4

◆ Color4d

◆ Color4f

◆ Color4u

◆ Distance

◆ Distance2

◆ Distance3

◆ Easing

◆ Id

◆ Matrix2d

◆ Matrix2f

◆ Matrix3d

◆ Matrix3f

◆ Matrix4d

◆ Matrix4f

◆ Path

◆ RangeF

◆ RangeI

◆ RangeU

◆ RangeZ

◆ RectD

◆ RectF

◆ RectI

◆ RectU

◆ RectZ

◆ SpatialQueryCallback

◆ Step

◆ Vector2b

◆ Vector2d

◆ Vector2f

◆ Vector2i

◆ Vector2u

◆ Vector2z

◆ Vector3b

◆ Vector3d

◆ Vector3f

◆ Vector3i

◆ Vector3u

◆ Vector3z

◆ Vector4b

◆ Vector4d

◆ Vector4f

◆ Vector4i

◆ Vector4u

◆ Vector4z

Enumeration Type Documentation

◆ AngularMove

◆ Direction

◆ LinearMove

◆ Orientation

◆ PixelFormat

◆ Quarter

◆ SpatialId

◆ SpatialQuery

◆ SpatialStructureType

◆ Winding

Function Documentation

◆ absdiff()

◆ almostEquals()

◆ angle() [1/2]

◆ angle() [2/2]

◆ angularFactor()

◆ array()

◆ buffer()