system
The vocabulary types everything else shares
Loading...
Searching...
No Matches
system

The vocabulary types everything else shares. More...

Files

file  Lambdify.hpp
 A simple utility to wrap stateless functions into callable objects.
 

Classes

class  Clock
 Une horloge par proprietaire. Rien ne l'impose a personne. More...
 
struct  Color
 
struct  Epsilon< T >
 
struct  Epsilon< float >
 
struct  Epsilon< double >
 
struct  Epsilon< long double >
 
struct  lambdify< Func >
 
class  Quaternion< T >
 Une rotation dans l'espace, parametree par son scalaire. More...
 
struct  Rect< T >
 
struct  Line< T >
 
struct  Triangle< T >
 
struct  Vector2< T >
 
struct  Vector3< T >
 
struct  Vector4< T >
 

Macros

#define OS   "linux"
 

Typedefs

template<auto Func>
using lambdify_t = typename lambdify< Func >::type
 
template<typename T , std::size_t ROWS, std::size_t COLS, typename = typename std::enable_if<ROWS >= 1 && COLS>
using Matrix3x3 = Matrix< double, 3, 3 >
 
using Matrix4x4 = Matrix< double, 4, 4 >
 
using Quaternionf = Quaternion< double >
 
using Rectu = Rect< std::uint32_t >
 
using Recti = Rect< std::int32_t >
 
using Rectf = Rect< double >
 
using Lineu = Line< std::uint32_t >
 
using Linei = Line< std::int32_t >
 
using Linef = Line< double >
 
using Triangleu = Triangle< std::uint32_t >
 
using Trianglei = Triangle< std::int32_t >
 
using Trianglef = Triangle< double >
 
using Vector2u = Vector2< std::uint32_t >
 
using Vector2i = Vector2< std::int32_t >
 
using Vector2f = Vector2< double >
 
using Vector3u = Vector3< std::uint32_t >
 
using Vector3i = Vector3< std::int32_t >
 
using Vector3f = Vector3< double >
 
using Vector4u = Vector4< std::uint32_t >
 
using Vector4i = Vector4< std::int32_t >
 
using Vector4f = Vector4< double >
 

Variables

template<typename T = float>
constexpr T epsilon_v = Epsilon<T>::value
 
constexpr double epsilonf = epsilon_v<float>
 
constexpr double epsilond = epsilon_v<double>
 
constexpr long double epsilonl = epsilon_v<long double>
 

Detailed Description

The vocabulary types everything else shares.

Vector2/3/4, Matrix, Quaternion, Color, Shape, plus the platform constants. No dependency, nothing to link.

Macro Definition Documentation

◆ OS

#define OS   "linux"

Typedef Documentation

◆ lambdify_t

template<auto Func>
using lambdify_t = typename lambdify<Func>::type

◆ Linef

◆ Linei

◆ Lineu

◆ Matrix3x3

template<typename T , std::size_t ROWS, std::size_t COLS, typename = typename std::enable_if<ROWS >= 1 && COLS>
using Matrix3x3 = Matrix<double, 3, 3>

◆ Matrix4x4

◆ Quaternionf

◆ Rectf

◆ Recti

◆ Rectu

◆ Trianglef

◆ Trianglei

◆ Triangleu

◆ Vector2f

◆ Vector2i

◆ Vector2u

◆ Vector3f

◆ Vector3i

◆ Vector3u

◆ Vector4f

◆ Vector4i

◆ Vector4u

Variable Documentation

◆ epsilon_v

template<typename T = float>
constexpr T epsilon_v = Epsilon<T>::value
constexpr

◆ epsilond

constexpr double epsilond = epsilon_v<double>
constexpr

◆ epsilonf

constexpr double epsilonf = epsilon_v<float>
constexpr

◆ epsilonl

constexpr long double epsilonl = epsilon_v<long double>
constexpr