RigLogicLib

bool av::operator!= ( const ArrayView< T >& lhs,
const ArrayView< U >& rhs
)

std::enable_ifArrayView< T >, TContainer >::value, bool >::type av::operator!= ( const ArrayView< T >& lhs,
const TContainer& rhs
)

std::enable_ifArrayView< T >, TContainer >::value, bool >::type av::operator!= ( const TContainer& lhs,
const ArrayView< T >& rhs
)

bool av::operator== ( const ArrayView< T >& lhs,
const ArrayView< U >& rhs
)

std::enable_ifArrayView< T >, TContainer >::value, bool >::type av::operator== ( const ArrayView< T >& lhs,
const TContainer& rhs
)

std::enable_ifArrayView< T >, TContainer >::value, bool >::type av::operator== ( const TContainer& lhs,
const ArrayView< T >& rhs
)

std::uint8_t bswap ( std::uint8_t x
)

std::uint16_t bswap ( std::uint16_t x
)

std::uint32_t bswap ( std::uint32_t x
)

std::uint64_t bswap ( std::uint64_t x
)

void bswap ( std::uint8_t* x
)

void bswap ( std::uint16_t* x
)

void bswap ( std::uint32_t* x
)

void bswap ( std::uint64_t* x
)

Vector3 dna::operator- ( Vector3 lhs,
const Vector3& rhs
)

Vector3 dna::operator- ( Vector3 lhs,
float rhs
)

bool dna::operator!= ( const Vector3& lhs,
const Vector3& rhs
)

Vector3 dna::operator* ( Vector3 lhs,
const Vector3& rhs
)

Vector3 dna::operator* ( Vector3 lhs,
float rhs
)

Vector3 dna::operator/ ( Vector3 lhs,
const Vector3& rhs
)

Vector3 dna::operator/ ( Vector3 lhs,
float rhs
)

DataLayer dna::operator| ( DataLayer lhs,
DataLayer rhs
)

Vector3 dna::operator+ ( Vector3 lhs,
const Vector3& rhs
)

Vector3 dna::operator+ ( Vector3 lhs,
float rhs
)

bool dna::operator== ( const Vector3& lhs,
const Vector3& rhs
)

std::uint8_t hton ( std::uint8_t x
)

std::uint16_t hton ( std::uint16_t x
)

std::uint32_t hton ( std::uint32_t x
)

std::uint64_t hton ( std::uint64_t x
)

void hton ( std::uint8_t* x
)

void hton ( std::uint16_t* x
)

void hton ( std::uint32_t* x
)

void hton ( std::uint64_t* x
)

std::uint8_t ntoh ( std::uint8_t x
)

std::uint16_t ntoh ( std::uint16_t x
)

std::uint32_t ntoh ( std::uint32_t x
)

std::uint64_t ntoh ( std::uint64_t x
)

void ntoh ( std::uint8_t* x
)

void ntoh ( std::uint16_t* x
)

void ntoh ( std::uint32_t* x
)

void ntoh ( std::uint64_t* x
)

ScopedPtr< Base, TDestroyer > pma::makeScoped ( Args&&... args
)

ScopedPtr< T, TDestroyerTemplate< T > > pma::makeScoped ( Args&&... args
)

ScopedPtr< T, typename DefaultInstanceDestroyer< T >::type > pma::makeScoped ( Args&&... args
)

bool pma::operator!= ( const PolyAllocator< T, TAlignment, TDefaultMemoryResource >& lhs,
const PolyAllocator< U, UAlignment, UDefaultMemoryResource >& rhs
)

bool pma::operator== ( const PolyAllocator< T, TAlignment, TDefaultMemoryResource >& lhs,
const PolyAllocator< U, UAlignment, UDefaultMemoryResource >& rhs
)

bool sc::operator!= ( const StatusCode& lhs,
const StatusCode& rhs
)

bool sc::operator== ( const StatusCode& lhs,
const StatusCode& rhs
)

mat< L, L, T > tdm::affine::scale ( const vec< L, T >& factors
)

mat< L, L, T > tdm::affine::scale ( T factor
)

mat< L, L, T > tdm::affine::scale ( const mat< L, L, T >& m,
const vec< L, T >& factors
)

mat< L, L, T > tdm::affine::scale ( const mat< L, L, T >& m,
T factor
)

fdeg tdm::ang_literals::operator""_fdeg ( long double angle
)

frad tdm::ang_literals::operator""_frad ( long double angle
)

mat< R, C, T > tdm::applied ( const mat< R, C, T >& lhs,
F func
)

vec< L, T > tdm::applied ( const vec< L, T >& lhs,
F func
)

quat< T > tdm::conjugate ( const quat< T >& q
)

vec3< T > tdm::cross ( const vec3< T >& lhs,
const vec3< T >& rhs
)

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::degrees ( T radians
)

T tdm::determinant ( const mat< N, N, T >& m
)

T tdm::dot ( const vec< L, T >& lhs,
const vec< L, T >& rhs
)

T tdm::dot ( const quat< T >& q1,
const quat< T >& q2
)

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::fastasin ( T value
)

mat< N, N, T > tdm::impl::adjoint ( const mat< N, N, T >& m
)

T tdm::impl::determinant ( const mat< N, N, T >& m,
dim_t dimensions
)

quat< T > tdm::impl::euler2quat ( const rad3< T >& rot,
rot_seq order
)

void tdm::impl::minor ( const mat< N, N, T >& input,
dim_t dimensions,
dim_t i,
dim_t j,
mat< N, N, T >& output
)

rad3< T > tdm::impl::quat2euler ( const quat< T >& q,
rot_seq order
)

quat< T > tdm::inverse ( const quat< T >& q
)

mat< N, N, T > tdm::inverse ( const mat< N, N, T >& m
)

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::length ( const vec< L, T >& v
)

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::length ( const quat< T >& q
)

quat< T > tdm::lerp ( const quat< T >& q1,
const quat< T >& q2,
T t
)

bool tdm::lu::decompose ( mat< N, N, T >& a,
vec< N, dim_t >& permute
)

mat< N, N, T > tdm::lu::inverse ( mat< N, N, T > m
)

void tdm::lu::substitute ( const mat< N, N, T >& a,
const vec< N, dim_t >& permute,
vec< N, T >& b
)

vec< L, T > tdm::negate ( vec< L, T > v
)

mat< R, C, T > tdm::negate ( mat< R, C, T > m
)

quat< T > tdm::negate ( quat< T > q
)

std::enable_if< std::is_floating_point< T >::value, vec< L, T > >::type tdm::normalize ( vec< L, T > v
)

std::enable_if< std::is_floating_point< T >::value, quat< T > >::type tdm::normalize ( quat< T > q
)

mat< R, C, T > tdm::operator- ( const mat< R, C, T >& m
)

vec< L, T > tdm::operator- ( vec< L, T > v
)

ang< T, TUnit > tdm::operator- ( const ang< T, TUnit >& lhs,
const ang< T, TUnit >& rhs
)

mat< R, C, T > tdm::operator- ( const mat< R, C, T >& lhs,
T rhs
)

mat< R, C, T > tdm::operator- ( T lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T > tdm::operator- ( const mat< R, C, T >& lhs,
const mat< R, C, T >& rhs
)

quat< T > tdm::operator- ( const quat< T >& lhs,
const quat< T >& rhs
)

vec< L, T > tdm::operator- ( const vec< L, T >& lhs,
const vec< L, U >& rhs
)

vec< L, T > tdm::operator- ( const vec< L, T >& lhs,
U rhs
)

vec< L, T > tdm::operator- ( T lhs,
const vec< L, U >& rhs
)

bool tdm::operator!= ( const ang< T, TUnit >& lhs,
const ang< T, TUnit >& rhs
)

bool tdm::operator!= ( const mat< R, C, T >& lhs,
const mat< R, C, T >& rhs
)

bool tdm::operator!= ( const quat< T >& lhs,
const quat< T >& rhs
)

bool tdm::operator!= ( const vec< L, T >& lhs,
const vec< L, T >& rhs
)

ang< T, TUnit > tdm::operator* ( const ang< T, TUnit >& lhs,
T rhs
)

ang< T, TUnit > tdm::operator* ( T lhs,
const ang< T, TUnit >& rhs
)

mat< R, C, T > tdm::operator* ( const mat< R, C, T >& lhs,
T rhs
)

mat< R, C, T > tdm::operator* ( T lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T >::row_type tdm::operator* ( const typename mat< R, C, T >::column_type& lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T >::column_type tdm::operator* ( const mat< R, C, T >& lhs,
const typename mat< R, C, T >::row_type& rhs
)

mat< R, C, T > tdm::operator* ( const mat< R, S, T >& lhs,
const mat< S, C, T >& rhs
)

quat< T > tdm::operator* ( const quat< T >& lhs,
const quat< T >& rhs
)

quat< T > tdm::operator* ( const quat< T >& lhs,
T rhs
)

quat< T > tdm::operator* ( T lhs,
const quat< T >& rhs
)

vec< L, T > tdm::operator* ( const vec< L, T >& lhs,
const vec< L, U >& rhs
)

std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type tdm::operator* ( const vec< L, T >& lhs,
U rhs
)

std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type tdm::operator* ( T lhs,
const vec< L, U >& rhs
)

ang< T, TUnit > tdm::operator/ ( const ang< T, TUnit >& lhs,
T rhs
)

mat< R, C, T > tdm::operator/ ( const mat< R, C, T >& lhs,
T rhs
)

mat< R, C, T > tdm::operator/ ( T lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T >::row_type tdm::operator/ ( const typename mat< R, C, T >::column_type& lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T >::column_type tdm::operator/ ( const mat< R, C, T >& lhs,
const typename mat< R, C, T >::row_type& rhs
)

mat< R, C, T > tdm::operator/ ( const mat< R, C, T >& lhs,
const mat< R, C, T >& rhs
)

quat< T > tdm::operator/ ( const quat< T >& lhs,
T rhs
)

quat< T > tdm::operator/ ( T lhs,
const quat< T >& rhs
)

vec< L, T > tdm::operator/ ( const vec< L, T >& lhs,
const vec< L, U >& rhs
)

std::enable_if< std::is_arithmetic< U >::value, vec< L, T > >::type tdm::operator/ ( const vec< L, T >& lhs,
U rhs
)

std::enable_if< std::is_arithmetic< T >::value, vec< L, T > >::type tdm::operator/ ( T lhs,
const vec< L, U >& rhs
)

mat< R, C, T > tdm::operator+ ( const mat< R, C, T >& m
)

vec< L, T > tdm::operator+ ( const vec< L, T >& v
)

ang< T, TUnit > tdm::operator+ ( const ang< T, TUnit >& lhs,
const ang< T, TUnit >& rhs
)

mat< R, C, T > tdm::operator+ ( const mat< R, C, T >& lhs,
T rhs
)

mat< R, C, T > tdm::operator+ ( T lhs,
const mat< R, C, T >& rhs
)

mat< R, C, T > tdm::operator+ ( const mat< R, C, T >& lhs,
const mat< R, C, T >& rhs
)

quat< T > tdm::operator+ ( const quat< T >& lhs,
const quat< T >& rhs
)

vec< L, T > tdm::operator+ ( const vec< L, T >& lhs,
const vec< L, U >& rhs
)

vec< L, T > tdm::operator+ ( const vec< L, T >& lhs,
U rhs
)

vec< L, T > tdm::operator+ ( T lhs,
const vec< L, U >& rhs
)

bool tdm::operator== ( const ang< T, TUnit >& lhs,
const ang< T, TUnit >& rhs
)

bool tdm::operator== ( const mat< R, C, T >& lhs,
const mat< R, C, T >& rhs
)

bool tdm::operator== ( const quat< T >& lhs,
const quat< T >& rhs
)

bool tdm::operator== ( const vec< L, T >& lhs,
const vec< L, T >& rhs
)

double tdm::pi()

mat4< T > tdm::projective::rotate ( const rad3< T >& rotation,
handedness h
)

mat4< T > tdm::projective::rotate ( const vec3< T >& axis,
rad< T > angle,
handedness h
)

mat4< T > tdm::projective::rotate ( const mat4< T >& m,
const rad3< T >& rotation,
handedness h
)

mat4< T > tdm::projective::rotate ( const mat4< T >& m,
const vec3< T >& axis,
rad< T > angle,
handedness h
)

mat4< T > tdm::projective::rotate ( rad< T > x,
rad< T > y,
rad< T > z,
handedness h
)

mat4< T > tdm::projective::rotate ( const mat4< T >& m,
rad< T > x,
rad< T > y,
rad< T > z,
handedness h
)

mat< L+1, L+1, T > tdm::projective::scale ( const vec< L, T >& factors
)

mat< L+1, L+1, T > tdm::projective::scale ( T factor
)

mat< L+1, L+1, T > tdm::projective::scale ( const mat< L+1, L+1, T >& m,
const vec< L, T >& factors
)

mat< L, L, T > tdm::projective::scale ( const mat< L, L, T >& m,
T factor
)

mat< L+1, L+1, T > tdm::projective::translate ( const vec< L, T >& position
)

mat< L+1, L+1, T > tdm::projective::translate ( const mat< L+1, L+1, T >& m,
const vec< L, T >& position
)

std::enable_if< std::is_floating_point< T >::value, T >::type tdm::radians ( T degrees
)

mat4< T > tdm::rotate ( const rad3< T >& rotation,
handedness h
)

mat4< T > tdm::rotate ( const vec3< T >& axis,
rad< T > angle,
handedness h
)

mat4< T > tdm::rotate ( const mat4< T >& m,
const rad3< T >& rotation,
handedness h
)

mat4< T > tdm::rotate ( const mat4< T >& m,
const vec3< T >& axis,
rad< T > angle,
handedness h
)

mat4< T > tdm::rotate ( rad< T > x,
rad< T > y,
rad< T > z,
handedness h
)

mat4< T > tdm::rotate ( const mat4< T >& m,
rad< T > x,
rad< T > y,
rad< T > z,
handedness h
)

mat< L+1, L+1, T > tdm::scale ( const vec< L, T >& factors
)

mat< L+1, L+1, T > tdm::scale ( T factor
)

mat< L+1, L+1, T > tdm::scale ( const mat< L+1, L+1, T >& m,
const vec< L, T >& factors
)

mat< L, L, T > tdm::scale ( const mat< L, L, T >& m,
T factor
)

quat< T > tdm::slerp ( const quat< T >& q1,
const quat< T >& q2,
T t
)

T tdm::trace ( const mat< N, N, T >& m
)

mat< L+1, L+1, T > tdm::translate ( const vec< L, T >& position
)

mat< L+1, L+1, T > tdm::translate ( const mat< L+1, L+1, T >& m,
const vec< L, T >& position
)

mat< C, R, T > tdm::transpose ( const mat< R, C, T >& m
)

std::size_t terse::base64decode ( std::size_t size
)

std::size_t terse::base64decode ( char* destination,
const char* source,
std::size_t size
)

std::size_t terse::base64encode ( std::size_t size
)

std::size_t terse::base64encode ( char* destination,
const char* source,
std::size_t size
)

void terse::hostToNetwork ( T& value
)

void terse::hostToNetwork128 ( T* values
)

void terse::networkToHost ( T& value
)

void terse::networkToHost128 ( T* values
)

ArchiveOffset< TOffset >::Proxy terse::proxy ( ArchiveOffset< TOffset >& offset
)

ArchiveSize< TSize, TOffset >::Proxy terse::proxy ( ArchiveSize< TSize, TOffset >& size,
Anchor< TOffset >& base
)

Transparent< T > terse::transparent ( T& data
)

Versioned< T, V > terse::versioned ( T& dest,
V
)

trimd::attribute ( (always_inline)
)

T256< T128 > trimd::fallback::abs ( const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::andnot ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator- ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator!= ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator& ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator* ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator/ ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator^ ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator| ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator~ ( const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator+ ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator== ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator> ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::operator>= ( const T256< T128 >& lhs,
const T256< T128 >& rhs
)

T256< T128 > trimd::fallback::rsqrt ( const T256< T128 >& rhs
)

void trimd::fallback::transpose ( T256< T128 >& row0,
T256< T128 >& row1,
T256< T128 >& row2,
T256< T128 >& row3,
T256< T128 >& row4,
T256< T128 >& row5,
T256< T128 >& row6,
T256< T128 >& row7
)

CPUFeatures trimd::getCPUFeatures()

T128< T > trimd::scalar::abs ( const T128< T >& rhs
)

T128< T > trimd::scalar::andnot ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator- ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator!= ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator& ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator* ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator/ ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator^ ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator| ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator~ ( const T128< T >& rhs
)

T128< T > trimd::scalar::operator+ ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator== ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator> ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::operator>= ( const T128< T >& lhs,
const T128< T >& rhs
)

T128< T > trimd::scalar::rsqrt ( const T128< T >& rhs
)

void trimd::scalar::transpose ( T128< T >& row0,
T128< T >& row1,
T128< T >& row2,
T128< T >& row3
)

static std::uint16_t bswap16 ( std::uint16_t x
)

static void bswap16x8 ( std::uint16_t* source
)

static std::uint32_t bswap32 ( std::uint32_t x
)

static void bswap32x4 ( std::uint32_t* source
)

static std::uint64_t bswap64 ( std::uint64_t x
)

static void bswap64x2 ( std::uint64_t* source
)

static true_sink< decltype(load(std::declval< T & >(), std::declval< T & >()))> terse::traits::test_load_function ( std::int32_t
)

static std::false_type terse::traits::test_load_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().load(std::declval< T & >()))> terse::traits::test_load_member ( std::int32_t
)

static std::false_type terse::traits::test_load_member ( std::uint32_t
)

static true_sink< decltype(std::declval< TContainer >().push_back(std::declval< typename TContainer::value_type >()))> terse::traits::test_push_back_member ( std::int32_t
)

static std::false_type terse::traits::test_push_back_member ( std::uint32_t
)

static true_sink< decltype(std::declval< TContainer >().reserve(0u))> terse::traits::test_reserve_member ( std::int32_t
)

static std::false_type terse::traits::test_reserve_member ( std::uint32_t
)

static true_sink< decltype(save(std::declval< T & >(), std::declval< T & >()))> terse::traits::test_save_function ( std::int32_t
)

static std::false_type terse::traits::test_save_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().save(std::declval< T & >()))> terse::traits::test_save_member ( std::int32_t
)

static std::false_type terse::traits::test_save_member ( std::uint32_t
)

static true_sink< decltype(serialize(std::declval< T & >(), std::declval< T & >()))> terse::traits::test_serialize_function ( std::int32_t
)

static std::false_type terse::traits::test_serialize_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().serialize(std::declval< T & >()))> terse::traits::test_serialize_member ( std::int32_t
)

static std::false_type terse::traits::test_serialize_member ( std::uint32_t
)

static true_sink< decltype(load(std::declval< T & >(), V{}, std::declval< T & >())) > terse::traits::test_versioned_load_function ( std::int32_t
)

static std::false_type terse::traits::test_versioned_load_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().load(std::declval< T & >(), V{})) > terse::traits::test_versioned_load_member ( std::int32_t
)

static std::false_type terse::traits::test_versioned_load_member ( std::uint32_t
)

static true_sink< decltype(save(std::declval< T & >(), V{}, std::declval< T & >())) > terse::traits::test_versioned_save_function ( std::int32_t
)

static std::false_type terse::traits::test_versioned_save_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().save(std::declval< T & >(), V{})) > terse::traits::test_versioned_save_member ( std::int32_t
)

static std::false_type terse::traits::test_versioned_save_member ( std::uint32_t
)

static true_sink< decltype(serialize(std::declval< T & >(), V{}, std::declval< T & >())) > terse::traits::test_versioned_serialize_function ( std::int32_t
)

static std::false_type terse::traits::test_versioned_serialize_function ( std::uint32_t
)

static true_sink< decltype(std::declval< T >().serialize(std::declval< T & >(), V{})) > terse::traits::test_versioned_serialize_member ( std::int32_t
)

static std::false_type terse::traits::test_versioned_serialize_member ( std::uint32_t
)