P-E-R-R-Y
Utilitaires, contrats et vendors du moteur, en une seule doc
Loading...
Searching...
No Matches

The vocabulary types everything else shares. More...

Collaboration diagram for system:

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 >
struct  Matrix< T, ROWS, COLS, typename, type >
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
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.

system

The vocabulary types everything else shares.

Header-only, no dependency. Whatever two libraries need to agree on before they can talk to each other.

Macro Definition Documentation

◆ OS

#define OS   "linux"

Typedef Documentation

◆ lambdify_t

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

◆ Linef

using Linef = Line<double>

◆ Linei

using Linei = Line<std::int32_t>

◆ Lineu

using Lineu = Line<std::uint32_t>

◆ Matrix3x3

using Matrix3x3 = Matrix<double, 3, 3>

◆ Matrix4x4

using Matrix4x4 = Matrix<double, 4, 4>

◆ Quaternionf

using Quaternionf = Quaternion<double>

◆ Rectf

using Rectf = Rect<double>

◆ Recti

using Recti = Rect<std::int32_t>

◆ Rectu

using Rectu = Rect<std::uint32_t>

◆ Trianglef

using Trianglef = Triangle<double>

◆ Trianglei

using Trianglei = Triangle<std::int32_t>

◆ Triangleu

using Triangleu = Triangle<std::uint32_t>

◆ Vector2f

using Vector2f = Vector2<double>

◆ Vector2i

using Vector2i = Vector2<std::int32_t>

◆ Vector2u

using Vector2u = Vector2<std::uint32_t>

◆ Vector3f

using Vector3f = Vector3<double>

◆ Vector3i

using Vector3i = Vector3<std::int32_t>

◆ Vector3u

using Vector3u = Vector3<std::uint32_t>

◆ Vector4f

using Vector4f = Vector4<double>

◆ Vector4i

using Vector4i = Vector4<std::int32_t>

◆ Vector4u

using Vector4u = Vector4<std::uint32_t>

Variable Documentation

◆ epsilon_v

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

◆ epsilond

double epsilond = epsilon_v<double>
constexpr

◆ epsilonf

double epsilonf = epsilon_v<float>
constexpr

◆ epsilonl

long double epsilonl = epsilon_v<long double>
constexpr