DubiousEngine  0.2.0
Simple Game Engine
Namespaces | Classes | Typedefs | Functions
Dubious::Math Namespace Reference

Namespaces

 Matrix_index
 

Classes

class  Coordinate_space
 Representation of a position and rotation. More...
 
class  PointT
 A 3D Point. More...
 
class  QuaternionT
 Quaternion. More...
 
struct  Triple
 Three floats. More...
 
class  Unit_quaternionT
 Unit Quaternions are used to represent rotation. More...
 
class  Unit_vectorT
 A 3D Unit Vector. More...
 
class  VectorT
 A 3D Vector. More...
 

Typedefs

typedef PointT< 0 > Point
 
typedef PointT< 1 > Local_point
 
typedef QuaternionT< 0 > Quaternion
 
typedef QuaternionT< 1 > Local_quaternion
 
typedef Unit_quaternionT< 0 > Unit_quaternion
 
typedef Unit_quaternionT< 1 > Local_unit_quaternion
 
typedef Unit_vectorT< 0 > Unit_vector
 
typedef Unit_vectorT< 1 > Local_unit_vector
 
typedef VectorT< 0 > Vector
 
typedef VectorT< 1 > Local_vector
 

Functions

bool operator== (const Coordinate_space &a, const Coordinate_space &b)
 
bool operator!= (const Coordinate_space &a, const Coordinate_space &b)
 
std::ostream & operator<< (std::ostream &o, const Coordinate_space &c)
 
template<int T>
bool operator== (const PointT< T > &a, const PointT< T > &b)
 
template<int T>
bool operator!= (const PointT< T > &a, const PointT< T > &b)
 
template<int T>
std::ostream & operator<< (std::ostream &o, const PointT< T > &a)
 
template<int T>
VectorT< T > operator- (const PointT< T > &a, const PointT< T > &b)
 
template<int T>
PointT< T > operator+ (const PointT< T > &a, const VectorT< T > &b)
 
template<int T>
PointT< T > operator- (const PointT< T > &a, const VectorT< T > &b)
 
template<int T>
PointT< T > operator+ (const PointT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
PointT< T > operator- (const PointT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
bool operator== (const QuaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
bool operator!= (const QuaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator+ (const QuaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator- (const QuaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const QuaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const VectorT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const QuaternionT< T > &a, const VectorT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const QuaternionT< T > &a, float b)
 
template<int T>
QuaternionT< T > operator* (float a, const QuaternionT< T > &b)
 
template<int T>
std::ostream & operator<< (std::ostream &o, const QuaternionT< T > &q)
 
template<int T>
float dot_product (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
Unit_quaternionT< T > slerp (Unit_quaternionT< T > a, const Unit_quaternionT< T > &b, float t)
 
bool operator== (const Triple &a, const Triple &b)
 
bool operator!= (const Triple &a, const Triple &b)
 
Triple operator+ (const Triple &a, const Triple &b)
 
Triple operator- (const Triple &a, const Triple &b)
 
std::ostream & operator<< (std::ostream &o, const Triple &a)
 
template<int T>
Unit_quaternionT< T > operator* (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
bool operator== (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
bool operator!= (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator+ (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator+ (const QuaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator+ (const Unit_quaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator- (const Unit_quaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator- (const QuaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator- (const Unit_quaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const Unit_quaternionT< T > &a, const QuaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const QuaternionT< T > &a, const Unit_quaternionT< T > &b)
 
template<int T>
QuaternionT< T > operator* (const Unit_quaternionT< T > &a, float b)
 
template<int T>
QuaternionT< T > operator* (float a, const Unit_quaternionT< T > &b)
 
template<int T>
std::ostream & operator<< (std::ostream &o, const Unit_quaternionT< T > &q)
 
template<int T>
bool operator== (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
bool operator!= (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
VectorT< T > operator* (const Unit_vectorT< T > &a, float b)
 
template<int T>
VectorT< T > operator* (float a, const Unit_vectorT< T > &b)
 
template<int T>
VectorT< T > operator+ (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
VectorT< T > operator- (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
bool equals (float a, float b)
 Tests equality of two floating point numbers. More...
 
float to_radians (float degrees)
 converts degrees to radians More...
 
float to_degrees (float radians)
 converts radians to degrees More...
 
template<int T>
bool operator== (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
bool operator!= (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
VectorT< T > operator+ (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
VectorT< T > operator- (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
VectorT< T > operator* (const VectorT< T > &a, float b)
 
template<int T>
VectorT< T > operator* (float a, const VectorT< T > &b)
 
template<int T>
VectorT< T > operator/ (const VectorT< T > &a, float b)
 
template<int T>
std::ostream & operator<< (std::ostream &o, const VectorT< T > &a)
 
template<int T>
VectorT< T > cross_product (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
VectorT< T > cross_product (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
float dot_product (const VectorT< T > &a, const VectorT< T > &b)
 
template<int T>
float dot_product (const Unit_vectorT< T > &a, const Unit_vectorT< T > &b)
 
template<int T>
VectorT< T > to_vector (const PointT< T > &p)
 
template<int T>
PointT< T > to_point (const VectorT< T > &v)
 

Typedef Documentation

typedef PointT<1> Dubious::Math::Local_point
typedef QuaternionT<1> Dubious::Math::Local_quaternion
typedef Unit_quaternionT<1> Dubious::Math::Local_unit_quaternion
typedef Unit_vectorT<1> Dubious::Math::Local_unit_vector
typedef VectorT<1> Dubious::Math::Local_vector
typedef PointT<0> Dubious::Math::Point
typedef QuaternionT<0> Dubious::Math::Quaternion
typedef Unit_quaternionT<0> Dubious::Math::Unit_quaternion
typedef Unit_vectorT<0> Dubious::Math::Unit_vector
typedef VectorT<0> Dubious::Math::Vector

Function Documentation

template<int T>
VectorT<T> Dubious::Math::cross_product ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
VectorT<T> Dubious::Math::cross_product ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
float Dubious::Math::dot_product ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
float Dubious::Math::dot_product ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
float Dubious::Math::dot_product ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
bool Dubious::Math::equals ( float  a,
float  b 
)

Tests equality of two floating point numbers.

Returns true if they are "close enough" to being equals. Basically does an == that takes rounding into account.

Parameters
a- [in] The first number
b- [in] The second number
Returns
True if the numbers are "close enough" to being equal
template<int T>
bool Dubious::Math::operator!= ( const PointT< T > &  a,
const PointT< T > &  b 
)
template<int T>
bool Dubious::Math::operator!= ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
bool Dubious::Math::operator!= ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
bool Dubious::Math::operator!= ( const QuaternionT< T > &  a,
const QuaternionT< T > &  b 
)
bool Dubious::Math::operator!= ( const Triple &  a,
const Triple &  b 
)
inline
bool Dubious::Math::operator!= ( const Coordinate_space &  a,
const Coordinate_space &  b 
)
template<int T>
bool Dubious::Math::operator!= ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator* ( const Unit_vectorT< T > &  a,
float  b 
)
template<int T>
VectorT< T > Dubious::Math::operator* ( float  a,
const Unit_vectorT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator* ( const VectorT< T > &  a,
float  b 
)
template<int T>
VectorT< T > Dubious::Math::operator* ( float  a,
const VectorT< T > &  b 
)
template<int T>
Unit_quaternionT< T > Dubious::Math::operator* ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const QuaternionT< T > &  a,
const QuaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const VectorT< T > &  a,
const QuaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const QuaternionT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const QuaternionT< T > &  a,
float  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( float  a,
const QuaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const Unit_quaternionT< T > &  a,
const QuaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const QuaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( const Unit_quaternionT< T > &  a,
float  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator* ( float  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator+ ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator+ ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator+ ( const QuaternionT< T > &  a,
const QuaternionT< T > &  b 
)
Triple Dubious::Math::operator+ ( const Triple &  a,
const Triple &  b 
)
inline
template<int T>
PointT<T> Dubious::Math::operator+ ( const PointT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
PointT<T> Dubious::Math::operator+ ( const PointT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator+ ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator+ ( const QuaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator+ ( const Unit_quaternionT< T > &  a,
const QuaternionT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator- ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator- ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
VectorT<T> Dubious::Math::operator- ( const PointT< T > &  a,
const PointT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator- ( const QuaternionT< T > &  a,
const QuaternionT< T > &  b 
)
Triple Dubious::Math::operator- ( const Triple &  a,
const Triple &  b 
)
inline
template<int T>
PointT<T> Dubious::Math::operator- ( const PointT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
PointT<T> Dubious::Math::operator- ( const PointT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator- ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator- ( const QuaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
QuaternionT<T> Dubious::Math::operator- ( const Unit_quaternionT< T > &  a,
const QuaternionT< T > &  b 
)
template<int T>
VectorT< T > Dubious::Math::operator/ ( const VectorT< T > &  a,
float  b 
)
template<int T>
std::ostream & Dubious::Math::operator<< ( std::ostream &  o,
const PointT< T > &  a 
)
template<int T>
std::ostream & Dubious::Math::operator<< ( std::ostream &  o,
const VectorT< T > &  a 
)
std::ostream& Dubious::Math::operator<< ( std::ostream &  o,
const Triple &  a 
)
inline
template<int T>
std::ostream& Dubious::Math::operator<< ( std::ostream &  o,
const QuaternionT< T > &  q 
)
std::ostream & Dubious::Math::operator<< ( std::ostream &  o,
const Coordinate_space &  c 
)
template<int T>
std::ostream& Dubious::Math::operator<< ( std::ostream &  o,
const Unit_quaternionT< T > &  q 
)
template<int T>
bool Dubious::Math::operator== ( const Unit_vectorT< T > &  a,
const Unit_vectorT< T > &  b 
)
template<int T>
bool Dubious::Math::operator== ( const VectorT< T > &  a,
const VectorT< T > &  b 
)
template<int T>
bool Dubious::Math::operator== ( const PointT< T > &  a,
const PointT< T > &  b 
)
template<int T>
bool Dubious::Math::operator== ( const QuaternionT< T > &  a,
const QuaternionT< T > &  b 
)
bool Dubious::Math::operator== ( const Triple &  a,
const Triple &  b 
)
inline
bool Dubious::Math::operator== ( const Coordinate_space &  a,
const Coordinate_space &  b 
)
template<int T>
bool Dubious::Math::operator== ( const Unit_quaternionT< T > &  a,
const Unit_quaternionT< T > &  b 
)
template<int T>
Unit_quaternionT<T> Dubious::Math::slerp ( Unit_quaternionT< T >  a,
const Unit_quaternionT< T > &  b,
float  t 
)
float Dubious::Math::to_degrees ( float  radians)

converts radians to degrees

Parameters
radians- [in] Angle in Radians
Returns
Angle in Degrees
template<int T>
PointT<T> Dubious::Math::to_point ( const VectorT< T > &  v)
float Dubious::Math::to_radians ( float  degrees)

converts degrees to radians

Parameters
degrees- [in] Angle in Degrees
Returns
Angle in Radians
template<int T>
VectorT<T> Dubious::Math::to_vector ( const PointT< T > &  p)