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 AxisAlignedBoundingBox &aabb, const Vec3f &barycentric_min, const Vec3f &barycentric_max)
 
 clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox (const Vec3f &aabb_min, const Vec3f &aabb_max)
 
 clan::Circle::Circle ()
 
 clan::Circle::Circle (const Circlex< int > &copy)
 
 clan::Circle::Circle (const Vec2< int > &p, int radius)
 
 clan::Circle::Circle (int x, int y, int radius)
 
 clan::Circled::Circled ()
 
 clan::Circled::Circled (const Circlex< double > &copy)
 
 clan::Circled::Circled (const Vec2< double > &p, double radius)
 
 clan::Circled::Circled (double x, double y, double radius)
 
 clan::Circlef::Circlef ()
 
 clan::Circlef::Circlef (const Circlex< float > &copy)
 
 clan::Circlef::Circlef (const Vec2< float > &p, float radius)
 
 clan::Circlef::Circlef (float x, float y, float radius)
 
 clan::Circlex< Type >::Circlex ()
 
 clan::Circlex< Type >::Circlex (const Circlex< Type > &copy)
 
 clan::Circlex< Type >::Circlex (const Vec2< Type > &p, Type radius)
 
 clan::Circlex< Type >::Circlex (Type x, Type y, Type radius)
 
 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 (const Pointx< int > &p)
 
 clan::Point::Point (const Vec2< int > &p)
 
 clan::Point::Point (int x, int y)
 
 clan::Pointd::Pointd ()
 
 clan::Pointd::Pointd (const Pointx< double > &p)
 
 clan::Pointd::Pointd (const Vec2< double > &p)
 
 clan::Pointd::Pointd (double x, double y)
 
 clan::Pointf::Pointf ()
 
 clan::Pointf::Pointf (const Pointx< float > &p)
 
 clan::Pointf::Pointf (const Vec2< float > &p)
 
 clan::Pointf::Pointf (float x, float y)
 
 clan::Pointx< Type >::Pointx ()
 
 clan::Pointx< Type >::Pointx (const Pointx< Type > &p)
 
 clan::Pointx< Type >::Pointx (const Vec2< Type > &p)
 
 clan::Pointx< Type >::Pointx (Type x, Type y)
 
 clan::Quad::Quad ()
 
 clan::Quad::Quad (const Quadx< int > &quad)
 
 clan::Quad::Quad (const Rect &rect)
 
 clan::Quad::Quad (const Vec2< int > &new_p, const Vec2< int > &new_q, const Vec2< int > &new_r, const Vec2< int > &new_s)
 
 clan::Quadd::Quadd ()
 
 clan::Quadd::Quadd (const Quadx< double > &quad)
 
 clan::Quadd::Quadd (const Rectd &rect)
 
 clan::Quadd::Quadd (const Vec2< double > &new_p, const Vec2< double > &new_q, const Vec2< double > &new_r, const Vec2< double > &new_s)
 
 clan::Quadf::Quadf ()
 
 clan::Quadf::Quadf (const Quadx< float > &quad)
 
 clan::Quadf::Quadf (const Rectf &rect)
 
 clan::Quadf::Quadf (const Vec2< float > &new_p, const Vec2< float > &new_q, const Vec2< float > &new_r, const Vec2< float > &new_s)
 
 clan::Quaterniond::Quaterniond ()
 
 clan::Quaterniond::Quaterniond (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
 
 clan::Quaterniond::Quaterniond (const Mat4< double > &rotation_matrix)
 
 clan::Quaterniond::Quaterniond (const Quaternionx< double > &copy)
 
 clan::Quaterniond::Quaterniond (const Vec3< double > &euler, AngleUnit unit, EulerOrder order)
 
 clan::Quaterniond::Quaterniond (double euler_x, double euler_y, double euler_z, AngleUnit unit, EulerOrder order)
 
 clan::Quaterniond::Quaterniond (double real, const Vec3< double > &imag)
 
 clan::Quaterniond::Quaterniond (double real, double i, double j, double k)
 
 clan::Quaternionf::Quaternionf ()
 
 clan::Quaternionf::Quaternionf (const Angle &euler_x, const Angle &euler_y, const Angle &euler_z, EulerOrder order)
 
 clan::Quaternionf::Quaternionf (const Mat4< float > &rotation_matrix)
 
 clan::Quaternionf::Quaternionf (const Quaternionx< float > &copy)
 
 clan::Quaternionf::Quaternionf (const Vec3< float > &euler, AngleUnit unit, EulerOrder order)
 
 clan::Quaternionf::Quaternionf (float euler_x, float euler_y, float euler_z, AngleUnit unit, EulerOrder order)
 
 clan::Quaternionf::Quaternionf (float real, const Vec3< float > &imag)
 
 clan::Quaternionf::Quaternionf (float real, float i, float j, float k)
 
 clan::Quaternionx< Type >::Quaternionx ()
 
 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::Quaternionx< Type >::Quaternionx (const Quaternionx< Type > &copy)
 
 clan::Quaternionx< Type >::Quaternionx (const Vec3< Type > &euler, AngleUnit unit, EulerOrder order)
 
 clan::Quaternionx< Type >::Quaternionx (Type euler_x, Type euler_y, Type euler_z, AngleUnit unit, EulerOrder order)
 
 clan::Quaternionx< Type >::Quaternionx (Type real, const Vec3< Type > &imag)
 
 clan::Quaternionx< Type >::Quaternionx (Type real, Type i, Type j, Type k)
 
 clan::Rect::Rect ()
 
 clan::Rect::Rect (const Pointx< int > &p, const Sizex< int > &size)
 
 clan::Rect::Rect (const Rectx< double > &rect)
 
 clan::Rect::Rect (const Rectx< float > &rect)
 
 clan::Rect::Rect (const Rectx< int > &rect)
 
 clan::Rect::Rect (const Sizex< int > &s)
 
 clan::Rect::Rect (int new_left, int new_top, const Sizex< int > &size)
 
 clan::Rect::Rect (int new_left, int new_top, int new_right, int new_bottom)
 
 clan::Rectd::Rectd ()
 
 clan::Rectd::Rectd (const Pointx< double > &p, const Sizex< double > &size)
 
 clan::Rectd::Rectd (const Rectx< double > &rect)
 
 clan::Rectd::Rectd (const Rectx< float > &rect)
 
 clan::Rectd::Rectd (const Rectx< int > &rect)
 
 clan::Rectd::Rectd (const Sizex< double > &s)
 
 clan::Rectd::Rectd (const Sizex< float > &s)
 
 clan::Rectd::Rectd (const Sizex< int > &s)
 
 clan::Rectd::Rectd (double new_left, double new_top, const Sizex< double > &size)
 
 clan::Rectd::Rectd (double new_left, double new_top, double new_right, double new_bottom)
 
 clan::Rectf::Rectf ()
 
 clan::Rectf::Rectf (const Pointx< float > &p, const Sizex< float > &size)
 
 clan::Rectf::Rectf (const Rectx< double > &rect)
 
 clan::Rectf::Rectf (const Rectx< float > &rect)
 
 clan::Rectf::Rectf (const Rectx< int > &rect)
 
 clan::Rectf::Rectf (const Sizex< float > &s)
 
 clan::Rectf::Rectf (const Sizex< int > &s)
 
 clan::Rectf::Rectf (float new_left, float new_top, const Sizex< float > &size)
 
 clan::Rectf::Rectf (float new_left, float new_top, float new_right, float new_bottom)
 
 clan::Size::Size ()
 
 clan::Size::Size (const Sizex< double > &copy)
 
 clan::Size::Size (const Sizex< float > &copy)
 
 clan::Size::Size (const Sizex< int > &s)
 
 clan::Size::Size (const Vec2< int > &s)
 
 clan::Size::Size (int width, int height)
 
 clan::Sized::Sized ()
 
 clan::Sized::Sized (const Sizex< double > &s)
 
 clan::Sized::Sized (const Sizex< float > &copy)
 
 clan::Sized::Sized (const Sizex< int > &copy)
 
 clan::Sized::Sized (const Vec2< double > &s)
 
 clan::Sized::Sized (double width, double height)
 
 clan::Sizef::Sizef ()
 
 clan::Sizef::Sizef (const Sizex< double > &copy)
 
 clan::Sizef::Sizef (const Sizex< float > &s)
 
 clan::Sizef::Sizef (const Sizex< int > &copy)
 
 clan::Sizef::Sizef (const Vec2< float > &s)
 
 clan::Sizef::Sizef (float width, float height)
 
 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 &p1, const Type &p2)
 
 clan::Vec2< Type >::Vec2 (const Type &scalar)
 
 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::Vec2< Type >::Vec2 (const Vec3< Type > &copy)
 
 clan::Vec2< Type >::Vec2 (const Vec4< Type > &copy)
 
 clan::Vec2hf::Vec2hf ()
 
 clan::Vec2hf::Vec2hf (const HalfFloat &p1, const HalfFloat &p2)
 
 clan::Vec2hf::Vec2hf (const HalfFloat &scalar)
 
 clan::Vec2hf::Vec2hf (const HalfFloat *array_xy)
 
 clan::Vec2hf::Vec2hf (const Pointx< double > &point)
 
 clan::Vec2hf::Vec2hf (const Pointx< float > &point)
 
 clan::Vec2hf::Vec2hf (const Pointx< int > &point)
 
 clan::Vec2hf::Vec2hf (const Vec2d &copy)
 
 clan::Vec2hf::Vec2hf (const Vec2f &copy)
 
 clan::Vec2hf::Vec2hf (const Vec2hf &copy)
 
 clan::Vec2hf::Vec2hf (const Vec2i &copy)
 
 clan::Vec2hf::Vec2hf (const Vec3f &copy)
 
 clan::Vec2hf::Vec2hf (const Vec3hf &copy)
 
 clan::Vec2hf::Vec2hf (const Vec4f &copy)
 
 clan::Vec2hf::Vec2hf (const Vec4hf &copy)
 
 clan::Vec2hf::Vec2hf (float *array_xy)
 
 clan::Vec2hf::Vec2hf (float p1, float p2)
 
 clan::Vec2hf::Vec2hf (float scalar)
 
 clan::Vec3< Type >::Vec3 ()
 
 clan::Vec3< Type >::Vec3 (const Type &p1, const Type &p2, const Type &p3)
 
 clan::Vec3< Type >::Vec3 (const Type &scalar)
 
 clan::Vec3< Type >::Vec3 (const Type *array_xyz)
 
 clan::Vec3< Type >::Vec3 (const Vec2< Type > &copy, const Type &p3)
 
 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 Vec4< Type > &copy)
 
 clan::Vec3hf::Vec3hf ()
 
 clan::Vec3hf::Vec3hf (const float *array_xyz)
 
 clan::Vec3hf::Vec3hf (const HalfFloat &p1, const HalfFloat &p2, const HalfFloat &p3)
 
 clan::Vec3hf::Vec3hf (const HalfFloat &scalar)
 
 clan::Vec3hf::Vec3hf (const HalfFloat *array_xyz)
 
 clan::Vec3hf::Vec3hf (const Vec2f &copy, float p3)
 
 clan::Vec3hf::Vec3hf (const Vec2hf &copy, const HalfFloat &p3)
 
 clan::Vec3hf::Vec3hf (const Vec3d &copy)
 
 clan::Vec3hf::Vec3hf (const Vec3f &copy)
 
 clan::Vec3hf::Vec3hf (const Vec3hf &copy)
 
 clan::Vec3hf::Vec3hf (const Vec3i &copy)
 
 clan::Vec3hf::Vec3hf (const Vec4f &copy)
 
 clan::Vec3hf::Vec3hf (const Vec4hf &copy)
 
 clan::Vec3hf::Vec3hf (float p1, float p2, float p3)
 
 clan::Vec3hf::Vec3hf (float scalar)
 
 clan::Vec4< Type >::Vec4 ()
 
 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 &scalar)
 
 clan::Vec4< Type >::Vec4 (const Type *array_xyzw)
 
 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::Vec4hf::Vec4hf ()
 
 clan::Vec4hf::Vec4hf (const float *array_xyzw)
 
 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 &scalar)
 
 clan::Vec4hf::Vec4hf (const HalfFloat *array_xyzw)
 
 clan::Vec4hf::Vec4hf (const Vec2f &copy, const Vec2f &copy34)
 
 clan::Vec4hf::Vec4hf (const Vec2f &copy, float p3, float p4)
 
 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 Vec3f &copy, float p4)
 
 clan::Vec4hf::Vec4hf (const Vec3hf &copy, const HalfFloat &p4)
 
 clan::Vec4hf::Vec4hf (const Vec4f &copy)
 
 clan::Vec4hf::Vec4hf (float p1, float p2, const Vec2f &copy34)
 
 clan::Vec4hf::Vec4hf (float p1, float p2, float p3, float p4)
 
 clan::Vec4hf::Vec4hf (float scalar)
 
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 >
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::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::Vec3< Type >::dot (const Vec3< Type > &vector1, const Vec3< Type > &vector2)
 Dot products between two vectors. 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...
 
HalfFloatclan::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 >
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 >
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 >
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 >
Vec2< Type > clan::operator* (const Mat2< Type > &matrix, const Vec2< Type > &v)
 
template<typename Type >
Vec3< Type > clan::operator* (const Mat3< Type > &matrix, const Vec3< Type > &v)
 
template<typename Type >
Vec4< Type > clan::operator* (const Mat4< Type > &matrix, const Vec4< Type > &v)
 
template<typename Type >
Vec2< Type > clan::operator* (const Vec2< Type > &v, const Mat2< Type > &matrix)
 
template<typename Type >
Vec2< Type > clan::operator* (const Vec2< 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 >
Vec3< Type > clan::operator* (const Vec3< Type > &v, const Mat3< Type > &matrix)
 
template<typename Type >
Vec3< Type > clan::operator* (const Vec3< 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 >
Vec4< Type > clan::operator* (const Vec4< Type > &v, const Mat4< Type > &matrix)
 
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 > &v1, const Vec4< Type > &v2)
 
  • operator.
More...
 
template<typename Type >
Vec2< Type > clan::operator* (Type s, const Vec2< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec3< Type > clan::operator* (Type s, const Vec3< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec4< Type > clan::operator* (Type s, const Vec4< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec2< Type > clan::operator+ (const Vec2< 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 >
Vec3< Type > clan::operator+ (const Vec3< 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 >
Vec4< Type > clan::operator+ (const Vec4< 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 >
Vec2< Type > clan::operator+ (Type s, const Vec2< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec3< Type > clan::operator+ (Type s, const Vec3< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec4< Type > clan::operator+ (Type s, const Vec4< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec2< Type > clan::operator- (const Vec2< 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 >
Vec3< Type > clan::operator- (const Vec3< 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 >
Vec4< Type > clan::operator- (const Vec4< 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 >
Vec2< Type > clan::operator- (Type s, const Vec2< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec3< Type > clan::operator- (Type s, const Vec3< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec4< Type > clan::operator- (Type s, const Vec4< Type > &v)
 
  • operator.
More...
 
template<typename Type >
Vec2< Type > clan::operator/ (const Vec2< 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 >
Vec3< Type > clan::operator/ (const Vec3< 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 >
Vec4< Type > clan::operator/ (const Vec4< 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 >
Vec2< Type > clan::operator/ (Type s, const Vec2< Type > &v)
 / operator. More...
 
template<typename Type >
Vec3< Type > clan::operator/ (Type s, const Vec3< Type > &v)
 / operator. More...
 
template<typename Type >
Vec4< Type > clan::operator/ (Type s, const Vec4< Type > &v)
 / operator. More...
 
HalfFloatclan::HalfFloat::operator= (const float v)
 
HalfFloatclan::HalfFloat::operator= (const HalfFloat &other)
 
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 (const Pointf &A, const Pointf &B, const Pointf &P)
 Point right of line. More...
 
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...
 
template<typename 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 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 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 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...
 
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)
 
double clan::sign (double x)
 
float clan::sign (float x)
 
int clan::sign (int 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 >
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)
 
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)
 
double clan::step (double edge, double x)
 
float clan::step (float edge, float x)
 
int clan::step (int edge, int x)
 
long long clan::step (long long edge, long long 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...
 
Angleclan::Angle::normalize ()
 Converts angle to range [0,360] degrees. More...
 
Angleclan::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

DataBufferclan::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

DataBufferclan::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< Pointfclan::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< Pointfclan::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...
 
BigIntclan::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_Vertexclan::DelauneyTriangulator_Triangle::vertex_A
 First point in the triangle. More...
 
DelauneyTriangulator_Vertexclan::DelauneyTriangulator_Triangle::vertex_B
 Second point in the triangle. More...
 
DelauneyTriangulator_Vertexclan::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_Triangleclan::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< Pointfclan::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< Pointfclan::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

◆ datatype [1/3]

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

◆ datatype [2/3]

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

◆ datatype [3/3]

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

◆ Mat2d

typedef Mat2<double> clan::Mat2d

◆ Mat2f

typedef Mat2<float> clan::Mat2f

◆ Mat2i

typedef Mat2<int> clan::Mat2i

◆ Mat3d

typedef Mat3<double> clan::Mat3d

◆ Mat3f

typedef Mat3<float> clan::Mat3f

◆ Mat3i

typedef Mat3<int> clan::Mat3i

◆ Mat4d

typedef Mat4<double> clan::Mat4d

◆ Mat4f

typedef Mat4<float> clan::Mat4f

◆ Mat4i

typedef Mat4<int> clan::Mat4i

◆ Vec2b

typedef Vec2<char> clan::Vec2b

◆ Vec2d

typedef Vec2<double> clan::Vec2d

◆ Vec2f

typedef Vec2<float> clan::Vec2f

◆ Vec2i

typedef Vec2<int> clan::Vec2i

◆ Vec2s

typedef Vec2<short> clan::Vec2s

◆ Vec2ub

typedef Vec2<unsigned char> clan::Vec2ub

◆ Vec2ui

typedef Vec2<unsigned int> clan::Vec2ui

◆ Vec2us

typedef Vec2<unsigned short> clan::Vec2us

◆ Vec3b

typedef Vec3<char> clan::Vec3b

◆ Vec3d

typedef Vec3<double> clan::Vec3d

◆ Vec3f

typedef Vec3<float> clan::Vec3f

◆ Vec3i

typedef Vec3<int> clan::Vec3i

◆ Vec3s

typedef Vec3<short> clan::Vec3s

◆ Vec3ub

typedef Vec3<unsigned char> clan::Vec3ub

◆ Vec3ui

typedef Vec3<unsigned int> clan::Vec3ui

◆ Vec3us

typedef Vec3<unsigned short> clan::Vec3us

◆ Vec4b

typedef Vec4<char> clan::Vec4b

◆ Vec4d

typedef Vec4<double> clan::Vec4d

◆ Vec4f

typedef Vec4<float> clan::Vec4f

◆ Vec4i

typedef Vec4<int> clan::Vec4i

◆ Vec4s

typedef Vec4<short> clan::Vec4s

◆ Vec4ub

typedef Vec4<unsigned char> clan::Vec4ub

◆ Vec4ui

typedef Vec4<unsigned int> clan::Vec4ui

◆ Vec4us

typedef Vec4<unsigned short> clan::Vec4us

Enumeration Type Documentation

◆ AllocationPolicy

Allocation policy.

Enumerator
create_new_group 
search_previous_groups 
fail_if_full 

◆ AngleUnit

Angle unit.

Enumerator
angle_degrees 
angle_radians 

◆ ClipZRange

Enumerator
clip_negative_positive_w 
clip_zero_positive_w 

◆ EulerOrder

Euler angle rotation order.

Enumerator
order_XYZ 
order_XZY 
order_YZX 
order_YXZ 
order_ZXY 
order_ZYX 

◆ Handedness

Enumerator
handed_left 
handed_right 

◆ 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 

◆ OverlapResult

Enumerator
disjoint 
overlap 

◆ PolygonOrientation

Polygon orientations.

Enumerator
cl_clockwise 
cl_counter_clockwise 

◆ Result

Enumerator
outside 
inside 
intersecting 

Function Documentation

◆ AllocatedRect()

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

◆ Angle() [1/2]

clan::Angle::Angle ( )

Constructs an NULL Angle object.

◆ Angle() [2/2]

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

Constructs an Angle object.

◆ AxisAlignedBoundingBox() [1/3]

clan::AxisAlignedBoundingBox::AxisAlignedBoundingBox ( )
inline

◆ AxisAlignedBoundingBox() [2/3]

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

◆ AxisAlignedBoundingBox() [3/3]

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

◆ Base64Decoder()

clan::Base64Decoder::Base64Decoder ( )

Constructs a base64 decoder.

◆ Base64Encoder()

clan::Base64Encoder::Base64Encoder ( )

Constructs a base64 encoder.

◆ BezierCurve()

clan::BezierCurve::BezierCurve ( )

Constructs a bezier curve generator.

◆ BigInt() [1/6]

clan::BigInt::BigInt ( )

Constructs a big integer (initialised to zero)

◆ BigInt() [2/6]

clan::BigInt::BigInt ( const BigInt other)

Copy constructor.

◆ BigInt() [3/6]

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

Constructs a big integer (initialised to value)

◆ BigInt() [4/6]

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

Constructs a big integer (initialised to value)

◆ BigInt() [5/6]

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

Constructs a big integer (initialised to value)

◆ BigInt() [6/6]

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

Constructs a big integer (initialised to value)

◆ Circle() [1/4]

clan::Circle::Circle ( )
inline

◆ Circle() [2/4]

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

◆ Circle() [3/4]

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

References clan::p.

◆ Circle() [4/4]

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

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

◆ Circled() [1/4]

clan::Circled::Circled ( )
inline

◆ Circled() [2/4]

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

◆ Circled() [3/4]

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

References clan::p.

◆ Circled() [4/4]

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

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

◆ Circlef() [1/4]

clan::Circlef::Circlef ( )
inline

◆ Circlef() [2/4]

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

◆ Circlef() [3/4]

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

References clan::p.

◆ Circlef() [4/4]

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

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

◆ Circlex() [1/4]

template<typename Type >
clan::Circlex< Type >::Circlex ( )
inline

◆ Circlex() [2/4]

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

◆ Circlex() [3/4]

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

◆ Circlex() [4/4]

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

◆ DelauneyTriangulator()

clan::DelauneyTriangulator::DelauneyTriangulator ( )

Creates a triangulator object.

◆ EarClipResult()

clan::EarClipResult::EarClipResult ( int  num_triangles)

Constructs an ear clipping result structure.

◆ EarClipTriangulator()

clan::EarClipTriangulator::EarClipTriangulator ( )

Constructs a triangulator.

◆ HalfFloat() [1/3]

clan::HalfFloat::HalfFloat ( )
inline

◆ HalfFloat() [2/3]

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

◆ HalfFloat() [3/3]

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

References clan::v.

◆ Line2() [1/4]

clan::Line2::Line2 ( )
inline

◆ Line2() [2/4]

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

◆ Line2() [3/4]

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

◆ Line2() [4/4]

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

◆ Line2d() [1/4]

clan::Line2d::Line2d ( )
inline

◆ Line2d() [2/4]

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

◆ Line2d() [3/4]

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

◆ Line2d() [4/4]

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

◆ Line2f() [1/4]

clan::Line2f::Line2f ( )
inline

◆ Line2f() [2/4]

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

◆ Line2f() [3/4]

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

◆ Line2f() [4/4]

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

◆ Line2x() [1/4]

template<typename Type >
clan::Line2x< Type >::Line2x ( )
inline

◆ Line2x() [2/4]

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

◆ Line2x() [3/4]

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

◆ Line2x() [4/4]

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

◆ Line3() [1/3]

clan::Line3::Line3 ( )
inline

◆ Line3() [2/3]

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

◆ Line3() [3/3]

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

◆ Line3d() [1/3]

clan::Line3d::Line3d ( )
inline

◆ Line3d() [2/3]

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

◆ Line3d() [3/3]

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

◆ Line3f() [1/3]

clan::Line3f::Line3f ( )
inline

◆ Line3f() [2/3]

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

◆ Line3f() [3/3]

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

◆ Line3x() [1/3]

template<typename Type >
clan::Line3x< Type >::Line3x ( )
inline

◆ Line3x() [2/3]

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

◆ Line3x() [3/3]

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

◆ LineRay2() [1/3]

clan::LineRay2::LineRay2 ( )
inline

◆ LineRay2() [2/3]

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

◆ LineRay2() [3/3]

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

◆ LineRay2d() [1/3]

clan::LineRay2d::LineRay2d ( )
inline

◆ LineRay2d() [2/3]

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

◆ LineRay2d() [3/3]

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

◆ LineRay2f() [1/3]

clan::LineRay2f::LineRay2f ( )
inline

◆ LineRay2f() [2/3]

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

◆ LineRay2f() [3/3]

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

◆ LineRay2x() [1/3]

template<typename Type >
clan::LineRay2x< Type >::LineRay2x ( )
inline

◆ LineRay2x() [2/3]

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

◆ LineRay2x() [3/3]

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

◆ LineRay3() [1/3]

clan::LineRay3::LineRay3 ( )
inline

◆ LineRay3() [2/3]

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

◆ LineRay3() [3/3]

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

◆ LineRay3d() [1/3]

clan::LineRay3d::LineRay3d ( )
inline

◆ LineRay3d() [2/3]

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

◆ LineRay3d() [3/3]

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

◆ LineRay3f() [1/3]

clan::LineRay3f::LineRay3f ( )
inline

◆ LineRay3f() [2/3]

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

◆ LineRay3f() [3/3]

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

◆ LineRay3x() [1/3]

template<typename Type >
clan::LineRay3x< Type >::LineRay3x ( )
inline

◆ LineRay3x() [2/3]

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

◆ LineRay3x() [3/3]

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

◆ LineSegment2() [1/3]

clan::LineSegment2::LineSegment2 ( )
inline

◆ LineSegment2() [2/3]

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

◆ LineSegment2() [3/3]

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

◆ LineSegment2d() [1/3]

clan::LineSegment2d::LineSegment2d ( )
inline

◆ LineSegment2d() [2/3]

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

◆ LineSegment2d() [3/3]

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

◆ LineSegment2f() [1/3]

clan::LineSegment2f::LineSegment2f ( )
inline

◆ LineSegment2f() [2/3]

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

◆ LineSegment2f() [3/3]

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

◆ LineSegment2x() [1/3]

template<typename Type >
clan::LineSegment2x< Type >::LineSegment2x ( )
inline

◆ LineSegment2x() [2/3]

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

◆ LineSegment2x() [3/3]

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

◆ LineSegment3() [1/3]

clan::LineSegment3::LineSegment3 ( )
inline

◆ LineSegment3() [2/3]

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

◆ LineSegment3() [3/3]

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

◆ LineSegment3d() [1/3]

clan::LineSegment3d::LineSegment3d ( )
inline

◆ LineSegment3d() [2/3]

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

◆ LineSegment3d() [3/3]

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

◆ LineSegment3f() [1/3]

clan::LineSegment3f::LineSegment3f ( )
inline

◆ LineSegment3f() [2/3]

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

◆ LineSegment3f() [3/3]

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

◆ LineSegment3x() [1/3]

template<typename Type >
clan::LineSegment3x< Type >::LineSegment3x ( )
inline

◆ LineSegment3x() [2/3]

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

◆ LineSegment3x() [3/3]

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

◆ Mat2() [1/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( )
inline

Constructs a 2x2 matrix (zero'ed)

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

◆ Mat2() [2/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const double *  init_matrix)
inlineexplicit

Constructs a 2x2 matrix (copied from 4 doubles)

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

◆ Mat2() [3/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const float *  init_matrix)
inlineexplicit

Constructs a 2x2 matrix (copied from 4 floats)

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

◆ Mat2() [4/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const int16_t *  init_matrix)
inlineexplicit

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

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

◆ Mat2() [5/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const int32_t *  init_matrix)
inlineexplicit

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

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

◆ Mat2() [6/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const int64_t *  init_matrix)
inlineexplicit

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

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

◆ Mat2() [7/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( const int8_t *  init_matrix)
inlineexplicit

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

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

◆ Mat2() [8/11]

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.

◆ Mat2() [9/11]

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

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

◆ Mat2() [10/11]

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

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

◆ Mat2() [11/11]

template<typename Type >
clan::Mat2< Type >::Mat2 ( Type  m00,
Type  m01,
Type  m10,
Type  m11 
)
inlineexplicit

Constructs a 2x2 matrix (copied from specified values)

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

◆ Mat3() [1/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( )
inline

Constructs a 3x3 matrix (zero'ed)

◆ Mat3() [2/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const double *  init_matrix)
inlineexplicit

Constructs a 3x3 matrix (copied from 9 doubles)

◆ Mat3() [3/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const float *  init_matrix)
inlineexplicit

Constructs a 3x3 matrix (copied from 9 floats)

◆ Mat3() [4/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const int16_t *  init_matrix)
inlineexplicit

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

◆ Mat3() [5/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const int32_t *  init_matrix)
inlineexplicit

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

◆ Mat3() [6/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const int64_t *  init_matrix)
inlineexplicit

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

◆ Mat3() [7/11]

template<typename Type >
clan::Mat3< Type >::Mat3 ( const int8_t *  init_matrix)
inlineexplicit

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

◆ Mat3() [8/11]

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

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

◆ Mat3() [9/11]

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

Constructs a 3x3 matrix (copied)

◆ Mat3() [10/11]

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

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

◆ Mat3() [11/11]

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 
)
inlineexplicit

Constructs a 3x3 matrix (copied from specified values)

◆ Mat4() [1/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( )
inline

Constructs a 4x4 matrix (zero'ed)

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

◆ Mat4() [2/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const double *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [3/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const float *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [4/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const int16_t *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [5/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const int32_t *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [6/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const int64_t *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [7/10]

template<typename Type >
clan::Mat4< Type >::Mat4 ( const int8_t *  init_matrix)
inlineexplicit

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

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

◆ Mat4() [8/10]

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

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

◆ Mat4() [9/10]

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

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

◆ Mat4() [10/10]

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.

◆ OutlineTriangulator()

clan::OutlineTriangulator::OutlineTriangulator ( )

Creates a tessellation object.

◆ Point() [1/4]

clan::Point::Point ( )
inline

◆ Point() [2/4]

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

References clan::p.

◆ Point() [3/4]

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

References clan::p.

◆ Point() [4/4]

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

◆ Pointd() [1/4]

clan::Pointd::Pointd ( )
inline

◆ Pointd() [2/4]

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

References clan::p.

◆ Pointd() [3/4]

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

References clan::p.

◆ Pointd() [4/4]

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

◆ Pointf() [1/4]

clan::Pointf::Pointf ( )
inline

◆ Pointf() [2/4]

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

References clan::p.

◆ Pointf() [3/4]

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

References clan::p.

◆ Pointf() [4/4]

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

◆ Pointx() [1/4]

template<typename Type >
clan::Pointx< Type >::Pointx ( )
inline

◆ Pointx() [2/4]

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

◆ Pointx() [3/4]

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

◆ Pointx() [4/4]

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

◆ Quad() [1/4]

clan::Quad::Quad ( )
inline

◆ Quad() [2/4]

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

◆ Quad() [3/4]

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

◆ Quad() [4/4]

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

◆ Quadd() [1/4]

clan::Quadd::Quadd ( )
inline

◆ Quadd() [2/4]

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

◆ Quadd() [3/4]

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

◆ Quadd() [4/4]

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

◆ Quadf() [1/4]

clan::Quadf::Quadf ( )
inline

◆ Quadf() [2/4]

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

◆ Quadf() [3/4]

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

◆ Quadf() [4/4]

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

◆ Quadx() [1/4]

template<typename Type >
clan::Quadx< Type >::Quadx ( )
inline

Constructs a quad.

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

◆ Quadx() [2/4]

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

Constructs a quad.

Parameters
quad= Quad used to initialize this quad.

◆ Quadx() [3/4]

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

Constructs a quad.

Parameters
rectRectangle 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

◆ Quadx() [4/4]

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.

◆ Quaterniond() [1/8]

clan::Quaterniond::Quaterniond ( )
inline

◆ Quaterniond() [2/8]

clan::Quaterniond::Quaterniond ( const Angle euler_x,
const Angle euler_y,
const Angle euler_z,
EulerOrder  order 
)
inlineexplicit

◆ Quaterniond() [3/8]

clan::Quaterniond::Quaterniond ( const Mat4< double > &  rotation_matrix)
inlineexplicit

◆ Quaterniond() [4/8]

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

◆ Quaterniond() [5/8]

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

◆ Quaterniond() [6/8]

clan::Quaterniond::Quaterniond ( double  euler_x,
double  euler_y,
double  euler_z,
AngleUnit  unit,
EulerOrder  order 
)
inlineexplicit

◆ Quaterniond() [7/8]

clan::Quaterniond::Quaterniond ( double  real,
const Vec3< double > &  imag 
)
inlineexplicit

◆ Quaterniond() [8/8]

clan::Quaterniond::Quaterniond ( double  real,
double  i,
double  j,
double  k 
)
inlineexplicit

◆ Quaternionf() [1/8]

clan::Quaternionf::Quaternionf ( )
inline

◆ Quaternionf() [2/8]

clan::Quaternionf::Quaternionf ( const Angle euler_x,
const Angle euler_y,
const Angle euler_z,
EulerOrder  order 
)
inlineexplicit

◆ Quaternionf() [3/8]

clan::Quaternionf::Quaternionf ( const Mat4< float > &  rotation_matrix)
inlineexplicit

◆ Quaternionf() [4/8]

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

◆ Quaternionf() [5/8]

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

◆ Quaternionf() [6/8]

clan::Quaternionf::Quaternionf ( float  euler_x,
float  euler_y,
float  euler_z,
AngleUnit  unit,
EulerOrder  order 
)
inlineexplicit

◆ Quaternionf() [7/8]

clan::Quaternionf::Quaternionf ( float  real,
const Vec3< float > &  imag 
)
inlineexplicit

◆ Quaternionf() [8/8]

clan::Quaternionf::Quaternionf ( float  real,
float  i,
float  j,
float  k 
)
inlineexplicit

◆ Quaternionx() [1/8]

template<typename Type >
clan::Quaternionx< Type >::Quaternionx ( )
inline

◆ Quaternionx() [2/8]

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

◆ Quaternionx() [3/8]

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

◆ Quaternionx() [4/8]

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

◆ Quaternionx() [5/8]

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

◆ Quaternionx() [6/8]

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

◆ Quaternionx() [7/8]

template<typename Type >
clan::Quaternionx< Type >::Quaternionx ( Type  real,
const Vec3< Type > &  imag 
)
inlineexplicit

◆ Quaternionx() [8/8]

template<typename Type >
clan::Quaternionx< Type >::Quaternionx ( Type  real,
Type  i,
Type  j,
Type  k 
)
inlineexplicit

◆ Rect() [1/8]

clan::Rect::Rect ( )
inline

◆ Rect() [2/8]

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

References clan::p.

◆ Rect() [3/8]

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

◆ Rect() [4/8]

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

◆ Rect() [5/8]

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

◆ Rect() [6/8]

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

References clan::s.

◆ Rect() [7/8]

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

◆ Rect() [8/8]

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

◆ Rectd() [1/10]

clan::Rectd::Rectd ( )
inline

◆ Rectd() [2/10]

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

References clan::p.

◆ Rectd() [3/10]

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

◆ Rectd() [4/10]

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

◆ Rectd() [5/10]

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

◆ Rectd() [6/10]

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

References clan::s.

◆ Rectd() [7/10]

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

References clan::s.

◆ Rectd() [8/10]

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

References clan::s.

◆ Rectd() [9/10]

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

◆ Rectd() [10/10]

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

◆ Rectf() [1/9]

clan::Rectf::Rectf ( )
inline

◆ Rectf() [2/9]

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

References clan::p.

◆ Rectf() [3/9]

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

◆ Rectf() [4/9]

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

◆ Rectf() [5/9]

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

◆ Rectf() [6/9]

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

References clan::s.

◆ Rectf() [7/9]

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

References clan::s.

◆ Rectf() [8/9]

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

◆ Rectf() [9/9]

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

◆ RectPacker() [1/2]

clan::RectPacker::RectPacker ( )

Constructs a null instance.

◆ RectPacker() [2/2]

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

Constructs a rect group.

◆ Rectx() [1/8]

template<typename Type >
clan::Rectx< Type >::Rectx ( )
inline

Constructs an rectangle.

Initialised to zero

◆ Rectx() [2/8]

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.
sizeInitial size of rectangle.

◆ Rectx() [3/8]

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

Constructs an rectangle.

Parameters
rectInitial rectangle position and size.

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

◆ Rectx() [4/8]

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

Constructs an rectangle.

Parameters
rectInitial rectangle position and size.

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

◆ Rectx() [5/8]

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

Constructs an rectangle.

Parameters
rectInitial rectangle position and size.

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

◆ Rectx() [6/8]

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

Constructs an rectangle.

Parameters
s= Size

◆ Rectx() [7/8]

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

Constructs an rectangle.

Parameters
new_leftInitial left position of rectangle.
new_topInitial top position of rectangle.
sizeInitial size of rectangle.

◆ Rectx() [8/8]

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_leftInitial left position of rectangle.
new_topInitial top position of rectangle.
new_rightInitial right position of rectangle.
new_bottomInitial bottom position of rectangle.

◆ Size() [1/6]

clan::Size::Size ( )
inline

◆ Size() [2/6]

clan::Size::Size ( const Sizex< double > &  copy)
inlineexplicit

◆ Size() [3/6]

clan::Size::Size ( const Sizex< float > &  copy)
inlineexplicit

◆ Size() [4/6]

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

References clan::s.

◆ Size() [5/6]

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

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

◆ Size() [6/6]

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

◆ Sized() [1/6]

clan::Sized::Sized ( )
inline

◆ Sized() [2/6]

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

References clan::s.

◆ Sized() [3/6]

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

◆ Sized() [4/6]

◆ Sized() [5/6]

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

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

◆ Sized() [6/6]

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

◆ Sizef() [1/6]

clan::Sizef::Sizef ( )
inline

◆ Sizef() [2/6]

clan::Sizef::Sizef ( const Sizex< double > &  copy)
inlineexplicit

◆ Sizef() [3/6]

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

References clan::s.

◆ Sizef() [4/6]

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

◆ Sizef() [5/6]

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

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

◆ Sizef() [6/6]

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

◆ Sizex() [1/3]

template<typename Type >
clan::Sizex< Type >::Sizex ( )
inline

Constructs a size structure.

◆ Sizex() [2/3]

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.

◆ Sizex() [3/3]

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

Constructs a size structure.

Parameters
widthInitial width of size structure.
heightInitial height of size structure.

◆ Triangle() [1/3]

clan::Triangle::Triangle ( )
inline

◆ Triangle() [2/3]

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

◆ Triangle() [3/3]

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

◆ Triangled() [1/3]

clan::Triangled::Triangled ( )
inline

◆ Triangled() [2/3]

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

◆ Triangled() [3/3]

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

◆ Trianglef() [1/3]

clan::Trianglef::Trianglef ( )
inline

◆ Trianglef() [2/3]

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

◆ Trianglef() [3/3]

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

◆ Trianglex() [1/3]

template<typename Type >
clan::Trianglex< Type >::Trianglex ( )
inline

◆ Trianglex() [2/3]

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

◆ Trianglex() [3/3]

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

◆ Vec2() [1/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( )
inline

◆ Vec2() [2/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( const Type &  p1,
const Type &  p2 
)
inlineexplicit

◆ Vec2() [3/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( const Type &  scalar)
inlineexplicit

◆ Vec2() [4/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( const Type *  array_xy)
inlineexplicit

◆ Vec2() [5/9]

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

◆ Vec2() [6/9]

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

◆ Vec2() [7/9]

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

◆ Vec2() [8/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( const Vec3< Type > &  copy)
inlineexplicit

◆ Vec2() [9/9]

template<typename Type >
clan::Vec2< Type >::Vec2 ( const Vec4< Type > &  copy)
inlineexplicit

◆ Vec2hf() [1/18]

clan::Vec2hf::Vec2hf ( )
inline

◆ Vec2hf() [2/18]

clan::Vec2hf::Vec2hf ( const HalfFloat p1,
const HalfFloat p2 
)
inlineexplicit

◆ Vec2hf() [3/18]

clan::Vec2hf::Vec2hf ( const HalfFloat scalar)
inlineexplicit

◆ Vec2hf() [4/18]

clan::Vec2hf::Vec2hf ( const HalfFloat array_xy)
inlineexplicit

◆ Vec2hf() [5/18]

clan::Vec2hf::Vec2hf ( const Pointx< double > &  point)
inlineexplicit

◆ Vec2hf() [6/18]

clan::Vec2hf::Vec2hf ( const Pointx< float > &  point)
inlineexplicit

◆ Vec2hf() [7/18]

clan::Vec2hf::Vec2hf ( const Pointx< int > &  point)
inlineexplicit

◆ Vec2hf() [8/18]

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

◆ Vec2hf() [9/18]

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

◆ Vec2hf() [10/18]

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

◆ Vec2hf() [11/18]

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

◆ Vec2hf() [12/18]

clan::Vec2hf::Vec2hf ( const Vec3f copy)
inlineexplicit

◆ Vec2hf() [13/18]

clan::Vec2hf::Vec2hf ( const Vec3hf copy)
inlineexplicit

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

◆ Vec2hf() [14/18]

clan::Vec2hf::Vec2hf ( const Vec4f copy)
inlineexplicit

◆ Vec2hf() [15/18]

clan::Vec2hf::Vec2hf ( const Vec4hf copy)
inlineexplicit

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

◆ Vec2hf() [16/18]

clan::Vec2hf::Vec2hf ( float *  array_xy)
inlineexplicit

◆ Vec2hf() [17/18]

clan::Vec2hf::Vec2hf ( float  p1,
float  p2 
)
inlineexplicit

◆ Vec2hf() [18/18]

clan::Vec2hf::Vec2hf ( float  scalar)
inlineexplicit

◆ Vec3() [1/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( )
inline

◆ Vec3() [2/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( const Type &  p1,
const Type &  p2,
const Type &  p3 
)
inlineexplicit

◆ Vec3() [3/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( const Type &  scalar)
inlineexplicit

◆ Vec3() [4/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( const Type *  array_xyz)
inlineexplicit

◆ Vec3() [5/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( const Vec2< Type > &  copy,
const Type &  p3 
)
inlineexplicit

◆ Vec3() [6/9]

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

◆ Vec3() [7/9]

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

◆ Vec3() [8/9]

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

◆ Vec3() [9/9]

template<typename Type >
clan::Vec3< Type >::Vec3 ( const Vec4< Type > &  copy)
inlineexplicit

◆ Vec3hf() [1/15]

clan::Vec3hf::Vec3hf ( )
inline

◆ Vec3hf() [2/15]

clan::Vec3hf::Vec3hf ( const float *  array_xyz)
inlineexplicit

◆ Vec3hf() [3/15]

clan::Vec3hf::Vec3hf ( const HalfFloat p1,
const HalfFloat p2,
const HalfFloat p3 
)
inlineexplicit

◆ Vec3hf() [4/15]

clan::Vec3hf::Vec3hf ( const HalfFloat scalar)
inlineexplicit

◆ Vec3hf() [5/15]

clan::Vec3hf::Vec3hf ( const HalfFloat array_xyz)
inlineexplicit

◆ Vec3hf() [6/15]

clan::Vec3hf::Vec3hf ( const Vec2f copy,
float  p3 
)
inlineexplicit

◆ Vec3hf() [7/15]

clan::Vec3hf::Vec3hf ( const Vec2hf copy,
const HalfFloat p3 
)
inlineexplicit

◆ Vec3hf() [8/15]

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

◆ Vec3hf() [9/15]

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

◆ Vec3hf() [10/15]

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

◆ Vec3hf() [11/15]

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

◆ Vec3hf() [12/15]

clan::Vec3hf::Vec3hf ( const Vec4f copy)
inlineexplicit

◆ Vec3hf() [13/15]

clan::Vec3hf::Vec3hf ( const Vec4hf copy)
inlineexplicit

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

◆ Vec3hf() [14/15]

clan::Vec3hf::Vec3hf ( float  p1,
float  p2,
float  p3 
)
inlineexplicit

◆ Vec3hf() [15/15]

clan::Vec3hf::Vec3hf ( float  scalar)
inlineexplicit

◆ Vec4() [1/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( )
inline

◆ Vec4() [2/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Type &  p1,
const Type &  p2,
const Type &  p3,
const Type &  p4 
)
inlineexplicit

◆ Vec4() [3/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Type &  p1,
const Type &  p2,
const Vec2< Type > &  copy34 
)
inlineexplicit

◆ Vec4() [4/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Type &  scalar)
inlineexplicit

◆ Vec4() [5/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Type *  array_xyzw)
inlineexplicit

◆ Vec4() [6/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Vec2< Type > &  copy,
const Type &  p3,
const Type &  p4 
)
inlineexplicit

◆ Vec4() [7/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Vec2< Type > &  copy,
const Vec2< Type > &  copy34 
)
inlineexplicit

◆ Vec4() [8/8]

template<typename Type >
clan::Vec4< Type >::Vec4 ( const Vec3< Type > &  copy,
const Type &  p4 
)
inlineexplicit

◆ Vec4hf() [1/16]

clan::Vec4hf::Vec4hf ( )
inline

◆ Vec4hf() [2/16]

clan::Vec4hf::Vec4hf ( const float *  array_xyzw)
inlineexplicit

◆ Vec4hf() [3/16]

clan::Vec4hf::Vec4hf ( const HalfFloat p1,
const HalfFloat p2,
const HalfFloat p3,
const HalfFloat p4 
)
inlineexplicit

◆ Vec4hf() [4/16]

clan::Vec4hf::Vec4hf ( const HalfFloat p1,
const HalfFloat p2,
const Vec2hf copy34 
)
inlineexplicit

◆ Vec4hf() [5/16]

clan::Vec4hf::Vec4hf ( const HalfFloat scalar)
inlineexplicit

◆ Vec4hf() [6/16]

clan::Vec4hf::Vec4hf ( const HalfFloat array_xyzw)
inlineexplicit

◆ Vec4hf() [7/16]

clan::Vec4hf::Vec4hf ( const Vec2f copy,
const Vec2f copy34 
)
inlineexplicit

◆ Vec4hf() [8/16]

clan::Vec4hf::Vec4hf ( const Vec2f copy,
float  p3,
float  p4 
)
inlineexplicit

◆ Vec4hf() [9/16]

clan::Vec4hf::Vec4hf ( const Vec2hf copy,
const HalfFloat p3,
const HalfFloat p4 
)
inlineexplicit

◆ Vec4hf() [10/16]

clan::Vec4hf::Vec4hf ( const Vec2hf copy,
const Vec2hf copy34 
)
inlineexplicit

◆ Vec4hf() [11/16]

clan::Vec4hf::Vec4hf ( const Vec3f copy,
float  p4 
)
inlineexplicit

◆ Vec4hf() [12/16]

clan::Vec4hf::Vec4hf ( const Vec3hf copy,
const HalfFloat p4 
)
inlineexplicit

◆ Vec4hf() [13/16]

clan::Vec4hf::Vec4hf ( const Vec4f copy)
inlineexplicit

◆ Vec4hf() [14/16]

clan::Vec4hf::Vec4hf ( float  p1,
float  p2,
const Vec2f copy34 
)
inlineexplicit

◆ Vec4hf() [15/16]

clan::Vec4hf::Vec4hf ( float  p1,
float  p2,
float  p3,
float  p4 
)
inlineexplicit

◆ Vec4hf() [16/16]

clan::Vec4hf::Vec4hf ( float  scalar)
inlineexplicit

◆ ~BezierCurve()

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

◆ ~BigInt()

clan::BigInt::~BigInt ( )

Destructor.

◆ ~DelauneyTriangulator()

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

◆ ~EarClipResult()

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

◆ ~EarClipTriangulator()

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

◆ ~OutlineTriangulator()

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

◆ ~RectPacker()

clan::RectPacker::~RectPacker ( )

◆ aabb()

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

◆ abs()

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

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

◆ add() [1/4]

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

◆ add() [2/4]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::add ( const Mat3< Type > &  matrix_1,
const Mat3< Type > &  matrix_2 
)
inlinestatic

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

◆ add() [3/4]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::add ( const Mat4< Type > &  matrix_1,
const Mat4< Type > &  matrix_2 
)
inlinestatic

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

◆ add() [4/4]

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

Allocate space for another rect.

◆ add_control_point() [1/2]

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

◆ add_control_point() [2/2]

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

Adds a control point to bezier.

◆ add_vertex() [1/4]

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

Add vertex.

Parameters
p= Pointf

◆ add_vertex() [2/4]

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

Add the next vertex of the polygon to the triangulator.

◆ add_vertex() [3/4]

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

This function specifies a vertex on a polygon.

◆ add_vertex() [4/4]

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

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

◆ adjoint() [1/4]

template<typename Type >
Mat3<Type>& clan::Mat3< Type >::adjoint ( )

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

Returns
reference to this object

◆ adjoint() [2/4]

template<typename Type >
Mat4<Type>& clan::Mat4< Type >::adjoint ( )

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

Returns
reference to this object

◆ adjoint() [3/4]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::adjoint ( const Mat3< Type > &  matrix)
inlinestatic

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

Parameters
matrix= The matrix to use
Returns
The adjoint matrix

◆ adjoint() [4/4]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::adjoint ( const Mat4< Type > &  matrix)
inlinestatic

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().

◆ angle() [1/2]

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

◆ angle() [2/2]

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

Calculate the angle between this vector and an other vector.

Parameters
vectorSecond vector used to calculate angle.
Returns
The angle between the two vectors.

◆ angle3()

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.

◆ angle_line()

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

◆ angle_normed() [1/2]

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

◆ angle_normed() [2/2]

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
vectorSecond vector used to calculate angle.
Returns
The angle between the two vectors.

◆ apply_alignment() [1/2]

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
originThe new origin to adjust to from default upper-left position
x,yOffsets applied negatively to each corner of the rectangle
Returns
reference to this object

◆ apply_alignment() [2/2]

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
originThe new origin to adjust to from default upper-left position
x,yOffsets applied negatively to each corner of the rectangle
Returns
reference to this object

◆ axis_angle()

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

◆ begin_hole()

void clan::EarClipTriangulator::begin_hole ( )

Mark beginning of a polygon hole.

◆ bounding_box()

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

◆ bounding_rect()

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

◆ calc_origin()

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().

◆ calculate_polygon_orientation()

PolygonOrientation clan::EarClipTriangulator::calculate_polygon_orientation ( )

Determine the orientation of the vertices in the triangulator.

◆ center() [1/2]

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

◆ center() [2/2]

template<typename Type >
Vec2<Type> clan::Quadx< Type >::center ( ) const

Returns the center point of the quad.

◆ clamp()

template<typename A , typename B , typename C >
C clan::clamp ( val,
minval,
maxval 
)
inline

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

Referenced by clan::smoothstep(), and clan::Style::to_rgba().

◆ clear()

void clan::EarClipTriangulator::clear ( )

Remove all vertices from triangulator.

◆ clip() [1/2]

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

◆ clip() [2/2]

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

◆ closest_point()

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
Ppoint P
Apoint A
Bpoint B

◆ closest_point_relative()

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
Ppoint P
Apoint A
Bpoint B

◆ cmp()

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

◆ cmp_d()

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.

◆ cmp_z()

int clan::BigInt::cmp_z ( ) const

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

◆ collinear()

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

◆ contains()

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

Returns true if the rectangle contains the point.

◆ convex_hull_from_polygon()

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
pointsthe set of points

◆ cross() [1/2]

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

◆ cross() [2/2]

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

◆ cross3() [1/2]

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
vectorSecond vector used to perform the calculation.
Returns
reference to this object

◆ cross3() [2/2]

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).

\vector1 = The first vector \vector2 = The second vector

Returns
= Cross product

◆ decode() [1/3]

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

Decode.

Parameters
data= Data Buffer
Returns
Data Buffer

◆ decode() [2/3]

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

Decode.

Parameters
data= String Ref8
Returns
Data Buffer

◆ decode() [3/3]

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

Decode base64 data and return it in a buffer.

◆ decompose()

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.

◆ det() [1/2]

template<typename Type >
double clan::Mat3< Type >::det ( ) const

Calculate the matrix determinant.

◆ det() [2/2]

template<typename Type >
double clan::Mat4< Type >::det ( ) const

Calculate the matrix determinant of this matrix.

Returns
The determinant

◆ distance() [1/2]

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.

◆ distance() [2/2]

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.

◆ distance3()

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.

◆ distance4()

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.

◆ div() [1/2]

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)

◆ div() [2/2]

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

◆ div_2()

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

Compute c = a / 2, disregarding the remainder.

◆ div_d()

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).

◆ dot() [1/4]

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
vectorSecond vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ dot() [2/4]

template<typename Type >
static Type clan::Vec2< Type >::dot ( const Vec2< Type > &  vector_1,
const Vec2< Type > &  vector_2 
)
inlinestatic

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.

◆ dot() [3/4]

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
vectorSecond vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ dot() [4/4]

template<typename Type >
static Type clan::Vec3< Type >::dot ( const Vec3< Type > &  vector1,
const Vec3< Type > &  vector2 
)
inlinestatic

Dot products between two vectors.

Returns
The dot product

◆ dot3() [1/2]

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
vectorSecond vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ dot3() [2/2]

template<typename Type >
static Type clan::Vec4< Type >::dot3 ( const Vec4< Type > &  vector1,
const Vec4< Type > &  vector2 
)
inlinestatic

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

Operates in the native datatype

Parameters
vector1First vector used for the dot product.
vector2Second vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ dot4() [1/2]

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
vectorSecond vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ dot4() [2/2]

template<typename Type >
static Type clan::Vec4< Type >::dot4 ( const Vec4< Type > &  vector1,
const Vec4< Type > &  vector2 
)
inlinestatic

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

Operates in the native datatype

Parameters
vector1First vector used for the dot product.
vector2Second vector used for the dot product.
Returns
The resulting dot product of the two vectors.

◆ encode() [1/3]

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

Encode.

Parameters
data= Data Buffer
Returns
String8

◆ encode() [2/3]

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

Encode.

Parameters
data= String Ref8
Returns
String8

◆ encode() [3/3]

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

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

◆ end_hole()

void clan::EarClipTriangulator::end_hole ( )

Mark ending of a polygon hole.

◆ exch()

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.

◆ expand() [1/3]

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

Expand the rectangle.

Returns
reference to this object

◆ expand() [2/3]

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().

◆ expand() [3/3]

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

◆ exptmod()

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)

◆ extents()

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

◆ feed() [1/2]

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

Feeds the decoder with base64 encoded data.

◆ feed() [2/2]

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

Feeds the encoder with more data.

◆ fermat()

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.

◆ finalize()

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

Ends the base64 encoding.

◆ float_to_half()

static unsigned short clan::HalfFloat::float_to_half ( float  float_value)
inlinestatic

References clan::f.

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

◆ float_to_half_simple()

static unsigned short clan::HalfFloat::float_to_half_simple ( float  float_value)
inlinestatic

Only works for 'normal' half-float values.

References clan::f.

◆ from_degrees()

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

From degrees.

Parameters
value= value
Returns
Angle

◆ from_float()

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

◆ from_radians()

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

From radians.

Parameters
value= value
Returns
Angle

◆ frustum()

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)

◆ frustum_aabb()

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

◆ frustum_obb()

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

◆ generate() [1/2]

void clan::OutlineTriangulator::generate ( )

Converts passed polygons into triangles.

◆ generate() [2/2]

void clan::DelauneyTriangulator::generate ( )

Converts passed points into triangles.

◆ generate_curve_points()

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

Generates points on the bezier curve.

◆ get() [1/4]

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

◆ get() [2/4]

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

◆ get() [3/4]

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

Gets a value.

Throws exception if number exceeds datatype bounds

◆ get() [4/4]

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

◆ get_allocation_policy()

AllocationPolicy clan::RectPacker::get_allocation_policy ( ) const

Returns the allocation policy.

◆ get_bottom_left()

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

Returns the bottom-left point outside the rectangle.

◆ get_bottom_right()

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

Returns the bottom-right point outside the rectangle.

◆ get_bounds()

template<typename Type >
Rect clan::Quadx< Type >::get_bounds ( ) const

Returns the bounding box of the quad as a Rect.

◆ get_center()

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

Returns the center point of the rectangle.

◆ get_control_points()

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

Returns the control points of the bezier.

◆ get_euler()

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)

◆ get_group_count()

int clan::RectPacker::get_group_count ( ) const

Returns the amount of rects used by group.

◆ get_height() [1/2]

template<typename Type >
Type clan::Rectx< Type >::get_height ( ) const
inline

Returns the height of the rectangle.

◆ get_height() [2/2]

template<typename Type >
Type clan::Quadx< Type >::get_height ( ) const

Returns the height of the quad.

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

◆ get_intersection() [1/3]

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

◆ get_intersection() [2/3]

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

◆ get_intersection() [3/3]

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

◆ get_max_group_size()

Size clan::RectPacker::get_max_group_size ( ) const

Returns the max group size.

◆ get_midpoint() [1/2]

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

Get the midpoint of this line.

Returns
The midpoint

◆ get_midpoint() [2/2]

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

Get the midpoint of this line.

Returns
The midpoint

◆ get_point_relative()

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

Get a point on the bezier curve.

◆ get_rect_count()

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

Returns the amount of rects in a group.

◆ get_result() [1/2]

DataBuffer& clan::Base64Decoder::get_result ( )

Returns the decoded data.

◆ get_result() [2/2]

DataBuffer& clan::Base64Encoder::get_result ( )

Returns the data in encoded form.

◆ get_rot_bounds() [1/2]

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
hotspotPoint to rotate around.
angleAngle to rotate.

◆ get_rot_bounds() [2/2]

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
originDetermines the hotspot point within the rectangle
xOffsets applied negatively to the hotspot point
yOffsets applied negatively to the hotspot point
angleAngle

◆ get_size() [1/2]

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().

◆ get_size() [2/2]

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

Returns the size of the rectangle.

◆ get_top_left()

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

Returns the top-left point inside the rectangle.

◆ get_top_right()

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

Returns the top-right point outside the rectangle.

◆ get_total_rect_count()

int clan::RectPacker::get_total_rect_count ( ) const

Returns the total amount of rects.

◆ get_transformed_point()

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

◆ get_translate()

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

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

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

◆ get_triangle()

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.

◆ get_triangles() [1/2]

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

Returns the triangles for this result.

◆ get_triangles() [2/2]

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

Returns the resulting triangles produced from triangulation.

◆ get_vertice_count()

int clan::EarClipTriangulator::get_vertice_count ( )

Returns the number of vertices in the triangulator.

◆ get_vertices() [1/2]

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

Returns a list of the vertices added to the triangulator.

◆ get_vertices() [2/2]

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

Returns the list of vertices in the triangulation.

◆ get_width() [1/2]

template<typename Type >
Type clan::Rectx< Type >::get_width ( ) const
inline

Returns the width of the rectangle.

◆ get_width() [2/2]

template<typename Type >
Type clan::Quadx< Type >::get_width ( ) const

Returns the width of the quad.

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

◆ half_to_float()

static float clan::HalfFloat::half_to_float ( unsigned short  hf)
inlinestatic

◆ half_to_float_simple()

static float clan::HalfFloat::half_to_float_simple ( unsigned short  hf)
inlinestatic

Only works for 'normal' half-float values.

◆ identity() [1/3]

template<typename Type >
static Mat2<Type> clan::Mat2< Type >::identity ( )
static

◆ identity() [2/3]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::identity
inlinestatic

References clan::m.

◆ identity() [3/3]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::identity
inlinestatic

Create the identity matrix.

Returns
The matrix

References clan::m.

◆ intersects()

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

◆ inverse() [1/6]

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

◆ inverse() [2/6]

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

◆ inverse() [3/6]

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

◆ inverse() [4/6]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::inverse ( const Mat3< Type > &  matrix)
inlinestatic

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

◆ inverse() [5/6]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::inverse ( const Mat4< Type > &  matrix)
inlinestatic

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().

◆ inverse() [6/6]

template<typename Type >
static Quaternionx<Type> clan::Quaternionx< Type >::inverse ( Quaternionx< Type >  q)
inlinestatic

Inverse this quaternion.

This is the same as the conjugate of a quaternion

Returns
reference to this object

◆ invmod()

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.

◆ is_equal() [1/12]

template<typename Type >
static bool clan::Mat2< Type >::is_equal ( const Mat2< Type > &  first,
const Mat2< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [2/12]

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().

◆ is_equal() [3/12]

template<typename Type >
static bool clan::Mat3< Type >::is_equal ( const Mat3< Type > &  first,
const Mat3< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [4/12]

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)

◆ is_equal() [5/12]

template<typename Type >
static bool clan::Mat4< Type >::is_equal ( const Mat4< Type > &  first,
const Mat4< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [6/12]

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().

◆ is_equal() [7/12]

template<typename Type >
static bool clan::Vec2< Type >::is_equal ( const Vec2< Type > &  first,
const Vec2< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [8/12]

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)

◆ is_equal() [9/12]

template<typename Type >
static bool clan::Vec3< Type >::is_equal ( const Vec3< Type > &  first,
const Vec3< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [10/12]

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)

◆ is_equal() [11/12]

template<typename Type >
static bool clan::Vec4< Type >::is_equal ( const Vec4< Type > &  first,
const Vec4< Type > &  second,
Type  epsilon 
)
inlinestatic

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().

◆ is_equal() [12/12]

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)

◆ is_even()

bool clan::BigInt::is_even ( ) const

Returns a true if number is even.

◆ is_inside() [1/3]

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

Returns true if rectangle passed is inside this rectangle.

◆ is_inside() [2/3]

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

◆ is_inside() [3/3]

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

Check if a point is inside or outside the quad.

◆ is_null()

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

Returns true if this object is invalid.

◆ is_odd()

bool clan::BigInt::is_odd ( ) const

Returns a true if number is odd.

◆ is_overlapped()

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.

◆ length() [1/2]

template<typename Type >
Type clan::Vec2< Type >::length
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.

◆ length() [2/2]

template<typename Type >
Type clan::Vec3< Type >::length
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.

◆ length3()

template<typename Type >
Type clan::Vec4< Type >::length3
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.

◆ length4()

template<typename Type >
Type clan::Vec4< Type >::length4
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.

◆ lerp()

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

◆ look_at() [1/2]

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().

◆ look_at() [2/2]

template<typename Type >
static Mat4<Type> clan::Mat4< Type >::look_at ( Vec3< Type >  eye,
Vec3< Type >  center,
Vec3< Type >  up 
)
inlinestatic

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::center, clan::Mat4< Type >::look_at(), clan::up, clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

◆ ltrb()

template<typename Type >
static Rectx<Type> clan::Rectx< Type >::ltrb ( Type  left,
Type  top,
Type  right,
Type  bottom 
)
inlinestatic

◆ magnitude()

template<typename Type >
Type clan::Quaternionx< Type >::magnitude ( ) const

Get the quaternion magnitude.

◆ make_prime()

bool clan::BigInt::make_prime ( unsigned int  num_bits)

◆ make_unique()

template<typename T , typename ... Args>
std::unique_ptr<T> clan::make_unique ( Args &&...  args)

◆ max() [1/4]

template<typename A , typename B >
A clan::max ( a,
b 
)
inline

◆ max() [2/4]

template<typename Type >
Vec2<Type> clan::max ( Vec2< Type >  a,
Vec2< Type >  b 
)
inline

References clan::a, clan::b, and clan::max().

◆ max() [3/4]

template<typename Type >
Vec3<Type> clan::max ( Vec3< Type >  a,
Vec3< Type >  b 
)
inline

References clan::a, clan::b, and clan::max().

◆ max() [4/4]

template<typename Type >
Vec4<Type> clan::max ( Vec4< Type >  a,
Vec4< Type >  b 
)
inline

References clan::a, clan::b, and clan::max().

◆ midpoint()

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

◆ min() [1/4]

template<typename A , typename B >
A clan::min ( a,
b 
)
inline

◆ min() [2/4]

template<typename Type >
Vec2<Type> clan::min ( Vec2< Type >  a,
Vec2< Type >  b 
)
inline

References clan::a, clan::b, and clan::min().

◆ min() [3/4]

template<typename Type >
Vec3<Type> clan::min ( Vec3< Type >  a,
Vec3< Type >  b 
)
inline

References clan::a, clan::b, and clan::min().

◆ min() [4/4]

template<typename Type >
Vec4<Type> clan::min ( Vec4< Type >  a,
Vec4< Type >  b 
)
inline

References clan::a, clan::b, and clan::min().

◆ minimum_enclosing_disc()

static Circlef clan::PointSetMath::minimum_enclosing_disc ( const std::vector< Pointf > &  points)
static

Find minimum spanning circle for the set of points.

Parameters
pointsthe points to calulate on

◆ mix()

template<typename A , typename B , typename C >
A clan::mix ( a,
b,
mix 
)
inline

References clan::a, and clan::b.

◆ mod()

void clan::BigInt::mod ( const BigInt m,
BigInt c 
) const

Compute c = a (mod m). Result will always be 0 <= c < m.

◆ mod_d()

uint32_t clan::BigInt::mod_d ( uint32_t  d) const

Compute c = a (mod d). Result will always be 0 <= c < d.

◆ multiply() [1/4]

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

◆ multiply() [2/4]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::multiply ( const Mat3< Type > &  matrix_1,
const Mat3< Type > &  matrix_2 
)
inlinestatic

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

◆ multiply() [3/4]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::multiply ( const Mat4< Type > &  matrix_1,
const Mat4< Type > &  matrix_2 
)
inlinestatic

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

◆ multiply() [4/4]

template<typename Type >
static Quaternionx<Type> clan::Quaternionx< Type >::multiply ( const Quaternionx< Type > &  quaternion_1,
const Quaternionx< Type > &  quaternion_2 
)
static

◆ neg()

void clan::BigInt::neg ( BigInt b) const

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

◆ next_contour()

void clan::OutlineTriangulator::next_contour ( )

Mark next contour in polygon path.

◆ next_polygon()

void clan::OutlineTriangulator::next_polygon ( )

Mark next polygon.

◆ normal()

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

◆ normalize() [1/8]

Angle& clan::Angle::normalize ( )

Converts angle to range [0,360] degrees.

Returns
reference to this object

◆ normalize() [2/8]

template<typename Type >
Quaternionx<Type>& clan::Quaternionx< Type >::normalize ( )

Normalizes this quaternion.

Returns
reference to this object

◆ normalize() [3/8]

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.

◆ normalize() [4/8]

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.

◆ normalize() [5/8]

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

◆ normalize() [6/8]

template<typename Type >
Vec2< Type > clan::Vec2< Type >::normalize ( const Vec2< Type > &  vector)
inlinestatic

Normalizes a vector.

Operates in the native datatype

Parameters
vector= Vector to use
Returns
normalized vector

◆ normalize() [7/8]

template<typename Type >
Vec3< Type > clan::Vec3< Type >::normalize ( const Vec3< Type > &  vector)
inlinestatic

Normalizes a vector.

Parameters
vector= Vector to use

Operates in the native datatype

◆ normalize() [8/8]

template<typename Type >
static Quaternionx<Type> clan::Quaternionx< Type >::normalize ( Quaternionx< Type >  q)
inlinestatic

Normalizes this quaternion.

Returns
reference to this object

◆ normalize3() [1/2]

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

◆ normalize3() [2/2]

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

◆ normalize4() [1/2]

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

◆ normalize4() [2/2]

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

◆ normalize_180()

Angle& clan::Angle::normalize_180 ( )

Converts angle to range [-180,180] degrees.

Returns
reference to this object

◆ null() [1/3]

template<typename Type >
static Mat2<Type> clan::Mat2< Type >::null ( )
static

◆ null() [2/3]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::null
inlinestatic

References clan::m.

◆ null() [3/3]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::null
inlinestatic

Create a zero matrix.

Returns
The matrix

References clan::m.

◆ operator float()

clan::HalfFloat::operator float ( ) const
inline

◆ operator Type *() [1/3]

template<typename Type >
clan::Mat2< Type >::operator Type * ( )
inline

Operator that returns the matrix as a array.

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

◆ operator Type *() [2/3]

template<typename Type >
clan::Mat3< Type >::operator Type * ( )
inline

Operator that returns the matrix as a array.

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

◆ operator Type *() [3/3]

template<typename Type >
clan::Mat4< Type >::operator Type * ( )
inline

Operator that returns the matrix as a array.

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

◆ operator Type const *() [1/3]

template<typename Type >
clan::Mat2< Type >::operator Type const * ( ) const
inline

Operator that returns the matrix as a array.

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

◆ operator Type const *() [2/3]

template<typename Type >
clan::Mat3< Type >::operator Type const * ( ) const
inline

Operator that returns the matrix as a array.

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

◆ operator Type const *() [3/3]

template<typename Type >
clan::Mat4< Type >::operator Type const * ( ) const
inline

Operator that returns the matrix as a array.

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

◆ operator Vec2< Type >()

template<typename Type >
clan::Sizex< Type >::operator Vec2< Type > ( ) const
inline

◆ operator Vec2f()

clan::Vec2hf::operator Vec2f ( ) const
inline

◆ operator Vec3f()

clan::Vec3hf::operator Vec3f ( ) const
inline

◆ operator Vec4f()

clan::Vec4hf::operator Vec4f ( ) const
inline

◆ operator!=() [1/19]

bool clan::Angle::operator!= ( const Angle angle) const

!= operator.

◆ operator!=() [2/19]

template<typename Type >
bool clan::Circlex< Type >::operator!= ( const Circlex< Type > &  circle) const
inline

!= operator.

◆ operator!=() [3/19]

template<typename Type >
bool clan::Line2x< Type >::operator!= ( const Line2x< Type > &  line) const
inline

!= operator.

◆ operator!=() [4/19]

template<typename Type >
bool clan::Line3x< Type >::operator!= ( const Line3x< Type > &  line) const
inline

!= operator.

◆ operator!=() [5/19]

template<typename Type >
bool clan::LineRay2x< Type >::operator!= ( const LineRay2x< Type > &  line) const
inline

!= operator.

◆ operator!=() [6/19]

template<typename Type >
bool clan::LineRay3x< Type >::operator!= ( const LineRay3x< Type > &  line) const
inline

!= operator.

◆ operator!=() [7/19]

template<typename Type >
bool clan::LineSegment2x< Type >::operator!= ( const LineSegment2x< Type > &  line) const
inline

!= operator.

◆ operator!=() [8/19]

template<typename Type >
bool clan::LineSegment3x< Type >::operator!= ( const LineSegment3x< Type > &  line) const
inline

!= operator.

◆ operator!=() [9/19]

template<typename Type >
bool clan::Mat2< Type >::operator!= ( const Mat2< Type > &  other) const
inline

Not-equal operator.

◆ operator!=() [10/19]

template<typename Type >
bool clan::Mat3< Type >::operator!= ( const Mat3< Type > &  other)
inline

Not-equal operator.

◆ operator!=() [11/19]

template<typename Type >
bool clan::Mat4< Type >::operator!= ( const Mat4< Type > &  other)
inline

Not-equal operator.

◆ operator!=() [12/19]

template<typename Type >
bool clan::Quadx< Type >::operator!= ( const Quadx< Type > &  quad) const
inline

Quad != Quad operator.

◆ operator!=() [13/19]

template<typename Type >
bool clan::Quaternionx< Type >::operator!= ( const Quaternionx< Type > &  other) const
inline

Not equal operator.

◆ operator!=() [14/19]

template<typename Type >
bool clan::Rectx< Type >::operator!= ( const Rectx< Type > &  r) const
inline

Rect != Rect operator.

◆ operator!=() [15/19]

template<typename Type >
bool clan::Sizex< Type >::operator!= ( const Sizex< Type > &  s) const
inline

Size != Size operator (deep compare).

◆ operator!=() [16/19]

template<typename Type >
bool clan::Trianglex< Type >::operator!= ( const Trianglex< Type > &  triangle) const
inline

!= operator.

◆ operator!=() [17/19]

template<typename Type >
bool clan::Vec2< Type >::operator!= ( const Vec2< Type > &  vector) const
inline

!= operator.

◆ operator!=() [18/19]

template<typename Type >
bool clan::Vec3< Type >::operator!= ( const Vec3< Type > &  vector) const
inline

!= operator.

◆ operator!=() [19/19]

template<typename Type >
bool clan::Vec4< Type >::operator!= ( const Vec4< Type > &  vector) const
inline

!= operator.

◆ operator%() [1/2]

BigInt clan::BigInt::operator% ( const BigInt b)

Compute result = this % b.

◆ operator%() [2/2]

BigInt clan::BigInt::operator% ( uint32_t  d)

◆ operator%=() [1/2]

BigInt clan::BigInt::operator%= ( const BigInt b)

Compute this %= b.

◆ operator%=() [2/2]

BigInt clan::BigInt::operator%= ( uint32_t  d)

◆ operator*() [1/26]

Angle clan::Angle::operator* ( const Angle angle) const

  • operator.

◆ operator*() [2/26]

BigInt clan::BigInt::operator* ( const BigInt b)

Compute result = this * b.

◆ operator*() [3/26]

template<typename Type >
Vec2<Type> clan::operator* ( const Mat2< Type > &  matrix,
const Vec2< Type > &  v 
)

References clan::v.

◆ operator*() [4/26]

template<typename Type >
Mat2<Type> clan::Mat2< Type >::operator* ( const Mat2< Type > &  mult) const

Multiplication operator.

◆ operator*() [5/26]

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"

References clan::v.

◆ operator*() [6/26]

template<typename Type >
Mat3<Type> clan::Mat3< Type >::operator* ( const Mat3< Type > &  mult) const

Multiplication operator.

◆ operator*() [7/26]

template<typename Type >
Quaternionx<Type> clan::Quaternionx< Type >::operator* ( const Mat4< Type > &  matrix) const

◆ operator*() [8/26]

template<typename Type >
Vec4<Type> clan::operator* ( const Mat4< Type > &  matrix,
const Vec4< Type > &  v 
)

References clan::v.

◆ operator*() [9/26]

template<typename Type >
Mat4<Type> clan::Mat4< Type >::operator* ( const Mat4< Type > &  mult) const

Multiplication operator.

◆ operator*() [10/26]

template<typename Type >
Quaternionx<Type> clan::Quaternionx< Type >::operator* ( const Quaternionx< Type > &  mult) const
inline

Multiplication operator.

◆ operator*() [11/26]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator* ( const Type &  s) const
inline

Size * operator.

◆ operator*() [12/26]

template<typename Type >
Vec2<Type> clan::Mat3< Type >::operator* ( const Vec2< Type > &  mult) const

Multiplication operator.

◆ operator*() [13/26]

template<typename Type >
Vec2<Type> clan::operator* ( const Vec2< Type > &  v,
const Mat2< Type > &  matrix 
)

References clan::v.

◆ operator*() [14/26]

template<typename Type >
Vec2<Type> clan::operator* ( const Vec2< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [15/26]

template<typename Type >
Vec2<Type> clan::operator* ( const Vec2< Type > &  v1,
const Vec2< Type > &  v2 
)

  • operator.

◆ operator*() [16/26]

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"

References clan::v.

◆ operator*() [17/26]

template<typename Type >
Vec3<Type> clan::operator* ( const Vec3< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [18/26]

template<typename Type >
Vec3<Type> clan::operator* ( const Vec3< Type > &  v1,
const Vec3< Type > &  v2 
)

  • operator.

◆ operator*() [19/26]

template<typename Type >
Vec4<Type> clan::operator* ( const Vec4< Type > &  v,
const Mat4< Type > &  matrix 
)

References clan::v.

◆ operator*() [20/26]

template<typename Type >
Vec4<Type> clan::operator* ( const Vec4< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [21/26]

template<typename Type >
Vec4<Type> clan::operator* ( const Vec4< Type > &  v1,
const Vec4< Type > &  v2 
)

  • operator.

◆ operator*() [22/26]

Angle clan::Angle::operator* ( float  value) const

  • operator.

◆ operator*() [23/26]

template<typename Type >
Vec2<Type> clan::operator* ( Type  s,
const Vec2< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [24/26]

template<typename Type >
Vec3<Type> clan::operator* ( Type  s,
const Vec3< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [25/26]

template<typename Type >
Vec4<Type> clan::operator* ( Type  s,
const Vec4< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator*() [26/26]

BigInt clan::BigInt::operator* ( uint32_t  d)

◆ operator*=() [1/10]

void clan::Angle::operator*= ( const Angle angle)

*= operator.

◆ operator*=() [2/10]

BigInt clan::BigInt::operator*= ( const BigInt b)

Compute this *= b.

◆ operator*=() [3/10]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator*= ( const Type &  s)
inline

Size *= operator.

◆ operator*=() [4/10]

template<typename Type >
void clan::Vec2< Type >::operator*= ( const Vec2< Type > &  vector)
inline

*= operator.

◆ operator*=() [5/10]

template<typename Type >
void clan::Vec3< Type >::operator*= ( const Vec3< Type > &  vector)
inline

*= operator.

◆ operator*=() [6/10]

template<typename Type >
void clan::Vec4< Type >::operator*= ( const Vec4< Type > &  vector)
inline

*= operator.

◆ operator*=() [7/10]

template<typename Type >
void clan::Vec3< Type >::operator*= ( Type  value)
inline

*= operator.

◆ operator*=() [8/10]

template<typename Type >
void clan::Vec2< Type >::operator*= ( Type  value)
inline

*= operator.

◆ operator*=() [9/10]

template<typename Type >
void clan::Vec4< Type >::operator*= ( Type  value)
inline

*= operator.

◆ operator*=() [10/10]

BigInt clan::BigInt::operator*= ( uint32_t  d)

◆ operator+() [1/19]

Angle clan::Angle::operator+ ( const Angle angle) const

  • operator.

◆ operator+() [2/19]

BigInt clan::BigInt::operator+ ( const BigInt b)

Compute result = this + b.

◆ operator+() [3/19]

template<typename Type >
Mat2<Type> clan::Mat2< Type >::operator+ ( const Mat2< Type > &  add_matrix) const

Addition operator.

◆ operator+() [4/19]

template<typename Type >
Mat3<Type> clan::Mat3< Type >::operator+ ( const Mat3< Type > &  add_matrix) const

Addition operator.

◆ operator+() [5/19]

template<typename Type >
Mat4<Type> clan::Mat4< Type >::operator+ ( const Mat4< Type > &  add_matrix) const

Addition operator.

◆ operator+() [6/19]

template<typename Type >
Quadx<Type> clan::Quadx< Type >::operator+ ( const Quadx< Type > &  quad) const
inline

Quad + Quad operator.

◆ operator+() [7/19]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator+ ( const Sizex< Type > &  s) const
inline

Size + Size operator.

◆ operator+() [8/19]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator+ ( const Type &  s) const
inline

Size + operator.

◆ operator+() [9/19]

template<typename Type >
Quadx<Type> clan::Quadx< Type >::operator+ ( const Vec2< Type > &  point) const
inline

Quad + Point operator.

◆ operator+() [10/19]

template<typename Type >
Vec2<Type> clan::operator+ ( const Vec2< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [11/19]

template<typename Type >
Vec2<Type> clan::operator+ ( const Vec2< Type > &  v1,
const Vec2< Type > &  v2 
)

  • operator.

◆ operator+() [12/19]

template<typename Type >
Vec3<Type> clan::operator+ ( const Vec3< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [13/19]

template<typename Type >
Vec3<Type> clan::operator+ ( const Vec3< Type > &  v1,
const Vec3< Type > &  v2 
)

  • operator.

◆ operator+() [14/19]

template<typename Type >
Vec4<Type> clan::operator+ ( const Vec4< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [15/19]

template<typename Type >
Vec4<Type> clan::operator+ ( const Vec4< Type > &  v1,
const Vec4< Type > &  v2 
)

  • operator.

◆ operator+() [16/19]

template<typename Type >
Vec2<Type> clan::operator+ ( Type  s,
const Vec2< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [17/19]

template<typename Type >
Vec3<Type> clan::operator+ ( Type  s,
const Vec3< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [18/19]

template<typename Type >
Vec4<Type> clan::operator+ ( Type  s,
const Vec4< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator+() [19/19]

BigInt clan::BigInt::operator+ ( uint32_t  d)

◆ operator+=() [1/13]

void clan::Angle::operator+= ( const Angle angle)

+= operator.

◆ operator+=() [2/13]

BigInt clan::BigInt::operator+= ( const BigInt b)

Compute this += b.

◆ operator+=() [3/13]

template<typename Type >
Quadx<Type>& clan::Quadx< Type >::operator+= ( const Quadx< Type > &  quad)
inline

Quad += Quad operator.

◆ operator+=() [4/13]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator+= ( const Sizex< Type > &  s)
inline

Size += Size operator.

◆ operator+=() [5/13]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator+= ( const Type &  s)
inline

Size += operator.

◆ operator+=() [6/13]

template<typename Type >
Quadx<Type>& clan::Quadx< Type >::operator+= ( const Vec2< Type > &  point)
inline

Quad += Point operator.

◆ operator+=() [7/13]

template<typename Type >
void clan::Vec2< Type >::operator+= ( const Vec2< Type > &  vector)
inline

+= operator.

◆ operator+=() [8/13]

template<typename Type >
void clan::Vec3< Type >::operator+= ( const Vec3< Type > &  vector)
inline

+= operator.

◆ operator+=() [9/13]

template<typename Type >
void clan::Vec4< Type >::operator+= ( const Vec4< Type > &  vector)
inline

+= operator.

◆ operator+=() [10/13]

template<typename Type >
void clan::Vec3< Type >::operator+= ( Type  value)
inline

+= operator.

◆ operator+=() [11/13]

template<typename Type >
void clan::Vec2< Type >::operator+= ( Type  value)
inline

+= operator.

◆ operator+=() [12/13]

template<typename Type >
void clan::Vec4< Type >::operator+= ( Type  value)
inline

+= operator.

◆ operator+=() [13/13]

BigInt clan::BigInt::operator+= ( uint32_t  d)

◆ operator-() [1/22]

template<typename Type >
Vec3<Type> clan::Vec3< Type >::operator- ( ) const
inline

  • operator.

◆ operator-() [2/22]

template<typename Type >
Vec2<Type> clan::Vec2< Type >::operator- ( ) const
inline

  • operator.

◆ operator-() [3/22]

template<typename Type >
Vec4<Type> clan::Vec4< Type >::operator- ( ) const
inline

  • operator.

◆ operator-() [4/22]

Angle clan::Angle::operator- ( const Angle angle) const

  • operator.

◆ operator-() [5/22]

BigInt clan::BigInt::operator- ( const BigInt b)

Compute result = this - b.

◆ operator-() [6/22]

template<typename Type >
Mat2<Type> clan::Mat2< Type >::operator- ( const Mat2< Type > &  subtract_matrix) const

Subtract operator.

◆ operator-() [7/22]

template<typename Type >
Mat3<Type> clan::Mat3< Type >::operator- ( const Mat3< Type > &  sub_matrix) const

Subtraction operator.

◆ operator-() [8/22]

template<typename Type >
Mat4<Type> clan::Mat4< Type >::operator- ( const Mat4< Type > &  sub_matrix) const

Subtraction operator.

◆ operator-() [9/22]

template<typename Type >
Quadx<Type> clan::Quadx< Type >::operator- ( const Quadx< Type > &  quad) const
inline

Quad - Quad operator.

◆ operator-() [10/22]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator- ( const Sizex< Type > &  s) const
inline

Size - Size operator.

◆ operator-() [11/22]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator- ( const Type &  s) const
inline

Size - operator.

◆ operator-() [12/22]

template<typename Type >
Quadx<Type> clan::Quadx< Type >::operator- ( const Vec2< Type > &  point) const
inline

Quad - Point operator.

◆ operator-() [13/22]

template<typename Type >
Vec2<Type> clan::operator- ( const Vec2< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [14/22]

template<typename Type >
Vec2<Type> clan::operator- ( const Vec2< Type > &  v1,
const Vec2< Type > &  v2 
)

  • operator.

◆ operator-() [15/22]

template<typename Type >
Vec3<Type> clan::operator- ( const Vec3< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [16/22]

template<typename Type >
Vec3<Type> clan::operator- ( const Vec3< Type > &  v1,
const Vec3< Type > &  v2 
)

  • operator.

◆ operator-() [17/22]

template<typename Type >
Vec4<Type> clan::operator- ( const Vec4< Type > &  v,
Type  s 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [18/22]

template<typename Type >
Vec4<Type> clan::operator- ( const Vec4< Type > &  v1,
const Vec4< Type > &  v2 
)

  • operator.

◆ operator-() [19/22]

template<typename Type >
Vec2<Type> clan::operator- ( Type  s,
const Vec2< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [20/22]

template<typename Type >
Vec3<Type> clan::operator- ( Type  s,
const Vec3< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [21/22]

template<typename Type >
Vec4<Type> clan::operator- ( Type  s,
const Vec4< Type > &  v 
)

  • operator.

References clan::s, and clan::v.

◆ operator-() [22/22]

BigInt clan::BigInt::operator- ( uint32_t  d)

◆ operator-=() [1/13]

void clan::Angle::operator-= ( const Angle angle)

-= operator.

◆ operator-=() [2/13]

BigInt clan::BigInt::operator-= ( const BigInt b)

Compute this -= b.

◆ operator-=() [3/13]

template<typename Type >
Quadx<Type>& clan::Quadx< Type >::operator-= ( const Quadx< Type > &  quad)
inline

Quad -= Quad operator.

◆ operator-=() [4/13]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator-= ( const Sizex< Type > &  s)
inline

Size -= Size operator.

◆ operator-=() [5/13]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator-= ( const Type &  s)
inline

Size -= operator.

◆ operator-=() [6/13]

template<typename Type >
Quadx<Type>& clan::Quadx< Type >::operator-= ( const Vec2< Type > &  point)
inline

Quad -= Point operator.

◆ operator-=() [7/13]

template<typename Type >
void clan::Vec2< Type >::operator-= ( const Vec2< Type > &  vector)
inline

-= operator.

◆ operator-=() [8/13]

template<typename Type >
void clan::Vec3< Type >::operator-= ( const Vec3< Type > &  vector)
inline

-= operator.

◆ operator-=() [9/13]

template<typename Type >
void clan::Vec4< Type >::operator-= ( const Vec4< Type > &  vector)
inline

-= operator.

◆ operator-=() [10/13]

template<typename Type >
void clan::Vec3< Type >::operator-= ( Type  value)
inline

-= operator.

◆ operator-=() [11/13]

template<typename Type >
void clan::Vec2< Type >::operator-= ( Type  value)
inline

-= operator.

◆ operator-=() [12/13]

template<typename Type >
void clan::Vec4< Type >::operator-= ( Type  value)
inline

-= operator.

◆ operator-=() [13/13]

BigInt clan::BigInt::operator-= ( uint32_t  d)

◆ operator/() [1/14]

Angle clan::Angle::operator/ ( const Angle angle) const

/ operator.

◆ operator/() [2/14]

BigInt clan::BigInt::operator/ ( const BigInt b)

Compute result = this / b.

◆ operator/() [3/14]

template<typename Type >
Sizex<Type> clan::Sizex< Type >::operator/ ( const Type &  s) const
inline

Size / operator.

◆ operator/() [4/14]

template<typename Type >
Vec2<Type> clan::operator/ ( const Vec2< Type > &  v,
Type  s 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [5/14]

template<typename Type >
Vec2<Type> clan::operator/ ( const Vec2< Type > &  v1,
const Vec2< Type > &  v2 
)

/ operator.

◆ operator/() [6/14]

template<typename Type >
Vec3<Type> clan::operator/ ( const Vec3< Type > &  v,
Type  s 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [7/14]

template<typename Type >
Vec3<Type> clan::operator/ ( const Vec3< Type > &  v1,
const Vec3< Type > &  v2 
)

/ operator.

◆ operator/() [8/14]

template<typename Type >
Vec4<Type> clan::operator/ ( const Vec4< Type > &  v,
Type  s 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [9/14]

template<typename Type >
Vec4<Type> clan::operator/ ( const Vec4< Type > &  v1,
const Vec4< Type > &  v2 
)

/ operator.

◆ operator/() [10/14]

Angle clan::Angle::operator/ ( float  value) const

/ operator.

◆ operator/() [11/14]

template<typename Type >
Vec2<Type> clan::operator/ ( Type  s,
const Vec2< Type > &  v 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [12/14]

template<typename Type >
Vec3<Type> clan::operator/ ( Type  s,
const Vec3< Type > &  v 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [13/14]

template<typename Type >
Vec4<Type> clan::operator/ ( Type  s,
const Vec4< Type > &  v 
)

/ operator.

References clan::s, and clan::v.

◆ operator/() [14/14]

BigInt clan::BigInt::operator/ ( uint32_t  d)

◆ operator/=() [1/10]

void clan::Angle::operator/= ( const Angle angle)

/= operator.

◆ operator/=() [2/10]

BigInt clan::BigInt::operator/= ( const BigInt b)

Compute this /= b.

◆ operator/=() [3/10]

template<typename Type >
Sizex<Type>& clan::Sizex< Type >::operator/= ( const Type &  s)
inline

Size /= operator.

◆ operator/=() [4/10]

template<typename Type >
void clan::Vec2< Type >::operator/= ( const Vec2< Type > &  vector)
inline

/= operator.

◆ operator/=() [5/10]

template<typename Type >
void clan::Vec3< Type >::operator/= ( const Vec3< Type > &  vector)
inline

/= operator.

◆ operator/=() [6/10]

template<typename Type >
void clan::Vec4< Type >::operator/= ( const Vec4< Type > &  vector)
inline

/= operator.

◆ operator/=() [7/10]

template<typename Type >
void clan::Vec3< Type >::operator/= ( Type  value)
inline

/= operator.

◆ operator/=() [8/10]

template<typename Type >
void clan::Vec2< Type >::operator/= ( Type  value)
inline

/= operator.

◆ operator/=() [9/10]

template<typename Type >
void clan::Vec4< Type >::operator/= ( Type  value)
inline

/= operator.

◆ operator/=() [10/10]

BigInt clan::BigInt::operator/= ( uint32_t  d)

◆ operator<() [1/5]

bool clan::Angle::operator< ( const Angle angle) const

< operator.

◆ operator<() [2/5]

template<typename Type >
bool clan::Quaternionx< Type >::operator< ( const Quaternionx< Type > &  other) const
inline

Less operator.

◆ operator<() [3/5]

template<typename Type >
bool clan::Vec2< Type >::operator< ( const Vec2< Type > &  vector) const
inline

< operator.

◆ operator<() [4/5]

template<typename Type >
bool clan::Vec3< Type >::operator< ( const Vec3< Type > &  vector) const
inline

< operator.

◆ operator<() [5/5]

template<typename Type >
bool clan::Vec4< Type >::operator< ( const Vec4< Type > &  vector) const
inline

< operator.

◆ operator<=() [1/2]

bool clan::Angle::operator<= ( const Angle angle) const

< operator.

◆ operator<=() [2/2]

template<typename Type >
bool clan::Quaternionx< Type >::operator<= ( const Quaternionx< Type > &  other) const
inline

Less equal operator.

◆ operator=() [1/23]

BigInt& clan::BigInt::operator= ( const BigInt other)

◆ operator=() [2/23]

template<typename Type >
Circlex<Type>& clan::Circlex< Type >::operator= ( const Circlex< Type > &  copy)
inline

= operator.

◆ operator=() [3/23]

HalfFloat& clan::HalfFloat::operator= ( const float  v)
inline

◆ operator=() [4/23]

HalfFloat& clan::HalfFloat::operator= ( const HalfFloat other)
inline

◆ operator=() [5/23]

template<typename Type >
Line2x<Type>& clan::Line2x< Type >::operator= ( const Line2x< Type > &  copy)
inline

= operator.

◆ operator=() [6/23]

template<typename Type >
Line3x<Type>& clan::Line3x< Type >::operator= ( const Line3x< Type > &  copy)
inline

= operator.

◆ operator=() [7/23]

template<typename Type >
LineRay2x<Type>& clan::LineRay2x< Type >::operator= ( const LineRay2x< Type > &  copy)
inline

= operator.

◆ operator=() [8/23]

template<typename Type >
LineRay3x<Type>& clan::LineRay3x< Type >::operator= ( const LineRay3x< Type > &  copy)
inline

= operator.

◆ operator=() [9/23]

template<typename Type >
LineSegment2x<Type>& clan::LineSegment2x< Type >::operator= ( const LineSegment2x< Type > &  copy)
inline

= operator.

◆ operator=() [10/23]

template<typename Type >
LineSegment3x<Type>& clan::LineSegment3x< Type >::operator= ( const LineSegment3x< Type > &  copy)
inline

= operator.

◆ operator=() [11/23]

template<typename Type >
Mat2<Type>& clan::Mat2< Type >::operator= ( const Mat2< Type > &  copy)
inline

Copy assignment operator.

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

◆ operator=() [12/23]

template<typename Type >
Mat3<Type>& clan::Mat3< Type >::operator= ( const Mat2< Type > &  copy)

Copy assignment operator.

◆ operator=() [13/23]

template<typename Type >
Mat4<Type>& clan::Mat4< Type >::operator= ( const Mat2< Type > &  copy)

Copy assignment operator.

◆ operator=() [14/23]

template<typename Type >
Mat2<Type>& clan::Mat2< Type >::operator= ( const Mat3< Type > &  copy)

Copy assignment operator.

◆ operator=() [15/23]

template<typename Type >
Mat3<Type>& clan::Mat3< Type >::operator= ( const Mat3< Type > &  copy)
inline

Copy assignment operator.

◆ operator=() [16/23]

template<typename Type >
Mat4<Type>& clan::Mat4< Type >::operator= ( const Mat3< Type > &  copy)

Copy assignment operator.

◆ operator=() [17/23]

template<typename Type >
Mat2<Type>& clan::Mat2< Type >::operator= ( const Mat4< Type > &  copy)

Copy assignment operator.

◆ operator=() [18/23]

template<typename Type >
Mat3<Type>& clan::Mat3< Type >::operator= ( const Mat4< Type > &  copy)

Copy assignment operator.

◆ operator=() [19/23]

template<typename Type >
Mat4<Type>& clan::Mat4< Type >::operator= ( const Mat4< Type > &  copy)
inline

Copy assignment operator.

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

◆ operator=() [20/23]

template<typename Type >
Trianglex<Type>& clan::Trianglex< Type >::operator= ( const Trianglex< Type > &  copy)
inline

= operator.

◆ operator=() [21/23]

template<typename Type >
Vec2<Type>& clan::Vec2< Type >::operator= ( const Vec2< Type > &  vector)
inline

= operator.

◆ operator=() [22/23]

template<typename Type >
Vec3<Type>& clan::Vec3< Type >::operator= ( const Vec3< Type > &  vector)
inline

= operator.

◆ operator=() [23/23]

template<typename Type >
Vec4<Type>& clan::Vec4< Type >::operator= ( const Vec4< Type > &  vector)
inline

= operator.

◆ operator==() [1/19]

bool clan::Angle::operator== ( const Angle angle) const

== operator.

◆ operator==() [2/19]

template<typename Type >
bool clan::Circlex< Type >::operator== ( const Circlex< Type > &  circle) const
inline

== operator.

◆ operator==() [3/19]

template<typename Type >
bool clan::Line2x< Type >::operator== ( const Line2x< Type > &  line) const
inline

== operator.

◆ operator==() [4/19]

template<typename Type >
bool clan::Line3x< Type >::operator== ( const Line3x< Type > &  line) const
inline

== operator.

◆ operator==() [5/19]

template<typename Type >
bool clan::LineRay2x< Type >::operator== ( const LineRay2x< Type > &  line) const
inline

== operator.

◆ operator==() [6/19]

template<typename Type >
bool clan::LineRay3x< Type >::operator== ( const LineRay3x< Type > &  line) const
inline

== operator.

◆ operator==() [7/19]

template<typename Type >
bool clan::LineSegment2x< Type >::operator== ( const LineSegment2x< Type > &  line) const
inline

== operator.

◆ operator==() [8/19]

template<typename Type >
bool clan::LineSegment3x< Type >::operator== ( const LineSegment3x< Type > &  line) const
inline

== operator.

◆ operator==() [9/19]

template<typename Type >
bool clan::Mat2< Type >::operator== ( const Mat2< Type > &  other) const
inline

Equality operator.

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

◆ operator==() [10/19]

template<typename Type >
bool clan::Mat3< Type >::operator== ( const Mat3< Type > &  other) const
inline

Equality operator.

◆ operator==() [11/19]

template<typename Type >
bool clan::Mat4< Type >::operator== ( const Mat4< Type > &  other) const
inline

Equality operator.

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

◆ operator==() [12/19]

template<typename Type >
bool clan::Quadx< Type >::operator== ( const Quadx< Type > &  quad) const
inline

Quad == Quad operator.

◆ operator==() [13/19]

template<typename Type >
bool clan::Quaternionx< Type >::operator== ( const Quaternionx< Type > &  other) const
inline

Equal operator.

◆ operator==() [14/19]

template<typename Type >
bool clan::Rectx< Type >::operator== ( const Rectx< Type > &  r) const
inline

Rect == Rect operator.

◆ operator==() [15/19]

template<typename Type >
bool clan::Sizex< Type >::operator== ( const Sizex< Type > &  s) const
inline

Size == Size operator (deep compare).

◆ operator==() [16/19]

template<typename Type >
bool clan::Trianglex< Type >::operator== ( const Trianglex< Type > &  triangle) const
inline

== operator.

◆ operator==() [17/19]

template<typename Type >
bool clan::Vec2< Type >::operator== ( const Vec2< Type > &  vector) const
inline

== operator.

◆ operator==() [18/19]

template<typename Type >
bool clan::Vec3< Type >::operator== ( const Vec3< Type > &  vector) const
inline

== operator.

◆ operator==() [19/19]

template<typename Type >
bool clan::Vec4< Type >::operator== ( const Vec4< Type > &  vector) const
inline

== operator.

◆ operator>() [1/2]

bool clan::Angle::operator> ( const Angle angle) const

> operator.

◆ operator>() [2/2]

template<typename Type >
bool clan::Quaternionx< Type >::operator> ( const Quaternionx< Type > &  other) const
inline

Greater operator.

◆ operator>=() [1/2]

bool clan::Angle::operator>= ( const Angle angle) const

> operator.

◆ operator>=() [2/2]

template<typename Type >
bool clan::Quaternionx< Type >::operator>= ( const Quaternionx< Type > &  other) const
inline

Greater equal operator.

◆ operator[]() [1/12]

template<typename Type >
Type& clan::Mat2< Type >::operator[] ( int  i)
inline

Operator that returns the matrix cell at the given index.

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

◆ operator[]() [2/12]

template<typename Type >
Type& clan::Mat3< Type >::operator[] ( int  i)
inline

Operator that returns the matrix cell at the given index.

◆ operator[]() [3/12]

template<typename Type >
Type& clan::Mat4< Type >::operator[] ( int  i)
inline

Operator that returns the matrix cell at the given index.

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

◆ operator[]() [4/12]

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, and clan::Mat2< Type >::matrix.

◆ operator[]() [5/12]

template<typename Type >
const Type& clan::Mat3< Type >::operator[] ( int  i) const
inline

Operator that returns the matrix cell at the given index.

◆ operator[]() [6/12]

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, and clan::Mat4< Type >::matrix.

◆ operator[]() [7/12]

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, and clan::Mat2< Type >::matrix.

◆ operator[]() [8/12]

template<typename Type >
Type& clan::Mat3< Type >::operator[] ( unsigned int  i)
inline

Operator that returns the matrix cell at the given index.

◆ operator[]() [9/12]

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, and clan::Mat4< Type >::matrix.

◆ operator[]() [10/12]

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, and clan::Mat2< Type >::matrix.

◆ operator[]() [11/12]

template<typename Type >
const Type& clan::Mat3< Type >::operator[] ( unsigned int  i) const
inline

Operator that returns the matrix cell at the given index.

◆ operator[]() [12/12]

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, and clan::Mat4< Type >::matrix.

◆ ortho()

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)

◆ ortho_2d()

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)

◆ overlap()

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

◆ perspective()

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)

◆ plane_aabb()

static Result clan::IntersectionTest::plane_aabb ( const Vec4f plane,
const AxisAlignedBoundingBox aabb 
)
static

◆ plane_obb()

static Result clan::IntersectionTest::plane_obb ( const Vec4f plane,
const OrientedBoundingBox obb 
)
static

◆ point_distance() [1/2]

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.

◆ point_distance() [2/2]

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

◆ point_inside()

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

◆ point_right_of_line() [1/5]

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

◆ point_right_of_line() [2/5]

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)

◆ point_right_of_line() [3/5]

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}.

◆ point_right_of_line() [4/5]

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

◆ point_right_of_line() [5/5]

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)

◆ pow2()

template<typename T >
T clan::pow2 ( value)
inline

◆ pprime()

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

◆ random()

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.

◆ ray_aabb()

static OverlapResult clan::IntersectionTest::ray_aabb ( const Vec3f ray_start,
const Vec3f ray_end,
const AxisAlignedBoundingBox box 
)
static

◆ read_unsigned_octets()

void clan::BigInt::read_unsigned_octets ( const unsigned char *  input_str,
unsigned int  input_length 
)

◆ RectdPS()

Rectd clan::RectdPS ( double  x,
double  y,
double  width,
double  height 
)
inline

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

◆ RectfPS()

Rectf clan::RectfPS ( float  x,
float  y,
float  width,
float  height 
)
inline

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

◆ RectPS()

Rect clan::RectPS ( int  x,
int  y,
int  width,
int  height 
)
inline

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

◆ reflect()

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

◆ reset() [1/2]

void clan::Base64Decoder::reset ( )

Resets the decoder.

◆ reset() [2/2]

void clan::Base64Encoder::reset ( )

Resets the encoder.

◆ rotate() [1/14]

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)

◆ rotate() [2/14]

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
angleAngle to rotate.
axisRotation axis.
Returns
reference to this object

◆ rotate() [3/14]

template<typename Type >
Quaternionx<Type>& clan::Quaternionx< Type >::rotate ( const Angle angle,
const Vec3f axis 
)

◆ rotate() [4/14]

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().

◆ rotate() [5/14]

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().

◆ rotate() [6/14]

template<typename Type >
static Mat3<Type> clan::Mat3< Type >::rotate ( const Angle angle,
Vec3< Type >  rotation,
bool  normalize = true 
)
inlinestatic

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)

◆ rotate() [7/14]

template<typename Type >
static Mat4<Type> clan::Mat4< Type >::rotate ( const Angle angle,
Vec3< Type >  rotation,
bool  normalize = true 
)
inlinestatic

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::angle, clan::Mat4< Type >::rotate(), clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

◆ rotate() [8/14]

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)

◆ rotate() [9/14]

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)

◆ rotate() [10/14]

template<typename Type >
Quaternionx<Type>& clan::Quaternionx< Type >::rotate ( const Angle euler_x,
const Angle euler_y,
const Angle euler_z,
EulerOrder  order 
)

◆ rotate() [11/14]

template<typename Type >
Quadx<Type>& clan::Quadx< Type >::rotate ( const Vec2< Type > &  hotspot,
const Angle angle 
)

Rotates the Quad.

Parameters
hotspotPoint to rotate around.
angleAngle to rotate in degrees.
Returns
reference to this object

◆ rotate() [12/14]

template<typename Type >
Vec2<Type>& clan::Vec2< Type >::rotate ( const Vec2< Type > &  hotspot,
const Angle angle 
)

Rotate this vector around another point.

Parameters
hotspotThe point around which to rotate.
angle= Angle to rotate.
Returns
reference to this object

◆ rotate() [13/14]

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
hotspotThe point around which to rotate.
angle= Angle to rotate.

◆ rotate() [14/14]

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

◆ rotate3() [1/2]

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
angleAngle to rotate
axisRotation axis.
Returns
reference to this object

◆ rotate3() [2/2]

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
angleAngle to rotate
axisRotation axis.
Returns
The rotated vector

◆ rotate_vector() [1/2]

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

◆ rotate_vector() [2/2]

template<typename Type >
Vec4<Type> clan::Quaternionx< Type >::rotate_vector ( const Vec4< Type > &  v) const

◆ rotation_between() [1/2]

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.

◆ rotation_between() [2/2]

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.

◆ round() [1/6]

template<typename Type >
Vec2<Type>& clan::Vec2< Type >::round ( )

Rounds all components of this vector.

Uses Asymmetric Arithmetic Rounding

Returns
reference to this object

◆ round() [2/6]

template<typename Type >
Vec3<Type>& clan::Vec3< Type >::round ( )

Rounds all components on this vector.

Uses Asymmetric Arithmetic Rounding

Returns
reference to this object

◆ round() [3/6]

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

◆ round() [4/6]

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

◆ round() [5/6]

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

◆ round() [6/6]

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

◆ round_value()

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

◆ scale() [1/6]

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

◆ scale() [2/6]

template<typename Type >
static Mat3<Type> clan::Mat3< Type >::scale ( const Vec3< Type > &  xy)
inlinestatic

Create a 2d scale matrix.

Parameters
xy= Scale XY
Returns
The matrix

◆ scale() [3/6]

template<typename Type >
static Mat4<Type> clan::Mat4< Type >::scale ( const Vec3< Type > &  xyz)
inlinestatic

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.

◆ scale() [4/6]

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

◆ scale() [5/6]

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().

◆ scale() [6/6]

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(), and clan::Mat4< Type >::scale_self().

◆ scale_self() [1/2]

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(), and clan::Mat4< Type >::scale_self().

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

◆ scale_self() [2/2]

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

◆ set() [1/7]

template<typename Type >
void clan::Quaternionx< Type >::set ( const Angle euler_x,
const Angle euler_y,
const Angle euler_z,
EulerOrder  order 
)

◆ set() [2/7]

template<typename Type >
void clan::Quaternionx< Type >::set ( const Vec3< Type > &  euler,
AngleUnit  unit,
EulerOrder  order 
)

◆ set() [3/7]

void clan::BigInt::set ( int32_t  d)

Sets a value.

◆ set() [4/7]

void clan::BigInt::set ( int64_t  d)

◆ set() [5/7]

template<typename Type >
void clan::Quaternionx< Type >::set ( Type  euler_x,
Type  euler_y,
Type  euler_z,
AngleUnit  unit,
EulerOrder  order 
)

◆ set() [6/7]

void clan::BigInt::set ( uint32_t  d)

◆ set() [7/7]

void clan::BigInt::set ( uint64_t  d)

◆ set_allocation_policy()

void clan::RectPacker::set_allocation_policy ( AllocationPolicy  policy)

Set the allocation policy.

◆ set_bit()

void clan::BigInt::set_bit ( unsigned int  bit_number,
unsigned int  value 
)

◆ set_degrees()

void clan::Angle::set_degrees ( float  value_degrees)

Set the angle value in degrees.

◆ set_height()

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::set_height ( Type  height)
inline

Sets the height of the rectangle.

Returns
reference to this object

◆ set_orientation()

void clan::EarClipTriangulator::set_orientation ( PolygonOrientation  orientation)

Set polygon orientation.

◆ set_radians()

void clan::Angle::set_radians ( float  value_radians)

Set the angle value in radians.

◆ set_size()

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

◆ set_top_left()

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

◆ set_translate() [1/2]

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::Mat4< Type >::matrix, clan::Vec3< Type >::x, clan::Vec3< Type >::y, and clan::Vec3< Type >::z.

◆ set_translate() [2/2]

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::Mat4< Type >::matrix, clan::x, clan::y, and clan::z.

◆ set_width()

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::set_width ( Type  width)
inline

Sets the width of the rectangle.

Returns
reference to this object

◆ set_xy()

template<typename Type >
void clan::Vec4< Type >::set_xy ( const Vec2< Type > &  new_v)
inline

◆ set_zw()

template<typename Type >
void clan::Vec4< Type >::set_zw ( const Vec2< Type > &  new_v)
inline

◆ shrink() [1/3]

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

◆ shrink() [2/3]

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().

◆ shrink() [3/3]

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::shrink ( const Type &  shrink)
inline

Shrink the rectangle.

Returns
reference to this object

◆ sieve()

void clan::BigInt::sieve ( const uint32_t *  primes,
unsigned int  num_primes,
std::vector< unsigned char > &  sieve 
)

◆ sign() [1/6]

template<typename Type >
Vec2<Type> clan::sign ( const Vec2< Type > &  x)
inline

References clan::sign(), and clan::x.

◆ sign() [2/6]

template<typename Type >
Vec3<Type> clan::sign ( const Vec3< Type > &  x)
inline

References clan::sign(), and clan::x.

◆ sign() [3/6]

template<typename Type >
Vec4<Type> clan::sign ( const Vec4< Type > &  x)
inline

References clan::sign(), and clan::x.

◆ sign() [4/6]

double clan::sign ( double  x)
inline

References clan::x.

◆ sign() [5/6]

float clan::sign ( float  x)
inline

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

◆ sign() [6/6]

int clan::sign ( int  x)
inline

References clan::x.

Referenced by clan::sign().

◆ significant_bits()

int clan::BigInt::significant_bits ( ) const

◆ slerp()

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

◆ smoothstep()

template<typename A , typename B , typename C >
C clan::smoothstep ( edge0,
edge1,
x 
)
inline

References clan::clamp(), clan::t, and clan::x.

◆ sphere()

static OverlapResult clan::IntersectionTest::sphere ( const Vec3f center1,
float  radius1,
const Vec3f center2,
float  radius2 
)
static

◆ sphere_aabb()

static OverlapResult clan::IntersectionTest::sphere_aabb ( const Vec3f center,
float  radius,
const AxisAlignedBoundingBox aabb 
)
static

◆ sqr()

void clan::BigInt::sqr ( BigInt b) const

◆ sqrmod()

void clan::BigInt::sqrmod ( const BigInt m,
BigInt c 
) const

◆ step() [1/7]

template<typename Type >
Vec2<Type> clan::step ( const Vec2< Type > &  edge,
const Vec2< Type > &  x 
)
inline

◆ step() [2/7]

template<typename Type >
Vec3<Type> clan::step ( const Vec3< Type > &  edge,
const Vec3< Type > &  x 
)
inline

◆ step() [3/7]

template<typename Type >
Vec4<Type> clan::step ( const Vec4< Type > &  edge,
const Vec4< Type > &  x 
)
inline

◆ step() [4/7]

double clan::step ( double  edge,
double  x 
)
inline

References clan::x.

◆ step() [5/7]

float clan::step ( float  edge,
float  x 
)
inline

References clan::x.

◆ step() [6/7]

int clan::step ( int  edge,
int  x 
)
inline

References clan::x.

Referenced by clan::step().

◆ step() [7/7]

long long clan::step ( long long  edge,
long long  x 
)
inline

References clan::x.

◆ subtract() [1/3]

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

◆ subtract() [2/3]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::subtract ( const Mat3< Type > &  matrix_1,
const Mat3< Type > &  matrix_2 
)
inlinestatic

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

◆ subtract() [3/3]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::subtract ( const Mat4< Type > &  matrix_1,
const Mat4< Type > &  matrix_2 
)
inlinestatic

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

◆ throw_if_null()

void clan::RectPacker::throw_if_null ( ) const

Throw an exception if this object is invalid.

◆ to_degrees()

float clan::Angle::to_degrees ( ) const

Returns the angle as degrees.

◆ to_float() [1/4]

float clan::HalfFloat::to_float ( ) const
inline

◆ to_float() [2/4]

Vec2f clan::Vec2hf::to_float ( ) const
inline

◆ to_float() [3/4]

Vec3f clan::Vec3hf::to_float ( ) const
inline

◆ to_float() [4/4]

Vec4f clan::Vec4hf::to_float ( ) const
inline

◆ to_matrix()

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.

◆ to_radians()

float clan::Angle::to_radians ( ) const

Returns the angle as radians.

◆ to_unsigned_octets()

void clan::BigInt::to_unsigned_octets ( unsigned char *  output_str,
unsigned int  output_length 
) const

◆ trailing_zeros()

unsigned int clan::BigInt::trailing_zeros ( ) const

◆ translate() [1/8]

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

◆ translate() [2/8]

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::translate ( const Sizex< Type > &  p)
inline

Translate the rect.

Returns
reference to this object

◆ translate() [3/8]

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::translate ( const Vec2< Type > &  p)
inline

Translate the rect.

Returns
reference to this object

◆ translate() [4/8]

template<typename Type >
static Mat3<Type> clan::Mat3< Type >::translate ( const Vec2< Type > &  xy)
inlinestatic

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)

◆ translate() [5/8]

template<typename Type >
static Mat4<Type> clan::Mat4< Type >::translate ( const Vec3< Type > &  xyz)
inlinestatic

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.

◆ translate() [6/8]

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().

◆ translate() [7/8]

template<typename Type >
Rectx<Type>& clan::Rectx< Type >::translate ( Type  x,
Type  y 
)
inline

Translate the rect.

Returns
reference to this object

◆ translate() [8/8]

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().

◆ translate_self() [1/2]

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().

◆ translate_self() [2/2]

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

◆ transpose() [1/4]

template<typename Type >
Mat3<Type>& clan::Mat3< Type >::transpose ( )

Calculate the transpose of this matrix.

Returns
reference to this object

◆ transpose() [2/4]

template<typename Type >
Mat4<Type>& clan::Mat4< Type >::transpose ( )

Calculate the transpose of this matrix.

Returns
reference to this object

◆ transpose() [3/4]

template<typename Type >
Mat3< Type > clan::Mat3< Type >::transpose ( const Mat3< Type > &  matrix)
inlinestatic

Calculate the transpose of a matrix.

Parameters
matrix= The matrix to use
Returns
The transposed matrix

◆ transpose() [4/4]

template<typename Type >
Mat4< Type > clan::Mat4< Type >::transpose ( const Mat4< Type > &  matrix)
inlinestatic

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().

◆ triangulate()

EarClipResult clan::EarClipTriangulator::triangulate ( )

Perform triangulation.

◆ unsigned_octet_size()

int clan::BigInt::unsigned_octet_size ( ) const

◆ xgcd()

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()

◆ xywh()

template<typename Type >
static Rectx<Type> clan::Rectx< Type >::xywh ( Type  x,
Type  y,
Type  width,
Type  height 
)
inlinestatic

◆ zero()

void clan::BigInt::zero ( )

Variable Documentation

◆ @1

union { ... }

The imaginary vector part.

◆ @11

union { ... }

◆ @13

union { ... }

◆ @15

union { ... }

◆ @17

union { ... }

◆ @19

union { ... }

◆ @21

union { ... }

◆ @23

union { ... }

◆ @3

union { ... }

◆ @5

union { ... }

◆ @7

union { ... }

◆ @9

union { ... }

◆ a [1/2]

◆ a [2/2]

Type { ... } ::a

◆ aabb_max

Vec3f clan::AxisAlignedBoundingBox::aabb_max

◆ aabb_min

Vec3f clan::AxisAlignedBoundingBox::aabb_min

◆ axis_x

Vec3f clan::OrientedBoundingBox::axis_x

◆ axis_y

Vec3f clan::OrientedBoundingBox::axis_y

◆ axis_z

Vec3f clan::OrientedBoundingBox::axis_z

◆ b [1/4]

Type { ... } ::b

◆ b [2/4]

◆ b [3/4]

template<typename Type >
Type clan::Vec3< Type >::b

◆ b [4/4]

Type { ... } ::b

◆ bottom

◆ center

Vec3f clan::OrientedBoundingBox::center

◆ data

void* clan::DelauneyTriangulator_Vertex::data

Data pointer given when adding the vertex.

◆ extents

Vec3f clan::OrientedBoundingBox::extents

◆ g [1/6]

◆ g [2/6]

Type { ... } ::g

◆ g [3/6]

template<typename Type >
Type clan::Vec2< Type >::g

◆ g [4/6]

Type { ... } ::g

◆ g [5/6]

template<typename Type >
Type clan::Vec3< Type >::g

◆ g [6/6]

Type { ... } ::g

◆ group_index

int clan::RectPacker::AllocatedRect::group_index

◆ height

◆ i [1/2]

template<typename Type >
Type clan::Quaternionx< Type >::i

◆ i [2/2]

Type { ... } ::i

◆ j [1/2]

template<typename Type >
Type clan::Quaternionx< Type >::j

◆ j [2/2]

Type { ... } ::j

◆ k [1/2]

Type { ... } ::k

◆ k [2/2]

template<typename Type >
Type clan::Quaternionx< Type >::k

◆ left

◆ matrix [1/3]

◆ matrix [2/3]

◆ matrix [3/3]

◆ p [1/8]

template<typename Type >
Vec2<Type> clan::Trianglex< Type >::p

◆ p [2/8]

◆ p [3/8]

template<typename Type >
Vec3<Type> clan::LineRay3x< Type >::p

◆ p [4/8]

◆ p [5/8]

◆ p [6/8]

template<typename Type >
Vec2<Type> clan::LineRay2x< Type >::p

◆ p [7/8]

◆ p [8/8]

◆ position

◆ q [1/6]

◆ q [2/6]

◆ q [3/6]

◆ q [4/6]

◆ q [5/6]

◆ q [6/6]

◆ r [1/8]

◆ r [2/8]

◆ r [3/8]

template<typename Type >
Type clan::Vec2< Type >::r

◆ r [4/8]

Type { ... } ::r

◆ r [5/8]

Type { ... } ::r

◆ r [6/8]

template<typename Type >
Type clan::Vec3< Type >::r

◆ r [7/8]

Type { ... } ::r

◆ r [8/8]

◆ radius

◆ rect

Rect clan::RectPacker::AllocatedRect::rect

◆ right

◆ s [1/7]

template<typename Type >
Type clan::Vec4< Type >::s

◆ s [2/7]

Type { ... } ::s

◆ s [3/7]

template<typename Type >
Type clan::Vec2< Type >::s

◆ s [4/7]

Type { ... } ::s

◆ s [5/7]

template<typename Type >
Type clan::Vec3< Type >::s

◆ s [6/7]

Type { ... } ::s

◆ s [7/7]

◆ t [1/6]

Type { ... } ::t

◆ t [2/6]

template<typename Type >
Type clan::Vec4< Type >::t

◆ t [3/6]

Type { ... } ::t

◆ t [4/6]

template<typename Type >
Type clan::Vec2< Type >::t

◆ t [5/6]

Type { ... } ::t

◆ t [6/6]

template<typename Type >
Type clan::Vec3< Type >::t

◆ top

◆ u [1/4]

Type { ... } ::u

◆ u [2/4]

template<typename Type >
Type clan::Vec4< Type >::u

◆ u [3/4]

Type { ... } ::u

◆ u [4/4]

template<typename Type >
Type clan::Vec3< Type >::u

◆ v [1/4]

◆ v [2/4]

template<typename Type >
Type clan::Vec4< Type >::v

◆ v [3/4]

Type { ... } ::v

◆ v [4/4]

◆ vertex_A

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_A

First point in the triangle.

◆ vertex_B

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_B

Second point in the triangle.

◆ vertex_C

DelauneyTriangulator_Vertex* clan::DelauneyTriangulator_Triangle::vertex_C

Third point in the triangle.

◆ w [1/4]

◆ w [2/4]

◆ w [3/4]

Type { ... } ::w

◆ w [4/4]

HalfFloat clan::Vec4hf::w

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

◆ width

◆ x [1/12]

float clan::DelauneyTriangulator_Vertex::x

X position of vertex.

◆ x [2/12]

Type { ... } ::x

◆ x [3/12]

◆ x [4/12]

HalfFloat clan::Vec2hf::x

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

◆ x [5/12]

◆ x [6/12]

◆ x [7/12]

Type { ... } ::x

◆ x [8/12]

◆ x [9/12]

Type { ... } ::x

◆ x [10/12]

Type { ... } ::x

◆ x [11/12]

HalfFloat clan::Vec3hf::x

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

◆ x [12/12]

HalfFloat clan::Vec4hf::x

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

◆ x1

float clan::EarClipTriangulator_Triangle::x1

◆ x2

float clan::EarClipTriangulator_Triangle::x2

◆ x3

float clan::EarClipTriangulator_Triangle::x3

◆ y [1/12]

◆ y [2/12]

Type { ... } ::y

◆ y [3/12]

HalfFloat clan::Vec2hf::y

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

◆ y [4/12]

float clan::DelauneyTriangulator_Vertex::y

Y position of vertex.

◆ y [5/12]

◆ y [6/12]

Type { ... } ::y

◆ y [7/12]

◆ y [8/12]

Type { ... } ::y

◆ y [9/12]

◆ y [10/12]

Type { ... } ::y

◆ y [11/12]

HalfFloat clan::Vec3hf::y

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

◆ y [12/12]

HalfFloat clan::Vec4hf::y

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

◆ y1

float clan::EarClipTriangulator_Triangle::y1

◆ y2

float clan::EarClipTriangulator_Triangle::y2

◆ y3

float clan::EarClipTriangulator_Triangle::y3

◆ z [1/8]

◆ z [2/8]

Type { ... } ::z

◆ z [3/8]

◆ z [4/8]

◆ z [5/8]

Type { ... } ::z

◆ z [6/8]

Type { ... } ::z

◆ z [7/8]

HalfFloat clan::Vec3hf::z

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

◆ z [8/8]

HalfFloat clan::Vec4hf::z

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

Friends

◆ OutlineMath

friend class OutlineMath
friend