Classes | Typedefs | Enumerations | Enumerator | Functions | Variables
clanCore Math

## Classes
struct | clan::RectPacker::AllocatedRect
class | clan::Angle
| Angle class. More...
class | clan::AxisAlignedBoundingBox
class | clan::Base64Decoder
| Base64 decoder class. More...
class | clan::Base64Encoder
| Base64 encoder class. More...
class | clan::BezierCurve
| Bezier curve generator. More...
class | clan::BigInt
| Big Integer class. More...
class | clan::Circle
| Circle - Integer. More...
class | clan::Circled
| Circle - Double. More...
class | clan::Circlef
| Circle - Float. More...
class | clan::Circlex< Type >
| Circle. More...
class | clan::DelauneyTriangulator
| Delauney triangulator. More...
class | clan::DelauneyTriangulator_Triangle
| Triangle generated from a delauney triangulation. More...
class | clan::DelauneyTriangulator_Vertex
| Vertex in the delauney triangulation. More...
class | clan::EarClipResult
| Ear clipping triangulation result structure. More...
class | clan::EarClipTriangulator
| Ear-clipping triangulator. More...
class | clan::EarClipTriangulator_Triangle
| EarClipTriangulator_Triangle. More...
class | clan::HalfFloat
class | clan::IntersectionTest
class | clan::Line2
| 2D line - Integer More...
class | clan::Line2d
| 2D line - Double More...
class | clan::Line2f
| 2D line - Float More...
class | clan::Line2x< Type >
| 2D line More...
class | clan::Line3
| 3D line - Integer More...
class | clan::Line3d
| 3D line - Double More...
class | clan::Line3f
| 3D line - Float More...
class | clan::Line3x< Type >
| 3D line More...
class | clan::LineMath
| Math operations on 2D lines. More...
class | clan::LineRay2
| 2D line ray - Integer More...
class | clan::LineRay2d
| 2D line ray - Double More...
class | clan::LineRay2f
| 2D line ray - Float More...
class | clan::LineRay2x< Type >
| 2D line ray More...
class | clan::LineRay3
| 3D line ray - Integer More...
class | clan::LineRay3d
| 3D line ray - Double More...
class | clan::LineRay3f
| 3D line ray - Float More...
class | clan::LineRay3x< Type >
| 3D line ray More...
class | clan::LineSegment2
| 2D line segment - Integer More...
class | clan::LineSegment2d
| 2D line segment - Double More...
class | clan::LineSegment2f
| 2D line segment - Float More...
class | clan::LineSegment2x< Type >
| 2D line segment More...
class | clan::LineSegment3
| 3D line segment - Integer More...
class | clan::LineSegment3d
| 3D line segment - Double More...
class | clan::LineSegment3f
| 3D line segment - Float More...
class | clan::LineSegment3x< Type >
| 3D line segment More...
class | clan::Mat2< Type >
| 2D matrix More...
class | clan::Mat3< Type >
| 3D matrix More...
class | clan::Mat4< Type >
| 4D matrix More...
class | clan::OrientedBoundingBox
class | clan::OutlineTriangulator
| Polygon Tesselator. More...
class | clan::Point
| 2D (x,y) point structure - Integer More...
class | clan::Pointd
| 2D (x,y) point structure - Double More...
class | clan::Pointf
| 2D (x,y) point structure - Float More...
class | clan::PointSetMath
| Math operations related to point sets. More...
class | clan::Pointx< Type >
| 2D (x,y) point structure. More...
class | clan::Quad
| 2D quad structure - Integer More...
class | clan::Quadd
| 2D quad structure - Double More...
class | clan::Quadf
| 2D quad structure - Float More...
class | clan::Quadx< Type >
| 2D quad structure. More...
class | clan::Quaterniond
| Quaternion - Double. More...
class | clan::Quaternionf
| Quaternion - Float. More...
class | clan::Quaternionx< Type >
| Quaternion. More...
class | clan::Rect
| 2D (left,top,right,bottom) rectangle structure - Integer More...
class | clan::Rectd
| 2D (left,top,right,bottom) rectangle structure - Double More...
class | clan::Rectf
| 2D (left,top,right,bottom) rectangle structure - Float More...
class | clan::RectPacker
| Generic rect packer class. Implements an algorithm to pack rects into groups efficiently. More...
class | clan::Rectx< Type >
| 2D (left,top,right,bottom) rectangle structure. More...
class | clan::Size
| 2D (width,height) size structure - Integer More...
class | clan::Sized
| 2D (width,height) size structure - Double More...
class | clan::Sizef
| 2D (width,height) size structure - Float More...
class | clan::Sizex< Type >
| 2D (width,height) size structure. More...
class | clan::Triangle
| Triangles - Integer. More...
class | clan::Triangled
| Triangles - Double. More...
class | clan::Trianglef
| Triangles - Float. More...
class | clan::Trianglex< Type >
| Triangles. More...
class | clan::Vec2< Type >
| 2D vector More...
class | clan::Vec2hf
| 2D half-float vector More...
class | clan::Vec3< Type >
| 3D vector More...
class | clan::Vec3hf
| 3D half-float vector More...
class | clan::Vec4< Type >
| 4D vector More...
class | clan::Vec4hf
| 4D half-float vector More...

## Typedefs
typedef Type | clan::Vec2< Type >::datatype
typedef Type | clan::Vec3< Type >::datatype
typedef Type | clan::Vec4< Type >::datatype
typedef Mat2< double > | clan::Mat2d
typedef Mat2< float > | clan::Mat2f
typedef Mat2< int > | clan::Mat2i
typedef Mat3< double > | clan::Mat3d
typedef Mat3< float > | clan::Mat3f
typedef Mat3< int > | clan::Mat3i
typedef Mat4< double > | clan::Mat4d
typedef Mat4< float > | clan::Mat4f
typedef Mat4< int > | clan::Mat4i
typedef Vec2< char > | clan::Vec2b
typedef Vec2< double > | clan::Vec2d
typedef Vec2< float > | clan::Vec2f
typedef Vec2< int > | clan::Vec2i
typedef Vec2< short > | clan::Vec2s
typedef Vec2< unsigned char > | clan::Vec2ub
typedef Vec2< unsigned int > | clan::Vec2ui
typedef Vec2< unsigned short > | clan::Vec2us
typedef Vec3< char > | clan::Vec3b
typedef Vec3< double > | clan::Vec3d
typedef Vec3< float > | clan::Vec3f
typedef Vec3< int > | clan::Vec3i
typedef Vec3< short > | clan::Vec3s
typedef Vec3< unsigned char > | clan::Vec3ub
typedef Vec3< unsigned int > | clan::Vec3ui
typedef Vec3< unsigned short > | clan::Vec3us
typedef Vec4< char > | clan::Vec4b
typedef Vec4< double > | clan::Vec4d
typedef Vec4< float > | clan::Vec4f
typedef Vec4< int > | clan::Vec4i
typedef Vec4< short > | clan::Vec4s
typedef Vec4< unsigned char > | clan::Vec4ub
typedef Vec4< unsigned int > | clan::Vec4ui
typedef Vec4< unsigned short > | clan::Vec4us

## Enumerations
enum | clan::AngleUnit { clan::angle_degrees, clan::angle_radians }
| Angle unit. More...
enum | clan::ClipZRange { clan::clip_negative_positive_w, clan::clip_zero_positive_w }
enum | clan::EulerOrder { clan::order_XYZ, clan::order_XZY, clan::order_YZX, clan::order_YXZ, clan::order_ZXY, clan::order_ZYX }
| Euler angle rotation order. More...
enum | clan::Handedness { clan::handed_left, clan::handed_right }
enum | clan::Origin { clan::origin_top_left, clan::origin_top_center, clan::origin_top_right, clan::origin_center_left, clan::origin_center, clan::origin_center_right, clan::origin_bottom_left, clan::origin_bottom_center, clan::origin_bottom_right }
| Alignment origins. More...
enum | clan::IntersectionTest::OverlapResult { clan::IntersectionTest::disjoint, clan::IntersectionTest::overlap }
enum | clan::PolygonOrientation { clan::cl_clockwise, clan::cl_counter_clockwise }
| Polygon orientations. More...
enum | clan::IntersectionTest::Result { clan::IntersectionTest::outside, clan::IntersectionTest::inside, clan::IntersectionTest::intersecting }

## Functions
| clan::RectPacker::AllocatedRect::AllocatedRect (int group_index, Rect rect)
| clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox ()
| clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox (const Vec3f &aabb_min, const Vec3f &aabb_max)
| clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox (const AxisAlignedBoundingBox &aabb, const Vec3f &barycentric_min, const Vec3f &barycentric_max)
| clan::Circle::Circle (int x, int y, int radius)
| clan::Circle::Circle (const Vec2< int > &p, int radius)
| clan::Circle::Circle ()
| clan::Circle::Circle (const Circlex< int > &copy)
| clan::Circled::Circled (double x, double y, double radius)
| clan::Circled::Circled (const Vec2< double > &p, double radius)
| clan::Circled::Circled ()
| clan::Circled::Circled (const Circlex< double > &copy)
| clan::Circlef::Circlef (float x, float y, float radius)
| clan::Circlef::Circlef (const Vec2< float > &p, float radius)
| clan::Circlef::Circlef ()
| clan::Circlef::Circlef (const Circlex< float > &copy)
| clan::Circlex< Type >::Circlex (Type x, Type y, Type radius)
| clan::Circlex< Type >::Circlex (const Vec2< Type > &p, Type radius)
| clan::Circlex< Type >::Circlex ()
| clan::Circlex< Type >::Circlex (const Circlex< Type > &copy)
| clan::HalfFloat::HalfFloat ()
| clan::HalfFloat::HalfFloat (const HalfFloat &other)
| clan::HalfFloat::HalfFloat (float v)
| clan::Line2::Line2 ()
| clan::Line2::Line2 (const Line2x< int > &copy)
| clan::Line2::Line2 (const Vec2< int > &point_p, const Vec2< int > &point_q)
| clan::Line2::Line2 (const Vec2< int > &point_p, int gradient)
| clan::Line2d::Line2d ()
| clan::Line2d::Line2d (const Line2x< double > &copy)
| clan::Line2d::Line2d (const Vec2< double > &point_p, const Vec2< double > &point_q)
| clan::Line2d::Line2d (const Vec2< double > &point_p, double gradient)
| clan::Line2f::Line2f ()
| clan::Line2f::Line2f (const Line2x< float > &copy)
| clan::Line2f::Line2f (const Vec2< float > &point_p, const Vec2< float > &point_q)
| clan::Line2f::Line2f (const Vec2< float > &point_p, float gradient)
| clan::Line2x< Type >::Line2x ()
| clan::Line2x< Type >::Line2x (const Line2x< Type > &copy)
| clan::Line2x< Type >::Line2x (const Vec2< Type > &point_p, const Vec2< Type > &point_q)
| clan::Line2x< Type >::Line2x (const Vec2< Type > &point_p, Type gradient)
| clan::Line3::Line3 ()
| clan::Line3::Line3 (const Line3x< int > &copy)
| clan::Line3::Line3 (const Vec3< int > &point_p, const Vec3< int > &point_q)
| clan::Line3d::Line3d ()
| clan::Line3d::Line3d (const Line3x< double > &copy)
| clan::Line3d::Line3d (const Vec3< double > &podouble_p, const Vec3< double > &podouble_q)
| clan::Line3f::Line3f ()
| clan::Line3f::Line3f (const Line3x< float > &copy)
| clan::Line3f::Line3f (const Vec3< float > &point_p, const Vec3< float > &point_q)
| clan::Line3x< Type >::Line3x ()
| clan::Line3x< Type >::Line3x (const Line3x< Type > &copy)
| clan::Line3x< Type >::Line3x (const Vec3< Type > &point_p, const Vec3< Type > &point_q)
| clan::LineRay2::LineRay2 ()
| clan::LineRay2::LineRay2 (const LineRay2x< int > &copy)
| clan::LineRay2::LineRay2 (const Vec2< int > &point_p, const Vec2< int > &direction_v)
| clan::LineRay2d::LineRay2d ()
| clan::LineRay2d::LineRay2d (const LineRay2x< double > &copy)
| clan::LineRay2d::LineRay2d (const Vec2< double > &point_p, const Vec2< double > &direction_v)
| clan::LineRay2f::LineRay2f ()
| clan::LineRay2f::LineRay2f (const LineRay2x< float > &copy)
| clan::LineRay2f::LineRay2f (const Vec2< float > &point_p, const Vec2< float > &direction_v)
| clan::LineRay2x< Type >::LineRay2x ()
| clan::LineRay2x< Type >::LineRay2x (const LineRay2x< Type > &copy)
| clan::LineRay2x< Type >::LineRay2x (const Vec2< Type > &point_p, const Vec2< Type > &direction_v)
| clan::LineRay3::LineRay3 ()
| clan::LineRay3::LineRay3 (const LineRay3x< int > &copy)
| clan::LineRay3::LineRay3 (const Vec3< int > &point_p, const Vec3< int > &direction_v)
| clan::LineRay3d::LineRay3d ()
| clan::LineRay3d::LineRay3d (const LineRay3x< double > &copy)
| clan::LineRay3d::LineRay3d (const Vec3< double > &point_p, const Vec3< double > &direction_v)
| clan::LineRay3f::LineRay3f ()
| clan::LineRay3f::LineRay3f (const LineRay3x< float > &copy)
| clan::LineRay3f::LineRay3f (const Vec3< float > &point_p, const Vec3< float > &direction_v)
| clan::LineRay3x< Type >::LineRay3x ()
| clan::LineRay3x< Type >::LineRay3x (const LineRay3x< Type > &copy)
| clan::LineRay3x< Type >::LineRay3x (const Vec3< Type > &point_p, const Vec3< Type > &direction_v)
| clan::LineSegment2::LineSegment2 ()
| clan::LineSegment2::LineSegment2 (const LineSegment2x< int > &copy)
| clan::LineSegment2::LineSegment2 (const Vec2< int > &point_p, const Vec2< int > &point_q)
| clan::LineSegment2d::LineSegment2d ()
| clan::LineSegment2d::LineSegment2d (const LineSegment2x< double > &copy)
| clan::LineSegment2d::LineSegment2d (const Vec2< double > &point_p, const Vec2< double > &point_q)
| clan::LineSegment2f::LineSegment2f ()
| clan::LineSegment2f::LineSegment2f (const LineSegment2x< float > &copy)
| clan::LineSegment2f::LineSegment2f (const Vec2< float > &point_p, const Vec2< float > &point_q)
| clan::LineSegment2x< Type >::LineSegment2x ()
| clan::LineSegment2x< Type >::LineSegment2x (const LineSegment2x< Type > &copy)
| clan::LineSegment2x< Type >::LineSegment2x (const Vec2< Type > &point_p, const Vec2< Type > &point_q)
| clan::LineSegment3::LineSegment3 ()
| clan::LineSegment3::LineSegment3 (const LineSegment3x< int > &copy)
| clan::LineSegment3::LineSegment3 (const Vec3< int > &point_p, const Vec3< int > &point_q)
| clan::LineSegment3d::LineSegment3d ()
| clan::LineSegment3d::LineSegment3d (const LineSegment3x< double > &copy)
| clan::LineSegment3d::LineSegment3d (const Vec3< double > &point_p, const Vec3< double > &point_q)
| clan::LineSegment3f::LineSegment3f ()
| clan::LineSegment3f::LineSegment3f (const LineSegment3x< float > &copy)
| clan::LineSegment3f::LineSegment3f (const Vec3< float > &point_p, const Vec3< float > &point_q)
| clan::LineSegment3x< Type >::LineSegment3x ()
| clan::LineSegment3x< Type >::LineSegment3x (const LineSegment3x< Type > &copy)
| clan::LineSegment3x< Type >::LineSegment3x (const Vec3< Type > &point_p, const Vec3< Type > &point_q)
| clan::Point::Point ()
| clan::Point::Point (int x, int y)
| clan::Point::Point (const Pointx< int > &p)
| clan::Point::Point (const Vec2< int > &p)
| clan::Pointd::Pointd ()
| clan::Pointd::Pointd (double x, double y)
| clan::Pointd::Pointd (const Pointx< double > &p)
| clan::Pointd::Pointd (const Vec2< double > &p)
| clan::Pointf::Pointf ()
| clan::Pointf::Pointf (float x, float y)
| clan::Pointf::Pointf (const Pointx< float > &p)
| clan::Pointf::Pointf (const Vec2< float > &p)
| clan::Pointx< Type >::Pointx ()
| clan::Pointx< Type >::Pointx (Type x, Type y)
| clan::Pointx< Type >::Pointx (const Pointx< Type > &p)
| clan::Pointx< Type >::Pointx (const Vec2< Type > &p)
| clan::Quad::Quad ()
| clan::Quad::Quad (const Vec2< int > &new_p, const Vec2< int > &new_q, const Vec2< int > &new_r, const Vec2< int > &new_s)
| clan::Quad::Quad (const Rect &rect)
| clan::Quad::Quad (const Quadx< int > &quad)
| clan::Quadd::Quadd ()
| clan::Quadd::Quadd (const Vec2< double > &new_p, const Vec2< double > &new_q, const Vec2< double > &new_r, const Vec2< double > &new_s)
| clan::Quadd::Quadd (const Rectd &rect)
| clan::Quadd::Quadd (const Quadx< double > &quad)
| clan::Quadf::Quadf ()
| clan::Quadf::Quadf (const Vec2< float > &new_p, const Vec2< float > &new_q, const Vec2< float > &new_r, const Vec2< float > &new_s)
| clan::Quadf::Quadf (const Rectf &rect)
| clan::Quadf::Quadf (const Quadx< float > &quad)
| clan::Quaterniond::Quaterniond ()
| clan::Quaterniond::Quaterniond (const Quaternionx< double > &copy)
| clan::Quaterniond::Quaterniond (const Mat4< double > &rotation_matrix)
| clan::Quaterniond::Quaterniond (double real, double i, double j, double k)
| clan::Quaterniond::Quaterniond (double real, const Vec3< double > &imag)
| clan::Quaterniond::Quaterniond (double euler_x, double euler_y, double euler_z, AngleUnit unit, EulerOrder order)
| clan::Quaterniond::Quaterniond (const Vec3< double > &euler, AngleUnit unit, EulerOrder order)
| clan::Quaterniond::Quaterniond (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
| clan::Quaternionf::Quaternionf ()
| clan::Quaternionf::Quaternionf (const Quaternionx< float > &copy)
| clan::Quaternionf::Quaternionf (const Mat4< float > &rotation_matrix)
| clan::Quaternionf::Quaternionf (float real, float i, float j, float k)
| clan::Quaternionf::Quaternionf (float real, const Vec3< float > &imag)
| clan::Quaternionf::Quaternionf (float euler_x, float euler_y, float euler_z, AngleUnit unit, EulerOrder order)
| clan::Quaternionf::Quaternionf (const Vec3< float > &euler, AngleUnit unit, EulerOrder order)
| clan::Quaternionf::Quaternionf (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
| clan::Quaternionx< Type >::Quaternionx ()
| clan::Quaternionx< Type >::Quaternionx (Type real, Type i, Type j, Type k)
| clan::Quaternionx< Type >::Quaternionx (Type real, const Vec3< Type > &imag)
| clan::Quaternionx< Type >::Quaternionx (const Quaternionx< Type > &copy)
| clan::Quaternionx< Type >::Quaternionx (Type euler_x, Type euler_y, Type euler_z, AngleUnit unit, EulerOrder order)
| clan::Quaternionx< Type >::Quaternionx (const Vec3< Type > &euler, AngleUnit unit, EulerOrder order)
| clan::Quaternionx< Type >::Quaternionx (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
| clan::Quaternionx< Type >::Quaternionx (const Mat4< Type > &rotation_matrix)
| clan::Rect::Rect ()
| clan::Rect::Rect (const Sizex< int > &s)
| clan::Rect::Rect (int new_left, int new_top, int new_right, int new_bottom)
| clan::Rect::Rect (const Pointx< int > &p, const Sizex< int > &size)
| clan::Rect::Rect (const Rectx< int > &rect)
| clan::Rect::Rect (const Rectx< float > &rect)
| clan::Rect::Rect (const Rectx< double > &rect)
| clan::Rect::Rect (int new_left, int new_top, const Sizex< int > &size)
| clan::Rectd::Rectd ()
| clan::Rectd::Rectd (const Sizex< int > &s)
| clan::Rectd::Rectd (const Sizex< float > &s)
| clan::Rectd::Rectd (const Sizex< double > &s)
| clan::Rectd::Rectd (double new_left, double new_top, double new_right, double new_bottom)
| clan::Rectd::Rectd (const Pointx< double > &p, const Sizex< double > &size)
| clan::Rectd::Rectd (const Rectx< int > &rect)
| clan::Rectd::Rectd (const Rectx< float > &rect)
| clan::Rectd::Rectd (const Rectx< double > &rect)
| clan::Rectd::Rectd (double new_left, double new_top, const Sizex< double > &size)
| clan::Rectf::Rectf ()
| clan::Rectf::Rectf (const Sizex< int > &s)
| clan::Rectf::Rectf (const Sizex< float > &s)
| clan::Rectf::Rectf (float new_left, float new_top, float new_right, float new_bottom)
| clan::Rectf::Rectf (const Pointx< float > &p, const Sizex< float > &size)
| clan::Rectf::Rectf (const Rectx< int > &rect)
| clan::Rectf::Rectf (const Rectx< float > &rect)
| clan::Rectf::Rectf (const Rectx< double > &rect)
| clan::Rectf::Rectf (float new_left, float new_top, const Sizex< float > &size)
| clan::Size::Size ()
| clan::Size::Size (int width, int height)
| clan::Size::Size (const Sizex< int > &s)
| clan::Size::Size (const Vec2< int > &s)
| clan::Size::Size (const Sizex< float > &copy)
| clan::Size::Size (const Sizex< double > &copy)
| clan::Sized::Sized ()
| clan::Sized::Sized (double width, double height)
| clan::Sized::Sized (const Sizex< double > &s)
| clan::Sized::Sized (const Vec2< double > &s)
| clan::Sized::Sized (const Sizex< int > &copy)
| clan::Sized::Sized (const Sizex< float > &copy)
| clan::Sizef::Sizef ()
| clan::Sizef::Sizef (float width, float height)
| clan::Sizef::Sizef (const Sizex< float > &s)
| clan::Sizef::Sizef (const Vec2< float > &s)
| clan::Sizef::Sizef (const Sizex< int > &copy)
| clan::Sizef::Sizef (const Sizex< double > &copy)
| clan::Triangle::Triangle ()
| clan::Triangle::Triangle (const Trianglex< int > &copy)
| clan::Triangle::Triangle (const Vec2< int > &point_p, const Vec2< int > &point_q, const Vec2< int > &point_r)
| clan::Triangled::Triangled ()
| clan::Triangled::Triangled (const Trianglex< double > &copy)
| clan::Triangled::Triangled (const Vec2< double > &point_p, const Vec2< double > &point_q, const Vec2< double > &point_r)
| clan::Trianglef::Trianglef ()
| clan::Trianglef::Trianglef (const Trianglex< float > &copy)
| clan::Trianglef::Trianglef (const Vec2< float > &point_p, const Vec2< float > &point_q, const Vec2< float > &point_r)
| clan::Trianglex< Type >::Trianglex ()
| clan::Trianglex< Type >::Trianglex (const Trianglex< Type > &copy)
| clan::Trianglex< Type >::Trianglex (const Vec2< Type > &point_p, const Vec2< Type > &point_q, const Vec2< Type > &point_r)
| clan::Vec2< Type >::Vec2 ()
| clan::Vec2< Type >::Vec2 (const Type &scalar)
| clan::Vec2< Type >::Vec2 (const Vec3< Type > &copy)
| clan::Vec2< Type >::Vec2 (const Vec4< Type > &copy)
| clan::Vec2< Type >::Vec2 (const Type &p1, const Type &p2)
| clan::Vec2< Type >::Vec2 (const Type *array_xy)
| clan::Vec2< Type >::Vec2 (const Vec2< double > &copy)
| clan::Vec2< Type >::Vec2 (const Vec2< float > &copy)
| clan::Vec2< Type >::Vec2 (const Vec2< int > &copy)
| clan::Vec2hf::Vec2hf ()
| clan::Vec2hf::Vec2hf (const HalfFloat &scalar)
| clan::Vec2hf::Vec2hf (const Vec3hf &copy)
| clan::Vec2hf::Vec2hf (const Vec4hf &copy)
| clan::Vec2hf::Vec2hf (const HalfFloat &p1, const HalfFloat &p2)
| clan::Vec2hf::Vec2hf (const HalfFloat *array_xy)
| clan::Vec2hf::Vec2hf (float scalar)
| clan::Vec2hf::Vec2hf (const Vec3f &copy)
| clan::Vec2hf::Vec2hf (const Vec4f &copy)
| clan::Vec2hf::Vec2hf (float p1, float p2)
| clan::Vec2hf::Vec2hf (float *array_xy)
| clan::Vec2hf::Vec2hf (const Pointx< int > &point)
| clan::Vec2hf::Vec2hf (const Pointx< float > &point)
| clan::Vec2hf::Vec2hf (const Pointx< double > &point)
| clan::Vec2hf::Vec2hf (const Vec2hf &copy)
| clan::Vec2hf::Vec2hf (const Vec2d &copy)
| clan::Vec2hf::Vec2hf (const Vec2f &copy)
| clan::Vec2hf::Vec2hf (const Vec2i &copy)
| clan::Vec3< Type >::Vec3 ()
| clan::Vec3< Type >::Vec3 (const Type &scalar)
| clan::Vec3< Type >::Vec3 (const Vec2< Type > &copy, const Type &p3)
| clan::Vec3< Type >::Vec3 (const Vec4< Type > &copy)
| clan::Vec3< Type >::Vec3 (const Vec3< double > &copy)
| clan::Vec3< Type >::Vec3 (const Vec3< float > &copy)
| clan::Vec3< Type >::Vec3 (const Vec3< int > &copy)
| clan::Vec3< Type >::Vec3 (const Type &p1, const Type &p2, const Type &p3)
| clan::Vec3< Type >::Vec3 (const Type *array_xyz)
| clan::Vec3hf::Vec3hf ()
| clan::Vec3hf::Vec3hf (const HalfFloat &scalar)
| clan::Vec3hf::Vec3hf (const Vec2hf &copy, const HalfFloat &p3)
| clan::Vec3hf::Vec3hf (const Vec4hf &copy)
| clan::Vec3hf::Vec3hf (const HalfFloat &p1, const HalfFloat &p2, const HalfFloat &p3)
| clan::Vec3hf::Vec3hf (const HalfFloat *array_xyz)
| clan::Vec3hf::Vec3hf (float scalar)
| clan::Vec3hf::Vec3hf (const Vec2f &copy, float p3)
| clan::Vec3hf::Vec3hf (const Vec4f &copy)
| clan::Vec3hf::Vec3hf (float p1, float p2, float p3)
| clan::Vec3hf::Vec3hf (const float *array_xyz)
| clan::Vec3hf::Vec3hf (const Vec3hf &copy)
| clan::Vec3hf::Vec3hf (const Vec3d &copy)
| clan::Vec3hf::Vec3hf (const Vec3f &copy)
| clan::Vec3hf::Vec3hf (const Vec3i &copy)
| clan::Vec4< Type >::Vec4 ()
| clan::Vec4< Type >::Vec4 (const Type &scalar)
| clan::Vec4< Type >::Vec4 (const Vec2< Type > &copy, const Type &p3, const Type &p4)
| clan::Vec4< Type >::Vec4 (const Vec2< Type > &copy, const Vec2< Type > &copy34)
| clan::Vec4< Type >::Vec4 (const Vec3< Type > &copy, const Type &p4)
| clan::Vec4< Type >::Vec4 (const Type &p1, const Type &p2, const Type &p3, const Type &p4)
| clan::Vec4< Type >::Vec4 (const Type &p1, const Type &p2, const Vec2< Type > &copy34)
| clan::Vec4< Type >::Vec4 (const Type *array_xyzw)
| clan::Vec4hf::Vec4hf ()
| clan::Vec4hf::Vec4hf (const Vec4f &copy)
| clan::Vec4hf::Vec4hf (const HalfFloat &scalar)
| clan::Vec4hf::Vec4hf (const Vec2hf &copy, const HalfFloat &p3, const HalfFloat &p4)
| clan::Vec4hf::Vec4hf (const Vec2hf &copy, const Vec2hf &copy34)
| clan::Vec4hf::Vec4hf (const Vec3hf &copy, const HalfFloat &p4)
| clan::Vec4hf::Vec4hf (const HalfFloat &p1, const HalfFloat &p2, const HalfFloat &p3, const HalfFloat &p4)
| clan::Vec4hf::Vec4hf (const HalfFloat &p1, const HalfFloat &p2, const Vec2hf &copy34)
| clan::Vec4hf::Vec4hf (const HalfFloat *array_xyzw)
| clan::Vec4hf::Vec4hf (float scalar)
| clan::Vec4hf::Vec4hf (const Vec2f &copy, float p3, float p4)
| clan::Vec4hf::Vec4hf (const Vec2f &copy, const Vec2f &copy34)
| clan::Vec4hf::Vec4hf (const Vec3f &copy, float p4)
| clan::Vec4hf::Vec4hf (float p1, float p2, float p3, float p4)
| clan::Vec4hf::Vec4hf (float p1, float p2, const Vec2f &copy34)
| clan::Vec4hf::Vec4hf (const float *array_xyzw)
static OverlapResult | clan::IntersectionTest::aabb (const AxisAlignedBoundingBox &a, const AxisAlignedBoundingBox &b)
static Quaternionx< Type > | clan::Quaternionx< Type >::axis_angle (const Angle &angle, const Vec3f &axis)
static Pointx< Type > | clan::Vec2< Type >::calc_origin (Origin origin, const Sizex< Type > &size)
| Returns the anchor point for the origin within the dimensions of the size structure. More...
Vec3f | clan::AxisAlignedBoundingBox::center () const
template<typename A , typename B , typename C >
C | clan::clamp (A val, B minval, C maxval)
static Pointf | clan::LineMath::closest_point (const Pointf &P, const Pointf &A, const Pointf &B)
| Return the Point on the line from A to B closest to point P. More...
static float | clan::LineMath::closest_point_relative (const Pointf &P, const Pointf &A, const Pointf &B)
| Return the relative position (0-1) of the point R on the line from A to B closest to point P. More...
static Vec3< Type > | clan::Vec3< Type >::cross (const Vec3< Type > &vector1, const Vec3< Type > &vector2)
| Calculate the cross product between two vectors. More...
static Vec4< Type > | clan::Vec4< Type >::cross3 (const Vec4< Type > &vector1, const Vec4< Type > &vector2)
| Calculate the cross product between two vectors (not taking into account the w ordinate). More...
static Type | clan::Vec3< Type >::dot (const Vec3< Type > &vector1, const Vec3< Type > &vector2)
| Dot products between two vectors. More...
static Type | clan::Vec2< Type >::dot (const Vec2< Type > &vector_1, const Vec2< Type > &vector_2)
| Dot products a vector with an other vector. More...
static Type | clan::Vec4< Type >::dot3 (const Vec4< Type > &vector1, const Vec4< Type > &vector2)
| Dot products between two vectors (not taking into account the w ordinate). More...
static Type | clan::Vec4< Type >::dot4 (const Vec4< Type > &vector1, const Vec4< Type > &vector2)
| Dot products between two vectors (taking into account the w ordinate). More...
Vec3f | clan::AxisAlignedBoundingBox::extents () const
static unsigned short | clan::HalfFloat::float_to_half (float float_value)
static unsigned short | clan::HalfFloat::float_to_half_simple (float float_value)
| Only works for 'normal' half-float values. More...
HalfFloat & | clan::HalfFloat::from_float (float v)
static Result | clan::IntersectionTest::frustum_aabb (const FrustumPlanes &frustum, const AxisAlignedBoundingBox &box)
static Result | clan::IntersectionTest::frustum_obb (const FrustumPlanes &frustum, const OrientedBoundingBox &box)
static float | clan::HalfFloat::half_to_float (unsigned short hf)
static float | clan::HalfFloat::half_to_float_simple (unsigned short hf)
| Only works for 'normal' half-float values. More...
static bool | clan::Vec2< Type >::is_equal (const Vec2< Type > &first, const Vec2< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...
static bool | clan::Vec3< Type >::is_equal (const Vec3< Type > &first, const Vec3< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...
static bool | clan::Vec4< Type >::is_equal (const Vec4< Type > &first, const Vec4< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...
static Quaternionx< Type > | clan::Quaternionx< Type >::lerp (const Quaternionx< Type > &quaternion_initial, const Quaternionx< Type > &quaternion_final, Type lerp_time)
| Linear Quaternion Interpolation. More...
template<typename T , typename... Args>
std::unique_ptr< T > | clan::make_unique (Args &&...args)
template<typename A , typename B >
A | clan::max (A a, B b)
template<typename Type >
Vec2< Type > | clan::max (Vec2< Type > a, Vec2< Type > b)
template<typename Type >
Vec3< Type > | clan::max (Vec3< Type > a, Vec3< Type > b)
template<typename Type >
Vec4< Type > | clan::max (Vec4< Type > a, Vec4< Type > b)
static Pointf | clan::LineMath::midpoint (const Pointf &A, const Pointf &B)
| Return the midpoint of the line from point A to point B. More...
template<typename A , typename B >
A | clan::min (A a, B b)
template<typename Type >
Vec2< Type > | clan::min (Vec2< Type > a, Vec2< Type > b)
template<typename Type >
Vec3< Type > | clan::min (Vec3< Type > a, Vec3< Type > b)
template<typename Type >
Vec4< Type > | clan::min (Vec4< Type > a, Vec4< Type > b)
template<typename A , typename B , typename C >
A | clan::mix (A a, B b, C mix)
static Quaternionx< Type > | clan::Quaternionx< Type >::multiply (const Quaternionx< Type > &quaternion_1, const Quaternionx< Type > &quaternion_2)
static Vec2< Type > | clan::Vec2< Type >::normalize (const Vec2< Type > &vector)
| Normalizes a vector. More...
static Vec3< Type > | clan::Vec3< Type >::normalize (const Vec3< Type > &vector)
| Normalizes a vector. More...
static Vec4< Type > | clan::Vec4< Type >::normalize3 (const Vec4< Type > &vector)
| Normalizes a vector (not taking into account the w ordinate) More...
static Vec4< Type > | clan::Vec4< Type >::normalize4 (const Vec4< Type > &vector)
| Normalizes a vector (taking into account the w ordinate) More...
| clan::HalfFloat::operator float () const
| clan::Vec2hf::operator Vec2f () const
| clan::Vec3hf::operator Vec3f () const
| clan::Vec4hf::operator Vec4f () const
template<typename Type >
Vec3< Type > | clan::operator* (const Vec3< Type > &v1, const Vec3< Type > &v2)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator* (Type s, const Vec3< Type > &v)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator* (const Vec3< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator* (const Vec2< Type > &v1, const Vec2< Type > &v2)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator* (Type s, const Vec2< Type > &v)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator* (const Vec2< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator* (const Vec3< Type > &v, const Mat3< Type > &matrix)
template<typename Type >
Vec2< Type > | clan::operator* (const Vec2< Type > &v, const Mat2< Type > &matrix)
template<typename Type >
Vec3< Type > | clan::operator* (const Mat3< Type > &matrix, const Vec3< Type > &v)
template<typename Type >
Vec2< Type > | clan::operator* (const Mat2< Type > &matrix, const Vec2< Type > &v)
template<typename Type >
Vec4< Type > | clan::operator* (const Vec4< Type > &v1, const Vec4< Type > &v2)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator* (Type s, const Vec4< Type > &v)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator* (const Vec4< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator* (const Vec4< Type > &v, const Mat4< Type > &matrix)
template<typename Type >
Vec4< Type > | clan::operator* (const Mat4< Type > &matrix, const Vec4< Type > &v)
template<typename Type >
Vec3< Type > | clan::operator+ (const Vec3< Type > &v1, const Vec3< Type > &v2)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator+ (Type s, const Vec3< Type > &v)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator+ (const Vec3< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator+ (const Vec2< Type > &v1, const Vec2< Type > &v2)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator+ (Type s, const Vec2< Type > &v)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator+ (const Vec2< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator+ (const Vec4< Type > &v1, const Vec4< Type > &v2)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator+ (Type s, const Vec4< Type > &v)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator+ (const Vec4< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator- (const Vec3< Type > &v1, const Vec3< Type > &v2)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator- (Type s, const Vec3< Type > &v)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator- (const Vec3< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator- (const Vec2< Type > &v1, const Vec2< Type > &v2)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator- (Type s, const Vec2< Type > &v)
| operator. More...
template<typename Type >
Vec2< Type > | clan::operator- (const Vec2< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator- (const Vec4< Type > &v1, const Vec4< Type > &v2)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator- (Type s, const Vec4< Type > &v)
| operator. More...
template<typename Type >
Vec4< Type > | clan::operator- (const Vec4< Type > &v, Type s)
| operator. More...
template<typename Type >
Vec3< Type > | clan::operator/ (const Vec3< Type > &v1, const Vec3< Type > &v2)
| / operator. More...
template<typename Type >
Vec3< Type > | clan::operator/ (Type s, const Vec3< Type > &v)
| / operator. More...
template<typename Type >
Vec3< Type > | clan::operator/ (const Vec3< Type > &v, Type s)
| / operator. More...
template<typename Type >
Vec2< Type > | clan::operator/ (const Vec2< Type > &v1, const Vec2< Type > &v2)
| / operator. More...
template<typename Type >
Vec2< Type > | clan::operator/ (Type s, const Vec2< Type > &v)
| / operator. More...
template<typename Type >
Vec2< Type > | clan::operator/ (const Vec2< Type > &v, Type s)
| / operator. More...
template<typename Type >
Vec4< Type > | clan::operator/ (const Vec4< Type > &v1, const Vec4< Type > &v2)
| / operator. More...
template<typename Type >
Vec4< Type > | clan::operator/ (Type s, const Vec4< Type > &v)
| / operator. More...
template<typename Type >
Vec4< Type > | clan::operator/ (const Vec4< Type > &v, Type s)
| / operator. More...
HalfFloat & | clan::HalfFloat::operator= (const HalfFloat &other)
HalfFloat & | clan::HalfFloat::operator= (const float v)
static Result | clan::IntersectionTest::plane_aabb (const Vec4f &plane, const AxisAlignedBoundingBox &aabb)
static Result | clan::IntersectionTest::plane_obb (const Vec4f &plane, const OrientedBoundingBox &obb)
static float | clan::LineMath::point_right_of_line (float x, float y, float *line)
| Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B. More...
static float | clan::LineMath::point_right_of_line (float x, float y, float line_x1, float line_y1, float line_x2, float line_y2)
| Point right of line. More...
static float | clan::LineMath::point_right_of_line (const Pointf &A, const Pointf &B, const Pointf &P)
| Point right of line. More...
template<typename T >
T | clan::pow2 (T value)
static OverlapResult | clan::IntersectionTest::ray_aabb (const Vec3f &ray_start, const Vec3f &ray_end, const AxisAlignedBoundingBox &box)
Rectd | clan::RectdPS (double x, double y, double width, double height)
Rectf | clan::RectfPS (float x, float y, float width, float height)
Rect | clan::RectPS (int x, int y, int width, int height)
static Vec3< Type > | clan::Vec3< Type >::reflect (const Vec3< Type > &incident, const Vec3< Type > &normal)
| Calculate the reflection direction for an incident vector. More...
static Vec3< Type > | clan::Vec3< Type >::rotate (const Vec3< Type > &vector, const Angle &angle, const Vec3< Type > &axis)
| Rotate a vector around an axis. Same as glRotate[f|d](angle, a);. More...
static Vec2< Type > | clan::Vec2< Type >::rotate (const Vec2< Type > &vector, const Vec2< Type > &hotspot, const Angle &angle)
| Rotate a vector around another point. More...
static Vec4< Type > | clan::Vec4< Type >::rotate3 (const Vec4< Type > &vector, const Angle &angle, const Vec4< Type > &axis)
| Rotate a vector around an axis. Same as glRotate[f|d](angle, a);. More...
static Quaternionx< Type > | clan::Quaternionx< Type >::rotation_between (Vec3< Type > v0, Vec3< Type > v1)
| Calculates the shortest arc quaternion between two vectors. More...
static Quaternionx< Type > | clan::Quaternionx< Type >::rotation_between (Vec4< Type > v0, Vec4< Type > v1)
| Calculates the shortest arc quaternion between two vectors. More...
static Vec2< Type > | clan::Vec2< Type >::round (const Vec2< Type > &vector)
| Rounds all components on a vector. More...
static Vec3< Type > | clan::Vec3< Type >::round (const Vec3< Type > &vector)
| Rounds all components on a vector. More...
static Vec4< Type > | clan::Vec4< Type >::round (const Vec4< Type > &vector)
| Rounds all components on a vector. More...
int | clan::sign (int x)
float | clan::sign (float x)
double | clan::sign (double x)
template<typename Type >
Vec2< Type > | clan::sign (const Vec2< Type > &x)
template<typename Type >
Vec3< Type > | clan::sign (const Vec3< Type > &x)
template<typename Type >
Vec4< Type > | clan::sign (const Vec4< Type > &x)
static Quaternionx< Type > | clan::Quaternionx< Type >::slerp (const Quaternionx< Type > &quaternion_initial, const Quaternionx< Type > &quaternion_final, Type slerp_time)
| Spherical Quaternion Interpolation. More...
template<typename A , typename B , typename C >
C | clan::smoothstep (A edge0, B edge1, C x)
static OverlapResult | clan::IntersectionTest::sphere (const Vec3f &center1, float radius1, const Vec3f &center2, float radius2)
static OverlapResult | clan::IntersectionTest::sphere_aabb (const Vec3f &center, float radius, const AxisAlignedBoundingBox &aabb)
int | clan::step (int edge, int x)
long long | clan::step (long long edge, long long x)
float | clan::step (float edge, float x)
double | clan::step (double edge, double x)
template<typename Type >
Vec2< Type > | clan::step (const Vec2< Type > &edge, const Vec2< Type > &x)
template<typename Type >
Vec3< Type > | clan::step (const Vec3< Type > &edge, const Vec3< Type > &x)
template<typename Type >
Vec4< Type > | clan::step (const Vec4< Type > &edge, const Vec4< Type > &x)
float | clan::HalfFloat::to_float () const
Vec2f | clan::Vec2hf::to_float () const
Vec3f | clan::Vec3hf::to_float () const
Vec4f | clan::Vec4hf::to_float () const

## Variables
union {
Type clan::Quaternionx< Type >::i
Type clan::Quaternionx< Type >::x
}; |
| The imaginary vector part. More...
union {
Type clan::Vec3< Type >::r
Type clan::Vec3< Type >::s
Type clan::Vec3< Type >::x
}; |
union {
Type clan::Vec3< Type >::g
Type clan::Vec3< Type >::t
Type clan::Vec3< Type >::y
}; |
union {
Type clan::Vec3< Type >::b
Type clan::Vec3< Type >::u
Type clan::Vec3< Type >::z
}; |
union {
Type clan::Vec4< Type >::r
Type clan::Vec4< Type >::s
Type clan::Vec4< Type >::x
}; |
union {
Type clan::Vec4< Type >::g
Type clan::Vec4< Type >::t
Type clan::Vec4< Type >::y
}; |
union {
Type clan::Vec4< Type >::b
Type clan::Vec4< Type >::u
Type clan::Vec4< Type >::z
}; |
union {
Type clan::Vec4< Type >::a
Type clan::Vec4< Type >::v
Type clan::Vec4< Type >::w
}; |
union {
Type clan::Quaternionx< Type >::j
Type clan::Quaternionx< Type >::y
}; |
union {
Type clan::Quaternionx< Type >::k
Type clan::Quaternionx< Type >::z
}; |
union {
Type clan::Vec2< Type >::r
Type clan::Vec2< Type >::s
Type clan::Vec2< Type >::x
}; |
union {
Type clan::Vec2< Type >::g
Type clan::Vec2< Type >::t
Type clan::Vec2< Type >::y
}; |
Type clan::Vec4< Type >::a
Vec3f | clan::AxisAlignedBoundingBox::aabb_max
Vec3f | clan::AxisAlignedBoundingBox::aabb_min
Vec3f | clan::OrientedBoundingBox::axis_x
Vec3f | clan::OrientedBoundingBox::axis_y
Vec3f | clan::OrientedBoundingBox::axis_z
Type clan::Vec3< Type >::b
Type clan::Vec4< Type >::b
Vec3f | clan::OrientedBoundingBox::center
Vec3f | clan::OrientedBoundingBox::extents
Type clan::Vec2< Type >::g
Type clan::Vec3< Type >::g
Type clan::Vec4< Type >::g
int | clan::RectPacker::AllocatedRect::group_index
Type clan::Quaternionx< Type >::i
Type clan::Quaternionx< Type >::j
Type clan::Quaternionx< Type >::k
Vec2< Type > | clan::Trianglex< Type >::p
| First triangle point. More...
Vec3< Type > | clan::Line3x< Type >::p
Vec3< Type > | clan::LineRay3x< Type >::p
| Start point on the line ray. More...
Vec3< Type > | clan::LineSegment3x< Type >::p
| Start point on the line. More...
Vec2< Type > | clan::Line2x< Type >::p
| First point on the line. More...
Vec2< Type > | clan::LineRay2x< Type >::p
| Start point on the line ray. More...
Vec2< Type > | clan::LineSegment2x< Type >::p
| Start point on the line. More...
Vec2< Type > | clan::Circlex< Type >::position
| Circle center point. More...
Vec2< Type > | clan::Trianglex< Type >::q
Vec3< Type > | clan::Line3x< Type >::q
Vec3< Type > | clan::LineSegment3x< Type >::q
Vec2< Type > | clan::Line2x< Type >::q
Vec2< Type > | clan::LineSegment2x< Type >::q
Vec2< Type > | clan::Trianglex< Type >::r
Type clan::Vec2< Type >::r
Type clan::Vec3< Type >::r
Type clan::Vec4< Type >::r
Type | clan::Circlex< Type >::radius
| Circle radius. More...
Rect | clan::RectPacker::AllocatedRect::rect
Type clan::Vec2< Type >::s
Type clan::Vec4< Type >::s
Type clan::Vec3< Type >::s
Type clan::Vec4< Type >::t
Type clan::Vec2< Type >::t
Type clan::Vec3< Type >::t
Type clan::Vec4< Type >::u
Type clan::Vec3< Type >::u
Vec3< Type > | clan::LineRay3x< Type >::v
Type clan::Vec4< Type >::v
Vec2< Type > | clan::LineRay2x< Type >::v
Type | clan::Quaternionx< Type >::w
| The real scalar part. More...
Type clan::Vec4< Type >::w
HalfFloat | clan::Vec4hf::w
Type clan::Quaternionx< Type >::x
HalfFloat | clan::Vec2hf::x
Type clan::Vec2< Type >::x
Type clan::Vec4< Type >::x
Type clan::Vec3< Type >::x
HalfFloat | clan::Vec3hf::x
HalfFloat | clan::Vec4hf::x
float | clan::EarClipTriangulator_Triangle::x1
float | clan::EarClipTriangulator_Triangle::x2
float | clan::EarClipTriangulator_Triangle::x3
Type clan::Quaternionx< Type >::y
HalfFloat | clan::Vec2hf::y
Type clan::Vec2< Type >::y
Type clan::Vec4< Type >::y
Type clan::Vec3< Type >::y
HalfFloat | clan::Vec3hf::y
HalfFloat | clan::Vec4hf::y
float | clan::EarClipTriangulator_Triangle::y1
float | clan::EarClipTriangulator_Triangle::y2
float | clan::EarClipTriangulator_Triangle::y3
Type clan::Quaternionx< Type >::z
Type clan::Vec3< Type >::z
Type clan::Vec4< Type >::z
HalfFloat | clan::Vec3hf::z
HalfFloat | clan::Vec4hf::z

## Construction
| clan::Angle::Angle ()
| Constructs an NULL Angle object. More...
| clan::Angle::Angle (float value, AngleUnit unit)
| Constructs an Angle object. More...
static Angle | clan::Angle::from_radians (float value)
| From radians. More...
static Angle | clan::Angle::from_degrees (float value)
| From degrees. More...

## Attributes
float | clan::Angle::to_degrees () const
| Returns the angle as degrees. More...
float | clan::Angle::to_radians () const
| Returns the angle as radians. More...

## Operations
void | clan::Angle::set_degrees (float value_degrees)
| Set the angle value in degrees. More...
void | clan::Angle::set_radians (float value_radians)
| Set the angle value in radians. More...
Angle & | clan::Angle::normalize ()
| Converts angle to range [0,360] degrees. More...
Angle & | clan::Angle::normalize_180 ()
| Converts angle to range [-180,180] degrees. More...

## Operators
void | clan::Angle::operator+= (const Angle &angle)
| += operator. More...
void | clan::Angle::operator-= (const Angle &angle)
| -= operator. More...
void | clan::Angle::operator*= (const Angle &angle)
| *= operator. More...
void | clan::Angle::operator/= (const Angle &angle)
| /= operator. More...
Angle | clan::Angle::operator+ (const Angle &angle) const
| operator. More...
Angle | clan::Angle::operator- (const Angle &angle) const
| operator. More...
Angle | clan::Angle::operator* (const Angle &angle) const
| operator. More...
Angle | clan::Angle::operator* (float value) const
| operator. More...
Angle | clan::Angle::operator/ (const Angle &angle) const
| / operator. More...
Angle | clan::Angle::operator/ (float value) const
| / operator. More...
bool | clan::Angle::operator< (const Angle &angle) const
| < operator. More...
bool | clan::Angle::operator<= (const Angle &angle) const
| < operator. More...
bool | clan::Angle::operator> (const Angle &angle) const
| operator. More...
bool | clan::Angle::operator>= (const Angle &angle) const
| operator. More...
bool | clan::Angle::operator== (const Angle &angle) const
| == operator. More...
bool | clan::Angle::operator!= (const Angle &angle) const
| != operator. More...

## Construction
| clan::Base64Decoder::Base64Decoder ()
| Constructs a base64 decoder. More...

## Attributes
DataBuffer & | clan::Base64Decoder::get_result ()
| Returns the decoded data. More...

## Operations
void | clan::Base64Decoder::reset ()
| Resets the decoder. More...
void | clan::Base64Decoder::feed (const void *data, int size, bool append_result=true)
| Feeds the decoder with base64 encoded data. More...
static DataBuffer | clan::Base64Decoder::decode (const void *data, int size)
| Decode base64 data and return it in a buffer. More...
static DataBuffer | clan::Base64Decoder::decode (const std::string &data)
| Decode. More...
static DataBuffer | clan::Base64Decoder::decode (const DataBuffer &data)
| Decode. More...

## Construction
| clan::Base64Encoder::Base64Encoder ()
| Constructs a base64 encoder. More...

## Attributes
DataBuffer & | clan::Base64Encoder::get_result ()
| Returns the data in encoded form. More...

## Operations
void | clan::Base64Encoder::reset ()
| Resets the encoder. More...
void | clan::Base64Encoder::feed (const void *data, int size, bool append_result=true)
| Feeds the encoder with more data. More...
void | clan::Base64Encoder::finalize (bool append_result=true)
| Ends the base64 encoding. More...
static std::string | clan::Base64Encoder::encode (const void *data, int size)
| Base64 encodes data and returns it as an 8 bit string. More...
static std::string | clan::Base64Encoder::encode (const std::string &data)
| Encode. More...
static std::string | clan::Base64Encoder::encode (const DataBuffer &data)
| Encode. More...

## Construction
| clan::BezierCurve::BezierCurve ()
| Constructs a bezier curve generator. More...
virtual | clan::BezierCurve::~BezierCurve ()

## Attributes
std::vector< Pointf > | clan::BezierCurve::get_control_points () const
| Returns the control points of the bezier. More...

## Operations
void | clan::BezierCurve::add_control_point (float x, float y)
| Adds a control point to bezier. More...
void | clan::BezierCurve::add_control_point (const Pointf &)
std::vector< Pointf > | clan::BezierCurve::generate_curve_points (const Angle &split_angle)
| Generates points on the bezier curve. More...
Pointf | clan::BezierCurve::get_point_relative (float pos_0_to_1) const
| Get a point on the bezier curve. More...

## Construction
| clan::BigInt::BigInt ()
| Constructs a big integer (initialised to zero) More...
| clan::BigInt::BigInt (uint32_t value)
| Constructs a big integer (initialised to value) More...
| clan::BigInt::BigInt (int32_t value)
| Constructs a big integer (initialised to value) More...
| clan::BigInt::BigInt (uint64_t value)
| Constructs a big integer (initialised to value) More...
| clan::BigInt::BigInt (int64_t value)
| Constructs a big integer (initialised to value) More...
| clan::BigInt::BigInt (const BigInt &other)
| Copy constructor. More...
| clan::BigInt::~BigInt ()
| Destructor. More...
BigInt & | clan::BigInt::operator= (const BigInt &other)

## Operations
void | clan::BigInt::read_unsigned_octets (const unsigned char *input_str, unsigned int input_length)
void | clan::BigInt::zero ()
bool | clan::BigInt::make_prime (unsigned int num_bits)
int | clan::BigInt::cmp_z () const
| Compare a <=> 0. Returns <0 if a<0, 0 if a=0, >0 if a>0. More...
void | clan::BigInt::set_bit (unsigned int bit_number, unsigned int value)
int | clan::BigInt::significant_bits () const
void | clan::BigInt::sieve (const uint32_t *primes, unsigned int num_primes, std::vector< unsigned char > &sieve)
uint32_t | clan::BigInt::mod_d (uint32_t d) const
| Compute c = a (mod d). Result will always be 0 <= c < d. More...
void | clan::BigInt::div_d (uint32_t d, BigInt *q, uint32_t *r) const
| Compute the quotient q = a / d and remainder r = a mod d, for a single digit d. Respects the sign of its divisor (single digits are unsigned anyway). More...
bool | clan::BigInt::fermat (uint32_t w) const
| Using w as a witness, try pseudo-primality testing based on Fermat's little theorem. More...
bool | clan::BigInt::pprime (int nt) const
| Performs nt iteration of the Miller-Rabin probabilistic primality test on a. More...
void | clan::BigInt::set (int32_t d)
| Sets a value. More...
void | clan::BigInt::set (uint32_t d)
void | clan::BigInt::set (uint64_t d)
void | clan::BigInt::set (int64_t d)
void | clan::BigInt::get (uint32_t &d)
| Gets a value. More...
void | clan::BigInt::get (uint64_t &d)
void | clan::BigInt::get (int64_t &d)
void | clan::BigInt::get (int32_t &d)
void | clan::BigInt::exptmod (const BigInt *b, const BigInt *m, BigInt *c) const
| Compute c = (a ** b) mod m. More...
void | clan::BigInt::mod (const BigInt *m, BigInt *c) const
| Compute c = a (mod m). Result will always be 0 <= c < m. More...
void | clan::BigInt::div (const BigInt &b, BigInt *q, BigInt *r) const
| Compute q = a / b and r = a mod b. More...
void | clan::BigInt::div (uint32_t d, BigInt *q, BigInt *r) const
BigInt | clan::BigInt::operator+ (const BigInt &b)
| Compute result = this + b. More...
BigInt | clan::BigInt::operator+ (uint32_t d)
BigInt | clan::BigInt::operator+= (const BigInt &b)
| Compute this += b. More...
BigInt | clan::BigInt::operator+= (uint32_t d)
BigInt | clan::BigInt::operator- (const BigInt &b)
| Compute result = this - b. More...
BigInt | clan::BigInt::operator- (uint32_t d)
BigInt | clan::BigInt::operator-= (const BigInt &b)
| Compute this -= b. More...
BigInt | clan::BigInt::operator-= (uint32_t d)
BigInt | clan::BigInt::operator* (const BigInt &b)
| Compute result = this * b. More...
BigInt | clan::BigInt::operator* (uint32_t d)
BigInt | clan::BigInt::operator*= (const BigInt &b)
| Compute this *= b. More...
BigInt | clan::BigInt::operator*= (uint32_t d)
BigInt | clan::BigInt::operator/ (const BigInt &b)
| Compute result = this / b. More...
BigInt | clan::BigInt::operator/ (uint32_t d)
BigInt | clan::BigInt::operator/= (const BigInt &b)
| Compute this /= b. More...
BigInt | clan::BigInt::operator/= (uint32_t d)
BigInt | clan::BigInt::operator% (const BigInt &b)
| Compute result = this % b. More...
BigInt | clan::BigInt::operator% (uint32_t d)
BigInt | clan::BigInt::operator%= (const BigInt &b)
| Compute this %= b. More...
BigInt | clan::BigInt::operator%= (uint32_t d)
int | clan::BigInt::cmp (const BigInt *b) const
int | clan::BigInt::cmp_d (uint32_t d) const
| Compare a <=> d. Returns <0 if a<d, 0 if a=d, >0 if a>d. More...
void | clan::BigInt::neg (BigInt *b) const
| Compute b = -a. 'a' and 'b' may be identical. More...
unsigned int | clan::BigInt::trailing_zeros () const
void | clan::BigInt::sqrmod (const BigInt *m, BigInt *c) const
void | clan::BigInt::sqr (BigInt *b) const
void | clan::BigInt::random ()
| Assigns a random value to a. More...
void | clan::BigInt::exch (BigInt *mp2)
| Exchange mp1 and mp2 without allocating any intermediate memory. More...
bool | clan::BigInt::invmod (const BigInt *m, BigInt *c) const
| Compute c = a^-1 (mod m), if there is an inverse for a (mod m). More...
void | clan::BigInt::xgcd (const BigInt *b, BigInt *g, BigInt *x, BigInt *y) const
| Compute g = (a, b) and values x and y satisfying Bezout's identity. More...
void | clan::BigInt::abs (BigInt *b) const
| Compute b = |a|. 'a' and 'b' may be identical. More...
bool | clan::BigInt::is_even () const
| Returns a true if number is even. More...
bool | clan::BigInt::is_odd () const
| Returns a true if number is odd. More...
void | clan::BigInt::div_2 (BigInt *c) const
| Compute c = a / 2, disregarding the remainder. More...
void | clan::BigInt::to_unsigned_octets (unsigned char *output_str, unsigned int output_length) const
int | clan::BigInt::unsigned_octet_size () const

## Attributes
bool | clan::Circlex< Type >::is_inside (const Vec2< Type > &point)

## Operators
Circlex< Type > & | clan::Circlex< Type >::operator= (const Circlex< Type > &copy)
| = operator. More...
bool | clan::Circlex< Type >::operator== (const Circlex< Type > &circle) const
| == operator. More...
bool | clan::Circlex< Type >::operator!= (const Circlex< Type > &circle) const
| != operator. More...

## Attributes
void * | clan::DelauneyTriangulator_Vertex::data
| Data pointer given when adding the vertex. More...
float | clan::DelauneyTriangulator_Vertex::x
| X position of vertex. More...
float | clan::DelauneyTriangulator_Vertex::y
| Y position of vertex. More...

## Attributes
DelauneyTriangulator_Vertex * | clan::DelauneyTriangulator_Triangle::vertex_A
| First point in the triangle. More...
DelauneyTriangulator_Vertex * | clan::DelauneyTriangulator_Triangle::vertex_B
| Second point in the triangle. More...
DelauneyTriangulator_Vertex * | clan::DelauneyTriangulator_Triangle::vertex_C
| Third point in the triangle. More...

## Construction
| clan::DelauneyTriangulator::DelauneyTriangulator ()
| Creates a triangulator object. More...
virtual | clan::DelauneyTriangulator::~DelauneyTriangulator ()

## Attributes
const std::vector< DelauneyTriangulator_Vertex > & | clan::DelauneyTriangulator::get_vertices () const
| Returns the list of vertices in the triangulation. More...
const std::vector< DelauneyTriangulator_Triangle > & | clan::DelauneyTriangulator::get_triangles () const
| Returns the resulting triangles produced from triangulation. More...

## Operations
void | clan::DelauneyTriangulator::add_vertex (float x, float y, void *data)
| This function specifies a point to be used in the triangulation. More...
void | clan::DelauneyTriangulator::generate ()
| Converts passed points into triangles. More...

## Construction
| clan::EarClipResult::EarClipResult (int num_triangles)
| Constructs an ear clipping result structure. More...
virtual | clan::EarClipResult::~EarClipResult ()

## Attributes
std::vector< EarClipTriangulator_Triangle > & | clan::EarClipResult::get_triangles ()
| Returns the triangles for this result. More...
EarClipTriangulator_Triangle & | clan::EarClipResult::get_triangle (int index)
| return a reference to a triangle in the triangulation. More...

## Construction
| clan::EarClipTriangulator::EarClipTriangulator ()
| Constructs a triangulator. More...
virtual | clan::EarClipTriangulator::~EarClipTriangulator ()

## Attributes
std::vector< Pointf > | clan::EarClipTriangulator::get_vertices ()
| Returns a list of the vertices added to the triangulator. More...
int | clan::EarClipTriangulator::get_vertice_count ()
| Returns the number of vertices in the triangulator. More...
PolygonOrientation | clan::EarClipTriangulator::calculate_polygon_orientation ()
| Determine the orientation of the vertices in the triangulator. More...

## Operations
void | clan::EarClipTriangulator::add_vertex (float x, float y)
| Add the next vertex of the polygon to the triangulator. More...
void | clan::EarClipTriangulator::add_vertex (const Pointf &p)
| Add vertex. More...
void | clan::EarClipTriangulator::clear ()
| Remove all vertices from triangulator. More...
void | clan::EarClipTriangulator::set_orientation (PolygonOrientation orientation)
| Set polygon orientation. More...
EarClipResult | clan::EarClipTriangulator::triangulate ()
| Perform triangulation. More...
void | clan::EarClipTriangulator::begin_hole ()
| Mark beginning of a polygon hole. More...
void | clan::EarClipTriangulator::end_hole ()
| Mark ending of a polygon hole. More...

## Attributes
Vec3< Type > | clan::Line3x< Type >::get_intersection (const Line3x< Type > &second, bool &intersect, Type range=(Type) 0.5) const
| Return the intersection of this and other line. More...

## Operators
Line3x< Type > & | clan::Line3x< Type >::operator= (const Line3x< Type > &copy)
| = operator. More...
bool | clan::Line3x< Type >::operator== (const Line3x< Type > &line) const
| == operator. More...
bool | clan::Line3x< Type >::operator!= (const Line3x< Type > &line) const
| != operator. More...

## Attributes
Vec2< Type > | clan::Line2x< Type >::get_intersection (const Line2x< Type > &second, bool &intersect) const
| Return the intersection of this and other line. More...
Type | clan::Line2x< Type >::point_right_of_line (Vec2< Type > point) const
| Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B. More...

## Operators
Line2x< Type > & | clan::Line2x< Type >::operator= (const Line2x< Type > &copy)
| = operator. More...
bool | clan::Line2x< Type >::operator== (const Line2x< Type > &line) const
| == operator. More...
bool | clan::Line2x< Type >::operator!= (const Line2x< Type > &line) const
| != operator. More...

## Operators
LineRay3x< Type > & | clan::LineRay3x< Type >::operator= (const LineRay3x< Type > &copy)
| = operator. More...
bool | clan::LineRay3x< Type >::operator== (const LineRay3x< Type > &line) const
| == operator. More...
bool | clan::LineRay3x< Type >::operator!= (const LineRay3x< Type > &line) const
| != operator. More...

## Operators
LineRay2x< Type > & | clan::LineRay2x< Type >::operator= (const LineRay2x< Type > &copy)
| = operator. More...
bool | clan::LineRay2x< Type >::operator== (const LineRay2x< Type > &line) const
| == operator. More...
bool | clan::LineRay2x< Type >::operator!= (const LineRay2x< Type > &line) const
| != operator. More...

## Attributes
Vec3< Type > | clan::LineSegment3x< Type >::get_midpoint () const
| Get the midpoint of this line. More...
Type | clan::LineSegment3x< Type >::point_distance (const Vec3< Type > &point, Vec3< Type > &dest_intercept) const
| Calculate the distance from a line segment to a point. More...

## Operators
LineSegment3x< Type > & | clan::LineSegment3x< Type >::operator= (const LineSegment3x< Type > &copy)
| = operator. More...
bool | clan::LineSegment3x< Type >::operator== (const LineSegment3x< Type > &line) const
| == operator. More...
bool | clan::LineSegment3x< Type >::operator!= (const LineSegment3x< Type > &line) const
| != operator. More...

## Attributes
Vec2< Type > | clan::LineSegment2x< Type >::get_midpoint () const
| Get the midpoint of this line. More...
Type | clan::LineSegment2x< Type >::point_distance (const Vec2< Type > &point)
| Return the distance from a point to a line. More...
bool | clan::LineSegment2x< Type >::collinear (const LineSegment2x< Type > &second) const
| Return true if two line segments are collinear. (All points are on the same line.) More...
bool | clan::LineSegment2x< Type >::intersects (const LineSegment2x< Type > &second, bool collinear_intersect) const
| Return true if two line segments intersect. More...
Vec2< Type > | clan::LineSegment2x< Type >::get_intersection (const LineSegment2x< Type > &second, bool &intersect) const
| Return the intersection point of two lines. More...
Type | clan::LineSegment2x< Type >::point_right_of_line (const Vec2< Type > &point) const
| Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B. More...
Vec2< Type > | clan::LineSegment2x< Type >::normal () const
| Return the normal vector of the line from point A to point B. More...

## Operations
LineSegment2x< Type > & | clan::LineSegment2x< Type >::clip (const Rectx< Type > &rect, bool &clipped)
| Clip this line to a rectangle. More...

## Operators
LineSegment2x< Type > & | clan::LineSegment2x< Type >::operator= (const LineSegment2x< Type > &copy)
| = operator. More...
bool | clan::LineSegment2x< Type >::operator== (const LineSegment2x< Type > &line) const
| == operator. More...
bool | clan::LineSegment2x< Type >::operator!= (const LineSegment2x< Type > &line) const
| != operator. More...

## Construction
| clan::Mat2< Type >::Mat2 ()
| Constructs a 2x2 matrix (zero'ed) More...
| clan::Mat2< Type >::Mat2 (const Mat2< Type > &copy)
| Constructs a 2x2 matrix (copied) More...
| clan::Mat2< Type >::Mat2 (const Mat3< Type > &copy)
| Constructs a 2x2 matrix (copied from a 3d matrix) More...
| clan::Mat2< Type >::Mat2 (const Mat4< Type > &copy)
| Constructs a 2x2 matrix (copied from a 4d matrix) More...
| clan::Mat2< Type >::Mat2 (const float *init_matrix)
| Constructs a 2x2 matrix (copied from 4 floats) More...
| clan::Mat2< Type >::Mat2 (Type m00, Type m01, Type m10, Type m11)
| Constructs a 2x2 matrix (copied from specified values) More...
| clan::Mat2< Type >::Mat2 (const double *init_matrix)
| Constructs a 2x2 matrix (copied from 4 doubles) More...
| clan::Mat2< Type >::Mat2 (const int64_t *init_matrix)
| Constructs a 2x2 matrix (copied from 4, 64 bit integers) More...
| clan::Mat2< Type >::Mat2 (const int32_t *init_matrix)
| Constructs a 2x2 matrix (copied from 4, 32 bit integers) More...
| clan::Mat2< Type >::Mat2 (const int16_t *init_matrix)
| Constructs a 2x2 matrix (copied from 4, 16 bit integers) More...
| clan::Mat2< Type >::Mat2 (const int8_t *init_matrix)
| Constructs a 2x2 matrix (copied from 4, 8 bit integers) More...
static Mat2< Type > | clan::Mat2< Type >::null ()
static Mat2< Type > | clan::Mat2< Type >::identity ()
static Mat2< Type > | clan::Mat2< Type >::multiply (const Mat2< Type > &matrix_1, const Mat2< Type > &matrix_2)
| Multiply 2 matrices. More...
static Mat2< Type > | clan::Mat2< Type >::add (const Mat2< Type > &matrix_1, const Mat2< Type > &matrix_2)
| Add 2 matrices. More...
static Mat2< Type > | clan::Mat2< Type >::subtract (const Mat2< Type > &matrix_1, const Mat2< Type > &matrix_2)
| Subtract 2 matrices. More...
static bool | clan::Mat2< Type >::is_equal (const Mat2< Type > &first, const Mat2< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...

## Attributes
Type | clan::Mat2< Type >::matrix [4]

## Operations
bool | clan::Mat2< Type >::is_equal (const Mat2< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
| clan::Mat2< Type >::operator Type const * () const
| Operator that returns the matrix as a array. More...
| clan::Mat2< Type >::operator Type * ()
| Operator that returns the matrix as a array. More...
Type & | clan::Mat2< Type >::operator[] (int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat2< Type >::operator[] (int i) const
| Operator that returns the matrix cell at the given index. More...
Type & | clan::Mat2< Type >::operator[] (unsigned int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat2< Type >::operator[] (unsigned int i) const
| Operator that returns the matrix cell at the given index. More...
Mat2< Type > & | clan::Mat2< Type >::operator= (const Mat2< Type > &copy)
| Copy assignment operator. More...
Mat2< Type > & | clan::Mat2< Type >::operator= (const Mat4< Type > &copy)
| Copy assignment operator. More...
Mat2< Type > & | clan::Mat2< Type >::operator= (const Mat3< Type > &copy)
| Copy assignment operator. More...
Mat2< Type > | clan::Mat2< Type >::operator* (const Mat2< Type > &mult) const
| Multiplication operator. More...
Mat2< Type > | clan::Mat2< Type >::operator+ (const Mat2< Type > &add_matrix) const
| Addition operator. More...
Mat2< Type > | clan::Mat2< Type >::operator- (const Mat2< Type > &subtract_matrix) const
| Subtract operator. More...
bool | clan::Mat2< Type >::operator== (const Mat2< Type > &other) const
| Equality operator. More...
bool | clan::Mat2< Type >::operator!= (const Mat2< Type > &other) const
| Not-equal operator. More...

## Construction
| clan::Mat3< Type >::Mat3 ()
| Constructs a 3x3 matrix (zero'ed) More...
| clan::Mat3< Type >::Mat3 (const Mat3< Type > &copy)
| Constructs a 3x3 matrix (copied) More...
| clan::Mat3< Type >::Mat3 (const Mat2< Type > &copy)
| Constructs a 3x3 matrix (copied from a 2d matrix) More...
| clan::Mat3< Type >::Mat3 (const Mat4< Type > &copy)
| Constructs a 3x3 matrix (copied from a 4d matrix) More...
| clan::Mat3< Type >::Mat3 (const float *init_matrix)
| Constructs a 3x3 matrix (copied from 9 floats) More...
| clan::Mat3< Type >::Mat3 (Type m00, Type m01, Type m02, Type m10, Type m11, Type m12, Type m20, Type m21, Type m22)
| Constructs a 3x3 matrix (copied from specified values) More...
| clan::Mat3< Type >::Mat3 (const double *init_matrix)
| Constructs a 3x3 matrix (copied from 9 doubles) More...
| clan::Mat3< Type >::Mat3 (const int64_t *init_matrix)
| Constructs a 3x3 matrix (copied from 9, 64 bit integers) More...
| clan::Mat3< Type >::Mat3 (const int32_t *init_matrix)
| Constructs a 3x3 matrix (copied from 9, 32 bit integers) More...
| clan::Mat3< Type >::Mat3 (const int16_t *init_matrix)
| Constructs a 3x3 matrix (copied from 9, 16 bit integers) More...
| clan::Mat3< Type >::Mat3 (const int8_t *init_matrix)
| Constructs a 3x3 matrix (copied from 9, 8 bit integers) More...
static Mat3< Type > | clan::Mat3< Type >::null ()
static Mat3< Type > | clan::Mat3< Type >::identity ()
static Mat3< Type > | clan::Mat3< Type >::rotate (const Angle &angle, Type x, Type y, Type z, bool normalize=true)
| Create a 3d rotation matrix. More...
static Mat3< Type > | clan::Mat3< Type >::rotate (const Angle &angle, Vec3< Type > rotation, bool normalize=true)
| Create a 3d rotation matrix. More...
static Mat3< Type > | clan::Mat3< Type >::rotate (const Angle &angle_x, const Angle &angle_y, const Angle &angle_z, EulerOrder order)
| Create a 3d rotation matrix using euler angles. More...
static Mat3< Type > | clan::Mat3< Type >::rotate (const Angle &angle)
| Create a 2d rotation matrix. More...
static Mat3< Type > | clan::Mat3< Type >::scale (Type x, Type y)
| Create a 2d scale matrix. More...
static Mat3< Type > | clan::Mat3< Type >::scale (const Vec3< Type > &xy)
| Create a 2d scale matrix. More...
static Mat3< Type > | clan::Mat3< Type >::translate (Type x, Type y)
| Create a 2d translation matrix. More...
static Mat3< Type > | clan::Mat3< Type >::translate (const Vec2< Type > &xy)
| Create a 2d translation matrix. More...
static Mat3< Type > | clan::Mat3< Type >::multiply (const Mat3< Type > &matrix_1, const Mat3< Type > &matrix_2)
| Multiply 2 matrices. More...
static Mat3< Type > | clan::Mat3< Type >::add (const Mat3< Type > &matrix_1, const Mat3< Type > &matrix_2)
| Add 2 matrices. More...
static Mat3< Type > | clan::Mat3< Type >::subtract (const Mat3< Type > &matrix_1, const Mat3< Type > &matrix_2)
| Subtract 2 matrices. More...
static Mat3< Type > | clan::Mat3< Type >::adjoint (const Mat3< Type > &matrix)
| Calculate the adjoint (or known as Adjugate or Conjugate Transpose) of a matrix. More...
static Mat3< Type > | clan::Mat3< Type >::inverse (const Mat3< Type > &matrix)
| Calculate the matrix inverse of a matrix. More...
static Mat3< Type > | clan::Mat3< Type >::transpose (const Mat3< Type > &matrix)
| Calculate the transpose of a matrix. More...
static bool | clan::Mat3< Type >::is_equal (const Mat3< Type > &first, const Mat3< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...

## Attributes
Type | clan::Mat3< Type >::matrix [9]

## Operations
double | clan::Mat3< Type >::det () const
| Calculate the matrix determinant. More...
Mat3< Type > & | clan::Mat3< Type >::adjoint ()
| Creates the adjoint (or known as adjugate) of the matrix. More...
Mat3< Type > & | clan::Mat3< Type >::inverse ()
| Create the matrix inverse. (Returns a zero matrix if the determinent = 0) More...
Mat3< Type > & | clan::Mat3< Type >::transpose ()
| Calculate the transpose of this matrix. More...
bool | clan::Mat3< Type >::is_equal (const Mat3< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
| clan::Mat3< Type >::operator Type const * () const
| Operator that returns the matrix as a array. More...
| clan::Mat3< Type >::operator Type * ()
| Operator that returns the matrix as a array. More...
Type & | clan::Mat3< Type >::operator[] (int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat3< Type >::operator[] (int i) const
| Operator that returns the matrix cell at the given index. More...
Type & | clan::Mat3< Type >::operator[] (unsigned int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat3< Type >::operator[] (unsigned int i) const
| Operator that returns the matrix cell at the given index. More...
Mat3< Type > & | clan::Mat3< Type >::operator= (const Mat3< Type > &copy)
| Copy assignment operator. More...
Mat3< Type > & | clan::Mat3< Type >::operator= (const Mat4< Type > &copy)
| Copy assignment operator. More...
Mat3< Type > & | clan::Mat3< Type >::operator= (const Mat2< Type > &copy)
| Copy assignment operator. More...
Mat3< Type > | clan::Mat3< Type >::operator* (const Mat3< Type > &mult) const
| Multiplication operator. More...
Mat3< Type > | clan::Mat3< Type >::operator+ (const Mat3< Type > &add_matrix) const
| Addition operator. More...
Mat3< Type > | clan::Mat3< Type >::operator- (const Mat3< Type > &sub_matrix) const
| Subtraction operator. More...
Vec2< Type > | clan::Mat3< Type >::operator* (const Vec2< Type > &mult) const
| Multiplication operator. More...
bool | clan::Mat3< Type >::operator== (const Mat3< Type > &other) const
| Equality operator. More...
bool | clan::Mat3< Type >::operator!= (const Mat3< Type > &other)
| Not-equal operator. More...

## Construction
| clan::Mat4< Type >::Mat4 ()
| Constructs a 4x4 matrix (zero'ed) More...
| clan::Mat4< Type >::Mat4 (const Mat4< Type > &copy)
| Constructs a 4x4 matrix (copied) More...
| clan::Mat4< Type >::Mat4 (const Mat2< Type > &copy)
| Constructs a 4x4 matrix (copied from a 2d matrix) More...
| clan::Mat4< Type >::Mat4 (const Mat3< Type > &copy)
| Constructs a 4x4 matrix (copied from a 3d matrix) More...
| clan::Mat4< Type >::Mat4 (const float *init_matrix)
| Constructs a 4x4 matrix (copied from a array of floats) More...
| clan::Mat4< Type >::Mat4 (const double *init_matrix)
| Constructs a 4x4 matrix (copied from a array of doubles) More...
| clan::Mat4< Type >::Mat4 (const int64_t *init_matrix)
| Constructs a 4x4 matrix (copied from a array of 64 bit integers) More...
| clan::Mat4< Type >::Mat4 (const int32_t *init_matrix)
| Constructs a 4x4 matrix (copied from a array of 32 bit integers) More...
| clan::Mat4< Type >::Mat4 (const int16_t *init_matrix)
| Constructs a 4x4 matrix (copied from a array of 16 bit integers) More...
| clan::Mat4< Type >::Mat4 (const int8_t *init_matrix)
| Constructs a 4x4 matrix (copied from a array of 8 bit integers) More...
static Mat4< Type > | clan::Mat4< Type >::null ()
| Create a zero matrix. More...
static Mat4< Type > | clan::Mat4< Type >::identity ()
| Create the identity matrix. More...
static Mat4< Type > | clan::Mat4< Type >::frustum (Type left, Type right, Type bottom, Type top, Type z_near, Type z_far, Handedness handedness, ClipZRange clip_z)
| Create a frustum matrix. More...
static Mat4< Type > | clan::Mat4< Type >::perspective (Type field_of_view_y_degrees, Type aspect, Type z_near, Type z_far, Handedness handedness, ClipZRange clip_z)
| Create a perspective matrix. More...
static Mat4< Type > | clan::Mat4< Type >::ortho (Type left, Type right, Type bottom, Type top, Type z_near, Type z_far, Handedness handedness, ClipZRange clip_z)
| Create a ortho matrix. More...
static Mat4< Type > | clan::Mat4< Type >::ortho_2d (Type left, Type right, Type bottom, Type top, Handedness handedness, ClipZRange clip_z)
| Create a ortho_2d matrix. More...
static Mat4< Type > | clan::Mat4< Type >::rotate (const Angle &angle, Type x, Type y, Type z, bool normalize=true)
| Create a rotation matrix. More...
static Mat4< Type > | clan::Mat4< Type >::rotate (const Angle &angle, Vec3< Type > rotation, bool normalize=true)
| Create a rotation matrix. More...
static Mat4< Type > | clan::Mat4< Type >::rotate (const Angle &angle_x, const Angle &angle_y, const Angle &angle_z, EulerOrder order)
| Create a rotation matrix using euler angles. More...
static Mat4< Type > | clan::Mat4< Type >::scale (Type x, Type y, Type z)
| Create a scale matrix. More...
static Mat4< Type > | clan::Mat4< Type >::scale (const Vec3< Type > &xyz)
| Create a scale matrix. More...
static Mat4< Type > | clan::Mat4< Type >::translate (Type x, Type y, Type z)
| Create a translation matrix. More...
static Mat4< Type > | clan::Mat4< Type >::translate (const Vec3< Type > &xyz)
| Create a translation matrix. More...
static Mat4< Type > | clan::Mat4< Type >::look_at (Type eye_x, Type eye_y, Type eye_z, Type center_x, Type center_y, Type center_z, Type up_x, Type up_y, Type up_z)
| Create the "look at" matrix. More...
static Mat4< Type > | clan::Mat4< Type >::look_at (Vec3< Type > eye, Vec3< Type > center, Vec3< Type > up)
| Create the "look at" matrix. More...
static Mat4< Type > | clan::Mat4< Type >::multiply (const Mat4< Type > &matrix_1, const Mat4< Type > &matrix_2)
| Multiply 2 matrices. More...
static Mat4< Type > | clan::Mat4< Type >::add (const Mat4< Type > &matrix_1, const Mat4< Type > &matrix_2)
| Add 2 matrices. More...
static Mat4< Type > | clan::Mat4< Type >::subtract (const Mat4< Type > &matrix_1, const Mat4< Type > &matrix_2)
| Subtract 2 matrices. More...
static Mat4< Type > | clan::Mat4< Type >::adjoint (const Mat4< Type > &matrix)
| Calculate the adjoint (or known as Adjugate or Conjugate Transpose) of a matrix. More...
static Mat4< Type > | clan::Mat4< Type >::inverse (const Mat4< Type > &matrix)
| Calculate the matrix inverse of a matrix. More...
static Mat4< Type > | clan::Mat4< Type >::transpose (const Mat4< Type > &matrix)
| Calculate the transpose of a matrix. More...
static bool | clan::Mat4< Type >::is_equal (const Mat4< Type > &first, const Mat4< Type > &second, Type epsilon)
| Returns true if equal within the bounds of an epsilon. More...

## Attributes
Type | clan::Mat4< Type >::matrix [16]
| The matrix (in column-major format) More...
Vec3< Type > | clan::Mat4< Type >::get_translate () const
| Returns the translation coordinates for this matrix (in column-major format) More...
Vec3< Type > | clan::Mat4< Type >::get_euler (EulerOrder order) const
| Extract the euler angles (in radians) from a matrix (in column-major format) More...
Vec3< Type > | clan::Mat4< Type >::get_transformed_point (const Vec3< Type > &vector) const
| Get a transformed point from the matrix (in column-major format) More...

## Operations
Mat4< Type > & | clan::Mat4< Type >::scale_self (Type x, Type y, Type z)
| Scale this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::scale_self (const Vec3< Type > &scale)
| Scale this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::translate_self (Type x, Type y, Type z)
| Translate this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::translate_self (const Vec3< Type > &translation)
| Translate this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::set_translate (Type x, Type y, Type z)
| Set this matrix translation values. More...
Mat4< Type > & | clan::Mat4< Type >::set_translate (const Vec3< Type > &translation)
| Set this matrix translation values. More...
double | clan::Mat4< Type >::det () const
| Calculate the matrix determinant of this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::adjoint ()
| Calculate the adjoint (or known as adjugate) of this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::inverse ()
| Calculate the matrix inverse of this matrix. More...
Mat4< Type > & | clan::Mat4< Type >::transpose ()
| Calculate the transpose of this matrix. More...
void | clan::Mat4< Type >::decompose (Vec3< Type > &out_position, Quaternionx< Type > &out_orientation, Vec3< Type > &out_scale) const
| Decompose matrix into position, orientation/rotation and scale. More...
bool | clan::Mat4< Type >::is_equal (const Mat4< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
| clan::Mat4< Type >::operator Type const * () const
| Operator that returns the matrix as a array. More...
| clan::Mat4< Type >::operator Type * ()
| Operator that returns the matrix as a array. More...
Type & | clan::Mat4< Type >::operator[] (int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat4< Type >::operator[] (int i) const
| Operator that returns the matrix cell at the given index. More...
Type & | clan::Mat4< Type >::operator[] (unsigned int i)
| Operator that returns the matrix cell at the given index. More...
const Type & | clan::Mat4< Type >::operator[] (unsigned int i) const
| Operator that returns the matrix cell at the given index. More...
Mat4< Type > & | clan::Mat4< Type >::operator= (const Mat4< Type > &copy)
| Copy assignment operator. More...
Mat4< Type > & | clan::Mat4< Type >::operator= (const Mat3< Type > &copy)
| Copy assignment operator. More...
Mat4< Type > & | clan::Mat4< Type >::operator= (const Mat2< Type > &copy)
| Copy assignment operator. More...
Mat4< Type > | clan::Mat4< Type >::operator* (const Mat4< Type > &mult) const
| Multiplication operator. More...
Mat4< Type > | clan::Mat4< Type >::operator+ (const Mat4< Type > &add_matrix) const
| Addition operator. More...
Mat4< Type > | clan::Mat4< Type >::operator- (const Mat4< Type > &sub_matrix) const
| Subtraction operator. More...
bool | clan::Mat4< Type >::operator== (const Mat4< Type > &other) const
| Equality operator. More...
bool | clan::Mat4< Type >::operator!= (const Mat4< Type > &other)
| Not-equal operator. More...

## Construction
| clan::OutlineTriangulator::OutlineTriangulator ()
| Creates a tessellation object. More...
virtual | clan::OutlineTriangulator::~OutlineTriangulator ()

## Operations
void | clan::OutlineTriangulator::add_vertex (float x, float y, void *data)
| This function specifies a vertex on a polygon. More...
void | clan::OutlineTriangulator::next_contour ()
| Mark next contour in polygon path. More...
void | clan::OutlineTriangulator::next_polygon ()
| Mark next polygon. More...
void | clan::OutlineTriangulator::generate ()
| Converts passed polygons into triangles. More...

## Operations
static Circlef | clan::PointSetMath::minimum_enclosing_disc (const std::vector< Pointf > &points)
| Find minimum spanning circle for the set of points. More...
static std::vector< Pointf > | clan::PointSetMath::convex_hull_from_polygon (std::vector< Pointf > &points)
| Return the convex hull of the given set of points. More...
static Rect | clan::PointSetMath::bounding_box (const std::vector< Pointf > &points)

## Implementation
class | clan::PointSetMath::OutlineMath

## Construction
| clan::Quadx< Type >::Quadx ()
| Constructs a quad. More...
| clan::Quadx< Type >::Quadx (const Vec2< Type > &new_p, const Vec2< Type > &new_q, const Vec2< Type > &new_r, const Vec2< Type > &new_s)
| Constructs a quad. More...
| clan::Quadx< Type >::Quadx (const Rectx< Type > &rect)
| Constructs a quad. More...
| clan::Quadx< Type >::Quadx (const Quadx< Type > &quad)
| Constructs a quad. More...
Quadx< Type > & | clan::Quadx< Type >::operator+= (const Quadx< Type > &quad)
| Quad += Quad operator. More...
Quadx< Type > & | clan::Quadx< Type >::operator-= (const Quadx< Type > &quad)
| Quad -= Quad operator. More...
Quadx< Type > & | clan::Quadx< Type >::operator+= (const Vec2< Type > &point)
| Quad += Point operator. More...
Quadx< Type > & | clan::Quadx< Type >::operator-= (const Vec2< Type > &point)
| Quad -= Point operator. More...
Quadx< Type > | clan::Quadx< Type >::operator+ (const Quadx< Type > &quad) const
| Quad + Quad operator. More...
Quadx< Type > | clan::Quadx< Type >::operator- (const Quadx< Type > &quad) const
| Quad - Quad operator. More...
Quadx< Type > | clan::Quadx< Type >::operator+ (const Vec2< Type > &point) const
| Quad + Point operator. More...
Quadx< Type > | clan::Quadx< Type >::operator- (const Vec2< Type > &point) const
| Quad - Point operator. More...
bool | clan::Quadx< Type >::operator== (const Quadx< Type > &quad) const
| Quad == Quad operator. More...
bool | clan::Quadx< Type >::operator!= (const Quadx< Type > &quad) const
| Quad != Quad operator. More...

## Attributes
Vec2< Type > | clan::Quadx< Type >::p
| First Point. More...
Vec2< Type > | clan::Quadx< Type >::q
| Second Point. More...
Vec2< Type > | clan::Quadx< Type >::r
| Third Point. More...
Vec2< Type > | clan::Quadx< Type >::s
| Fourth Point. More...
Type | clan::Quadx< Type >::get_width () const
| Returns the width of the quad. More...
Type | clan::Quadx< Type >::get_height () const
| Returns the height of the quad. More...
Sizex< Type > | clan::Quadx< Type >::get_size () const
| Returns the size of the rectangle. More...
Rect | clan::Quadx< Type >::get_bounds () const
| Returns the bounding box of the quad as a Rect. More...

## Operations
Quadx< Type > & | clan::Quadx< Type >::rotate (const Vec2< Type > &hotspot, const Angle &angle)
| Rotates the Quad. More...
Quadx< Type > & | clan::Quadx< Type >::scale (float sx, float sy)
| Scale the Quad. More...
Quadx< Type > & | clan::Quadx< Type >::scale (const Vec2< Type > &hotspot, float sx, float sy)
| Scale the Quad. More...
Vec2< Type > | clan::Quadx< Type >::center () const
| Returns the center point of the quad. More...
Quadx< Type > & | clan::Quadx< Type >::apply_alignment (Origin origin, Type x, Type y)
| Applies an origin and offset pair to this rectangle. More...
bool | clan::Quadx< Type >::is_inside (const Vec2< Type > &point) const
| Check if a point is inside or outside the quad. More...

## Attributes
Mat4< Type > | clan::Quaternionx< Type >::to_matrix () const
| Convert the quaternion to a rotation matrix. More...
Type | clan::Quaternionx< Type >::magnitude () const
| Get the quaternion magnitude. More...

## Operations
void | clan::Quaternionx< Type >::set (Type euler_x, Type euler_y, Type euler_z, AngleUnit unit, EulerOrder order)
void | clan::Quaternionx< Type >::set (const Vec3< Type > &euler, AngleUnit unit, EulerOrder order)
void | clan::Quaternionx< Type >::set (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
Quaternionx< Type > & | clan::Quaternionx< Type >::rotate (const Angle &angle, const Vec3f &axis)
Quaternionx< Type > & | clan::Quaternionx< Type >::rotate (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
Quaternionx< Type > & | clan::Quaternionx< Type >::normalize ()
| Normalizes this quaternion. More...
Quaternionx< Type > & | clan::Quaternionx< Type >::inverse ()
| Inverse this quaternion. More...
Vec3< Type > | clan::Quaternionx< Type >::rotate_vector (const Vec3< Type > &v) const
| Rotates vector by this quaternion. More...
Vec4< Type > | clan::Quaternionx< Type >::rotate_vector (const Vec4< Type > &v) const
static Quaternionx< Type > | clan::Quaternionx< Type >::normalize (Quaternionx< Type > q)
| Normalizes this quaternion. More...
static Quaternionx< Type > | clan::Quaternionx< Type >::inverse (Quaternionx< Type > q)
| Inverse this quaternion. More...

## Operators
Quaternionx< Type > | clan::Quaternionx< Type >::operator* (const Quaternionx< Type > &mult) const
| Multiplication operator. More...
Quaternionx< Type > | clan::Quaternionx< Type >::operator* (const Mat4< Type > &matrix) const
bool | clan::Quaternionx< Type >::operator< (const Quaternionx< Type > &other) const
| Less operator. More...
bool | clan::Quaternionx< Type >::operator> (const Quaternionx< Type > &other) const
| Greater operator. More...
bool | clan::Quaternionx< Type >::operator<= (const Quaternionx< Type > &other) const
| Less equal operator. More...
bool | clan::Quaternionx< Type >::operator>= (const Quaternionx< Type > &other) const
| Greater equal operator. More...
bool | clan::Quaternionx< Type >::operator== (const Quaternionx< Type > &other) const
| Equal operator. More...
bool | clan::Quaternionx< Type >::operator!= (const Quaternionx< Type > &other) const
| Not equal operator. More...

## Construction
| clan::Rectx< Type >::Rectx ()
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (const Sizex< Type > &s)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (Type new_left, Type new_top, Type new_right, Type new_bottom)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (const Pointx< Type > &p, const Sizex< Type > &size)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (Type new_left, Type new_top, const Sizex< Type > &size)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (const Rectx< int > &rect)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (const Rectx< float > &rect)
| Constructs an rectangle. More...
| clan::Rectx< Type >::Rectx (const Rectx< double > &rect)
| Constructs an rectangle. More...
bool | clan::Rectx< Type >::operator== (const Rectx< Type > &r) const
| Rect == Rect operator. More...
bool | clan::Rectx< Type >::operator!= (const Rectx< Type > &r) const
| Rect != Rect operator. More...
static Rectx< Type > | clan::Rectx< Type >::xywh (Type x, Type y, Type width, Type height)
static Rectx< Type > | clan::Rectx< Type >::ltrb (Type left, Type top, Type right, Type bottom)

## Attributes
Type | clan::Rectx< Type >::left
| X1-coordinate (left point inside the rectangle) More...
Type | clan::Rectx< Type >::top
| Y1-coordinate (top point inside the rectangle) More...
Type | clan::Rectx< Type >::right
| X2-coordinate (point outside the rectangle) More...
Type | clan::Rectx< Type >::bottom
| Y2-coordinate (point outside the rectange) More...
Type | clan::Rectx< Type >::get_width () const
| Returns the width of the rectangle. More...
Type | clan::Rectx< Type >::get_height () const
| Returns the height of the rectangle. More...
Sizex< Type > | clan::Rectx< Type >::get_size () const
| Returns the size of the rectangle. More...
bool | clan::Rectx< Type >::contains (const Vec2< Type > &p) const
| Returns true if the rectangle contains the point. More...
Pointx< Type > | clan::Rectx< Type >::get_top_left () const
| Returns the top-left point inside the rectangle. More...
Pointx< Type > | clan::Rectx< Type >::get_top_right () const
| Returns the top-right point outside the rectangle. More...
Pointx< Type > | clan::Rectx< Type >::get_bottom_right () const
| Returns the bottom-right point outside the rectangle. More...
Pointx< Type > | clan::Rectx< Type >::get_bottom_left () const
| Returns the bottom-left point outside the rectangle. More...
bool | clan::Rectx< Type >::is_overlapped (const Rectx< Type > &r) const
| Returns true if rectangle passed is overlapping or inside this rectangle. More...
bool | clan::Rectx< Type >::is_inside (const Rectx< Type > &r) const
| Returns true if rectangle passed is inside this rectangle. More...
Rectx< Type > | clan::Rectx< Type >::get_rot_bounds (const Vec2< Type > &hotspot, const Angle &angle) const
| Returns another Rectx<Type> containing a rotated version of this one. More...
Rectx< Type > | clan::Rectx< Type >::get_rot_bounds (Origin origin, Type x, Type y, const Angle &angle) const
| Returns another Rectx<Type> containing a rotated version of this one. More...
Pointx< Type > | clan::Rectx< Type >::get_center () const
| Returns the center point of the rectangle. More...

## Operations
Rectx< Type > & | clan::Rectx< Type >::set_top_left (const Vec2< Type > &p)
| Sets the top-left point of the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::set_width (Type width)
| Sets the width of the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::set_height (Type height)
| Sets the height of the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::shrink (const Type &new_left, const Type &new_top, const Type &new_right, const Type &new_bottom)
| Shrink the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::shrink (const Type &left_right, const Type &top_bottom)
| Shrink the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::shrink (const Type &shrink)
| Shrink the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::expand (const Type &expand_left, const Type &expand_top, const Type &expand_right, const Type &expand_bottom)
| Expand the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::expand (const Type &left_and_right, const Type &top_and_bottom)
| Expand the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::expand (const Type &expand)
| Expand the rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::translate (const Vec2< Type > &p)
| Translate the rect. More...
Rectx< Type > & | clan::Rectx< Type >::translate (const Sizex< Type > &p)
| Translate the rect. More...
Rectx< Type > & | clan::Rectx< Type >::translate (const Rectx< Type > &p)
| Translate the rect by another rect (only uses the left and top coords). More...
Rectx< Type > & | clan::Rectx< Type >::translate (Type x, Type y)
| Translate the rect. More...
Rectx< Type > & | clan::Rectx< Type >::set_size (const Sizex< Type > &size)
| Sets the size of the rectangle, maintaining top/left position. More...
Rectx< Type > & | clan::Rectx< Type >::overlap (const Rectx< Type > &rect)
| Calculates the intersection of two rectangles. More...
Rectx< Type > & | clan::Rectx< Type >::bounding_rect (const Rectx< Type > &rect)
| Calculates the bounding rectangle of the rectangles. More...
Rectx< Type > & | clan::Rectx< Type >::normalize ()
| Normalize rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::apply_alignment (Origin origin, Type x, Type y)
| Applies an origin and offset pair to this rectangle. More...
Rectx< Type > & | clan::Rectx< Type >::clip (const Rectx< Type > &cr)
| Clip according to the specified clip rectangle. More...

## Enumerations and structs
enum | clan::RectPacker::AllocationPolicy { clan::RectPacker::create_new_group, clan::RectPacker::search_previous_groups, clan::RectPacker::fail_if_full }
| Allocation policy. More...

## Construction
| clan::RectPacker::RectPacker ()
| Constructs a null instance. More...
| clan::RectPacker::RectPacker (const Size &max_group_size, AllocationPolicy policy=create_new_group)
| Constructs a rect group. More...
| clan::RectPacker::~RectPacker ()

## Attributes
bool | clan::RectPacker::is_null () const
| Returns true if this object is invalid. More...
void | clan::RectPacker::throw_if_null () const
| Throw an exception if this object is invalid. More...
AllocationPolicy | clan::RectPacker::get_allocation_policy () const
| Returns the allocation policy. More...
Size | clan::RectPacker::get_max_group_size () const
| Returns the max group size. More...
int | clan::RectPacker::get_total_rect_count () const
| Returns the total amount of rects. More...
int | clan::RectPacker::get_rect_count (unsigned int group_index=0) const
| Returns the amount of rects in a group. More...
int | clan::RectPacker::get_group_count () const
| Returns the amount of rects used by group. More...

## Operations
void | clan::RectPacker::set_allocation_policy (AllocationPolicy policy)
| Set the allocation policy. More...
AllocatedRect | clan::RectPacker::add (const Size &size)
| Allocate space for another rect. More...

## Construction
| clan::Sizex< Type >::Sizex ()
| Constructs a size structure. More...
| clan::Sizex< Type >::Sizex (Type width, Type height)
| Constructs a size structure. More...
| clan::Sizex< Type >::Sizex (const Sizex< Type > &s)
| Constructs a size structure. More...

## Attributes
Type | clan::Sizex< Type >::width
| Size width. More...
Type | clan::Sizex< Type >::height
| Size height. More...

## Operations
| clan::Sizex< Type >::operator Vec2< Type > () const
Sizex< Type > & | clan::Sizex< Type >::operator+= (const Sizex< Type > &s)
| Size += Size operator. More...
Sizex< Type > & | clan::Sizex< Type >::operator-= (const Sizex< Type > &s)
| Size -= Size operator. More...
Sizex< Type > | clan::Sizex< Type >::operator+ (const Sizex< Type > &s) const
| Size + Size operator. More...
Sizex< Type > | clan::Sizex< Type >::operator- (const Sizex< Type > &s) const
| Size - Size operator. More...
Sizex< Type > & | clan::Sizex< Type >::operator+= (const Type &s)
| Size += operator. More...
Sizex< Type > & | clan::Sizex< Type >::operator-= (const Type &s)
| Size -= operator. More...
Sizex< Type > & | clan::Sizex< Type >::operator*= (const Type &s)
| Size *= operator. More...
Sizex< Type > & | clan::Sizex< Type >::operator/= (const Type &s)
| Size /= operator. More...
Sizex< Type > | clan::Sizex< Type >::operator+ (const Type &s) const
| Size + operator. More...
Sizex< Type > | clan::Sizex< Type >::operator- (const Type &s) const
| Size - operator. More...
Sizex< Type > | clan::Sizex< Type >::operator* (const Type &s) const
| Size * operator. More...
Sizex< Type > | clan::Sizex< Type >::operator/ (const Type &s) const
| Size / operator. More...
bool | clan::Sizex< Type >::operator== (const Sizex< Type > &s) const
| Size == Size operator (deep compare). More...
bool | clan::Sizex< Type >::operator!= (const Sizex< Type > &s) const
| Size != Size operator (deep compare). More...

## Attributes
bool | clan::Trianglex< Type >::point_inside (const Vec2< Type > &point) const
| Return true if the point is inside the triangle. More...

## Operators
Trianglex< Type > & | clan::Trianglex< Type >::operator= (const Trianglex< Type > &copy)
| = operator. More...
bool | clan::Trianglex< Type >::operator== (const Trianglex< Type > &triangle) const
| == operator. More...
bool | clan::Trianglex< Type >::operator!= (const Trianglex< Type > &triangle) const
| != operator. More...

## Attributes
Type | clan::Vec2< Type >::length () const
| Returns the length (magnitude) of this vector. More...
Vec2< Type > & | clan::Vec2< Type >::normalize ()
| Normalizes this vector. More...
Type | clan::Vec2< Type >::dot (const Vec2< Type > &vector) const
| Dot products this vector with an other vector. More...
Angle | clan::Vec2< Type >::angle (const Vec2< Type > &vector) const
| Calculate the angle between this vector and an other vector. More...
Angle | clan::Vec2< Type >::angle_normed (const Vec2< Type > &vector) const
| Calculate the angle between this vector and an other vector, where the vectors are unit vectors. More...
Angle | clan::Vec2< Type >::angle_line (const Vec2< Type > &point) const
| Calculate the angle of the line joining this point and other point. More...
Type | clan::Vec2< Type >::distance (const Vec2< Type > &vector) const
| Calculate the distance between this vector and an other vector. More...
Vec2< Type > & | clan::Vec2< Type >::round ()
| Rounds all components of this vector. More...
Vec2< Type > & | clan::Vec2< Type >::rotate (const Vec2< Type > &hotspot, const Angle &angle)
| Rotate this vector around another point. More...
Type | clan::Vec2< Type >::round_value (float value) const
| Rounds a value for the datatype. More...
bool | clan::Vec2< Type >::is_equal (const Vec2< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
void | clan::Vec2< Type >::operator+= (const Vec2< Type > &vector)
| += operator. More...
void | clan::Vec2< Type >::operator+= (Type value)
| += operator. More...
void | clan::Vec2< Type >::operator-= (const Vec2< Type > &vector)
| -= operator. More...
void | clan::Vec2< Type >::operator-= (Type value)
| -= operator. More...
Vec2< Type > | clan::Vec2< Type >::operator- () const
| operator. More...
void | clan::Vec2< Type >::operator*= (const Vec2< Type > &vector)
| *= operator. More...
void | clan::Vec2< Type >::operator*= (Type value)
| *= operator. More...
void | clan::Vec2< Type >::operator/= (const Vec2< Type > &vector)
| /= operator. More...
void | clan::Vec2< Type >::operator/= (Type value)
| /= operator. More...
Vec2< Type > & | clan::Vec2< Type >::operator= (const Vec2< Type > &vector)
| = operator. More...
bool | clan::Vec2< Type >::operator== (const Vec2< Type > &vector) const
| == operator. More...
bool | clan::Vec2< Type >::operator!= (const Vec2< Type > &vector) const
| != operator. More...
bool | clan::Vec2< Type >::operator< (const Vec2< Type > &vector) const
| < operator. More...

## Attributes
Type | clan::Vec3< Type >::length () const
| Returns the length (magnitude) of this vector. More...
Vec3< Type > & | clan::Vec3< Type >::normalize ()
| Normalizes this vector. More...
Type | clan::Vec3< Type >::dot (const Vec3< Type > &vector) const
| Dot products this vector with an other vector. More...
Angle | clan::Vec3< Type >::angle (const Vec3< Type > &vector) const
| Calculate the angle between this vector and an other vector. More...
Angle | clan::Vec3< Type >::angle_normed (const Vec3< Type > &vector) const
| Calculate the angle between this vector and an other vector, where the vectors are unit vectors. More...
Type | clan::Vec3< Type >::distance (const Vec3< Type > &vector) const
| Calculate the distance between this vector and an other vector. More...
Vec3< Type > & | clan::Vec3< Type >::cross (const Vec3< Type > &vector)
| Calculate the cross product between this vector and an other vector. More...
Vec3< Type > & | clan::Vec3< Type >::rotate (const Angle &angle, const Vec3< Type > &axis)
| Rotate this vector around an axis. Same as glRotate[f|d](angle, a);. More...
Vec3< Type > & | clan::Vec3< Type >::round ()
| Rounds all components on this vector. More...
bool | clan::Vec3< Type >::is_equal (const Vec3< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
void | clan::Vec3< Type >::operator+= (const Vec3< Type > &vector)
| += operator. More...
void | clan::Vec3< Type >::operator+= (Type value)
| += operator. More...
void | clan::Vec3< Type >::operator-= (const Vec3< Type > &vector)
| -= operator. More...
void | clan::Vec3< Type >::operator-= (Type value)
| -= operator. More...
Vec3< Type > | clan::Vec3< Type >::operator- () const
| operator. More...
void | clan::Vec3< Type >::operator*= (const Vec3< Type > &vector)
| *= operator. More...
void | clan::Vec3< Type >::operator*= (Type value)
| *= operator. More...
void | clan::Vec3< Type >::operator/= (const Vec3< Type > &vector)
| /= operator. More...
void | clan::Vec3< Type >::operator/= (Type value)
| /= operator. More...
Vec3< Type > & | clan::Vec3< Type >::operator= (const Vec3< Type > &vector)
| = operator. More...
bool | clan::Vec3< Type >::operator== (const Vec3< Type > &vector) const
| == operator. More...
bool | clan::Vec3< Type >::operator!= (const Vec3< Type > &vector) const
| != operator. More...
bool | clan::Vec3< Type >::operator< (const Vec3< Type > &vector) const
| < operator. More...

## Attributes
void | clan::Vec4< Type >::set_xy (const Vec2< Type > &new_v)
void | clan::Vec4< Type >::set_zw (const Vec2< Type > &new_v)
*Type | clan::Vec4< Type >::length3 () const
| Returns the length (magnitude) of this vector (not taking into account the w ordinate). More...
*Type | clan::Vec4< Type >::length4 () const
| Returns the length (magnitude) of this vector (taking into account the w ordinate). More...
Vec4< Type > & | clan::Vec4< Type >::normalize3 ()
| Normalizes this vector (not taking into account the w ordinate) More...
Vec4< Type > & | clan::Vec4< Type >::normalize4 ()
| Normalizes this vector (taking into account the w ordinate) More...
Type | clan::Vec4< Type >::dot3 (const Vec4< Type > &vector) const
| Dot products this vector with an other vector (not taking into account the w ordinate). More...
Type | clan::Vec4< Type >::dot4 (const Vec4< Type > &vector) const
| Dot products this vector with an other vector (taking into account the w ordinate). More...
Angle | clan::Vec4< Type >::angle3 (const Vec4< Type > &vector) const
| Calculate the angle between this vector and an other vector (not taking into account the w ordinate). More...
Type | clan::Vec4< Type >::distance3 (const Vec4< Type > &vector) const
| Calculate the distance between this vector and an other vector (not taking into account the w ordinate). More...
Type | clan::Vec4< Type >::distance4 (const Vec4< Type > &vector) const
| Calculate the distance between this vector and an other vector (taking into account the w ordinate). More...
Vec4< Type > & | clan::Vec4< Type >::cross3 (const Vec4< Type > &vector)
| Calculate the cross product between this vector and an other vector (not taking into account the w ordinate). More...
Vec4< Type > & | clan::Vec4< Type >::rotate3 (const Angle &angle, const Vec4< Type > &axis)
| Rotate this vector around an axis. Same as glRotate[f|d](angle, a);. More...
Vec4< Type > & | clan::Vec4< Type >::round ()
| Rounds all components on this vector. More...
bool | clan::Vec4< Type >::is_equal (const Vec4< Type > &other, Type epsilon) const
| Returns true if equal within the bounds of an epsilon. More...

## Operators
void | clan::Vec4< Type >::operator+= (const Vec4< Type > &vector)
| += operator. More...
void | clan::Vec4< Type >::operator+= (Type value)
| += operator. More...
void | clan::Vec4< Type >::operator-= (const Vec4< Type > &vector)
| -= operator. More...
void | clan::Vec4< Type >::operator-= (Type value)
| -= operator. More...
Vec4< Type > | clan::Vec4< Type >::operator- () const
| operator. More...
void | clan::Vec4< Type >::operator*= (const Vec4< Type > &vector)
| *= operator. More...
void | clan::Vec4< Type >::operator*= (Type value)
| *= operator. More...
void | clan::Vec4< Type >::operator/= (const Vec4< Type > &vector)
| /= operator. More...
void | clan::Vec4< Type >::operator/= (Type value)
| /= operator. More...
Vec4< Type > & | clan::Vec4< Type >::operator= (const Vec4< Type > &vector)
| = operator. More...
bool | clan::Vec4< Type >::operator== (const Vec4< Type > &vector) const
| == operator. More...
bool | clan::Vec4< Type >::operator!= (const Vec4< Type > &vector) const
| != operator. More...
bool | clan::Vec4< Type >::operator< (const Vec4< Type > &vector) const
| < operator. More...

## Detailed Description

## Typedef Documentation

template<typename Type>

typedef Type clan::Vec2< Type >::datatype

template<typename Type>

typedef Type clan::Vec3< Type >::datatype

template<typename Type>

typedef Type clan::Vec4< Type >::datatype

typedef Mat2<double> clan::Mat2d

typedef Mat2<float> clan::Mat2f

typedef Mat2<int> clan::Mat2i

typedef Mat3<double> clan::Mat3d

typedef Mat3<float> clan::Mat3f

typedef Mat3<int> clan::Mat3i

typedef Mat4<double> clan::Mat4d

typedef Mat4<float> clan::Mat4f

typedef Mat4<int> clan::Mat4i

typedef Vec2<char> clan::Vec2b

typedef Vec2<double> clan::Vec2d

typedef Vec2<float> clan::Vec2f

typedef Vec2<int> clan::Vec2i

typedef Vec2<short> clan::Vec2s

typedef Vec2<unsigned char> clan::Vec2ub

typedef Vec2<unsigned int> clan::Vec2ui

typedef Vec2<unsigned short> clan::Vec2us

typedef Vec3<char> clan::Vec3b

typedef Vec3<double> clan::Vec3d

typedef Vec3<float> clan::Vec3f

typedef Vec3<int> clan::Vec3i

typedef Vec3<short> clan::Vec3s

typedef Vec3<unsigned char> clan::Vec3ub

typedef Vec3<unsigned int> clan::Vec3ui

typedef Vec3<unsigned short> clan::Vec3us

typedef Vec4<char> clan::Vec4b

typedef Vec4<double> clan::Vec4d

typedef Vec4<float> clan::Vec4f

typedef Vec4<int> clan::Vec4i

typedef Vec4<short> clan::Vec4s

typedef Vec4<unsigned char> clan::Vec4ub

typedef Vec4<unsigned int> clan::Vec4ui

typedef Vec4<unsigned short> clan::Vec4us

## Enumeration Type Documentation

enum clan::RectPacker::AllocationPolicy

Allocation policy.

Enumerator
create_new_group |
search_previous_groups |
fail_if_full |

enum clan::AngleUnit

Angle unit.

Enumerator
angle_degrees |
angle_radians |

enum clan::ClipZRange

Enumerator
clip_negative_positive_w |
clip_zero_positive_w |

enum clan::EulerOrder

Euler angle rotation order.

Enumerator
order_XYZ |
order_XZY |
order_YZX |
order_YXZ |
order_ZXY |
order_ZYX |

enum clan::Handedness

Enumerator
handed_left |
handed_right |

enum clan::Origin

Alignment origins.

Enumerator
origin_top_left |
origin_top_center |
origin_top_right |
origin_center_left |
origin_center |
origin_center_right |
origin_bottom_left |
origin_bottom_center |
origin_bottom_right |

enum clan::IntersectionTest::OverlapResult

Enumerator
disjoint |
overlap |

enum clan::PolygonOrientation

Polygon orientations.

Enumerator
cl_clockwise |
cl_counter_clockwise |

enum clan::IntersectionTest::Result

Enumerator
outside |
inside |
intersecting |

## Function Documentation

clan::RectPacker::AllocatedRect::AllocatedRect | ( | int | group_index,
|  | Rect | rect
| ) |  |
| inline

clan::Angle::Angle | ( |  | ) |

Constructs an NULL Angle object.

clan::Angle::Angle | ( | float | value,
|  | AngleUnit | unit
| ) |  |

Constructs an Angle object.

clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox | ( |  | ) |
| inline

clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox | ( | const Vec3f & | aabb_min,
|  | const Vec3f & | aabb_max
| ) |  |
| inline

clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox | ( | const AxisAlignedBoundingBox & | aabb,
|  | const Vec3f & | barycentric_min,
|  | const Vec3f & | barycentric_max
| ) |  |
| inline

clan::Base64Decoder::Base64Decoder | ( |  | ) |

Constructs a base64 decoder.

clan::Base64Encoder::Base64Encoder | ( |  | ) |

Constructs a base64 encoder.

clan::BezierCurve::BezierCurve | ( |  | ) |

Constructs a bezier curve generator.

clan::BigInt::BigInt | ( |  | ) |

Constructs a big integer (initialised to zero)

clan::BigInt::BigInt | ( | uint32_t | value | ) |
| explicit

Constructs a big integer (initialised to value)

clan::BigInt::BigInt | ( | int32_t | value | ) |
| explicit

Constructs a big integer (initialised to value)

clan::BigInt::BigInt | ( | uint64_t | value | ) |
| explicit

Constructs a big integer (initialised to value)

clan::BigInt::BigInt | ( | int64_t | value | ) |
| explicit

Constructs a big integer (initialised to value)

clan::BigInt::BigInt | ( | const BigInt & | other | ) |

Copy constructor.

clan::Circle::Circle | ( | int | x,
|  | int | y,
|  | int | radius
| ) |  |
| inline

clan::Circle::Circle | ( | const Vec2< int > & | p,
|  | int | radius
| ) |  |
| inline

clan::Circle::Circle | ( |  | ) |
| inline

clan::Circle::Circle | ( | const Circlex< int > & | copy | ) |
| inline

clan::Circled::Circled | ( | double | x,
|  | double | y,
|  | double | radius
| ) |  |
| inline

clan::Circled::Circled | ( | const Vec2< double > & | p,
|  | double | radius
| ) |  |
| inline

clan::Circled::Circled | ( |  | ) |
| inline

clan::Circled::Circled | ( | const Circlex< double > & | copy | ) |
| inline

clan::Circlef::Circlef | ( | float | x,
|  | float | y,
|  | float | radius
| ) |  |
| inline

clan::Circlef::Circlef | ( | const Vec2< float > & | p,
|  | float | radius
| ) |  |
| inline

clan::Circlef::Circlef | ( |  | ) |
| inline

clan::Circlef::Circlef | ( | const Circlex< float > & | copy | ) |
| inline

template<typename Type>

clan::Circlex< Type >::Circlex | ( | Type | x,
|  | Type | y,
|  | Type | radius
| ) |  |
| inline

template<typename Type>

clan::Circlex< Type >::Circlex | ( | const Vec2< Type > & | p,
|  | Type | radius
| ) |  |
| inline

template<typename Type>

clan::Circlex< Type >::Circlex | ( |  | ) |
| inline

template<typename Type>

clan::Circlex< Type >::Circlex | ( | const Circlex< Type > & | copy | ) |
| inline

clan::DelauneyTriangulator::DelauneyTriangulator | ( |  | ) |

Creates a triangulator object.

clan::EarClipResult::EarClipResult | ( | int | num_triangles | ) |

Constructs an ear clipping result structure.

clan::EarClipTriangulator::EarClipTriangulator | ( |  | ) |

Constructs a triangulator.

clan::HalfFloat::HalfFloat | ( |  | ) |
| inline

clan::HalfFloat::HalfFloat | ( | const HalfFloat & | other | ) |
| inline

clan::HalfFloat::HalfFloat | ( | float | v | ) |
| inline

clan::Line2::Line2 | ( |  | ) |
| inline

clan::Line2::Line2 | ( | const Line2x< int > & | copy | ) |
| inline

clan::Line2::Line2 | ( | const Vec2< int > & | point_p,
|  | const Vec2< int > & | point_q
| ) |  |
| inline

clan::Line2::Line2 | ( | const Vec2< int > & | point_p,
|  | int | gradient
| ) |  |
| inline

clan::Line2d::Line2d | ( |  | ) |
| inline

clan::Line2d::Line2d | ( | const Line2x< double > & | copy | ) |
| inline

clan::Line2d::Line2d | ( | const Vec2< double > & | point_p,
|  | const Vec2< double > & | point_q
| ) |  |
| inline

clan::Line2d::Line2d | ( | const Vec2< double > & | point_p,
|  | double | gradient
| ) |  |
| inline

clan::Line2f::Line2f | ( |  | ) |
| inline

clan::Line2f::Line2f | ( | const Line2x< float > & | copy | ) |
| inline

clan::Line2f::Line2f | ( | const Vec2< float > & | point_p,
|  | const Vec2< float > & | point_q
| ) |  |
| inline

clan::Line2f::Line2f | ( | const Vec2< float > & | point_p,
|  | float | gradient
| ) |  |
| inline

template<typename Type>

clan::Line2x< Type >::Line2x | ( |  | ) |
| inline

template<typename Type>

clan::Line2x< Type >::Line2x | ( | const Line2x< Type > & | copy | ) |
| inline

template<typename Type>

clan::Line2x< Type >::Line2x | ( | const Vec2< Type > & | point_p,
|  | const Vec2< Type > & | point_q
| ) |  |
| inline

template<typename Type>

clan::Line2x< Type >::Line2x | ( | const Vec2< Type > & | point_p,
|  | Type | gradient
| ) |  |
| inline

clan::Line3::Line3 | ( |  | ) |
| inline

clan::Line3::Line3 | ( | const Line3x< int > & | copy | ) |
| inline

clan::Line3::Line3 | ( | const Vec3< int > & | point_p,
|  | const Vec3< int > & | point_q
| ) |  |
| inline

clan::Line3d::Line3d | ( |  | ) |
| inline

clan::Line3d::Line3d | ( | const Line3x< double > & | copy | ) |
| inline

clan::Line3d::Line3d | ( | const Vec3< double > & | podouble_p,
|  | const Vec3< double > & | podouble_q
| ) |  |
| inline

clan::Line3f::Line3f | ( |  | ) |
| inline

clan::Line3f::Line3f | ( | const Line3x< float > & | copy | ) |
| inline

clan::Line3f::Line3f | ( | const Vec3< float > & | point_p,
|  | const Vec3< float > & | point_q
| ) |  |
| inline

template<typename Type>

clan::Line3x< Type >::Line3x | ( |  | ) |
| inline

template<typename Type>

clan::Line3x< Type >::Line3x | ( | const Line3x< Type > & | copy | ) |
| inline

template<typename Type>

clan::Line3x< Type >::Line3x | ( | const Vec3< Type > & | point_p,
|  | const Vec3< Type > & | point_q
| ) |  |
| inline

clan::LineRay2::LineRay2 | ( |  | ) |
| inline

clan::LineRay2::LineRay2 | ( | const LineRay2x< int > & | copy | ) |
| inline

clan::LineRay2::LineRay2 | ( | const Vec2< int > & | point_p,
|  | const Vec2< int > & | direction_v
| ) |  |
| inline

clan::LineRay2d::LineRay2d | ( |  | ) |
| inline

clan::LineRay2d::LineRay2d | ( | const LineRay2x< double > & | copy | ) |
| inline

clan::LineRay2d::LineRay2d | ( | const Vec2< double > & | point_p,
|  | const Vec2< double > & | direction_v
| ) |  |
| inline

clan::LineRay2f::LineRay2f | ( |  | ) |
| inline

clan::LineRay2f::LineRay2f | ( | const LineRay2x< float > & | copy | ) |
| inline

clan::LineRay2f::LineRay2f | ( | const Vec2< float > & | point_p,
|  | const Vec2< float > & | direction_v
| ) |  |
| inline

template<typename Type>

clan::LineRay2x< Type >::LineRay2x | ( |  | ) |
| inline

template<typename Type>

clan::LineRay2x< Type >::LineRay2x | ( | const LineRay2x< Type > & | copy | ) |
| inline

template<typename Type>

clan::LineRay2x< Type >::LineRay2x | ( | const Vec2< Type > & | point_p,
|  | const Vec2< Type > & | direction_v
| ) |  |
| inline

clan::LineRay3::LineRay3 | ( |  | ) |
| inline

clan::LineRay3::LineRay3 | ( | const LineRay3x< int > & | copy | ) |
| inline

clan::LineRay3::LineRay3 | ( | const Vec3< int > & | point_p,
|  | const Vec3< int > & | direction_v
| ) |  |
| inline

clan::LineRay3d::LineRay3d | ( |  | ) |
| inline

clan::LineRay3d::LineRay3d | ( | const LineRay3x< double > & | copy | ) |
| inline

clan::LineRay3d::LineRay3d | ( | const Vec3< double > & | point_p,
|  | const Vec3< double > & | direction_v
| ) |  |
| inline

clan::LineRay3f::LineRay3f | ( |  | ) |
| inline

clan::LineRay3f::LineRay3f | ( | const LineRay3x< float > & | copy | ) |
| inline

clan::LineRay3f::LineRay3f | ( | const Vec3< float > & | point_p,
|  | const Vec3< float > & | direction_v
| ) |  |
| inline

template<typename Type>

clan::LineRay3x< Type >::LineRay3x | ( |  | ) |
| inline

template<typename Type>

clan::LineRay3x< Type >::LineRay3x | ( | const LineRay3x< Type > & | copy | ) |
| inline

template<typename Type>

clan::LineRay3x< Type >::LineRay3x | ( | const Vec3< Type > & | point_p,
|  | const Vec3< Type > & | direction_v
| ) |  |
| inline

clan::LineSegment2::LineSegment2 | ( |  | ) |
| inline

clan::LineSegment2::LineSegment2 | ( | const LineSegment2x< int > & | copy | ) |
| inline

clan::LineSegment2::LineSegment2 | ( | const Vec2< int > & | point_p,
|  | const Vec2< int > & | point_q
| ) |  |
| inline

clan::LineSegment2d::LineSegment2d | ( |  | ) |
| inline

clan::LineSegment2d::LineSegment2d | ( | const LineSegment2x< double > & | copy | ) |
| inline

clan::LineSegment2d::LineSegment2d | ( | const Vec2< double > & | point_p,
|  | const Vec2< double > & | point_q
| ) |  |
| inline

clan::LineSegment2f::LineSegment2f | ( |  | ) |
| inline

clan::LineSegment2f::LineSegment2f | ( | const LineSegment2x< float > & | copy | ) |
| inline

clan::LineSegment2f::LineSegment2f | ( | const Vec2< float > & | point_p,
|  | const Vec2< float > & | point_q
| ) |  |
| inline

template<typename Type>

clan::LineSegment2x< Type >::LineSegment2x | ( |  | ) |
| inline

template<typename Type>

clan::LineSegment2x< Type >::LineSegment2x | ( | const LineSegment2x< Type > & | copy | ) |
| inline

template<typename Type>

clan::LineSegment2x< Type >::LineSegment2x | ( | const Vec2< Type > & | point_p,
|  | const Vec2< Type > & | point_q
| ) |  |
| inline

clan::LineSegment3::LineSegment3 | ( |  | ) |
| inline

clan::LineSegment3::LineSegment3 | ( | const LineSegment3x< int > & | copy | ) |
| inline

clan::LineSegment3::LineSegment3 | ( | const Vec3< int > & | point_p,
|  | const Vec3< int > & | point_q
| ) |  |
| inline

clan::LineSegment3d::LineSegment3d | ( |  | ) |
| inline

clan::LineSegment3d::LineSegment3d | ( | const LineSegment3x< double > & | copy | ) |
| inline

clan::LineSegment3d::LineSegment3d | ( | const Vec3< double > & | point_p,
|  | const Vec3< double > & | point_q
| ) |  |
| inline

clan::LineSegment3f::LineSegment3f | ( |  | ) |
| inline

clan::LineSegment3f::LineSegment3f | ( | const LineSegment3x< float > & | copy | ) |
| inline

clan::LineSegment3f::LineSegment3f | ( | const Vec3< float > & | point_p,
|  | const Vec3< float > & | point_q
| ) |  |
| inline

template<typename Type>

clan::LineSegment3x< Type >::LineSegment3x | ( |  | ) |
| inline

template<typename Type>

clan::LineSegment3x< Type >::LineSegment3x | ( | const LineSegment3x< Type > & | copy | ) |
| inline

template<typename Type>

clan::LineSegment3x< Type >::LineSegment3x | ( | const Vec3< Type > & | point_p,
|  | const Vec3< Type > & | point_q
| ) |  |
| inline

template<typename Type>

clan::Mat2< Type >::Mat2 | ( |  | ) |
| inline

Constructs a 2x2 matrix (zero'ed)

References clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const Mat2< Type > & | copy | ) |
| inline

Constructs a 2x2 matrix (copied)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const Mat3< Type > & | copy | ) |
| explicit

Constructs a 2x2 matrix (copied from a 3d matrix)

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const Mat4< Type > & | copy | ) |
| explicit

Constructs a 2x2 matrix (copied from a 4d matrix)

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const float * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4 floats)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | Type | m00,
|  | Type | m01,
|  | Type | m10,
|  | Type | m11
| ) |  |
| inline explicit

Constructs a 2x2 matrix (copied from specified values)

References clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const double * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4 doubles)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const int64_t * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4, 64 bit integers)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const int32_t * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4, 32 bit integers)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const int16_t * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4, 16 bit integers)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::Mat2 | ( | const int8_t * | init_matrix | ) |
| inline explicit

Constructs a 2x2 matrix (copied from 4, 8 bit integers)

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat3< Type >::Mat3 | ( |  | ) |
| inline

Constructs a 3x3 matrix (zero'ed)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const Mat3< Type > & | copy | ) |
| inline

Constructs a 3x3 matrix (copied)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const Mat2< Type > & | copy | ) |
| explicit

Constructs a 3x3 matrix (copied from a 2d matrix)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const Mat4< Type > & | copy | ) |
| explicit

Constructs a 3x3 matrix (copied from a 4d matrix)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const float * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9 floats)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | Type | m00,
|  | Type | m01,
|  | Type | m02,
|  | Type | m10,
|  | Type | m11,
|  | Type | m12,
|  | Type | m20,
|  | Type | m21,
|  | Type | m22
| ) |  |
| inline explicit

Constructs a 3x3 matrix (copied from specified values)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const double * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9 doubles)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const int64_t * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9, 64 bit integers)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const int32_t * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9, 32 bit integers)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const int16_t * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9, 16 bit integers)

template<typename Type>

clan::Mat3< Type >::Mat3 | ( | const int8_t * | init_matrix | ) |
| inline explicit

Constructs a 3x3 matrix (copied from 9, 8 bit integers)

template<typename Type>

clan::Mat4< Type >::Mat4 | ( |  | ) |
| inline

Constructs a 4x4 matrix (zero'ed)

References clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const Mat4< Type > & | copy | ) |
| inline

Constructs a 4x4 matrix (copied)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const Mat2< Type > & | copy | ) |
| explicit

Constructs a 4x4 matrix (copied from a 2d matrix)

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const Mat3< Type > & | copy | ) |
| explicit

Constructs a 4x4 matrix (copied from a 3d matrix)

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const float * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of floats)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const double * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of doubles)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const int64_t * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of 64 bit integers)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const int32_t * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of 32 bit integers)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const int16_t * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of 16 bit integers)

References clan::i, and clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::Mat4 | ( | const int8_t * | init_matrix | ) |
| inline explicit

Constructs a 4x4 matrix (copied from a array of 8 bit integers)

References clan::i, and clan::Mat4< Type >::matrix.

clan::OutlineTriangulator::OutlineTriangulator | ( |  | ) |

Creates a tessellation object.

clan::Point::Point | ( |  | ) |
| inline

clan::Point::Point | ( | int | x,
|  | int | y
| ) |  |
| inline

clan::Point::Point | ( | const Pointx< int > & | p | ) |
| inline

clan::Point::Point | ( | const Vec2< int > & | p | ) |
| inline

clan::Pointd::Pointd | ( |  | ) |
| inline

clan::Pointd::Pointd | ( | double | x,
|  | double | y
| ) |  |
| inline

clan::Pointd::Pointd | ( | const Pointx< double > & | p | ) |
| inline

clan::Pointd::Pointd | ( | const Vec2< double > & | p | ) |
| inline

clan::Pointf::Pointf | ( |  | ) |
| inline

clan::Pointf::Pointf | ( | float | x,
|  | float | y
| ) |  |
| inline

clan::Pointf::Pointf | ( | const Pointx< float > & | p | ) |
| inline

clan::Pointf::Pointf | ( | const Vec2< float > & | p | ) |
| inline

template<typename Type>

clan::Pointx< Type >::Pointx | ( |  | ) |
| inline

template<typename Type>

clan::Pointx< Type >::Pointx | ( | Type | x,
|  | Type | y
| ) |  |
| inline

template<typename Type>

clan::Pointx< Type >::Pointx | ( | const Pointx< Type > & | p | ) |
| inline

template<typename Type>

clan::Pointx< Type >::Pointx | ( | const Vec2< Type > & | p | ) |
| inline

clan::Quad::Quad | ( |  | ) |
| inline

clan::Quad::Quad | ( | const Vec2< int > & | new_p,
|  | const Vec2< int > & | new_q,
|  | const Vec2< int > & | new_r,
|  | const Vec2< int > & | new_s
| ) |  |
| inline

clan::Quad::Quad | ( | const Rect & | rect | ) |
| inline

clan::Quad::Quad | ( | const Quadx< int > & | quad | ) |
| inline

clan::Quadd::Quadd | ( |  | ) |
| inline

clan::Quadd::Quadd | ( | const Vec2< double > & | new_p,
|  | const Vec2< double > & | new_q,
|  | const Vec2< double > & | new_r,
|  | const Vec2< double > & | new_s
| ) |  |
| inline

clan::Quadd::Quadd | ( | const Rectd & | rect | ) |
| inline

clan::Quadd::Quadd | ( | const Quadx< double > & | quad | ) |
| inline

clan::Quadf::Quadf | ( |  | ) |
| inline

clan::Quadf::Quadf | ( | const Vec2< float > & | new_p,
|  | const Vec2< float > & | new_q,
|  | const Vec2< float > & | new_r,
|  | const Vec2< float > & | new_s
| ) |  |
| inline

clan::Quadf::Quadf | ( | const Rectf & | rect | ) |
| inline

clan::Quadf::Quadf | ( | const Quadx< float > & | quad | ) |
| inline

template<typename Type>

clan::Quadx< Type >::Quadx | ( |  | ) |
| inline

Constructs a quad.

Referenced by clan::Quadx< int >::operator+(), and clan::Quadx< int >::operator-().

template<typename Type>

clan::Quadx< Type >::Quadx | ( | const Vec2< Type > & | new_p,
|  | const Vec2< Type > & | new_q,
|  | const Vec2< Type > & | new_r,
|  | const Vec2< Type > & | new_s
| ) |  |
| inline

Constructs a quad.

Parameters

  new_p | = coord for first point of quad.
  new_q | = coord for second point of quad.
  new_r | = coord for third point of quad.
  new_s | = coord for forth point of quad.

template<typename Type>

clan::Quadx< Type >::Quadx | ( | const Rectx< Type > & | rect | ) |
| inline

Constructs a quad.

Parameters

  rect | Rectangle used to initialize the quad.

The corners of the rect are mapped to the quad member variables as follows:

- Top-left: p
- Top-right: q
- Bottom-right: r
- Bottom-left: s

template<typename Type>

clan::Quadx< Type >::Quadx | ( | const Quadx< Type > & | quad | ) |
| inline

Constructs a quad.

Parameters

  quad | = Quad used to initialize this quad.

clan::Quaterniond::Quaterniond | ( |  | ) |
| inline

clan::Quaterniond::Quaterniond | ( | const Quaternionx< double > & | copy | ) |
| inline

clan::Quaterniond::Quaterniond | ( | const Mat4< double > & | rotation_matrix | ) |
| inline explicit

clan::Quaterniond::Quaterniond | ( | double | real,
|  | double | i,
|  | double | j,
|  | double | k
| ) |  |
| inline explicit

clan::Quaterniond::Quaterniond | ( | double | real,
|  | const Vec3< double > & | imag
| ) |  |
| inline explicit

clan::Quaterniond::Quaterniond | ( | double | euler_x,
|  | double | euler_y,
|  | double | euler_z,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| inline explicit

clan::Quaterniond::Quaterniond | ( | const Vec3< double > & | euler,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| inline explicit

clan::Quaterniond::Quaterniond | ( | const Angle & | euler_x,
|  | const Angle & | euler_y,
|  | const Angle & | euler_z,
|  | EulerOrder | order
| ) |  |
| inline explicit

clan::Quaternionf::Quaternionf | ( |  | ) |
| inline

clan::Quaternionf::Quaternionf | ( | const Quaternionx< float > & | copy | ) |
| inline

clan::Quaternionf::Quaternionf | ( | const Mat4< float > & | rotation_matrix | ) |
| inline explicit

clan::Quaternionf::Quaternionf | ( | float | real,
|  | float | i,
|  | float | j,
|  | float | k
| ) |  |
| inline explicit

clan::Quaternionf::Quaternionf | ( | float | real,
|  | const Vec3< float > & | imag
| ) |  |
| inline explicit

clan::Quaternionf::Quaternionf | ( | float | euler_x,
|  | float | euler_y,
|  | float | euler_z,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| inline explicit

clan::Quaternionf::Quaternionf | ( | const Vec3< float > & | euler,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| inline explicit

clan::Quaternionf::Quaternionf | ( | const Angle & | euler_x,
|  | const Angle & | euler_y,
|  | const Angle & | euler_z,
|  | EulerOrder | order
| ) |  |
| inline explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( |  | ) |
| inline

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | Type | real,
|  | Type | i,
|  | Type | j,
|  | Type | k
| ) |  |
| inline explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | Type | real,
|  | const Vec3< Type > & | imag
| ) |  |
| inline explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | const Quaternionx< Type > & | copy | ) |
| inline

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | Type | euler_x,
|  | Type | euler_y,
|  | Type | euler_z,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | const Vec3< Type > & | euler,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |
| explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | const Angle & | euler_x,
|  | const Angle & | euler_y,
|  | const Angle & | euler_z,
|  | EulerOrder | order
| ) |  |
| explicit

template<typename Type>

clan::Quaternionx< Type >::Quaternionx | ( | const Mat4< Type > & | rotation_matrix | ) |
| explicit

clan::Rect::Rect | ( |  | ) |
| inline

clan::Rect::Rect | ( | const Sizex< int > & | s | ) |
| inline

clan::Rect::Rect | ( | int | new_left,
|  | int | new_top,
|  | int | new_right,
|  | int | new_bottom
| ) |  |
| inline

clan::Rect::Rect | ( | const Pointx< int > & | p,
|  | const Sizex< int > & | size
| ) |  |
| inline

clan::Rect::Rect | ( | const Rectx< int > & | rect | ) |
| inline

clan::Rect::Rect | ( | const Rectx< float > & | rect | ) |
| inline

clan::Rect::Rect | ( | const Rectx< double > & | rect | ) |
| inline

clan::Rect::Rect | ( | int | new_left,
|  | int | new_top,
|  | const Sizex< int > & | size
| ) |  |
| inline

clan::Rectd::Rectd | ( |  | ) |
| inline

clan::Rectd::Rectd | ( | const Sizex< int > & | s | ) |
| inline

clan::Rectd::Rectd | ( | const Sizex< float > & | s | ) |
| inline

clan::Rectd::Rectd | ( | const Sizex< double > & | s | ) |
| inline

clan::Rectd::Rectd | ( | double | new_left,
|  | double | new_top,
|  | double | new_right,
|  | double | new_bottom
| ) |  |
| inline

clan::Rectd::Rectd | ( | const Pointx< double > & | p,
|  | const Sizex< double > & | size
| ) |  |
| inline

clan::Rectd::Rectd | ( | const Rectx< int > & | rect | ) |
| inline

clan::Rectd::Rectd | ( | const Rectx< float > & | rect | ) |
| inline

clan::Rectd::Rectd | ( | const Rectx< double > & | rect | ) |
| inline

clan::Rectd::Rectd | ( | double | new_left,
|  | double | new_top,
|  | const Sizex< double > & | size
| ) |  |
| inline

clan::Rectf::Rectf | ( |  | ) |
| inline

clan::Rectf::Rectf | ( | const Sizex< int > & | s | ) |
| inline

clan::Rectf::Rectf | ( | const Sizex< float > & | s | ) |
| inline

clan::Rectf::Rectf | ( | float | new_left,
|  | float | new_top,
|  | float | new_right,
|  | float | new_bottom
| ) |  |
| inline

clan::Rectf::Rectf | ( | const Pointx< float > & | p,
|  | const Sizex< float > & | size
| ) |  |
| inline

clan::Rectf::Rectf | ( | const Rectx< int > & | rect | ) |
| inline

clan::Rectf::Rectf | ( | const Rectx< float > & | rect | ) |
| inline

clan::Rectf::Rectf | ( | const Rectx< double > & | rect | ) |
| inline

clan::Rectf::Rectf | ( | float | new_left,
|  | float | new_top,
|  | const Sizex< float > & | size
| ) |  |
| inline

clan::RectPacker::RectPacker | ( |  | ) |

Constructs a null instance.

clan::RectPacker::RectPacker | ( | const Size & | max_group_size,
|  | AllocationPolicy | policy = `create_new_group`
| ) |  |

Constructs a rect group.

template<typename Type>

clan::Rectx< Type >::Rectx | ( |  | ) |
| inline

Constructs an rectangle.

Initialised to zero

template<typename Type>

clan::Rectx< Type >::Rectx | ( | const Sizex< Type > & | s | ) |
| inline

Constructs an rectangle.

Parameters

  s | = Size

template<typename Type>

clan::Rectx< Type >::Rectx | ( | Type | new_left,
|  | Type | new_top,
|  | Type | new_right,
|  | Type | new_bottom
| ) |  |
| inline

Constructs an rectangle.

Parameters

  new_left | Initial left position of rectangle.
  new_top | Initial top position of rectangle.
  new_right | Initial right position of rectangle.
  new_bottom | Initial bottom position of rectangle.

template<typename Type>

clan::Rectx< Type >::Rectx | ( | const Pointx< Type > & | p,
|  | const Sizex< Type > & | size
| ) |  |
| inline

Constructs an rectangle.

Parameters

  p | = Initial top-left position of rectangle.
  size | Initial size of rectangle.

template<typename Type>

clan::Rectx< Type >::Rectx | ( | Type | new_left,
|  | Type | new_top,
|  | const Sizex< Type > & | size
| ) |  |
| inline

Constructs an rectangle.

Parameters

  new_left | Initial left position of rectangle.
  new_top | Initial top position of rectangle.
  size | Initial size of rectangle.

template<typename Type>

clan::Rectx< Type >::Rectx | ( | const Rectx< int > & | rect | ) |
| inline

Constructs an rectangle.

Parameters

  rect | Initial rectangle position and size.

References clan::left, and clan::right.

template<typename Type>

clan::Rectx< Type >::Rectx | ( | const Rectx< float > & | rect | ) |
| inline

Constructs an rectangle.

Parameters

  rect | Initial rectangle position and size.

References clan::left, and clan::right.

template<typename Type>

clan::Rectx< Type >::Rectx | ( | const Rectx< double > & | rect | ) |
| inline

Constructs an rectangle.

Parameters

  rect | Initial rectangle position and size.

References clan::left, and clan::right.

clan::Size::Size | ( |  | ) |
| inline

clan::Size::Size | ( | int | width,
|  | int | height
| ) |  |
| inline

clan::Size::Size | ( | const Sizex< int > & | s | ) |
| inline

clan::Size::Size | ( | const Vec2< int > & | s | ) |
| inline

clan::Size::Size | ( | const Sizex< float > & | copy | ) |
| inline explicit

References clan::Sizex< int >::height, clan::Sizex< Type >::height, clan::Sizex< int >::width, and clan::Sizex< Type >::width.

clan::Size::Size | ( | const Sizex< double > & | copy | ) |
| inline explicit

References clan::Sizex< int >::height, clan::Sizex< Type >::height, clan::Sizex< int >::width, and clan::Sizex< Type >::width.

clan::Sized::Sized | ( |  | ) |
| inline

clan::Sized::Sized | ( | double | width,
|  | double | height
| ) |  |
| inline

clan::Sized::Sized | ( | const Sizex< double > & | s | ) |
| inline

clan::Sized::Sized | ( | const Vec2< double > & | s | ) |
| inline

clan::Sized::Sized | ( | const Sizex< int > & | copy | ) |
| inline

References clan::Sizex< double >::height, clan::Sizex< Type >::height, clan::Sizex< double >::width, and clan::Sizex< Type >::width.

clan::Sized::Sized | ( | const Sizex< float > & | copy | ) |
| inline

References clan::Sizex< double >::height, clan::Sizex< Type >::height, clan::Sizex< double >::width, and clan::Sizex< Type >::width.

clan::Sizef::Sizef | ( |  | ) |
| inline

clan::Sizef::Sizef | ( | float | width,
|  | float | height
| ) |  |
| inline

clan::Sizef::Sizef | ( | const Sizex< float > & | s | ) |
| inline

clan::Sizef::Sizef | ( | const Vec2< float > & | s | ) |
| inline

clan::Sizef::Sizef | ( | const Sizex< int > & | copy | ) |
| inline

References clan::Sizex< float >::height, clan::Sizex< Type >::height, clan::Sizex< float >::width, and clan::Sizex< Type >::width.

clan::Sizef::Sizef | ( | const Sizex< double > & | copy | ) |
| inline explicit

References clan::Sizex< float >::height, clan::Sizex< Type >::height, clan::Sizex< float >::width, and clan::Sizex< Type >::width.

template<typename Type>

clan::Sizex< Type >::Sizex | ( |  | ) |
| inline

Constructs a size structure.

template<typename Type>

clan::Sizex< Type >::Sizex | ( | Type | width,
|  | Type | height
| ) |  |
| inline

Constructs a size structure.

Parameters

  width | Initial width of size structure.
  height | Initial height of size structure.

template<typename Type>

clan::Sizex< Type >::Sizex | ( | const Sizex< Type > & | s | ) |
| inline

Constructs a size structure.

Parameters

  s | = Size structure to construct this one from.

clan::Triangle::Triangle | ( |  | ) |
| inline

clan::Triangle::Triangle | ( | const Trianglex< int > & | copy | ) |
| inline

clan::Triangle::Triangle | ( | const Vec2< int > & | point_p,
|  | const Vec2< int > & | point_q,
|  | const Vec2< int > & | point_r
| ) |  |
| inline

clan::Triangled::Triangled | ( |  | ) |
| inline

clan::Triangled::Triangled | ( | const Trianglex< double > & | copy | ) |
| inline

clan::Triangled::Triangled | ( | const Vec2< double > & | point_p,
|  | const Vec2< double > & | point_q,
|  | const Vec2< double > & | point_r
| ) |  |
| inline

clan::Trianglef::Trianglef | ( |  | ) |
| inline

clan::Trianglef::Trianglef | ( | const Trianglex< float > & | copy | ) |
| inline

clan::Trianglef::Trianglef | ( | const Vec2< float > & | point_p,
|  | const Vec2< float > & | point_q,
|  | const Vec2< float > & | point_r
| ) |  |
| inline

template<typename Type>

clan::Trianglex< Type >::Trianglex | ( |  | ) |
| inline

template<typename Type>

clan::Trianglex< Type >::Trianglex | ( | const Trianglex< Type > & | copy | ) |
| inline

template<typename Type>

clan::Trianglex< Type >::Trianglex | ( | const Vec2< Type > & | point_p,
|  | const Vec2< Type > & | point_q,
|  | const Vec2< Type > & | point_r
| ) |  |
| inline

template<typename Type>

clan::Vec2< Type >::Vec2 | ( |  | ) |
| inline

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Type & | scalar | ) |
| inline explicit

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Vec3< Type > & | copy | ) |
| inline explicit

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Vec4< Type > & | copy | ) |
| inline explicit

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Type & | p1,
|  | const Type & | p2
| ) |  |
| inline explicit

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Type * | array_xy | ) |
| inline explicit

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Vec2< double > & | copy | ) |

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Vec2< float > & | copy | ) |

template<typename Type>

clan::Vec2< Type >::Vec2 | ( | const Vec2< int > & | copy | ) |

clan::Vec2hf::Vec2hf | ( |  | ) |
| inline

clan::Vec2hf::Vec2hf | ( | const HalfFloat & | scalar | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Vec3hf & | copy | ) |
| inline explicit

References clan::x, and clan::y.

clan::Vec2hf::Vec2hf | ( | const Vec4hf & | copy | ) |
| inline explicit

References clan::x, and clan::y.

clan::Vec2hf::Vec2hf | ( | const HalfFloat & | p1,
|  | const HalfFloat & | p2
| ) |  |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const HalfFloat * | array_xy | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | float | scalar | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Vec3f & | copy | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Vec4f & | copy | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | float | p1,
|  | float | p2
| ) |  |
| inline explicit

clan::Vec2hf::Vec2hf | ( | float * | array_xy | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Pointx< int > & | point | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Pointx< float > & | point | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Pointx< double > & | point | ) |
| inline explicit

clan::Vec2hf::Vec2hf | ( | const Vec2hf & | copy | ) |
| inline

clan::Vec2hf::Vec2hf | ( | const Vec2d & | copy | ) |
| inline

clan::Vec2hf::Vec2hf | ( | const Vec2f & | copy | ) |
| inline

clan::Vec2hf::Vec2hf | ( | const Vec2i & | copy | ) |
| inline

template<typename Type>

clan::Vec3< Type >::Vec3 | ( |  | ) |
| inline

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Type & | scalar | ) |
| inline explicit

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Vec2< Type > & | copy,
|  | const Type & | p3
| ) |  |
| inline explicit

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Vec4< Type > & | copy | ) |
| inline explicit

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Vec3< double > & | copy | ) |

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Vec3< float > & | copy | ) |

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Vec3< int > & | copy | ) |

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Type & | p1,
|  | const Type & | p2,
|  | const Type & | p3
| ) |  |
| inline explicit

template<typename Type>

clan::Vec3< Type >::Vec3 | ( | const Type * | array_xyz | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( |  | ) |
| inline

clan::Vec3hf::Vec3hf | ( | const HalfFloat & | scalar | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const Vec2hf & | copy,
|  | const HalfFloat & | p3
| ) |  |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const Vec4hf & | copy | ) |
| inline explicit

References clan::x, clan::y, and clan::z.

clan::Vec3hf::Vec3hf | ( | const HalfFloat & | p1,
|  | const HalfFloat & | p2,
|  | const HalfFloat & | p3
| ) |  |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const HalfFloat * | array_xyz | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( | float | scalar | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const Vec2f & | copy,
|  | float | p3
| ) |  |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const Vec4f & | copy | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( | float | p1,
|  | float | p2,
|  | float | p3
| ) |  |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const float * | array_xyz | ) |
| inline explicit

clan::Vec3hf::Vec3hf | ( | const Vec3hf & | copy | ) |
| inline

clan::Vec3hf::Vec3hf | ( | const Vec3d & | copy | ) |
| inline

clan::Vec3hf::Vec3hf | ( | const Vec3f & | copy | ) |
| inline

clan::Vec3hf::Vec3hf | ( | const Vec3i & | copy | ) |
| inline

template<typename Type>

clan::Vec4< Type >::Vec4 | ( |  | ) |
| inline

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Type & | scalar | ) |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Vec2< Type > & | copy,
|  | const Type & | p3,
|  | const Type & | p4
| ) |  |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Vec2< Type > & | copy,
|  | const Vec2< Type > & | copy34
| ) |  |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Vec3< Type > & | copy,
|  | const Type & | p4
| ) |  |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Type & | p1,
|  | const Type & | p2,
|  | const Type & | p3,
|  | const Type & | p4
| ) |  |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Type & | p1,
|  | const Type & | p2,
|  | const Vec2< Type > & | copy34
| ) |  |
| inline explicit

template<typename Type>

clan::Vec4< Type >::Vec4 | ( | const Type * | array_xyzw | ) |
| inline explicit

clan::Vec4hf::Vec4hf | ( |  | ) |
| inline

clan::Vec4hf::Vec4hf | ( | const Vec4f & | copy | ) |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const HalfFloat & | scalar | ) |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec2hf & | copy,
|  | const HalfFloat & | p3,
|  | const HalfFloat & | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec2hf & | copy,
|  | const Vec2hf & | copy34
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec3hf & | copy,
|  | const HalfFloat & | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const HalfFloat & | p1,
|  | const HalfFloat & | p2,
|  | const HalfFloat & | p3,
|  | const HalfFloat & | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const HalfFloat & | p1,
|  | const HalfFloat & | p2,
|  | const Vec2hf & | copy34
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const HalfFloat * | array_xyzw | ) |
| inline explicit

clan::Vec4hf::Vec4hf | ( | float | scalar | ) |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec2f & | copy,
|  | float | p3,
|  | float | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec2f & | copy,
|  | const Vec2f & | copy34
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const Vec3f & | copy,
|  | float | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | float | p1,
|  | float | p2,
|  | float | p3,
|  | float | p4
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | float | p1,
|  | float | p2,
|  | const Vec2f & | copy34
| ) |  |
| inline explicit

clan::Vec4hf::Vec4hf | ( | const float * | array_xyzw | ) |
| inline explicit

virtual clan::BezierCurve::~BezierCurve | ( |  | ) |
| virtual

clan::BigInt::~BigInt | ( |  | ) |

Destructor.

virtual clan::DelauneyTriangulator::~DelauneyTriangulator | ( |  | ) |
| virtual

virtual clan::EarClipResult::~EarClipResult | ( |  | ) |
| virtual

virtual clan::EarClipTriangulator::~EarClipTriangulator | ( |  | ) |
| virtual

virtual clan::OutlineTriangulator::~OutlineTriangulator | ( |  | ) |
| virtual

clan::RectPacker::~RectPacker | ( |  | ) |

static OverlapResult clan::IntersectionTest::aabb | ( | const AxisAlignedBoundingBox & | a,
|  | const AxisAlignedBoundingBox & | b
| ) |  |
| static

void clan::BigInt::abs | ( | BigInt * | b | ) | const

Compute b = |a|. 'a' and 'b' may be identical.

AllocatedRect clan::RectPacker::add | ( | const Size & | size | ) |

Allocate space for another rect.

template<typename Type>

static Mat2<Type> clan::Mat2< Type >::add | ( | const Mat2< Type > & | matrix_1,
|  | const Mat2< Type > & | matrix_2
| ) |  |
| static

Add 2 matrices.

This adds the matrix as follows: result = matrix1 + matrix2

Parameters

  matrix_1 | = First Matrix to add
  matrix_2 | = Second Matrix to add

Returns
  The matrix

template<typename Type>

Mat3< Type > clan::Mat3< Type >::add | ( | const Mat3< Type > & | matrix_1,
|  | const Mat3< Type > & | matrix_2
| ) |  |
| inline static

Add 2 matrices.

This adds the matrix as follows: result = matrix1 + matrix2

Parameters

  matrix_1 | = First Matrix to add
  matrix_2 | = Second Matrix to add

Returns
  The matrix

template<typename Type >

Mat4< Type > clan::Mat4< Type >::add | ( | const Mat4< Type > & | matrix_1,
|  | const Mat4< Type > & | matrix_2
| ) |  |
| inline static

Add 2 matrices.

This adds the matrix as follows: result = matrix1 + matrix2

Parameters

  matrix_1 | = First Matrix to add
  matrix_2 | = Second Matrix to add

Returns
  The matrix

void clan::BezierCurve::add_control_point | ( | float | x,
|  | float | y
| ) |  |

Adds a control point to bezier.

void clan::BezierCurve::add_control_point | ( | const Pointf & |  | ) |

void clan::OutlineTriangulator::add_vertex | ( | float | x,
|  | float | y,
|  | void * | data
| ) |  |

This function specifies a vertex on a polygon.

void clan::EarClipTriangulator::add_vertex | ( | float | x,
|  | float | y
| ) |  |

Add the next vertex of the polygon to the triangulator.

void clan::EarClipTriangulator::add_vertex | ( | const Pointf & | p | ) |

Add vertex.

Parameters

  p | = Pointf

void clan::DelauneyTriangulator::add_vertex | ( | float | x,
|  | float | y,
|  | void * | data
| ) |  |

This function specifies a point to be used in the triangulation.

template<typename Type>

Mat3< Type > clan::Mat3< Type >::adjoint | ( | const Mat3< Type > & | matrix | ) |
| inline static

Calculate the adjoint (or known as Adjugate or Conjugate Transpose) of a matrix.

Parameters

  matrix | = The matrix to use

Returns
  The adjoint matrix

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::adjoint | ( |  | ) |

Creates the adjoint (or known as adjugate) of the matrix.

Returns
  reference to this object

template<typename Type >

Mat4< Type > clan::Mat4< Type >::adjoint | ( | const Mat4< Type > & | matrix | ) |
| inline static

Calculate the adjoint (or known as Adjugate or Conjugate Transpose) of a matrix.

Parameters

  matrix | = The matrix to use

Returns
  The adjoint matrix

References clan::Mat4< Type >::adjoint().

Referenced by clan::Mat4< Type >::adjoint().

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::adjoint | ( |  | ) |

Calculate the adjoint (or known as adjugate) of this matrix.

Returns
  reference to this object

template<typename Type>

Angle clan::Vec3< Type >::angle | ( | const Vec3< Type > & | vector | ) | const

Calculate the angle between this vector and an other vector.

Parameters

  vector | Second vector used to calculate angle.

Returns
  The angle between the two vectors.

template<typename Type>

Angle clan::Vec2< Type >::angle | ( | const Vec2< Type > & | vector | ) | const

Calculate the angle between this vector and an other vector.

Parameters

  vector | = Second vector used to calculate angle.

Returns
  The angle between the two vectors

template<typename Type>

Angle clan::Vec4< Type >::angle3 | ( | const Vec4< Type > & | vector | ) | const

Calculate the angle between this vector and an other vector (not taking into account the w ordinate).

Parameters

  vector | = Second vector used to calculate angle.

Returns
  The angle between the two vectors.

template<typename Type>

Angle clan::Vec2< Type >::angle_line | ( | const Vec2< Type > & | point | ) | const

Calculate the angle of the line joining this point and other point.

Parameters

  point | = Second point in the line

Returns
  The angle

template<typename Type>

Angle clan::Vec3< Type >::angle_normed | ( | const Vec3< Type > & | vector | ) | const

Calculate the angle between this vector and an other vector, where the vectors are unit vectors.

Parameters

  vector | Second vector used to calculate angle.

Returns
  The angle between the two vectors.

template<typename Type>

Angle clan::Vec2< Type >::angle_normed | ( | const Vec2< Type > & | vector | ) | const

Calculate the angle between this vector and an other vector, where the vectors are unit vectors.

Parameters

  vector | = Second vector used to calculate angle.

Returns
  The angle between the two vectors

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::apply_alignment | ( | Origin | origin,
|  | Type | x,
|  | Type | y
| ) |  |

Applies an origin and offset pair to this rectangle.

Parameters

  origin | The new origin to adjust to from default upper-left position
  x,y | Offsets applied negatively to each corner of the rectangle

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::apply_alignment | ( | Origin | origin,
|  | Type | x,
|  | Type | y
| ) |  |
| inline

Applies an origin and offset pair to this rectangle.

Parameters

  origin | The new origin to adjust to from default upper-left position
  x,y | Offsets applied negatively to each corner of the rectangle

Returns
  reference to this object

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::axis_angle | ( | const Angle & | angle,
|  | const Vec3f & | axis
| ) |  |
| static

void clan::EarClipTriangulator::begin_hole | ( |  | ) |

Mark beginning of a polygon hole.

static Rect clan::PointSetMath::bounding_box | ( | const std::vector< Pointf > & | points | ) |
| static

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::bounding_rect | ( | const Rectx< Type > & | rect | ) |
| inline

Calculates the bounding rectangle of the rectangles.

Rect values become: min left, min top, max right, max bottom.

Returns
  reference to this object

template<typename Type>

static Pointx<Type> clan::Vec2< Type >::calc_origin | ( | Origin | origin,
|  | const Sizex< Type > & | size
| ) |  |
| static

Returns the anchor point for the origin within the dimensions of the size structure.

Parameters

  origin | = The origin
  size | = The size

Returns
  The point

Referenced by clan::Rectx< int >::apply_alignment().

PolygonOrientation clan::EarClipTriangulator::calculate_polygon_orientation | ( |  | ) |

Determine the orientation of the vertices in the triangulator.

Vec3f clan::AxisAlignedBoundingBox::center | ( |  | ) | const
| inline

References clan::AxisAlignedBoundingBox::aabb_max, and clan::AxisAlignedBoundingBox::aabb_min.

template<typename Type>

Vec2<Type> clan::Quadx< Type >::center | ( |  | ) | const

Returns the center point of the quad.

template<typename A , typename B , typename C >

C clan::clamp | ( | A | val,
|  | B | minval,
|  | C | maxval
| ) |  |
| inline

References clan::max(), and clan::min().

Referenced by clan::smoothstep().

void clan::EarClipTriangulator::clear | ( |  | ) |

Remove all vertices from triangulator.

template<typename Type>

LineSegment2x<Type>& clan::LineSegment2x< Type >::clip | ( | const Rectx< Type > & | rect,
|  | bool & | clipped
| ) |  |

Clip this line to a rectangle.

If clipping was not successful, this object is undefined

Parameters

  rect | = Rectangle to clip to
  clipped | = On Return: true if the line could be clipped, false if line exists outside the rectangle

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::clip | ( | const Rectx< Type > & | cr | ) |
| inline

Clip according to the specified clip rectangle.

Returns
  reference to this object

static Pointf clan::LineMath::closest_point | ( | const Pointf & | P,
|  | const Pointf & | A,
|  | const Pointf & | B
| ) |  |
| static

Return the Point on the line from A to B closest to point P.

Parameters

  P | point P
  A | point A
  B | point B

static float clan::LineMath::closest_point_relative | ( | const Pointf & | P,
|  | const Pointf & | A,
|  | const Pointf & | B
| ) |  |
| static

Return the relative position (0-1) of the point R on the line from A to B closest to point P.

Parameters

  P | point P
  A | point A
  B | point B

int clan::BigInt::cmp | ( | const BigInt * | b | ) | const

int clan::BigInt::cmp_d | ( | uint32_t | d | ) | const

Compare a <=> d. Returns <0 if a<d, 0 if a=d, >0 if a>d.

int clan::BigInt::cmp_z | ( |  | ) | const

Compare a <=> 0. Returns <0 if a<0, 0 if a=0, >0 if a>0.

template<typename Type>

bool clan::LineSegment2x< Type >::collinear | ( | const LineSegment2x< Type > & | second | ) | const

Return true if two line segments are collinear. (All points are on the same line.)

Parameters

  second | = The second line to check with

Returns
  true = They are collinear

template<typename Type>

bool clan::Rectx< Type >::contains | ( | const Vec2< Type > & | p | ) | const
| inline

Returns true if the rectangle contains the point.

static std::vector<Pointf> clan::PointSetMath::convex_hull_from_polygon | ( | std::vector< Pointf > & | points | ) |
| static

Return the convex hull of the given set of points.

Parameters

  points | the set of points

template<typename Type>

static Vec3<Type> clan::Vec3< Type >::cross | ( | const Vec3< Type > & | vector1,
|  | const Vec3< Type > & | vector2
| ) |  |
| static

Calculate the cross product between two vectors.

Parameters

  vector1 | = The first vector
  vector2 | = The second vector

Returns
  The cross product

template<typename Type>

Vec3<Type>& clan::Vec3< Type >::cross | ( | const Vec3< Type > & | vector | ) |

Calculate the cross product between this vector and an other vector.

Operates in the native datatype

Parameters

  vector | = Second vector used to perform the calculation.

Returns
  reference to this object

template<typename Type>

static Vec4<Type> clan::Vec4< Type >::cross3 | ( | const Vec4< Type > & | vector1,
|  | const Vec4< Type > & | vector2
| ) |  |
| static

Calculate the cross product between two vectors (not taking into account the w ordinate).

= The first vector = The second vector

Returns
  = Cross product

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::cross3 | ( | const Vec4< Type > & | vector | ) |

Calculate the cross product between this vector and an other vector (not taking into account the w ordinate).

Operates in the native datatype

Parameters

  vector | Second vector used to perform the calculation.

Returns
  reference to this object

static DataBuffer clan::Base64Decoder::decode | ( | const void * | data,
|  | int | size
| ) |  |
| static

Decode base64 data and return it in a buffer.

static DataBuffer clan::Base64Decoder::decode | ( | const std::string & | data | ) |
| static

Decode.

Parameters

  data | = String Ref8

Returns
  Data Buffer

static DataBuffer clan::Base64Decoder::decode | ( | const DataBuffer & | data | ) |
| static

Decode.

Parameters

  data | = Data Buffer

Returns
  Data Buffer

template<typename Type>

void clan::Mat4< Type >::decompose | ( | Vec3< Type > & | out_position,
|  | Quaternionx< Type > & | out_orientation,
|  | Vec3< Type > & | out_scale
| ) |  | const

Decompose matrix into position, orientation/rotation and scale.

template<typename Type>

double clan::Mat3< Type >::det | ( |  | ) | const

Calculate the matrix determinant.

template<typename Type>

double clan::Mat4< Type >::det | ( |  | ) | const

Calculate the matrix determinant of this matrix.

Returns
  The determinant

template<typename Type>

Type clan::Vec3< Type >::distance | ( | const Vec3< Type > & | vector | ) | const

Calculate the distance between this vector and an other vector.

Parameters

  vector | = Second vector used to calculate distance.

Returns
  The distance between the two vectors.

template<typename Type>

Type clan::Vec2< Type >::distance | ( | const Vec2< Type > & | vector | ) | const

Calculate the distance between this vector and an other vector.

Parameters

  vector | = Second vector used to calculate distance.

Returns
  The distance between the two vectors.

Referenced by clan::Circlex< int >::is_inside().

template<typename Type>

Type clan::Vec4< Type >::distance3 | ( | const Vec4< Type > & | vector | ) | const

Calculate the distance between this vector and an other vector (not taking into account the w ordinate).

Parameters

  vector | = Second vector used to calculate distance.

Returns
  The distance between the two vectors.

template<typename Type>

Type clan::Vec4< Type >::distance4 | ( | const Vec4< Type > & | vector | ) | const

Calculate the distance between this vector and an other vector (taking into account the w ordinate).

Parameters

  vector | = Second vector used to calculate distance.

Returns
  The distance between the two vectors.

void clan::BigInt::div | ( | const BigInt & | b,
|  | BigInt * | q,
|  | BigInt * | r
| ) |  | const

Compute q = a / b and r = a mod b.

Input parameters may be re-used as output parameters. If q or r is NULL, that portion of the computation will be discarded (although it will still be computed)

void clan::BigInt::div | ( | uint32_t | d,
|  | BigInt * | q,
|  | BigInt * | r
| ) |  | const

void clan::BigInt::div_2 | ( | BigInt * | c | ) | const

Compute c = a / 2, disregarding the remainder.

void clan::BigInt::div_d | ( | uint32_t | d,
|  | BigInt * | q,
|  | uint32_t * | r
| ) |  | const

Compute the quotient q = a / d and remainder r = a mod d, for a single digit d. Respects the sign of its divisor (single digits are unsigned anyway).

template<typename Type>

static Type clan::Vec3< Type >::dot | ( | const Vec3< Type > & | vector1,
|  | const Vec3< Type > & | vector2
| ) |  |
| inline static

Dot products between two vectors.

Returns
  The dot product

template<typename Type>

static Type clan::Vec2< Type >::dot | ( | const Vec2< Type > & | vector_1,
|  | const Vec2< Type > & | vector_2
| ) |  |
| inline static

Dot products a vector with an other vector.

Operates in the native datatype

Parameters

  vector_1 | = First vector used for the dot product.
  vector_2 | = Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

Type clan::Vec3< Type >::dot | ( | const Vec3< Type > & | vector | ) | const
| inline

Dot products this vector with an other vector.

Operates in the native datatype

Parameters

  vector | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

Type clan::Vec2< Type >::dot | ( | const Vec2< Type > & | vector | ) | const
| inline

Dot products this vector with an other vector.

Operates in the native datatype

Parameters

  vector | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

static Type clan::Vec4< Type >::dot3 | ( | const Vec4< Type > & | vector1,
|  | const Vec4< Type > & | vector2
| ) |  |
| inline static

Dot products between two vectors (not taking into account the w ordinate).

Operates in the native datatype

Parameters

  vector1 | First vector used for the dot product.
  vector2 | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

Type clan::Vec4< Type >::dot3 | ( | const Vec4< Type > & | vector | ) | const
| inline

Dot products this vector with an other vector (not taking into account the w ordinate).

Operates in the native datatype

Parameters

  vector | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

static Type clan::Vec4< Type >::dot4 | ( | const Vec4< Type > & | vector1,
|  | const Vec4< Type > & | vector2
| ) |  |
| inline static

Dot products between two vectors (taking into account the w ordinate).

Operates in the native datatype

Parameters

  vector1 | First vector used for the dot product.
  vector2 | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

template<typename Type>

Type clan::Vec4< Type >::dot4 | ( | const Vec4< Type > & | vector | ) | const
| inline

Dot products this vector with an other vector (taking into account the w ordinate).

Operates in the native datatype

Parameters

  vector | Second vector used for the dot product.

Returns
  The resulting dot product of the two vectors.

static std::string clan::Base64Encoder::encode | ( | const void * | data,
|  | int | size
| ) |  |
| static

Base64 encodes data and returns it as an 8 bit string.

static std::string clan::Base64Encoder::encode | ( | const std::string & | data | ) |
| static

Encode.

Parameters

  data | = String Ref8

Returns
  String8

static std::string clan::Base64Encoder::encode | ( | const DataBuffer & | data | ) |
| static

Encode.

Parameters

  data | = Data Buffer

Returns
  String8

void clan::EarClipTriangulator::end_hole | ( |  | ) |

Mark ending of a polygon hole.

void clan::BigInt::exch | ( | BigInt * | mp2 | ) |

Exchange mp1 and mp2 without allocating any intermediate memory.

(well, unless you count the stack space needed for this call and the locals it creates...). This cannot fail.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::expand | ( | const Type & | expand_left,
|  | const Type & | expand_top,
|  | const Type & | expand_right,
|  | const Type & | expand_bottom
| ) |  |
| inline

Expand the rectangle.

Returns
  reference to this object

Referenced by clan::Rectx< int >::expand().

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::expand | ( | const Type & | left_and_right,
|  | const Type & | top_and_bottom
| ) |  |
| inline

Expand the rectangle.

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::expand | ( | const Type & | expand | ) |
| inline

Expand the rectangle.

Returns
  reference to this object

void clan::BigInt::exptmod | ( | const BigInt * | b,
|  | const BigInt * | m,
|  | BigInt * | c
| ) |  | const

Compute c = (a ** b) mod m.

Uses a standard square-and-multiply method with modular reductions at each step. (This is basically the same code as expt(), except for the addition of the reductions)

The modular reductions are done using Barrett's algorithm (see reduce() for details)

Vec3f clan::AxisAlignedBoundingBox::extents | ( |  | ) | const
| inline

References clan::AxisAlignedBoundingBox::aabb_max, and clan::AxisAlignedBoundingBox::aabb_min.

void clan::Base64Decoder::feed | ( | const void * | data,
|  | int | size,
|  | bool | append_result = `true`
| ) |  |

Feeds the decoder with base64 encoded data.

void clan::Base64Encoder::feed | ( | const void * | data,
|  | int | size,
|  | bool | append_result = `true`
| ) |  |

Feeds the encoder with more data.

bool clan::BigInt::fermat | ( | uint32_t | w | ) | const

Using w as a witness, try pseudo-primality testing based on Fermat's little theorem.

If a is prime, and (w, a) = 1, then w^a == w (mod a). So, we compute z = w^a (mod a) and compare z to w; if they are equal, the test passes and we return true. Otherwise, we return false.

void clan::Base64Encoder::finalize | ( | bool | append_result = `true` | ) |

Ends the base64 encoding.

static unsigned short clan::HalfFloat::float_to_half | ( | float | float_value | ) |
| inline static

References clan::f.

Referenced by clan::HalfFloat::from_float().

static unsigned short clan::HalfFloat::float_to_half_simple | ( | float | float_value | ) |
| inline static

Only works for 'normal' half-float values.

References clan::f.

static Angle clan::Angle::from_degrees | ( | float | value | ) |
| static

From degrees.

Parameters

  value | = value

Returns
  Angle

HalfFloat& clan::HalfFloat::from_float | ( | float | v | ) |
| inline

References clan::HalfFloat::float_to_half().

Referenced by clan::HalfFloat::operator=().

static Angle clan::Angle::from_radians | ( | float | value | ) |
| static

From radians.

Parameters

  value | = value

Returns
  Angle

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::frustum | ( | Type | left,
|  | Type | right,
|  | Type | bottom,
|  | Type | top,
|  | Type | z_near,
|  | Type | z_far,
|  | Handedness | handedness,
|  | ClipZRange | clip_z
| ) |  |
| static

Create a frustum matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

static Result clan::IntersectionTest::frustum_aabb | ( | const FrustumPlanes & | frustum,
|  | const AxisAlignedBoundingBox & | box
| ) |  |
| static

static Result clan::IntersectionTest::frustum_obb | ( | const FrustumPlanes & | frustum,
|  | const OrientedBoundingBox & | box
| ) |  |
| static

void clan::OutlineTriangulator::generate | ( |  | ) |

Converts passed polygons into triangles.

void clan::DelauneyTriangulator::generate | ( |  | ) |

Converts passed points into triangles.

std::vector<Pointf> clan::BezierCurve::generate_curve_points | ( | const Angle & | split_angle | ) |

Generates points on the bezier curve.

void clan::BigInt::get | ( | uint32_t & | d | ) |

Gets a value.

Throws exception if number exceeds datatype bounds

void clan::BigInt::get | ( | uint64_t & | d | ) |

void clan::BigInt::get | ( | int64_t & | d | ) |

void clan::BigInt::get | ( | int32_t & | d | ) |

AllocationPolicy clan::RectPacker::get_allocation_policy | ( |  | ) | const

Returns the allocation policy.

template<typename Type>

Pointx<Type> clan::Rectx< Type >::get_bottom_left | ( |  | ) | const
| inline

Returns the bottom-left point outside the rectangle.

template<typename Type>

Pointx<Type> clan::Rectx< Type >::get_bottom_right | ( |  | ) | const
| inline

Returns the bottom-right point outside the rectangle.

template<typename Type>

Rect clan::Quadx< Type >::get_bounds | ( |  | ) | const

Returns the bounding box of the quad as a Rect.

template<typename Type>

Pointx<Type> clan::Rectx< Type >::get_center | ( |  | ) | const
| inline

Returns the center point of the rectangle.

std::vector<Pointf> clan::BezierCurve::get_control_points | ( |  | ) | const

Returns the control points of the bezier.

template<typename Type>

Vec3<Type> clan::Mat4< Type >::get_euler | ( | EulerOrder | order | ) | const

Extract the euler angles (in radians) from a matrix (in column-major format)

Returns
  The x,y,z angles (in radians)

int clan::RectPacker::get_group_count | ( |  | ) | const

Returns the amount of rects used by group.

template<typename Type>

Type clan::Rectx< Type >::get_height | ( |  | ) | const
| inline

Returns the height of the rectangle.

template<typename Type>

Type clan::Quadx< Type >::get_height | ( |  | ) | const

Returns the height of the quad.

Referenced by clan::Quadx< int >::get_size().

template<typename Type>

Vec3<Type> clan::Line3x< Type >::get_intersection | ( | const Line3x< Type > & | second,
|  | bool & | intersect,
|  | Type | range = `(Type) 0.5`
| ) |  | const

Return the intersection of this and other line.

Parameters

  second | = The second line to use
  intersect | = On Return: true if the lines intersect, false if the lines are parallel
  range | = Rounding error delta, to use to judge whether of not the lines intersect

Returns
  The point

template<typename Type>

Vec2<Type> clan::Line2x< Type >::get_intersection | ( | const Line2x< Type > & | second,
|  | bool & | intersect
| ) |  | const

Return the intersection of this and other line.

Parameters

  second | = The second line to use
  intersect | = On Return: true if the lines intersect, false if the lines are parallel

Returns
  The point

template<typename Type>

Vec2<Type> clan::LineSegment2x< Type >::get_intersection | ( | const LineSegment2x< Type > & | second,
|  | bool & | intersect
| ) |  | const

Return the intersection point of two lines.

Parameters

  second | = Second line.
  intersect | = On Return: The intercept. If the lines are parallel, this contains this line's first point

Returns
  true if the lines intersect, false if the lines are parallel

Size clan::RectPacker::get_max_group_size | ( |  | ) | const

Returns the max group size.

template<typename Type>

Vec3<Type> clan::LineSegment3x< Type >::get_midpoint | ( |  | ) | const
| inline

Get the midpoint of this line.

Returns
  The midpoint

template<typename Type>

Vec2<Type> clan::LineSegment2x< Type >::get_midpoint | ( |  | ) | const
| inline

Get the midpoint of this line.

Returns
  The midpoint

Pointf clan::BezierCurve::get_point_relative | ( | float | pos_0_to_1 | ) | const

Get a point on the bezier curve.

int clan::RectPacker::get_rect_count | ( | unsigned int | group_index = `0` | ) | const

Returns the amount of rects in a group.

DataBuffer& clan::Base64Decoder::get_result | ( |  | ) |

Returns the decoded data.

DataBuffer& clan::Base64Encoder::get_result | ( |  | ) |

Returns the data in encoded form.

template<typename Type>

Rectx<Type> clan::Rectx< Type >::get_rot_bounds | ( | const Vec2< Type > & | hotspot,
|  | const Angle & | angle
| ) |  | const

Returns another Rectx<Type> containing a rotated version of this one.

Parameters

  hotspot | Point to rotate around.
  angle | Angle to rotate.

template<typename Type>

Rectx<Type> clan::Rectx< Type >::get_rot_bounds | ( | Origin | origin,
|  | Type | x,
|  | Type | y,
|  | const Angle & | angle
| ) |  | const

Returns another Rectx<Type> containing a rotated version of this one.

Parameters

  origin | Determines the hotspot point within the rectangle
  x | Offsets applied negatively to the hotspot point
  y | Offsets applied negatively to the hotspot point
  angle | Angle

template<typename Type>

Sizex<Type> clan::Rectx< Type >::get_size | ( |  | ) | const
| inline

Returns the size of the rectangle.

Referenced by clan::Rectx< int >::apply_alignment().

template<typename Type>

Sizex<Type> clan::Quadx< Type >::get_size | ( |  | ) | const
| inline

Returns the size of the rectangle.

template<typename Type>

Pointx<Type> clan::Rectx< Type >::get_top_left | ( |  | ) | const
| inline

Returns the top-left point inside the rectangle.

template<typename Type>

Pointx<Type> clan::Rectx< Type >::get_top_right | ( |  | ) | const
| inline

Returns the top-right point outside the rectangle.

int clan::RectPacker::get_total_rect_count | ( |  | ) | const

Returns the total amount of rects.

template<typename Type>

Vec3<Type> clan::Mat4< Type >::get_transformed_point | ( | const Vec3< Type > & | vector | ) | const

Get a transformed point from the matrix (in column-major format)

Returns
  The transformed point

template<typename Type>

Vec3<Type> clan::Mat4< Type >::get_translate | ( |  | ) | const
| inline

Returns the translation coordinates for this matrix (in column-major format)

EarClipTriangulator_Triangle& clan::EarClipResult::get_triangle | ( | int | index | ) |

return a reference to a triangle in the triangulation.

Memory is preallocated for all triangles at creation. Use the returned reference to modify the triangles.

std::vector<EarClipTriangulator_Triangle>& clan::EarClipResult::get_triangles | ( |  | ) |

Returns the triangles for this result.

const std::vector<DelauneyTriangulator_Triangle>& clan::DelauneyTriangulator::get_triangles | ( |  | ) | const

Returns the resulting triangles produced from triangulation.

int clan::EarClipTriangulator::get_vertice_count | ( |  | ) |

Returns the number of vertices in the triangulator.

std::vector<Pointf> clan::EarClipTriangulator::get_vertices | ( |  | ) |

Returns a list of the vertices added to the triangulator.

const std::vector<DelauneyTriangulator_Vertex>& clan::DelauneyTriangulator::get_vertices | ( |  | ) | const

Returns the list of vertices in the triangulation.

template<typename Type>

Type clan::Rectx< Type >::get_width | ( |  | ) | const
| inline

Returns the width of the rectangle.

template<typename Type>

Type clan::Quadx< Type >::get_width | ( |  | ) | const

Returns the width of the quad.

Referenced by clan::Quadx< int >::get_size().

static float clan::HalfFloat::half_to_float | ( | unsigned short | hf | ) |
| inline static

Referenced by clan::HalfFloat::to_float().

static float clan::HalfFloat::half_to_float_simple | ( | unsigned short | hf | ) |
| inline static

Only works for 'normal' half-float values.

template<typename Type>

static Mat2<Type> clan::Mat2< Type >::identity | ( |  | ) |
| static

template<typename Type >

Mat3< Type > clan::Mat3< Type >::identity | ( |  | ) |
| inline static

References clan::m, and clan::null.

template<typename Type >

Mat4< Type > clan::Mat4< Type >::identity | ( |  | ) |
| inline static

Create the identity matrix.

Returns
  The matrix

References clan::m, clan::Mat4< Type >::matrix, and clan::null.

template<typename Type>

bool clan::LineSegment2x< Type >::intersects | ( | const LineSegment2x< Type > & | second,
|  | bool | collinear_intersect
| ) |  | const

Return true if two line segments intersect.

Parameters

  second | = Second line.
  collinear_intersect | = true if a collision is reported when all points are on the same line.

Returns
  true = Intersects

template<typename Type>

Quaternionx<Type>& clan::Quaternionx< Type >::inverse | ( |  | ) |

Inverse this quaternion.

This is the same as the conjugate of a quaternion

Returns
  reference to this object

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::inverse | ( | Quaternionx< Type > | q | ) |
| inline static

Inverse this quaternion.

This is the same as the conjugate of a quaternion

Returns
  reference to this object

template<typename Type>

Mat3< Type > clan::Mat3< Type >::inverse | ( | const Mat3< Type > & | matrix | ) |
| inline static

Calculate the matrix inverse of a matrix.

Creates a zero matrix if the determinent == 0

Parameters

  matrix | = The matrix to use

Returns
  The inversed matrix

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::inverse | ( |  | ) |

Create the matrix inverse. (Returns a zero matrix if the determinent = 0)

Returns
  reference to this object

template<typename Type >

Mat4< Type > clan::Mat4< Type >::inverse | ( | const Mat4< Type > & | matrix | ) |
| inline static

Calculate the matrix inverse of a matrix.

Creates a zero matrix if the determinent == 0

Parameters

  matrix | = The matrix to use

Returns
  The inversed matrix

References clan::Mat4< Type >::inverse().

Referenced by clan::Mat4< Type >::inverse().

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::inverse | ( |  | ) |

Calculate the matrix inverse of this matrix.

Creates a zero matrix if the determinent == 0

Returns
  reference to this object

bool clan::BigInt::invmod | ( | const BigInt * | m,
|  | BigInt * | c
| ) |  | const

Compute c = a^-1 (mod m), if there is an inverse for a (mod m).

This is equivalent to the question of whether (a, m) = 1. If not, false is returned, and there is no inverse.

template<typename Type>

static bool clan::Vec2< Type >::is_equal | ( | const Vec2< Type > & | first,
|  | const Vec2< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

Referenced by clan::Vec2< int >::is_equal().

template<typename Type>

static bool clan::Vec3< Type >::is_equal | ( | const Vec3< Type > & | first,
|  | const Vec3< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

Referenced by clan::Vec3< int >::is_equal().

template<typename Type>

static bool clan::Vec4< Type >::is_equal | ( | const Vec4< Type > & | first,
|  | const Vec4< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

Referenced by clan::Vec4< float >::is_equal().

template<typename Type>

static bool clan::Mat2< Type >::is_equal | ( | const Mat2< Type > & | first,
|  | const Mat2< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

References clan::i, and clan::Mat2< Type >::matrix.

Referenced by clan::Mat2< Type >::is_equal().

template<typename Type>

bool clan::Mat2< Type >::is_equal | ( | const Mat2< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

References clan::Mat2< Type >::is_equal().

template<typename Type>

bool clan::Vec3< Type >::is_equal | ( | const Vec3< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

template<typename Type>

bool clan::Vec2< Type >::is_equal | ( | const Vec2< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

template<typename Type>

bool clan::Vec4< Type >::is_equal | ( | const Vec4< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

template<typename Type>

static bool clan::Mat3< Type >::is_equal | ( | const Mat3< Type > & | first,
|  | const Mat3< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

Referenced by clan::Mat3< float >::is_equal().

template<typename Type>

bool clan::Mat3< Type >::is_equal | ( | const Mat3< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

template<typename Type>

static bool clan::Mat4< Type >::is_equal | ( | const Mat4< Type > & | first,
|  | const Mat4< Type > & | second,
|  | Type | epsilon
| ) |  |
| inline static

Returns true if equal within the bounds of an epsilon.

Parameters

  first | = Value A
  second | = Value B
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

References clan::i, and clan::Mat4< Type >::matrix.

Referenced by clan::Mat4< Type >::is_equal().

template<typename Type>

bool clan::Mat4< Type >::is_equal | ( | const Mat4< Type > & | other,
|  | Type | epsilon
| ) |  | const
| inline

Returns true if equal within the bounds of an epsilon.

Parameters

  other | = Other value
  epsilon | = The epsilon (eg FLT_EPSILON/2, DBL_EPSILON/2)

References clan::Mat4< Type >::is_equal().

bool clan::BigInt::is_even | ( |  | ) | const

Returns a true if number is even.

template<typename Type>

bool clan::Circlex< Type >::is_inside | ( | const Vec2< Type > & | point | ) |
| inline

template<typename Type>

bool clan::Rectx< Type >::is_inside | ( | const Rectx< Type > & | r | ) | const
| inline

Returns true if rectangle passed is inside this rectangle.

template<typename Type>

bool clan::Quadx< Type >::is_inside | ( | const Vec2< Type > & | point | ) | const

Check if a point is inside or outside the quad.

bool clan::RectPacker::is_null | ( |  | ) | const
| inline

Returns true if this object is invalid.

bool clan::BigInt::is_odd | ( |  | ) | const

Returns a true if number is odd.

template<typename Type>

bool clan::Rectx< Type >::is_overlapped | ( | const Rectx< Type > & | r | ) | const
| inline

Returns true if rectangle passed is overlapping or inside this rectangle.

template<typename Type >

Type clan::Vec2< Type >::length | ( |  | ) | const
| inline

Returns the length (magnitude) of this vector.

Operates in the native datatype

Returns
  the length of the vector

References clan::f, clan::x, and clan::y.

template<typename Type >

Type clan::Vec3< Type >::length | ( |  | ) | const
| inline

Returns the length (magnitude) of this vector.

Operates in the native datatype

Returns
  the length of the vector

References clan::f, clan::x, clan::y, and clan::z.

template<typename Type >

Type clan::Vec4< Type >::length3 | ( |  | ) | const
| inline

Returns the length (magnitude) of this vector (not taking into account the w ordinate).

Operates in the native datatype

Returns
  the length of the vector

References clan::f, clan::x, clan::y, and clan::z.

template<typename Type >

Type clan::Vec4< Type >::length4 | ( |  | ) | const
| inline

Returns the length (magnitude) of this vector (taking into account the w ordinate).

Operates in the native datatype

Returns
  the length of the vector

References clan::f, clan::w, clan::x, clan::y, and clan::z.

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::lerp | ( | const Quaternionx< Type > & | quaternion_initial,
|  | const Quaternionx< Type > & | quaternion_final,
|  | Type | lerp_time
| ) |  |
| static

Linear Quaternion Interpolation.

Parameters

  quaternion_initial | = Source quaternion
  quaternion_final | = Destination quaternion
  lerp_time | = Time in the range of 0.0 to 1.0

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::look_at | ( | Type | eye_x,
|  | Type | eye_y,
|  | Type | eye_z,
|  | Type | center_x,
|  | Type | center_y,
|  | Type | center_z,
|  | Type | up_x,
|  | Type | up_y,
|  | Type | up_z
| ) |  |
| static

Create the "look at" matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  eye_x | = Eye position X
  eye_y | = Eye position Y
  eye_z | = Eye position Z
  center_x | = Center X
  center_y | = Center Y
  center_z | = Center Z
  up_x | = Camera up direction X
  up_y | = Camera up direction Y
  up_z | = Camera up direction Z

Returns
  The matrix (in column-major format)

Referenced by clan::Mat4< Type >::look_at().

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::look_at | ( | Vec3< Type > | eye,
|  | Vec3< Type > | center,
|  | Vec3< Type > | up
| ) |  |
| inline static

Create the "look at" matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  eye | = Eye position
  center | = Center position
  up | = Camera up direction

Returns
  The matrix (in column-major format)

References clan::Mat4< Type >::look_at(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type>

static Rectx<Type> clan::Rectx< Type >::ltrb | ( | Type | left,
|  | Type | top,
|  | Type | right,
|  | Type | bottom
| ) |  |
| inline static

template<typename Type>

Type clan::Quaternionx< Type >::magnitude | ( |  | ) | const

Get the quaternion magnitude.

bool clan::BigInt::make_prime | ( | unsigned int | num_bits | ) |

template<typename T , typename... Args>

std::unique_ptr<T> clan::make_unique | ( | Args &&... | args | ) |

template<typename A , typename B >

A clan::max | ( | A | a,
|  | B | b
| ) |  |
| inline

Referenced by clan::Rectx< int >::bounding_rect(), clan::clamp(), clan::Rectx< int >::clip(), clan::max(), and clan::Rectx< int >::overlap().

template<typename Type >

Vec2<Type> clan::max | ( | Vec2< Type > | a,
|  | Vec2< Type > | b
| ) |  |
| inline

References clan::max(), clan::Vec2< Type >::x, and clan::Vec2< Type >::y.

template<typename Type >

Vec3<Type> clan::max | ( | Vec3< Type > | a,
|  | Vec3< Type > | b
| ) |  |
| inline

References clan::max(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type >

Vec4<Type> clan::max | ( | Vec4< Type > | a,
|  | Vec4< Type > | b
| ) |  |
| inline

References clan::max(), clan::Vec4< Type >::w, clan::Vec4< Type >::x, clan::Vec4< Type >::y, and clan::Vec4< Type >::z.

static Pointf clan::LineMath::midpoint | ( | const Pointf & | A,
|  | const Pointf & | B
| ) |  |
| static

Return the midpoint of the line from point A to point B.

Also See LineSegment

Parameters

  A | = point A
  B | = point B

Returns
  The point

template<typename A , typename B >

A clan::min | ( | A | a,
|  | B | b
| ) |  |
| inline

Referenced by clan::Rectx< int >::bounding_rect(), clan::clamp(), clan::Rectx< int >::clip(), clan::min(), and clan::Rectx< int >::overlap().

template<typename Type >

Vec2<Type> clan::min | ( | Vec2< Type > | a,
|  | Vec2< Type > | b
| ) |  |
| inline

References clan::min(), clan::Vec2< Type >::x, and clan::Vec2< Type >::y.

template<typename Type >

Vec3<Type> clan::min | ( | Vec3< Type > | a,
|  | Vec3< Type > | b
| ) |  |
| inline

References clan::min(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type >

Vec4<Type> clan::min | ( | Vec4< Type > | a,
|  | Vec4< Type > | b
| ) |  |
| inline

References clan::min(), clan::Vec4< Type >::w, clan::Vec4< Type >::x, clan::Vec4< Type >::y, and clan::Vec4< Type >::z.

static Circlef clan::PointSetMath::minimum_enclosing_disc | ( | const std::vector< Pointf > & | points | ) |
| static

Find minimum spanning circle for the set of points.

Parameters

  points | the points to calulate on

template<typename A , typename B , typename C >

A clan::mix | ( | A | a,
|  | B | b,
|  | C | mix
| ) |  |
| inline

void clan::BigInt::mod | ( | const BigInt * | m,
|  | BigInt * | c
| ) |  | const

Compute c = a (mod m). Result will always be 0 <= c < m.

uint32_t clan::BigInt::mod_d | ( | uint32_t | d | ) | const

Compute c = a (mod d). Result will always be 0 <= c < d.

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::multiply | ( | const Quaternionx< Type > & | quaternion_1,
|  | const Quaternionx< Type > & | quaternion_2
| ) |  |
| static

Referenced by clan::Quaternionx< float >::operator*().

template<typename Type>

static Mat2<Type> clan::Mat2< Type >::multiply | ( | const Mat2< Type > & | matrix_1,
|  | const Mat2< Type > & | matrix_2
| ) |  |
| static

Multiply 2 matrices.

This multiplies the matrix as follows: result = matrix1 * matrix2
Matrix is multiplied in the Column-Major matrix format (opengl native)

Parameters

  matrix_1 | = First Matrix to multiply
  matrix_2 | = Second Matrix to multiply

Returns
  The matrix

template<typename Type>

Mat3< Type > clan::Mat3< Type >::multiply | ( | const Mat3< Type > & | matrix_1,
|  | const Mat3< Type > & | matrix_2
| ) |  |
| inline static

Multiply 2 matrices.

This multiplies the matrix as follows: result = matrix1 * matrix2
Matrix is multiplied in the Column-Major matrix format (opengl native)

Parameters

  matrix_1 | = First Matrix to multiply
  matrix_2 | = Second Matrix to multiply

Returns
  The matrix

template<typename Type >

Mat4< Type > clan::Mat4< Type >::multiply | ( | const Mat4< Type > & | matrix_1,
|  | const Mat4< Type > & | matrix_2
| ) |  |
| inline static

Multiply 2 matrices.

This multiplies the matrix as follows: result = matrix1 * matrix2
Matrix is multiplied in the Column-Major matrix format (opengl native)

Parameters

  matrix_1 | = First Matrix to multiply
  matrix_2 | = Second Matrix to multiply

Returns
  The matrix

void clan::BigInt::neg | ( | BigInt * | b | ) | const

Compute b = -a. 'a' and 'b' may be identical.

void clan::OutlineTriangulator::next_contour | ( |  | ) |

Mark next contour in polygon path.

void clan::OutlineTriangulator::next_polygon | ( |  | ) |

Mark next polygon.

template<typename Type>

Vec2<Type> clan::LineSegment2x< Type >::normal | ( |  | ) | const

Return the normal vector of the line from point A to point B.

When using Vec2i, the vector is an 8 bit fraction (multiplied by 256)

Returns
  The normal vector

template<typename Type>

Vec2< Type > clan::Vec2< Type >::normalize | ( | const Vec2< Type > & | vector | ) |
| inline static

Normalizes a vector.

Operates in the native datatype

Parameters

  vector | = Vector to use

Returns
  normalized vector

template<typename Type>

Vec3< Type > clan::Vec3< Type >::normalize | ( | const Vec3< Type > & | vector | ) |
| inline static

Normalizes a vector.

Parameters

  vector | = Vector to use

Operates in the native datatype

Angle& clan::Angle::normalize | ( |  | ) |

Converts angle to range [0,360] degrees.

Returns
  reference to this object

template<typename Type>

Quaternionx<Type>& clan::Quaternionx< Type >::normalize | ( |  | ) |

Normalizes this quaternion.

Returns
  reference to this object

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::normalize | ( | Quaternionx< Type > | q | ) |
| inline static

Normalizes this quaternion.

Returns
  reference to this object

template<typename Type>

Vec3< Type > & clan::Vec3< Type >::normalize | ( |  | ) |
| inline

Normalizes this vector.

Operates in the native datatype

Returns
  reference to this object

References clan::f, clan::length, clan::x, clan::y, and clan::z.

template<typename Type>

Vec2< Type > & clan::Vec2< Type >::normalize | ( |  | ) |
| inline

Normalizes this vector.

Operates in the native datatype

Returns
  reference to this object

References clan::f, clan::length, clan::x, and clan::y.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::normalize | ( |  | ) |
| inline

Normalize rectangle.

Sets the width to 0 if found a negative width Sets the height to 0 if found a negative height

Returns
  reference to this object

template<typename Type>

static Vec4<Type> clan::Vec4< Type >::normalize3 | ( | const Vec4< Type > & | vector | ) |
| static

Normalizes a vector (not taking into account the w ordinate)

Operates in the native datatype

Parameters

  vector | = The vector to use

Returns
  the normalized vector

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::normalize3 | ( |  | ) |

Normalizes this vector (not taking into account the w ordinate)

Operates in the native datatype

Returns
  reference to this object

template<typename Type>

static Vec4<Type> clan::Vec4< Type >::normalize4 | ( | const Vec4< Type > & | vector | ) |
| static

Normalizes a vector (taking into account the w ordinate)

Operates in the native datatype

Parameters

  vector | = The vector to use

Returns
  the normalized vector

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::normalize4 | ( |  | ) |

Normalizes this vector (taking into account the w ordinate)

Operates in the native datatype

Returns
  reference to this object

Angle& clan::Angle::normalize_180 | ( |  | ) |

Converts angle to range [-180,180] degrees.

Returns
  reference to this object

template<typename Type>

static Mat2<Type> clan::Mat2< Type >::null | ( |  | ) |
| static

template<typename Type >

Mat3< Type > clan::Mat3< Type >::null | ( |  | ) |
| inline static

References clan::m.

template<typename Type >

Mat4< Type > clan::Mat4< Type >::null | ( |  | ) |
| inline static

Create a zero matrix.

Returns
  The matrix

References clan::m, and clan::Mat4< Type >::matrix.

clan::HalfFloat::operator float | ( |  | ) | const
| inline

References clan::HalfFloat::to_float().

template<typename Type>

clan::Mat2< Type >::operator Type * | ( |  | ) |
| inline

Operator that returns the matrix as a array.

References clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat3< Type >::operator Type * | ( |  | ) |
| inline

Operator that returns the matrix as a array.

References clan::Mat3< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::operator Type * | ( |  | ) |
| inline

Operator that returns the matrix as a array.

References clan::Mat4< Type >::matrix.

template<typename Type>

clan::Mat2< Type >::operator Type const * | ( |  | ) | const
| inline

Operator that returns the matrix as a array.

References clan::Mat2< Type >::matrix.

template<typename Type>

clan::Mat3< Type >::operator Type const * | ( |  | ) | const
| inline

Operator that returns the matrix as a array.

References clan::Mat3< Type >::matrix.

template<typename Type>

clan::Mat4< Type >::operator Type const * | ( |  | ) | const
| inline

Operator that returns the matrix as a array.

References clan::Mat4< Type >::matrix.

template<typename Type>

clan::Sizex< Type >::operator Vec2< Type > | ( |  | ) | const
| inline

References clan::Sizex< Type >::height, and clan::Sizex< Type >::width.

clan::Vec2hf::operator Vec2f | ( |  | ) | const
| inline

References clan::Vec2hf::to_float().

clan::Vec3hf::operator Vec3f | ( |  | ) | const
| inline

References clan::Vec3hf::to_float().

clan::Vec4hf::operator Vec4f | ( |  | ) | const
| inline

References clan::Vec4hf::to_float().

template<typename Type>

bool clan::Circlex< Type >::operator!= | ( | const Circlex< Type > & | circle | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Trianglex< Type >::operator!= | ( | const Trianglex< Type > & | triangle | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Line3x< Type >::operator!= | ( | const Line3x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::LineRay3x< Type >::operator!= | ( | const LineRay3x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::LineSegment3x< Type >::operator!= | ( | const LineSegment3x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Rectx< Type >::operator!= | ( | const Rectx< Type > & | r | ) | const
| inline

Rect != Rect operator.

template<typename Type>

bool clan::Quadx< Type >::operator!= | ( | const Quadx< Type > & | quad | ) | const
| inline

Quad != Quad operator.

template<typename Type>

bool clan::LineRay2x< Type >::operator!= | ( | const LineRay2x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Line2x< Type >::operator!= | ( | const Line2x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Sizex< Type >::operator!= | ( | const Sizex< Type > & | s | ) | const
| inline

Size != Size operator (deep compare).

bool clan::Angle::operator!= | ( | const Angle & | angle | ) | const

!= operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator!= | ( | const Quaternionx< Type > & | other | ) | const
| inline

Not equal operator.

template<typename Type>

bool clan::LineSegment2x< Type >::operator!= | ( | const LineSegment2x< Type > & | line | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Mat2< Type >::operator!= | ( | const Mat2< Type > & | other | ) | const
| inline

Not-equal operator.

template<typename Type>

bool clan::Vec3< Type >::operator!= | ( | const Vec3< Type > & | vector | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Vec2< Type >::operator!= | ( | const Vec2< Type > & | vector | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Vec4< Type >::operator!= | ( | const Vec4< Type > & | vector | ) | const
| inline

!= operator.

template<typename Type>

bool clan::Mat3< Type >::operator!= | ( | const Mat3< Type > & | other | ) |
| inline

Not-equal operator.

template<typename Type>

bool clan::Mat4< Type >::operator!= | ( | const Mat4< Type > & | other | ) |
| inline

Not-equal operator.

BigInt clan::BigInt::operator% | ( | const BigInt & | b | ) |

Compute result = this % b.

BigInt clan::BigInt::operator% | ( | uint32_t | d | ) |

BigInt clan::BigInt::operator%= | ( | const BigInt & | b | ) |

Compute this %= b.

BigInt clan::BigInt::operator%= | ( | uint32_t | d | ) |

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator* | ( | const Type & | s | ) | const
| inline

Size * operator.

Angle clan::Angle::operator* | ( | const Angle & | angle | ) | const

- operator.

Angle clan::Angle::operator* | ( | float | value | ) | const

- operator.

template<typename Type>

Quaternionx<Type> clan::Quaternionx< Type >::operator* | ( | const Quaternionx< Type > & | mult | ) | const
| inline

Multiplication operator.

template<typename Type>

Quaternionx<Type> clan::Quaternionx< Type >::operator* | ( | const Mat4< Type > & | matrix | ) | const

BigInt clan::BigInt::operator* | ( | const BigInt & | b | ) |

Compute result = this * b.

BigInt clan::BigInt::operator* | ( | uint32_t | d | ) |

template<typename Type>

Mat2<Type> clan::Mat2< Type >::operator* | ( | const Mat2< Type > & | mult | ) | const

Multiplication operator.

template<typename Type >

Vec3<Type> clan::operator* | ( | const Vec3< Type > & | v1,
|  | const Vec3< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator* | ( | Type | s,
|  | const Vec3< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator* | ( | const Vec3< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator* | ( | const Vec2< Type > & | v1,
|  | const Vec2< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator* | ( | Type | s,
|  | const Vec2< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator* | ( | const Vec2< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator* | ( | const Vec3< Type > & | v,
|  | const Mat3< Type > & | matrix
| ) |  |

Matrix is assumed to be in the Column-Major matrix format (opengl native)
Note: "vec = vector * matrix" is different to "vec = matrix * vector"

template<typename Type >

Vec2<Type> clan::operator* | ( | const Vec2< Type > & | v,
|  | const Mat2< Type > & | matrix
| ) |  |

template<typename Type >

Vec3<Type> clan::operator* | ( | const Mat3< Type > & | matrix,
|  | const Vec3< Type > & | v
| ) |  |

Matrix is assumed to be in the Column-Major matrix format (opengl native)
Note: "vec = vector * matrix" is different to "vec = matrix * vector"

template<typename Type >

Vec2<Type> clan::operator* | ( | const Mat2< Type > & | matrix,
|  | const Vec2< Type > & | v
| ) |  |

template<typename Type >

Vec4<Type> clan::operator* | ( | const Vec4< Type > & | v1,
|  | const Vec4< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator* | ( | Type | s,
|  | const Vec4< Type > & | v
| ) |  |

- operator.

template<typename Type>

Mat3<Type> clan::Mat3< Type >::operator* | ( | const Mat3< Type > & | mult | ) | const

Multiplication operator.

template<typename Type >

Vec4<Type> clan::operator* | ( | const Vec4< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type>

Vec2<Type> clan::Mat3< Type >::operator* | ( | const Vec2< Type > & | mult | ) | const

Multiplication operator.

template<typename Type >

Vec4<Type> clan::operator* | ( | const Vec4< Type > & | v,
|  | const Mat4< Type > & | matrix
| ) |  |

template<typename Type >

Vec4<Type> clan::operator* | ( | const Mat4< Type > & | matrix,
|  | const Vec4< Type > & | v
| ) |  |

template<typename Type>

Mat4<Type> clan::Mat4< Type >::operator* | ( | const Mat4< Type > & | mult | ) | const

Multiplication operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator*= | ( | const Type & | s | ) |
| inline

Size *= operator.

void clan::Angle::operator*= | ( | const Angle & | angle | ) |

*= operator.

BigInt clan::BigInt::operator*= | ( | const BigInt & | b | ) |

Compute this *= b.

BigInt clan::BigInt::operator*= | ( | uint32_t | d | ) |

template<typename Type>

void clan::Vec3< Type >::operator*= | ( | const Vec3< Type > & | vector | ) |
| inline

*= operator.

template<typename Type>

void clan::Vec3< Type >::operator*= | ( | Type | value | ) |
| inline

*= operator.

template<typename Type>

void clan::Vec2< Type >::operator*= | ( | const Vec2< Type > & | vector | ) |
| inline

*= operator.

template<typename Type>

void clan::Vec2< Type >::operator*= | ( | Type | value | ) |
| inline

*= operator.

template<typename Type>

void clan::Vec4< Type >::operator*= | ( | const Vec4< Type > & | vector | ) |
| inline

*= operator.

template<typename Type>

void clan::Vec4< Type >::operator*= | ( | Type | value | ) |
| inline

*= operator.

template<typename Type>

Quadx<Type> clan::Quadx< Type >::operator+ | ( | const Quadx< Type > & | quad | ) | const
| inline

Quad + Quad operator.

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator+ | ( | const Sizex< Type > & | s | ) | const
| inline

Size + Size operator.

template<typename Type>

Quadx<Type> clan::Quadx< Type >::operator+ | ( | const Vec2< Type > & | point | ) | const
| inline

Quad + Point operator.

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator+ | ( | const Type & | s | ) | const
| inline

Size + operator.

Angle clan::Angle::operator+ | ( | const Angle & | angle | ) | const

- operator.

BigInt clan::BigInt::operator+ | ( | const BigInt & | b | ) |

Compute result = this + b.

BigInt clan::BigInt::operator+ | ( | uint32_t | d | ) |

template<typename Type>

Mat2<Type> clan::Mat2< Type >::operator+ | ( | const Mat2< Type > & | add_matrix | ) | const

Addition operator.

template<typename Type >

Vec3<Type> clan::operator+ | ( | const Vec3< Type > & | v1,
|  | const Vec3< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator+ | ( | Type | s,
|  | const Vec3< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator+ | ( | const Vec3< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator+ | ( | const Vec2< Type > & | v1,
|  | const Vec2< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator+ | ( | Type | s,
|  | const Vec2< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator+ | ( | const Vec2< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator+ | ( | const Vec4< Type > & | v1,
|  | const Vec4< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator+ | ( | Type | s,
|  | const Vec4< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator+ | ( | const Vec4< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type>

Mat3<Type> clan::Mat3< Type >::operator+ | ( | const Mat3< Type > & | add_matrix | ) | const

Addition operator.

template<typename Type>

Mat4<Type> clan::Mat4< Type >::operator+ | ( | const Mat4< Type > & | add_matrix | ) | const

Addition operator.

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::operator+= | ( | const Quadx< Type > & | quad | ) |
| inline

Quad += Quad operator.

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::operator+= | ( | const Vec2< Type > & | point | ) |
| inline

Quad += Point operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator+= | ( | const Sizex< Type > & | s | ) |
| inline

Size += Size operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator+= | ( | const Type & | s | ) |
| inline

Size += operator.

void clan::Angle::operator+= | ( | const Angle & | angle | ) |

+= operator.

BigInt clan::BigInt::operator+= | ( | const BigInt & | b | ) |

Compute this += b.

BigInt clan::BigInt::operator+= | ( | uint32_t | d | ) |

template<typename Type>

void clan::Vec3< Type >::operator+= | ( | const Vec3< Type > & | vector | ) |
| inline

+= operator.

template<typename Type>

void clan::Vec3< Type >::operator+= | ( | Type | value | ) |
| inline

+= operator.

template<typename Type>

void clan::Vec2< Type >::operator+= | ( | const Vec2< Type > & | vector | ) |
| inline

+= operator.

template<typename Type>

void clan::Vec2< Type >::operator+= | ( | Type | value | ) |
| inline

+= operator.

template<typename Type>

void clan::Vec4< Type >::operator+= | ( | const Vec4< Type > & | vector | ) |
| inline

+= operator.

template<typename Type>

void clan::Vec4< Type >::operator+= | ( | Type | value | ) |
| inline

+= operator.

template<typename Type>

Quadx<Type> clan::Quadx< Type >::operator- | ( | const Quadx< Type > & | quad | ) | const
| inline

Quad - Quad operator.

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator- | ( | const Sizex< Type > & | s | ) | const
| inline

Size - Size operator.

template<typename Type>

Quadx<Type> clan::Quadx< Type >::operator- | ( | const Vec2< Type > & | point | ) | const
| inline

Quad - Point operator.

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator- | ( | const Type & | s | ) | const
| inline

Size - operator.

Angle clan::Angle::operator- | ( | const Angle & | angle | ) | const

- operator.

BigInt clan::BigInt::operator- | ( | const BigInt & | b | ) |

Compute result = this - b.

BigInt clan::BigInt::operator- | ( | uint32_t | d | ) |

template<typename Type>

Vec3<Type> clan::Vec3< Type >::operator- | ( |  | ) | const
| inline

- operator.

template<typename Type>

Mat2<Type> clan::Mat2< Type >::operator- | ( | const Mat2< Type > & | subtract_matrix | ) | const

Subtract operator.

template<typename Type>

Vec2<Type> clan::Vec2< Type >::operator- | ( |  | ) | const
| inline

- operator.

template<typename Type >

Vec3<Type> clan::operator- | ( | const Vec3< Type > & | v1,
|  | const Vec3< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec3<Type> clan::operator- | ( | Type | s,
|  | const Vec3< Type > & | v
| ) |  |

- operator.

template<typename Type>

Vec4<Type> clan::Vec4< Type >::operator- | ( |  | ) | const
| inline

- operator.

template<typename Type >

Vec3<Type> clan::operator- | ( | const Vec3< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator- | ( | const Vec2< Type > & | v1,
|  | const Vec2< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator- | ( | Type | s,
|  | const Vec2< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec2<Type> clan::operator- | ( | const Vec2< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator- | ( | const Vec4< Type > & | v1,
|  | const Vec4< Type > & | v2
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator- | ( | Type | s,
|  | const Vec4< Type > & | v
| ) |  |

- operator.

template<typename Type >

Vec4<Type> clan::operator- | ( | const Vec4< Type > & | v,
|  | Type | s
| ) |  |

- operator.

template<typename Type>

Mat3<Type> clan::Mat3< Type >::operator- | ( | const Mat3< Type > & | sub_matrix | ) | const

Subtraction operator.

template<typename Type>

Mat4<Type> clan::Mat4< Type >::operator- | ( | const Mat4< Type > & | sub_matrix | ) | const

Subtraction operator.

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::operator-= | ( | const Quadx< Type > & | quad | ) |
| inline

Quad -= Quad operator.

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::operator-= | ( | const Vec2< Type > & | point | ) |
| inline

Quad -= Point operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator-= | ( | const Sizex< Type > & | s | ) |
| inline

Size -= Size operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator-= | ( | const Type & | s | ) |
| inline

Size -= operator.

void clan::Angle::operator-= | ( | const Angle & | angle | ) |

-= operator.

BigInt clan::BigInt::operator-= | ( | const BigInt & | b | ) |

Compute this -= b.

BigInt clan::BigInt::operator-= | ( | uint32_t | d | ) |

template<typename Type>

void clan::Vec3< Type >::operator-= | ( | const Vec3< Type > & | vector | ) |
| inline

-= operator.

template<typename Type>

void clan::Vec3< Type >::operator-= | ( | Type | value | ) |
| inline

-= operator.

template<typename Type>

void clan::Vec2< Type >::operator-= | ( | const Vec2< Type > & | vector | ) |
| inline

-= operator.

template<typename Type>

void clan::Vec2< Type >::operator-= | ( | Type | value | ) |
| inline

-= operator.

template<typename Type>

void clan::Vec4< Type >::operator-= | ( | const Vec4< Type > & | vector | ) |
| inline

-= operator.

template<typename Type>

void clan::Vec4< Type >::operator-= | ( | Type | value | ) |
| inline

-= operator.

template<typename Type>

Sizex<Type> clan::Sizex< Type >::operator/ | ( | const Type & | s | ) | const
| inline

Size / operator.

Angle clan::Angle::operator/ | ( | const Angle & | angle | ) | const

/ operator.

Angle clan::Angle::operator/ | ( | float | value | ) | const

/ operator.

BigInt clan::BigInt::operator/ | ( | const BigInt & | b | ) |

Compute result = this / b.

BigInt clan::BigInt::operator/ | ( | uint32_t | d | ) |

template<typename Type >

Vec3<Type> clan::operator/ | ( | const Vec3< Type > & | v1,
|  | const Vec3< Type > & | v2
| ) |  |

/ operator.

template<typename Type >

Vec3<Type> clan::operator/ | ( | Type | s,
|  | const Vec3< Type > & | v
| ) |  |

/ operator.

template<typename Type >

Vec3<Type> clan::operator/ | ( | const Vec3< Type > & | v,
|  | Type | s
| ) |  |

/ operator.

template<typename Type >

Vec2<Type> clan::operator/ | ( | const Vec2< Type > & | v1,
|  | const Vec2< Type > & | v2
| ) |  |

/ operator.

template<typename Type >

Vec2<Type> clan::operator/ | ( | Type | s,
|  | const Vec2< Type > & | v
| ) |  |

/ operator.

template<typename Type >

Vec2<Type> clan::operator/ | ( | const Vec2< Type > & | v,
|  | Type | s
| ) |  |

/ operator.

template<typename Type >

Vec4<Type> clan::operator/ | ( | const Vec4< Type > & | v1,
|  | const Vec4< Type > & | v2
| ) |  |

/ operator.

template<typename Type >

Vec4<Type> clan::operator/ | ( | Type | s,
|  | const Vec4< Type > & | v
| ) |  |

/ operator.

template<typename Type >

Vec4<Type> clan::operator/ | ( | const Vec4< Type > & | v,
|  | Type | s
| ) |  |

/ operator.

template<typename Type>

Sizex<Type>& clan::Sizex< Type >::operator/= | ( | const Type & | s | ) |
| inline

Size /= operator.

void clan::Angle::operator/= | ( | const Angle & | angle | ) |

/= operator.

BigInt clan::BigInt::operator/= | ( | const BigInt & | b | ) |

Compute this /= b.

BigInt clan::BigInt::operator/= | ( | uint32_t | d | ) |

template<typename Type>

void clan::Vec3< Type >::operator/= | ( | const Vec3< Type > & | vector | ) |
| inline

/= operator.

template<typename Type>

void clan::Vec3< Type >::operator/= | ( | Type | value | ) |
| inline

/= operator.

template<typename Type>

void clan::Vec2< Type >::operator/= | ( | const Vec2< Type > & | vector | ) |
| inline

/= operator.

template<typename Type>

void clan::Vec2< Type >::operator/= | ( | Type | value | ) |
| inline

/= operator.

template<typename Type>

void clan::Vec4< Type >::operator/= | ( | const Vec4< Type > & | vector | ) |
| inline

/= operator.

template<typename Type>

void clan::Vec4< Type >::operator/= | ( | Type | value | ) |
| inline

/= operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator< | ( | const Quaternionx< Type > & | other | ) | const
| inline

Less operator.

bool clan::Angle::operator< | ( | const Angle & | angle | ) | const

< operator.

template<typename Type>

bool clan::Vec3< Type >::operator< | ( | const Vec3< Type > & | vector | ) | const
| inline

< operator.

template<typename Type>

bool clan::Vec2< Type >::operator< | ( | const Vec2< Type > & | vector | ) | const
| inline

< operator.

template<typename Type>

bool clan::Vec4< Type >::operator< | ( | const Vec4< Type > & | vector | ) | const
| inline

< operator.

bool clan::Angle::operator<= | ( | const Angle & | angle | ) | const

< operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator<= | ( | const Quaternionx< Type > & | other | ) | const
| inline

Less equal operator.

HalfFloat& clan::HalfFloat::operator= | ( | const HalfFloat & | other | ) |
| inline

HalfFloat& clan::HalfFloat::operator= | ( | const float | v | ) |
| inline

References clan::HalfFloat::from_float().

template<typename Type>

Circlex<Type>& clan::Circlex< Type >::operator= | ( | const Circlex< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

Trianglex<Type>& clan::Trianglex< Type >::operator= | ( | const Trianglex< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

Line3x<Type>& clan::Line3x< Type >::operator= | ( | const Line3x< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

LineRay3x<Type>& clan::LineRay3x< Type >::operator= | ( | const LineRay3x< Type > & | copy | ) |
| inline

= operator.

BigInt& clan::BigInt::operator= | ( | const BigInt & | other | ) |

template<typename Type>

LineSegment3x<Type>& clan::LineSegment3x< Type >::operator= | ( | const LineSegment3x< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

LineRay2x<Type>& clan::LineRay2x< Type >::operator= | ( | const LineRay2x< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

Line2x<Type>& clan::Line2x< Type >::operator= | ( | const Line2x< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

LineSegment2x<Type>& clan::LineSegment2x< Type >::operator= | ( | const LineSegment2x< Type > & | copy | ) |
| inline

= operator.

template<typename Type>

Mat2<Type>& clan::Mat2< Type >::operator= | ( | const Mat2< Type > & | copy | ) |
| inline

Copy assignment operator.

References clan::Mat2< Type >::matrix.

template<typename Type>

Mat2<Type>& clan::Mat2< Type >::operator= | ( | const Mat4< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

Mat2<Type>& clan::Mat2< Type >::operator= | ( | const Mat3< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

Vec3<Type>& clan::Vec3< Type >::operator= | ( | const Vec3< Type > & | vector | ) |
| inline

= operator.

template<typename Type>

Vec2<Type>& clan::Vec2< Type >::operator= | ( | const Vec2< Type > & | vector | ) |
| inline

= operator.

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::operator= | ( | const Vec4< Type > & | vector | ) |
| inline

= operator.

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::operator= | ( | const Mat3< Type > & | copy | ) |
| inline

Copy assignment operator.

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::operator= | ( | const Mat4< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::operator= | ( | const Mat2< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::operator= | ( | const Mat4< Type > & | copy | ) |
| inline

Copy assignment operator.

References clan::Mat4< Type >::matrix.

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::operator= | ( | const Mat3< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::operator= | ( | const Mat2< Type > & | copy | ) |

Copy assignment operator.

template<typename Type>

bool clan::Circlex< Type >::operator== | ( | const Circlex< Type > & | circle | ) | const
| inline

== operator.

template<typename Type>

bool clan::Trianglex< Type >::operator== | ( | const Trianglex< Type > & | triangle | ) | const
| inline

== operator.

template<typename Type>

bool clan::LineRay3x< Type >::operator== | ( | const LineRay3x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::Line3x< Type >::operator== | ( | const Line3x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::LineSegment3x< Type >::operator== | ( | const LineSegment3x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::Rectx< Type >::operator== | ( | const Rectx< Type > & | r | ) | const
| inline

Rect == Rect operator.

template<typename Type>

bool clan::Quadx< Type >::operator== | ( | const Quadx< Type > & | quad | ) | const
| inline

Quad == Quad operator.

template<typename Type>

bool clan::LineRay2x< Type >::operator== | ( | const LineRay2x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::Line2x< Type >::operator== | ( | const Line2x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::Sizex< Type >::operator== | ( | const Sizex< Type > & | s | ) | const
| inline

Size == Size operator (deep compare).

bool clan::Angle::operator== | ( | const Angle & | angle | ) | const

== operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator== | ( | const Quaternionx< Type > & | other | ) | const
| inline

Equal operator.

template<typename Type>

bool clan::LineSegment2x< Type >::operator== | ( | const LineSegment2x< Type > & | line | ) | const
| inline

== operator.

template<typename Type>

bool clan::Mat2< Type >::operator== | ( | const Mat2< Type > & | other | ) | const
| inline

Equality operator.

References clan::i, and clan::Mat2< Type >::matrix.

template<typename Type>

bool clan::Vec3< Type >::operator== | ( | const Vec3< Type > & | vector | ) | const
| inline

== operator.

template<typename Type>

bool clan::Vec2< Type >::operator== | ( | const Vec2< Type > & | vector | ) | const
| inline

== operator.

template<typename Type>

bool clan::Vec4< Type >::operator== | ( | const Vec4< Type > & | vector | ) | const
| inline

== operator.

template<typename Type>

bool clan::Mat3< Type >::operator== | ( | const Mat3< Type > & | other | ) | const
| inline

Equality operator.

template<typename Type>

bool clan::Mat4< Type >::operator== | ( | const Mat4< Type > & | other | ) | const
| inline

Equality operator.

References clan::i, and clan::Mat4< Type >::matrix.

bool clan::Angle::operator> | ( | const Angle & | angle | ) | const

> operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator> | ( | const Quaternionx< Type > & | other | ) | const
| inline

Greater operator.

bool clan::Angle::operator>= | ( | const Angle & | angle | ) | const

> operator.

template<typename Type>

bool clan::Quaternionx< Type >::operator>= | ( | const Quaternionx< Type > & | other | ) | const
| inline

Greater equal operator.

template<typename Type>

Type& clan::Mat2< Type >::operator[] | ( | int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

const Type& clan::Mat2< Type >::operator[] | ( | int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

Type& clan::Mat2< Type >::operator[] | ( | unsigned int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

const Type& clan::Mat2< Type >::operator[] | ( | unsigned int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

Type& clan::Mat3< Type >::operator[] | ( | int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

template<typename Type>

const Type& clan::Mat3< Type >::operator[] | ( | int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

template<typename Type>

Type& clan::Mat3< Type >::operator[] | ( | unsigned int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

template<typename Type>

const Type& clan::Mat3< Type >::operator[] | ( | unsigned int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

template<typename Type>

Type& clan::Mat4< Type >::operator[] | ( | int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

const Type& clan::Mat4< Type >::operator[] | ( | int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

Type& clan::Mat4< Type >::operator[] | ( | unsigned int | i | ) |
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

const Type& clan::Mat4< Type >::operator[] | ( | unsigned int | i | ) | const
| inline

Operator that returns the matrix cell at the given index.

References clan::i.

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::ortho | ( | Type | left,
|  | Type | right,
|  | Type | bottom,
|  | Type | top,
|  | Type | z_near,
|  | Type | z_far,
|  | Handedness | handedness,
|  | ClipZRange | clip_z
| ) |  |
| static

Create a ortho matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::ortho_2d | ( | Type | left,
|  | Type | right,
|  | Type | bottom,
|  | Type | top,
|  | Handedness | handedness,
|  | ClipZRange | clip_z
| ) |  |
| static

Create a ortho_2d matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::overlap | ( | const Rectx< Type > & | rect | ) |
| inline

Calculates the intersection of two rectangles.

Rect values become: max left, max top, min right, min bottom.

Returns
  reference to this object

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::perspective | ( | Type | field_of_view_y_degrees,
|  | Type | aspect,
|  | Type | z_near,
|  | Type | z_far,
|  | Handedness | handedness,
|  | ClipZRange | clip_z
| ) |  |
| static

Create a perspective matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

static Result clan::IntersectionTest::plane_aabb | ( | const Vec4f & | plane,
|  | const AxisAlignedBoundingBox & | aabb
| ) |  |
| static

static Result clan::IntersectionTest::plane_obb | ( | const Vec4f & | plane,
|  | const OrientedBoundingBox & | obb
| ) |  |
| static

template<typename Type>

Type clan::LineSegment3x< Type >::point_distance | ( | const Vec3< Type > & | point,
|  | Vec3< Type > & | dest_intercept
| ) |  | const

Calculate the distance from a line segment to a point.

Parameters

  point | = The point
  dest_intercept | = On Return: The point on the line closest to the point

Returns
  The Distance

template<typename Type>

Type clan::LineSegment2x< Type >::point_distance | ( | const Vec2< Type > & | point | ) |

Return the distance from a point to a line.

Parameters

  point | = The point.

template<typename Type>

bool clan::Trianglex< Type >::point_inside | ( | const Vec2< Type > & | point | ) | const

Return true if the point is inside the triangle.

Parameters

  point | = point to test.

Returns
  true if the point is inside the triangle

static float clan::LineMath::point_right_of_line | ( | float | x,
|  | float | y,
|  | float * | line
| ) |  |
| static

Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B.

Also See Line and LineSegment

Parameters

  x | = x coordinate of the point being tested.
  y | = y coordinate of the point being tested.
  line | = The line. A pointer to a float array with the elements {x1,y1,x2,y2}.

static float clan::LineMath::point_right_of_line | ( | float | x,
|  | float | y,
|  | float | line_x1,
|  | float | line_y1,
|  | float | line_x2,
|  | float | line_y2
| ) |  |
| static

Point right of line.

Parameters

  x | = value
  y | = value
  line_x1 | = value
  line_y1 | = value
  line_x2 | = value
  line_y2 | = value

Returns
  float

static float clan::LineMath::point_right_of_line | ( | const Pointf & | A,
|  | const Pointf & | B,
|  | const Pointf & | P
| ) |  |
| static

Point right of line.

Parameters

  A | = Pointf
  B | = Pointf
  P | = Pointf

Returns
  float

template<typename Type>

Type clan::Line2x< Type >::point_right_of_line | ( | Vec2< Type > | point | ) | const
| inline

Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B.

Parameters

  point | = The point

Returns
  Value representing - left (>0), centre (=0), or right (<0)

template<typename Type>

Type clan::LineSegment2x< Type >::point_right_of_line | ( | const Vec2< Type > & | point | ) | const
| inline

Return [<0, 0, >0] if the Point P is right, on or left of the line trough A,B.

Parameters

  point | = The point

Returns
  Value representing - left (>0), centre (=0), or right (<0)

template<typename T >

T clan::pow2 | ( | T | value | ) |
| inline

bool clan::BigInt::pprime | ( | int | nt | ) | const

Performs nt iteration of the Miller-Rabin probabilistic primality test on a.

Returns true if the tests pass, false if one fails. If false is returned, the number is definitely composite. If true

void clan::BigInt::random | ( |  | ) |

Assigns a random value to a.

This value is generated using the standard C library's rand() function, so it should not be used for cryptographic purposes, but it should be fine for primality testing, since all we really care about there is reasonable statistical properties. As many digits as a currently has are filled with random digits.

static OverlapResult clan::IntersectionTest::ray_aabb | ( | const Vec3f & | ray_start,
|  | const Vec3f & | ray_end,
|  | const AxisAlignedBoundingBox & | box
| ) |  |
| static

void clan::BigInt::read_unsigned_octets | ( | const unsigned char * | input_str,
|  | unsigned int | input_length
| ) |  |

Rectd clan::RectdPS | ( | double | x,
|  | double | y,
|  | double | width,
|  | double | height
| ) |  |
| inline

Rectf clan::RectfPS | ( | float | x,
|  | float | y,
|  | float | width,
|  | float | height
| ) |  |
| inline

Rect clan::RectPS | ( | int | x,
|  | int | y,
|  | int | width,
|  | int | height
| ) |  |
| inline

template<typename Type>

static Vec3<Type> clan::Vec3< Type >::reflect | ( | const Vec3< Type > & | incident,
|  | const Vec3< Type > & | normal
| ) |  |
| static

Calculate the reflection direction for an incident vector.

Normal vector should be normalized

void clan::Base64Decoder::reset | ( |  | ) |

Resets the decoder.

void clan::Base64Encoder::reset | ( |  | ) |

Resets the encoder.

template<typename Type>

Quaternionx<Type>& clan::Quaternionx< Type >::rotate | ( | const Angle & | angle,
|  | const Vec3f & | axis
| ) |  |

template<typename Type>

Quaternionx<Type>& clan::Quaternionx< Type >::rotate | ( | const Angle & | euler_x,
|  | const Angle & | euler_y,
|  | const Angle & | euler_z,
|  | EulerOrder | order
| ) |  |

template<typename Type>

static Vec3<Type> clan::Vec3< Type >::rotate | ( | const Vec3< Type > & | vector,
|  | const Angle & | angle,
|  | const Vec3< Type > & | axis
| ) |  |
| static

Rotate a vector around an axis. Same as glRotate[f|d](angle, a);.

Parameters

  vector | = Vector to use
  angle | = Angle to rotate.
  axis | = Rotation axis.

Returns
  The rotated vector

template<typename Type>

static Vec2<Type> clan::Vec2< Type >::rotate | ( | const Vec2< Type > & | vector,
|  | const Vec2< Type > & | hotspot,
|  | const Angle & | angle
| ) |  |
| static

Rotate a vector around another point.

Parameters

  vector | = Vector to use
  hotspot | The point around which to rotate.
  angle | = Angle to rotate.

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::rotate | ( | const Angle & | angle,
|  | Type | x,
|  | Type | y,
|  | Type | z,
|  | bool | normalize = `true`
| ) |  |
| static

Create a 3d rotation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  angle | = Angle to rotate by
  x | = Amount to rotate in the X axis
  y | = Amount to rotate in the Y axis
  z | = Amount to rotate in the Z axis
  normalize | = true = Normalize x,y,z before creating rotation matrix

Returns
  The matrix (in column-major format)

Referenced by clan::Mat3< float >::rotate().

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::rotate | ( | const Angle & | angle,
|  | Vec3< Type > | rotation,
|  | bool | normalize = `true`
| ) |  |
| inline static

Create a 3d rotation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  angle | = Angle to rotate by
  rotation | = Amount to rotate in the XYZ axes
  normalize | = true = Normalize x,y,z before creating rotation matrix

Returns
  The matrix (in column-major format)

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::rotate | ( | const Vec2< Type > & | hotspot,
|  | const Angle & | angle
| ) |  |

Rotates the Quad.

Parameters

  hotspot | Point to rotate around.
  angle | Angle to rotate in degrees.

Returns
  reference to this object

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::rotate | ( | const Angle & | angle_x,
|  | const Angle & | angle_y,
|  | const Angle & | angle_z,
|  | EulerOrder | order
| ) |  |
| static

Create a 3d rotation matrix using euler angles.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::rotate | ( | const Angle & | angle | ) |
| static

Create a 2d rotation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  angle | = Angle to rotate by

Returns
  The matrix (in column-major format)

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::rotate | ( | const Angle & | angle,
|  | Type | x,
|  | Type | y,
|  | Type | z,
|  | bool | normalize = `true`
| ) |  |
| static

Create a rotation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  angle | = Angle to rotate by
  x | = Amount to rotate in the X axis
  y | = Amount to rotate in the Y axis
  z | = Amount to rotate in the Z axis
  normalize | = true = Normalize x,y,z before creating rotation matrix

Returns
  The matrix (in column-major format)

Referenced by clan::Mat4< Type >::rotate().

template<typename Type>

Vec3<Type>& clan::Vec3< Type >::rotate | ( | const Angle & | angle,
|  | const Vec3< Type > & | axis
| ) |  |

Rotate this vector around an axis. Same as glRotate[f|d](angle, a);.

Parameters

  angle | Angle to rotate.
  axis | Rotation axis.

Returns
  reference to this object

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::rotate | ( | const Angle & | angle,
|  | Vec3< Type > | rotation,
|  | bool | normalize = `true`
| ) |  |
| inline static

Create a rotation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  angle | = Angle to rotate by
  rotate | = Amount to rotate in the XYZ axes
  normalize | = true = Normalize x,y,z before creating rotation matrix

Returns
  The matrix (in column-major format)

References clan::Mat4< Type >::rotate(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type>

Vec2<Type>& clan::Vec2< Type >::rotate | ( | const Vec2< Type > & | hotspot,
|  | const Angle & | angle
| ) |  |

Rotate this vector around another point.

Parameters

  hotspot | The point around which to rotate.
  angle | = Angle to rotate.

Returns
  reference to this object

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::rotate | ( | const Angle & | angle_x,
|  | const Angle & | angle_y,
|  | const Angle & | angle_z,
|  | EulerOrder | order
| ) |  |
| static

Create a rotation matrix using euler angles.

Matrix is created in the Column-Major matrix format (opengl native)

Returns
  The matrix (in column-major format)

template<typename Type>

static Vec4<Type> clan::Vec4< Type >::rotate3 | ( | const Vec4< Type > & | vector,
|  | const Angle & | angle,
|  | const Vec4< Type > & | axis
| ) |  |
| static

Rotate a vector around an axis. Same as glRotate[f|d](angle, a);.

Not taking into account the w ordinate
The w ordinate is not modified

Parameters

  vector | = The vector to use
  angle | Angle to rotate
  axis | Rotation axis.

Returns
  The rotated vector

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::rotate3 | ( | const Angle & | angle,
|  | const Vec4< Type > & | axis
| ) |  |

Rotate this vector around an axis. Same as glRotate[f|d](angle, a);.

Not taking into account the w ordinate
The w ordinate is not modified

Parameters

  angle | Angle to rotate
  axis | Rotation axis.

Returns
  reference to this object

template<typename Type>

Vec3<Type> clan::Quaternionx< Type >::rotate_vector | ( | const Vec3< Type > & | v | ) | const

Rotates vector by this quaternion.

Parameters

  v | = Vertex to rotate

Returns
  rotated vector

template<typename Type>

Vec4<Type> clan::Quaternionx< Type >::rotate_vector | ( | const Vec4< Type > & | v | ) | const

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::rotation_between | ( | Vec3< Type > | v0,
|  | Vec3< Type > | v1
| ) |  |
| static

Calculates the shortest arc quaternion between two vectors.

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::rotation_between | ( | Vec4< Type > | v0,
|  | Vec4< Type > | v1
| ) |  |
| static

Calculates the shortest arc quaternion between two vectors.

template<typename Type>

static Vec2<Type> clan::Vec2< Type >::round | ( | const Vec2< Type > & | vector | ) |
| static

Rounds all components on a vector.

Uses Asymmetric Arithmetic Rounding

Parameters

  vector | = Vector to use

Returns
  The rounded vector

template<typename Type>

static Vec3<Type> clan::Vec3< Type >::round | ( | const Vec3< Type > & | vector | ) |
| static

Rounds all components on a vector.

Uses Asymmetric Arithmetic Rounding

Parameters

  vector | = Vector to use

Returns
  The rounded vector

template<typename Type>

static Vec4<Type> clan::Vec4< Type >::round | ( | const Vec4< Type > & | vector | ) |
| static

Rounds all components on a vector.

Includes the w ordinate
Uses Asymmetric Arithmetic Rounding

Parameters

  vector | = The vector to use

Returns
  The rounded vector

template<typename Type>

Vec2<Type>& clan::Vec2< Type >::round | ( |  | ) |

Rounds all components of this vector.

Uses Asymmetric Arithmetic Rounding

Returns
  reference to this object

template<typename Type>

Vec3<Type>& clan::Vec3< Type >::round | ( |  | ) |

Rounds all components on this vector.

Uses Asymmetric Arithmetic Rounding

Returns
  reference to this object

template<typename Type>

Vec4<Type>& clan::Vec4< Type >::round | ( |  | ) |

Rounds all components on this vector.

Includes the w ordinate
Uses Asymmetric Arithmetic Rounding

Returns
  reference to this object

template<typename Type>

Type clan::Vec2< Type >::round_value | ( | float | value | ) | const

Rounds a value for the datatype.

For doubles and floats, this function does not round.

Parameters

  value | = Value to round

Returns
  The rounded value

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::scale | ( | float | sx,
|  | float | sy
| ) |  |

Scale the Quad.

Parameters

  sx | = Scale value in x-axis
  sy | = Scale value in y-axis

Returns
  reference to this object

template<typename Type>

Quadx<Type>& clan::Quadx< Type >::scale | ( | const Vec2< Type > & | hotspot,
|  | float | sx,
|  | float | sy
| ) |  |

Scale the Quad.

Parameters

  sx | = Scale value in x-axis
  sy | = Scale value in y-axis
  hotspot | = Point to scale around.

Returns
  reference to this object

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::scale | ( | Type | x,
|  | Type | y
| ) |  |
| static

Create a 2d scale matrix.

Parameters

  x | = Scale X
  y | = Scale Y

Returns
  The matrix

Referenced by clan::Mat3< float >::scale().

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::scale | ( | const Vec3< Type > & | xy | ) |
| inline static

Create a 2d scale matrix.

Parameters

  xy | = Scale XY

Returns
  The matrix

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::scale | ( | Type | x,
|  | Type | y,
|  | Type | z
| ) |  |
| static

Create a scale matrix.

Parameters

  x | = Scale X
  y | = Scale Y
  z | = Scale Z

Returns
  The matrix

Referenced by clan::Mat4< Type >::scale().

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::scale | ( | const Vec3< Type > & | xyz | ) |
| inline static

Create a scale matrix.

Parameters

  xyz | = Scale XYZ

Returns
  The matrix

References clan::Mat4< Type >::scale(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::scale_self | ( | Type | x,
|  | Type | y,
|  | Type | z
| ) |  |

Scale this matrix.

This is faster than using: multiply(Mat4<Type>::scale(x,y,z) )

Parameters

  x | = Scale X
  y | = Scale Y
  z | = Scale Z

Returns
  reference to this object

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::scale_self | ( | const Vec3< Type > & | scale | ) |
| inline

Scale this matrix.

This is faster than using: multiply(Mat4<Type>::scale(x,y,z) )

Parameters

  scale | = Scale XYZ

Returns
  reference to this object

References clan::Mat4< Type >::scale_self(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

Referenced by clan::Mat4< Type >::scale_self().

template<typename Type>

void clan::Quaternionx< Type >::set | ( | Type | euler_x,
|  | Type | euler_y,
|  | Type | euler_z,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |

template<typename Type>

void clan::Quaternionx< Type >::set | ( | const Vec3< Type > & | euler,
|  | AngleUnit | unit,
|  | EulerOrder | order
| ) |  |

template<typename Type>

void clan::Quaternionx< Type >::set | ( | const Angle & | euler_x,
|  | const Angle & | euler_y,
|  | const Angle & | euler_z,
|  | EulerOrder | order
| ) |  |

void clan::BigInt::set | ( | int32_t | d | ) |

Sets a value.

void clan::BigInt::set | ( | uint32_t | d | ) |

void clan::BigInt::set | ( | uint64_t | d | ) |

void clan::BigInt::set | ( | int64_t | d | ) |

void clan::RectPacker::set_allocation_policy | ( | AllocationPolicy | policy | ) |

Set the allocation policy.

void clan::BigInt::set_bit | ( | unsigned int | bit_number,
|  | unsigned int | value
| ) |  |

void clan::Angle::set_degrees | ( | float | value_degrees | ) |

Set the angle value in degrees.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::set_height | ( | Type | height | ) |
| inline

Sets the height of the rectangle.

Returns
  reference to this object

void clan::EarClipTriangulator::set_orientation | ( | PolygonOrientation | orientation | ) |

Set polygon orientation.

void clan::Angle::set_radians | ( | float | value_radians | ) |

Set the angle value in radians.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::set_size | ( | const Sizex< Type > & | size | ) |
| inline

Sets the size of the rectangle, maintaining top/left position.

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::set_top_left | ( | const Vec2< Type > & | p | ) |
| inline

Sets the top-left point of the rectangle.

Returns
  reference to this object

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::set_translate | ( | Type | x,
|  | Type | y,
|  | Type | z
| ) |  |
| inline

Set this matrix translation values.

Matrix is assumed to be in the Column-Major matrix format (opengl native)
This does not translate the matrix, see translate_self() if this is desired

Parameters

  x | = Translate X
  y | = Translate Y
  z | = Translate Z

Returns
  reference to this object

References clan::x, clan::y, and clan::z.

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::set_translate | ( | const Vec3< Type > & | translation | ) |
| inline

Set this matrix translation values.

Matrix is assumed to be in the Column-Major matrix format (opengl native)
This does not translate the matrix, see translate_self() if this is desired

Parameters

  translation | = Translate XYZ

Returns
  reference to this object

References clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::set_width | ( | Type | width | ) |
| inline

Sets the width of the rectangle.

Returns
  reference to this object

template<typename Type>

void clan::Vec4< Type >::set_xy | ( | const Vec2< Type > & | new_v | ) |
| inline

template<typename Type>

void clan::Vec4< Type >::set_zw | ( | const Vec2< Type > & | new_v | ) |
| inline

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::shrink | ( | const Type & | new_left,
|  | const Type & | new_top,
|  | const Type & | new_right,
|  | const Type & | new_bottom
| ) |  |
| inline

Shrink the rectangle.

Returns
  reference to this object

Referenced by clan::Rectx< int >::shrink().

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::shrink | ( | const Type & | left_right,
|  | const Type & | top_bottom
| ) |  |
| inline

Shrink the rectangle.

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::shrink | ( | const Type & | shrink | ) |
| inline

Shrink the rectangle.

Returns
  reference to this object

void clan::BigInt::sieve | ( | const uint32_t * | primes,
|  | unsigned int | num_primes,
|  | std::vector< unsigned char > & | sieve
| ) |  |

int clan::sign | ( | int | x | ) |
| inline

Referenced by clan::sign().

float clan::sign | ( | float | x | ) |
| inline

References clan::f.

double clan::sign | ( | double | x | ) |
| inline

template<typename Type >

Vec2<Type> clan::sign | ( | const Vec2< Type > & | x | ) |
| inline

References clan::sign(), clan::Vec2< Type >::x, and clan::Vec2< Type >::y.

template<typename Type >

Vec3<Type> clan::sign | ( | const Vec3< Type > & | x | ) |
| inline

References clan::sign(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type >

Vec4<Type> clan::sign | ( | const Vec4< Type > & | x | ) |
| inline

References clan::sign(), clan::Vec4< Type >::w, clan::Vec4< Type >::x, clan::Vec4< Type >::y, and clan::Vec4< Type >::z.

int clan::BigInt::significant_bits | ( |  | ) | const

template<typename Type>

static Quaternionx<Type> clan::Quaternionx< Type >::slerp | ( | const Quaternionx< Type > & | quaternion_initial,
|  | const Quaternionx< Type > & | quaternion_final,
|  | Type | slerp_time
| ) |  |
| static

Spherical Quaternion Interpolation.

Parameters

  quaternion_initial | = Source quaternion
  quaternion_final | = Destination quaternion
  slerp_time | = Time in the range of 0.0 to 1.0

template<typename A , typename B , typename C >

C clan::smoothstep | ( | A | edge0,
|  | B | edge1,
|  | C | x
| ) |  |
| inline

References clan::clamp(), and clan::t.

static OverlapResult clan::IntersectionTest::sphere | ( | const Vec3f & | center1,
|  | float | radius1,
|  | const Vec3f & | center2,
|  | float | radius2
| ) |  |
| static

static OverlapResult clan::IntersectionTest::sphere_aabb | ( | const Vec3f & | center,
|  | float | radius,
|  | const AxisAlignedBoundingBox & | aabb
| ) |  |
| static

void clan::BigInt::sqr | ( | BigInt * | b | ) | const

void clan::BigInt::sqrmod | ( | const BigInt * | m,
|  | BigInt * | c
| ) |  | const

int clan::step | ( | int | edge,
|  | int | x
| ) |  |
| inline

Referenced by clan::step().

long long clan::step | ( | long long | edge,
|  | long long | x
| ) |  |
| inline

float clan::step | ( | float | edge,
|  | float | x
| ) |  |
| inline

double clan::step | ( | double | edge,
|  | double | x
| ) |  |
| inline

template<typename Type >

Vec2<Type> clan::step | ( | const Vec2< Type > & | edge,
|  | const Vec2< Type > & | x
| ) |  |
| inline

References clan::step(), clan::Vec2< Type >::x, and clan::Vec2< Type >::y.

template<typename Type >

Vec3<Type> clan::step | ( | const Vec3< Type > & | edge,
|  | const Vec3< Type > & | x
| ) |  |
| inline

References clan::step(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type >

Vec4<Type> clan::step | ( | const Vec4< Type > & | edge,
|  | const Vec4< Type > & | x
| ) |  |
| inline

References clan::step(), clan::Vec4< Type >::w, clan::Vec4< Type >::x, clan::Vec4< Type >::y, and clan::Vec4< Type >::z.

template<typename Type>

static Mat2<Type> clan::Mat2< Type >::subtract | ( | const Mat2< Type > & | matrix_1,
|  | const Mat2< Type > & | matrix_2
| ) |  |
| static

Subtract 2 matrices.

This subtract the matrix as follows: result = matrix1 - matrix2

Parameters

  matrix_1 | = First Matrix to subtract
  matrix_2 | = Second Matrix to subtract

Returns
  The matrix

template<typename Type>

Mat3< Type > clan::Mat3< Type >::subtract | ( | const Mat3< Type > & | matrix_1,
|  | const Mat3< Type > & | matrix_2
| ) |  |
| inline static

Subtract 2 matrices.

This subtracts the matrix as follows: result = matrix1 - matrix2

Parameters

  matrix_1 | = First Matrix to subtract
  matrix_2 | = Second Matrix to subtract

Returns
  The matrix

template<typename Type >

Mat4< Type > clan::Mat4< Type >::subtract | ( | const Mat4< Type > & | matrix_1,
|  | const Mat4< Type > & | matrix_2
| ) |  |
| inline static

Subtract 2 matrices.

This subtracts the matrix as follows: result = matrix1 - matrix2

Parameters

  matrix_1 | = First Matrix to subtract
  matrix_2 | = Second Matrix to subtract

Returns
  The matrix

void clan::RectPacker::throw_if_null | ( |  | ) | const

Throw an exception if this object is invalid.

float clan::Angle::to_degrees | ( |  | ) | const

Returns the angle as degrees.

float clan::HalfFloat::to_float | ( |  | ) | const
| inline

References clan::HalfFloat::half_to_float().

Referenced by clan::HalfFloat::operator float().

Vec2f clan::Vec2hf::to_float | ( |  | ) | const
| inline

Referenced by clan::Vec2hf::operator Vec2f().

Vec3f clan::Vec3hf::to_float | ( |  | ) | const
| inline

Referenced by clan::Vec3hf::operator Vec3f().

Vec4f clan::Vec4hf::to_float | ( |  | ) | const
| inline

Referenced by clan::Vec4hf::operator Vec4f().

template<typename Type>

Mat4<Type> clan::Quaternionx< Type >::to_matrix | ( |  | ) | const

Convert the quaternion to a rotation matrix.

This function assumes that the quarternion is normalized.

float clan::Angle::to_radians | ( |  | ) | const

Returns the angle as radians.

void clan::BigInt::to_unsigned_octets | ( | unsigned char * | output_str,
|  | unsigned int | output_length
| ) |  | const

unsigned int clan::BigInt::trailing_zeros | ( |  | ) | const

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::translate | ( | Type | x,
|  | Type | y
| ) |  |
| static

Create a 2d translation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  x | = Translate X
  y | = Translate Y

Returns
  The matrix (in column-major format)

Referenced by clan::Mat3< float >::translate().

template<typename Type>

static Mat3<Type> clan::Mat3< Type >::translate | ( | const Vec2< Type > & | xy | ) |
| inline static

Create a 2d translation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  xy | = Translate XY

Returns
  The matrix (in column-major format)

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::translate | ( | Type | x,
|  | Type | y,
|  | Type | z
| ) |  |
| static

Create a translation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  x | = Translate X
  y | = Translate Y
  z | = Translate Z

Returns
  The matrix (in column-major format)

Referenced by clan::Mat4< Type >::translate().

template<typename Type>

static Mat4<Type> clan::Mat4< Type >::translate | ( | const Vec3< Type > & | xyz | ) |
| inline static

Create a translation matrix.

Matrix is created in the Column-Major matrix format (opengl native)

Parameters

  xyz | = Translate XYZ

Returns
  The matrix (in column-major format)

References clan::Mat4< Type >::translate(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::translate | ( | const Vec2< Type > & | p | ) |
| inline

Translate the rect.

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::translate | ( | const Sizex< Type > & | p | ) |
| inline

Translate the rect.

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::translate | ( | const Rectx< Type > & | p | ) |
| inline

Translate the rect by another rect (only uses the left and top coords).

Returns
  reference to this object

template<typename Type>

Rectx<Type>& clan::Rectx< Type >::translate | ( | Type | x,
|  | Type | y
| ) |  |
| inline

Translate the rect.

Returns
  reference to this object

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::translate_self | ( | Type | x,
|  | Type | y,
|  | Type | z
| ) |  |

Translate this matrix.

Matrix is assumed to be in the Column-Major matrix format (opengl native)
This is faster than using: multiply(Mat4<Type>::translate(x,y,z) )

Parameters

  x | = Translate X
  y | = Translate Y
  z | = Translate Z

Returns
  reference to this object

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::translate_self | ( | const Vec3< Type > & | translation | ) |
| inline

Translate this matrix.

Matrix is assumed to be in the Column-Major matrix format (opengl native)
This is faster than using: multiply(Mat4<Type>::translate(x,y,z) )

Parameters

  translation | = Translate XYZ

Returns
  reference to this object

References clan::Mat4< Type >::translate_self(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

Referenced by clan::Mat4< Type >::translate_self().

template<typename Type>

Mat3< Type > clan::Mat3< Type >::transpose | ( | const Mat3< Type > & | matrix | ) |
| inline static

Calculate the transpose of a matrix.

Parameters

  matrix | = The matrix to use

Returns
  The transposed matrix

template<typename Type>

Mat3<Type>& clan::Mat3< Type >::transpose | ( |  | ) |

Calculate the transpose of this matrix.

Returns
  reference to this object

template<typename Type >

Mat4< Type > clan::Mat4< Type >::transpose | ( | const Mat4< Type > & | matrix | ) |
| inline static

Calculate the transpose of a matrix.

Parameters

  matrix | = The matrix to use

Returns
  The transposed matrix

References clan::Mat4< Type >::transpose().

Referenced by clan::Mat4< Type >::transpose().

template<typename Type>

Mat4<Type>& clan::Mat4< Type >::transpose | ( |  | ) |

Calculate the transpose of this matrix.

Returns
  reference to this object

EarClipResult clan::EarClipTriangulator::triangulate | ( |  | ) |

Perform triangulation.

int clan::BigInt::unsigned_octet_size | ( |  | ) | const

void clan::BigInt::xgcd | ( | const BigInt * | b,
|  | BigInt * | g,
|  | BigInt * | x,
|  | BigInt * | y
| ) |  | const

Compute g = (a, b) and values x and y satisfying Bezout's identity.

(that is, ax + by = g). This uses the extended binary GCD algorithm based on the Stein algorithm used for mp_gcd()

template<typename Type>

static Rectx<Type> clan::Rectx< Type >::xywh | ( | Type | x,
|  | Type | y,
|  | Type | width,
|  | Type | height
| ) |  |
| inline static

void clan::BigInt::zero | ( |  | ) |

## Variable Documentation

union { ... }

The imaginary vector part.

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

union { ... }

template<typename Type>

Type clan::Vec4< Type >::a

Referenced by clan::StyleGetValue::from_color(), clan::Color::get_abgr8(), clan::Color::get_alpha(), clan::Colorf::get_alpha(), clan::Color::get_alpha_f(), clan::Color::get_argb8(), clan::Color::get_bgra8(), clan::Color::get_rgba8(), clan::Colorf::normalize(), clan::Color::operator!=(), clan::Colorf::operator!=(), clan::Color::operator==(), clan::Colorf::operator==(), clan::Color::set_alpha(), clan::Colorf::set_alpha(), clan::Color::set_alpha_f(), clan::Image::set_color(), clan::Sprite::set_color(), clan::Color::set_color(), clan::Color::set_colorf(), and clan::Style::to_rgba().

Type { ... } ::a

Vec3f clan::AxisAlignedBoundingBox::aabb_max

Referenced by clan::AxisAlignedBoundingBox::center(), and clan::AxisAlignedBoundingBox::extents().

Vec3f clan::AxisAlignedBoundingBox::aabb_min

Referenced by clan::AxisAlignedBoundingBox::center(), and clan::AxisAlignedBoundingBox::extents().

Vec3f clan::OrientedBoundingBox::axis_x

Vec3f clan::OrientedBoundingBox::axis_y

Vec3f clan::OrientedBoundingBox::axis_z

Type { ... } ::b

template<typename Type>

Type clan::Vec4< Type >::b

Referenced by clan::StyleGetValue::from_color(), clan::Color::get_abgr8(), clan::Color::get_argb8(), clan::Color::get_bgra8(), clan::Color::get_blue(), clan::Colorf::get_blue(), clan::Color::get_blue_f(), clan::Color::get_rgba8(), clan::Colorf::normalize(), clan::Color::operator!=(), clan::Colorf::operator!=(), clan::Color::operator==(), clan::Colorf::operator==(), clan::Color::set_blue(), clan::Colorf::set_blue(), clan::Color::set_blue_f(), clan::Image::set_color(), clan::Sprite::set_color(), clan::Color::set_color(), clan::Color::set_colorf(), and clan::Style::to_rgba().

template<typename Type>

Type clan::Vec3< Type >::b

Type { ... } ::b

template<typename Type>

Type clan::Rectx< Type >::bottom

Y2-coordinate (point outside the rectange)

Referenced by clan::Rectx< int >::contains(), clan::Rectx< int >::get_bottom_left(), clan::Rectx< int >::get_bottom_right(), clan::Rectx< int >::ltrb(), clan::Rectx< int >::operator!=(), and clan::Rectx< int >::operator==().

Vec3f clan::OrientedBoundingBox::center

void* clan::DelauneyTriangulator_Vertex::data

Data pointer given when adding the vertex.

Vec3f clan::OrientedBoundingBox::extents

template<typename Type>

Type clan::Vec4< Type >::g

Referenced by clan::StyleGetValue::from_color(), clan::Color::get_abgr8(), clan::Color::get_argb8(), clan::Color::get_bgra8(), clan::Color::get_green(), clan::Colorf::get_green(), clan::Color::get_green_f(), clan::Color::get_rgba8(), clan::Colorf::normalize(), clan::Color::operator!=(), clan::Colorf::operator!=(), clan::Color::operator==(), clan::Colorf::operator==(), clan::Image::set_color(), clan::Sprite::set_color(), clan::Color::set_color(), clan::Color::set_colorf(), clan::Color::set_green(), clan::Colorf::set_green(), clan::Color::set_green_f(), and clan::Style::to_rgba().

Type { ... } ::g

template<typename Type>

Type clan::Vec2< Type >::g

Type { ... } ::g

template<typename Type>

Type clan::Vec3< Type >::g

Type { ... } ::g

int clan::RectPacker::AllocatedRect::group_index

template<typename Type>

Type clan::Sizex< Type >::height

Size height.

Referenced by clan::Sizex< Type >::operator Vec2< Type >(), clan::Sizex< int >::operator!=(), clan::Sizex< int >::operator+(), clan::Sizex< int >::operator+=(), clan::Sizex< int >::operator-(), clan::Sizex< int >::operator-=(), clan::Sizex< int >::operator==(), clan::Rectx< int >::set_size(), clan::Size::Size(), clan::Sized::Sized(), clan::Sizef::Sizef(), and clan::Rectx< int >::translate().

template<typename Type>

Type clan::Quaternionx< Type >::i

Type { ... } ::i

template<typename Type>

Type clan::Quaternionx< Type >::j

Type { ... } ::j

Type { ... } ::k

template<typename Type>

Type clan::Quaternionx< Type >::k

template<typename Type>

Type clan::Rectx< Type >::left

X1-coordinate (left point inside the rectangle)

Referenced by clan::Rectx< int >::get_bottom_left(), clan::Rectx< int >::get_size(), clan::Rectx< int >::get_top_left(), clan::Rectx< int >::get_width(), clan::Rectx< int >::ltrb(), clan::Rectx< int >::normalize(), clan::Rectx< int >::operator!=(), and clan::Rectx< int >::operator==().

template<typename Type>

Type clan::Mat2< Type >::matrix[4]

Referenced by clan::Mat2< Type >::is_equal(), clan::Mat2< Type >::Mat2(), clan::Mat2< Type >::operator Type *(), clan::Mat2< Type >::operator Type const *(), clan::Mat2< Type >::operator=(), clan::Mat2< Type >::operator==(), and clan::ProgramObject::set_uniform_matrix().

template<typename Type>

Type clan::Mat3< Type >::matrix[9]

Referenced by clan::Mat3< float >::Mat3(), clan::Mat3< Type >::operator Type *(), clan::Mat3< Type >::operator Type const *(), and clan::ProgramObject::set_uniform_matrix().

template<typename Type>

Type clan::Mat4< Type >::matrix[16]

The matrix (in column-major format)

Referenced by clan::Mat4< Type >::identity(), clan::Mat4< Type >::is_equal(), clan::Mat4< Type >::Mat4(), clan::Mat4< Type >::null(), clan::Mat4< Type >::operator Type *(), clan::Mat4< Type >::operator Type const *(), clan::Mat4< Type >::operator=(), clan::Mat4< Type >::operator==(), and clan::ProgramObject::set_uniform_matrix().

template<typename Type>

Vec2<Type> clan::Trianglex< Type >::p

First triangle point.

Referenced by clan::Trianglex< int >::operator!=(), clan::Trianglex< int >::operator=(), and clan::Trianglex< int >::operator==().

template<typename Type>

Vec3<Type> clan::Line3x< Type >::p

Referenced by clan::Line3x< int >::operator!=(), clan::Line3x< int >::operator=(), and clan::Line3x< int >::operator==().

template<typename Type>

Vec3<Type> clan::LineRay3x< Type >::p

Start point on the line ray.

Referenced by clan::LineRay3x< int >::operator!=(), clan::LineRay3x< int >::operator=(), and clan::LineRay3x< int >::operator==().

template<typename Type>

Vec3<Type> clan::LineSegment3x< Type >::p

Start point on the line.

Referenced by clan::LineSegment3x< int >::operator!=(), clan::LineSegment3x< int >::operator=(), and clan::LineSegment3x< int >::operator==().

template<typename Type>

Vec2<Type> clan::Line2x< Type >::p

First point on the line.

template<typename Type>

Vec2<Type> clan::LineRay2x< Type >::p

Start point on the line ray.

template<typename Type>

Vec2<Type> clan::LineSegment2x< Type >::p

Start point on the line.

template<typename Type>

Vec2<Type> clan::Quadx< Type >::p

First Point.

Referenced by clan::Quadx< int >::operator!=(), clan::Quadx< int >::operator+(), clan::Quadx< int >::operator+=(), clan::Quadx< int >::operator-(), clan::Quadx< int >::operator-=(), and clan::Quadx< int >::operator==().

template<typename Type>

Vec2<Type> clan::Circlex< Type >::position

Circle center point.

Referenced by clan::Circlex< int >::operator!=(), clan::Circlex< int >::operator=(), and clan::Circlex< int >::operator==().

template<typename Type>

Vec2<Type> clan::Trianglex< Type >::q

Referenced by clan::Trianglex< int >::operator!=(), clan::Trianglex< int >::operator=(), and clan::Trianglex< int >::operator==().

template<typename Type>

Vec3<Type> clan::Line3x< Type >::q

Referenced by clan::Line3x< int >::operator!=(), clan::Line3x< int >::operator=(), and clan::Line3x< int >::operator==().

template<typename Type>

Vec3<Type> clan::LineSegment3x< Type >::q

Referenced by clan::LineSegment3x< int >::operator!=(), clan::LineSegment3x< int >::operator=(), and clan::LineSegment3x< int >::operator==().

template<typename Type>

Vec2<Type> clan::Line2x< Type >::q

template<typename Type>

Vec2<Type> clan::LineSegment2x< Type >::q

template<typename Type>

Vec2<Type> clan::Quadx< Type >::q

Second Point.

Referenced by clan::Quadx< int >::operator!=(), clan::Quadx< int >::operator+(), clan::Quadx< int >::operator+=(), clan::Quadx< int >::operator-(), clan::Quadx< int >::operator-=(), and clan::Quadx< int >::operator==().

template<typename Type>

Vec2<Type> clan::Trianglex< Type >::r

Referenced by clan::Trianglex< int >::operator!=(), clan::Trianglex< int >::operator=(), and clan::Trianglex< int >::operator==().

template<typename Type>

Type clan::Vec4< Type >::r

Referenced by clan::StyleGetValue::from_color(), clan::Color::get_abgr8(), clan::Color::get_argb8(), clan::Color::get_bgra8(), clan::Color::get_red(), clan::Colorf::get_red(), clan::Color::get_red_f(), clan::Color::get_rgba8(), clan::Colorf::normalize(), clan::Color::operator!=(), clan::Colorf::operator!=(), clan::Color::operator==(), clan::Colorf::operator==(), clan::Image::set_color(), clan::Sprite::set_color(), clan::Color::set_color(), clan::Color::set_colorf(), clan::Color::set_red(), clan::Colorf::set_red(), clan::Color::set_red_f(), and clan::Style::to_rgba().

template<typename Type>

Type clan::Vec2< Type >::r

Type { ... } ::r

Type { ... } ::r

template<typename Type>

Type clan::Vec3< Type >::r

Type { ... } ::r

template<typename Type>

Vec2<Type> clan::Quadx< Type >::r

Third Point.

Referenced by clan::Quadx< int >::operator!=(), clan::Quadx< int >::operator+(), clan::Quadx< int >::operator+=(), clan::Quadx< int >::operator-(), clan::Quadx< int >::operator-=(), and clan::Quadx< int >::operator==().

template<typename Type>

Type clan::Circlex< Type >::radius

Circle radius.

Referenced by clan::Circlex< int >::operator!=(), clan::Circlex< int >::operator=(), and clan::Circlex< int >::operator==().

Rect clan::RectPacker::AllocatedRect::rect

template<typename Type>

Type clan::Rectx< Type >::right

X2-coordinate (point outside the rectangle)

Referenced by clan::Rectx< int >::get_bottom_right(), clan::Rectx< int >::get_center(), clan::Rectx< int >::get_top_right(), clan::Rectx< int >::ltrb(), clan::Rectx< int >::operator!=(), and clan::Rectx< int >::operator==().

template<typename Type>

Type clan::Vec4< Type >::s

Type { ... } ::s

Type { ... } ::s

template<typename Type>

Type clan::Vec2< Type >::s

Type { ... } ::s

template<typename Type>

Type clan::Vec3< Type >::s

template<typename Type>

Vec2<Type> clan::Quadx< Type >::s

Fourth Point.

Referenced by clan::Quadx< int >::operator!=(), clan::Quadx< int >::operator+(), clan::Quadx< int >::operator+=(), clan::Quadx< int >::operator-(), clan::Quadx< int >::operator-=(), and clan::Quadx< int >::operator==().

Type { ... } ::t

template<typename Type>

Type clan::Vec4< Type >::t

Type { ... } ::t

template<typename Type>

Type clan::Vec2< Type >::t

Type { ... } ::t

template<typename Type>

Type clan::Vec3< Type >::t

template<typename Type>

Type clan::Rectx< Type >::top

Y1-coordinate (top point inside the rectangle)

Referenced by clan::Rectx< int >::get_height(), clan::Rectx< int >::get_size(), clan::Rectx< int >::get_top_left(), clan::Rectx< int >::get_top_right(), clan::Rectx< int >::ltrb(), clan::Rectx< int >::normalize(), clan::Rectx< int >::operator!=(), and clan::Rectx< int >::operator==().

Type { ... } ::u

template<typename Type>

Type clan::Vec4< Type >::u

Type { ... } ::u

template<typename Type>

Type clan::Vec3< Type >::u

template<typename Type>

Vec3<Type> clan::LineRay3x< Type >::v

Referenced by clan::LineRay3x< int >::operator!=(), clan::LineRay3x< int >::operator=(), and clan::LineRay3x< int >::operator==().

template<typename Type>

Type clan::Vec4< Type >::v

Type { ... } ::v

template<typename Type>

Vec2<Type> clan::LineRay2x< Type >::v

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_A

First point in the triangle.

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_B

Second point in the triangle.

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_C

Third point in the triangle.

template<typename Type>

Type clan::Quaternionx< Type >::w

The real scalar part.

template<typename Type>

Type clan::Vec4< Type >::w

Referenced by clan::Vec4< float >::dot4(), clan::max(), clan::min(), clan::Vec4< float >::operator!=(), clan::Vec4< float >::operator*=(), clan::Vec4< float >::operator+=(), clan::Vec4< float >::operator-(), clan::Vec4< float >::operator-=(), clan::Vec4< float >::operator/=(), clan::Vec4< float >::operator<(), clan::Vec4< float >::operator=(), clan::Vec4< float >::operator==(), clan::ProgramObject::set_uniform4b(), clan::ProgramObject::set_uniform4f(), clan::ProgramObject::set_uniform4i(), clan::ProgramObject::set_uniform4s(), clan::Vec4< float >::set_zw(), clan::sign(), clan::step(), and clan::Vec4< float >::Vec4().

Type { ... } ::w

HalfFloat clan::Vec4hf::w

template<typename Type>

Type clan::Sizex< Type >::width

Size width.

Referenced by clan::Sizex< Type >::operator Vec2< Type >(), clan::Sizex< int >::operator!=(), clan::Sizex< int >::operator+(), clan::Sizex< int >::operator+=(), clan::Sizex< int >::operator-(), clan::Sizex< int >::operator-=(), clan::Sizex< int >::operator==(), clan::Rectx< int >::set_size(), clan::Size::Size(), clan::Sized::Sized(), clan::Sizef::Sizef(), and clan::Rectx< int >::translate().

float clan::DelauneyTriangulator_Vertex::x

X position of vertex.

Type { ... } ::x

template<typename Type>

Type clan::Quaternionx< Type >::x

Referenced by clan::Quaternionx< float >::operator!=(), clan::Quaternionx< float >::operator<(), clan::Quaternionx< float >::operator==(), and clan::Quaternionx< float >::operator>().

HalfFloat clan::Vec2hf::x

template<typename Type>

Type clan::Vec4< Type >::x

Referenced by clan::Vec4< float >::dot3(), clan::Vec4< float >::dot4(), clan::max(), clan::min(), clan::Vec4< float >::operator!=(), clan::Vec4< float >::operator*=(), clan::Vec4< float >::operator+=(), clan::Vec4< float >::operator-(), clan::Vec4< float >::operator-=(), clan::Vec4< float >::operator/=(), clan::Vec4< float >::operator<(), clan::Vec4< float >::operator=(), clan::Vec4< float >::operator==(), clan::ProgramObject::set_uniform4b(), clan::ProgramObject::set_uniform4f(), clan::ProgramObject::set_uniform4i(), clan::ProgramObject::set_uniform4s(), clan::ProgramObject::set_uniformfv(), clan::ProgramObject::set_uniformiv(), clan::Vec4< float >::set_xy(), clan::sign(), clan::step(), clan::Vec2< int >::Vec2(), clan::Vec3< int >::Vec3(), and clan::Vec4< float >::Vec4().

template<typename Type>

Type clan::Vec2< Type >::x

Referenced by clan::Rectx< int >::apply_alignment(), clan::Rectx< int >::contains(), clan::Vec2< int >::dot(), clan::LineSegment2x< int >::get_midpoint(), clan::max(), clan::min(), clan::Vec2< int >::operator!=(), clan::Vec2< int >::operator*=(), clan::Vec2< int >::operator+=(), clan::Vec2< int >::operator-(), clan::Vec2< int >::operator-=(), clan::Vec2< int >::operator/=(), clan::Vec2< int >::operator<(), clan::Vec2< int >::operator=(), clan::Vec2< int >::operator==(), clan::Line2x< int >::point_right_of_line(), clan::LineSegment2x< int >::point_right_of_line(), clan::Rectx< int >::set_top_left(), clan::ProgramObject::set_uniform2b(), clan::ProgramObject::set_uniform2f(), clan::ProgramObject::set_uniform2i(), clan::ProgramObject::set_uniform2s(), clan::ProgramObject::set_uniformfv(), clan::ProgramObject::set_uniformiv(), clan::Vec4< float >::set_xy(), clan::Vec4< float >::set_zw(), clan::sign(), clan::step(), clan::Mat3< float >::translate(), clan::Rectx< int >::translate(), clan::Vec2< int >::Vec2(), clan::Vec2< Type >::Vec2(), clan::Vec3< int >::Vec3(), and clan::Vec4< float >::Vec4().

Type { ... } ::x

template<typename Type>

Type clan::Vec3< Type >::x

Referenced by clan::Vec3< int >::dot(), clan::LineSegment3x< int >::get_midpoint(), clan::Mat4< Type >::look_at(), clan::max(), clan::min(), clan::Vec3< int >::operator!=(), clan::Vec3< int >::operator*=(), clan::Vec3< int >::operator+=(), clan::Vec3< int >::operator-(), clan::Vec3< int >::operator-=(), clan::Vec3< int >::operator/=(), clan::Vec3< int >::operator<(), clan::Vec3< int >::operator=(), clan::Vec3< int >::operator==(), clan::Mat3< float >::rotate(), clan::Mat4< Type >::rotate(), clan::Mat3< float >::scale(), clan::Mat4< Type >::scale(), clan::Mat4< Type >::scale_self(), clan::Mat4< Type >::set_translate(), clan::ProgramObject::set_uniform3b(), clan::ProgramObject::set_uniform3f(), clan::ProgramObject::set_uniform3i(), clan::ProgramObject::set_uniform3s(), clan::ProgramObject::set_uniformfv(), clan::ProgramObject::set_uniformiv(), clan::sign(), clan::step(), clan::Mat4< Type >::translate(), clan::Mat4< Type >::translate_self(), clan::Vec2< int >::Vec2(), clan::Vec3< int >::Vec3(), clan::Vec3< Type >::Vec3(), and clan::Vec4< float >::Vec4().

Type { ... } ::x

Type { ... } ::x

HalfFloat clan::Vec3hf::x

HalfFloat clan::Vec4hf::x

float clan::EarClipTriangulator_Triangle::x1

float clan::EarClipTriangulator_Triangle::x2

float clan::EarClipTriangulator_Triangle::x3

Type { ... } ::y

template<typename Type>

Type clan::Quaternionx< Type >::y

Referenced by clan::Quaternionx< float >::operator!=(), clan::Quaternionx< float >::operator<(), clan::Quaternionx< float >::operator==(), and clan::Quaternionx< float >::operator>().

HalfFloat clan::Vec2hf::y

float clan::DelauneyTriangulator_Vertex::y

Y position of vertex.

Type { ... } ::y

template<typename Type>

Type clan::Vec2< Type >::y

Referenced by clan::Rectx< int >::apply_alignment(), clan::Rectx< int >::contains(), clan::Vec2< int >::dot(), clan::LineSegment2x< int >::get_midpoint(), clan::max(), clan::min(), clan::Vec2< int >::operator!=(), clan::Vec2< int >::operator*=(), clan::Vec2< int >::operator+=(), clan::Vec2< int >::operator-(), clan::Vec2< int >::operator-=(), clan::Vec2< int >::operator/=(), clan::Vec2< int >::operator<(), clan::Vec2< int >::operator=(), clan::Vec2< int >::operator==(), clan::Line2x< int >::point_right_of_line(), clan::LineSegment2x< int >::point_right_of_line(), clan::Rectx< int >::set_top_left(), clan::ProgramObject::set_uniform2b(), clan::ProgramObject::set_uniform2f(), clan::ProgramObject::set_uniform2i(), clan::ProgramObject::set_uniform2s(), clan::Vec4< float >::set_xy(), clan::Vec4< float >::set_zw(), clan::sign(), clan::step(), clan::Mat3< float >::translate(), clan::Rectx< int >::translate(), clan::Vec2< int >::Vec2(), clan::Vec2< Type >::Vec2(), clan::Vec3< int >::Vec3(), and clan::Vec4< float >::Vec4().

Type { ... } ::y

Type { ... } ::y

template<typename Type>

Type clan::Vec3< Type >::y

Referenced by clan::Vec3< int >::dot(), clan::LineSegment3x< int >::get_midpoint(), clan::Mat4< Type >::look_at(), clan::max(), clan::min(), clan::Vec3< int >::operator!=(), clan::Vec3< int >::operator*=(), clan::Vec3< int >::operator+=(), clan::Vec3< int >::operator-(), clan::Vec3< int >::operator-=(), clan::Vec3< int >::operator/=(), clan::Vec3< int >::operator<(), clan::Vec3< int >::operator=(), clan::Vec3< int >::operator==(), clan::Mat3< float >::rotate(), clan::Mat4< Type >::rotate(), clan::Mat3< float >::scale(), clan::Mat4< Type >::scale(), clan::Mat4< Type >::scale_self(), clan::Mat4< Type >::set_translate(), clan::ProgramObject::set_uniform3b(), clan::ProgramObject::set_uniform3f(), clan::ProgramObject::set_uniform3i(), clan::ProgramObject::set_uniform3s(), clan::sign(), clan::step(), clan::Mat4< Type >::translate(), clan::Mat4< Type >::translate_self(), clan::Vec2< int >::Vec2(), clan::Vec3< int >::Vec3(), clan::Vec3< Type >::Vec3(), and clan::Vec4< float >::Vec4().

template<typename Type>

Type clan::Vec4< Type >::y

Referenced by clan::Vec4< float >::dot3(), clan::Vec4< float >::dot4(), clan::max(), clan::min(), clan::Vec4< float >::operator!=(), clan::Vec4< float >::operator*=(), clan::Vec4< float >::operator+=(), clan::Vec4< float >::operator-(), clan::Vec4< float >::operator-=(), clan::Vec4< float >::operator/=(), clan::Vec4< float >::operator<(), clan::Vec4< float >::operator=(), clan::Vec4< float >::operator==(), clan::ProgramObject::set_uniform4b(), clan::ProgramObject::set_uniform4f(), clan::ProgramObject::set_uniform4i(), clan::ProgramObject::set_uniform4s(), clan::Vec4< float >::set_xy(), clan::sign(), clan::step(), clan::Vec2< int >::Vec2(), clan::Vec3< int >::Vec3(), and clan::Vec4< float >::Vec4().

HalfFloat clan::Vec3hf::y

HalfFloat clan::Vec4hf::y

float clan::EarClipTriangulator_Triangle::y1

float clan::EarClipTriangulator_Triangle::y2

float clan::EarClipTriangulator_Triangle::y3

template<typename Type>

Type clan::Quaternionx< Type >::z

Referenced by clan::Quaternionx< float >::operator!=(), clan::Quaternionx< float >::operator<(), clan::Quaternionx< float >::operator==(), and clan::Quaternionx< float >::operator>().

Type { ... } ::z

template<typename Type>

Type clan::Vec3< Type >::z

Referenced by clan::Vec3< int >::dot(), clan::LineSegment3x< int >::get_midpoint(), clan::Mat4< Type >::look_at(), clan::max(), clan::min(), clan::Vec3< int >::operator!=(), clan::Vec3< int >::operator*=(), clan::Vec3< int >::operator+=(), clan::Vec3< int >::operator-(), clan::Vec3< int >::operator-=(), clan::Vec3< int >::operator/=(), clan::Vec3< int >::operator<(), clan::Vec3< int >::operator=(), clan::Vec3< int >::operator==(), clan::Mat3< float >::rotate(), clan::Mat4< Type >::rotate(), clan::Mat4< Type >::scale(), clan::Mat4< Type >::scale_self(), clan::Mat4< Type >::set_translate(), clan::ProgramObject::set_uniform3b(), clan::ProgramObject::set_uniform3f(), clan::ProgramObject::set_uniform3i(), clan::ProgramObject::set_uniform3s(), clan::sign(), clan::step(), clan::Mat4< Type >::translate(), clan::Mat4< Type >::translate_self(), clan::Vec3< int >::Vec3(), clan::Vec3< Type >::Vec3(), and clan::Vec4< float >::Vec4().

template<typename Type>

Type clan::Vec4< Type >::z

Referenced by clan::Vec4< float >::dot3(), clan::Vec4< float >::dot4(), clan::max(), clan::min(), clan::Vec4< float >::operator!=(), clan::Vec4< float >::operator*=(), clan::Vec4< float >::operator+=(), clan::Vec4< float >::operator-(), clan::Vec4< float >::operator-=(), clan::Vec4< float >::operator/=(), clan::Vec4< float >::operator<(), clan::Vec4< float >::operator=(), clan::Vec4< float >::operator==(), clan::ProgramObject::set_uniform4b(), clan::ProgramObject::set_uniform4f(), clan::ProgramObject::set_uniform4i(), clan::ProgramObject::set_uniform4s(), clan::Vec4< float >::set_zw(), clan::sign(), clan::step(), clan::Vec3< int >::Vec3(), and clan::Vec4< float >::Vec4().

Type { ... } ::z

Type { ... } ::z

HalfFloat clan::Vec3hf::z

HalfFloat clan::Vec4hf::z

## Friends

friend class OutlineMath
| friend