Nexus Engine  v0.0.1
Loading...
Searching...
No Matches
Nexus Namespace Referenceexport

Namespaces

namespace  Config
namespace  ECS
namespace  Network

Classes

class  Application
struct  EnableFlagOperators
struct  LogEntry
class  Logger
class  Mat
struct  ModuleRange
class  Quaternion
class  RingBuffer
class  Vec
class  Window

Concepts

concept  NoneOf
concept  Numeric
concept  FlagsEnum

Typedefs

using RowMajor = std::layout_right
using ColumnMajor = std::layout_left
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
using MatCommon = Mat<std::common_type_t<T, U>, RowCount, ColCount, Layout>
template<Numeric T, usize RowCount, usize ColCount>
using MatRowMajor = Mat<T, RowCount, ColCount, RowMajor>
template<Numeric T, usize RowCount, usize ColCount>
using MatColumnMajor = Mat<T, RowCount, ColCount, ColumnMajor>
template<Numeric T, usize N>
using SquareMatrix = Mat<T, N, N>
template<Numeric T, usize N>
using SquareMatrixRowMajor = Mat<T, N, N, RowMajor>
template<Numeric T, usize N>
using SquareMatrixColumnMajor = Mat<T, N, N, ColumnMajor>
template<Numeric T>
using Mat2 = Mat<T, 2, 2>
template<Numeric T>
using Mat2ColumnMajor = Mat<T, 2, 2, ColumnMajor>
template<Numeric T>
using Mat3 = Mat<T, 3, 3>
template<Numeric T>
using Mat3ColumnMajor = Mat<T, 3, 3, ColumnMajor>
template<Numeric T>
using Mat4 = Mat<T, 4, 4>
template<Numeric T>
using Mat4ColumnMajor = Mat<T, 4, 4, ColumnMajor>
using Mat2f = Mat2<float32>
using Mat3f = Mat3<float32>
using Mat4f = Mat4<float32>
using Mat2fColumnMajor = Mat2ColumnMajor<float32>
using Mat3fColumnMajor = Mat3ColumnMajor<float32>
using Mat4fColumnMajor = Mat4ColumnMajor<float32>
using Mat2d = Mat2<float64>
using Mat3d = Mat3<float64>
using Mat4d = Mat4<float64>
using Mat2dColumnMajor = Mat2ColumnMajor<float64>
using Mat3dColumnMajor = Mat3ColumnMajor<float64>
using Mat4dColumnMajor = Mat4ColumnMajor<float64>
using Mat2i = Mat2<int>
using Mat3i = Mat3<int>
using Mat4i = Mat4<int>
using Mat2iColumnMajor = Mat2ColumnMajor<int>
using Mat3iColumnMajor = Mat3ColumnMajor<int>
using Mat4iColumnMajor = Mat4ColumnMajor<int>
using Mat2u = Mat2<unsigned int>
using Mat3u = Mat3<unsigned int>
using Mat4u = Mat4<unsigned int>
using Mat2uColumnMajor = Mat2ColumnMajor<unsigned int>
using Mat3uColumnMajor = Mat3ColumnMajor<unsigned int>
using Mat4uColumnMajor = Mat4ColumnMajor<unsigned int>
template<std::floating_point T, std::floating_point U>
using QuaternionCommon = Quaternion<std::common_type_t<T, U>>
using Quaternionf = Quaternion<float32>
using Quaterniond = Quaternion<float64>
template<Numeric T, Numeric U, usize N>
using VecCommon = Vec<std::common_type_t<T, U>, N>
template<Numeric T>
using Vec2 = Vec<T, 2>
template<Numeric T>
using Vec3 = Vec<T, 3>
template<Numeric T>
using Vec4 = Vec<T, 4>
using Vec2f = Vec2<float32>
using Vec3f = Vec3<float32>
using Vec4f = Vec4<float32>
using Vec2d = Vec2<float64>
using Vec3d = Vec3<float64>
using Vec4d = Vec4<float64>
using Vec2i = Vec2<int>
using Vec3i = Vec3<int>
using Vec4i = Vec4<int>
using Vec2u = Vec2<unsigned int>
using Vec3u = Vec3<unsigned int>
using Vec4u = Vec4<unsigned int>
using uint8 = std::uint8_t
using uint16 = std::uint16_t
using uint32 = std::uint32_t
using uint64 = std::uint64_t
using int8 = std::int8_t
using int16 = std::int16_t
using int32 = std::int32_t
using int64 = std::int64_t
using float32 = float
using float64 = double
using usize = std::size_t
using isize = std::ptrdiff_t
using uptr = std::uintptr_t
using iptr = std::intptr_t
using byte = std::byte

Enumerations

enum class  LogLevel {
  Trace , Debug , Info , Warn ,
  Error , Fatal
}

Functions

bool EnableAnsiColors ()
std::string ANSI (int code, bool bold)
std::string ANSI_RGB (int r, int g, int b, bool bold)
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
constexpr auto operator+ (const Mat< T, RowCount, ColCount, Layout > &a, const Mat< U, RowCount, ColCount, Layout > &b) -> MatCommon< T, U, RowCount, ColCount, Layout >
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
constexpr auto operator- (const Mat< T, RowCount, ColCount, Layout > &a, const Mat< U, RowCount, ColCount, Layout > &b) -> MatCommon< T, U, RowCount, ColCount, Layout >
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
constexpr auto operator* (const Mat< T, RowCount, ColCount, Layout > &mat, U scalar) -> MatCommon< T, U, RowCount, ColCount, Layout >
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
constexpr auto operator* (U scalar, const Mat< T, RowCount, ColCount, Layout > &mat) -> MatCommon< T, U, RowCount, ColCount, Layout >
template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
constexpr auto operator/ (const Mat< T, RowCount, ColCount, Layout > &mat, U scalar) -> MatCommon< T, U, RowCount, ColCount, Layout >
template<Numeric T, Numeric U, usize A, usize B, usize C, typename Layout>
constexpr auto operator* (const Mat< T, A, B, Layout > &lhs, const Mat< U, B, C, Layout > &rhs) -> MatCommon< T, U, A, C, Layout >
template<Numeric T, usize RowCount, usize ColCount, typename FromLayout, typename ToLayout>
constexpr Mat< T, RowCount, ColCount, ToLayout > MatCastLayout (const Mat< T, RowCount, ColCount, FromLayout > &mat)
template<std::floating_point T, std::floating_point U>
constexpr auto operator+ (const Quaternion< T > &a, const Quaternion< U > &b) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator- (const Quaternion< T > &a, const Quaternion< U > &b) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator* (const Quaternion< T > &a, const Quaternion< U > &b) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator* (const Quaternion< T > &q, U scalar) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator* (U scalar, const Quaternion< T > &q) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator/ (const Quaternion< T > &q, U scalar) -> QuaternionCommon< T, U >
template<std::floating_point T, std::floating_point U>
constexpr auto operator* (const Quaternion< T > &q, const Vec3< U > &v) -> Vec3< std::common_type_t< T, U > >
template<std::floating_point T>
constexpr T Dot (const Quaternion< T > &a, const Quaternion< T > &b)
template<std::floating_point T>
constexpr Quaternion< T > Lerp (const Quaternion< T > &a, const Quaternion< T > &b, T t)
template<std::floating_point T>
constexpr Quaternion< T > Slerp (const Quaternion< T > &a, const Quaternion< T > &b, T t)
template<Numeric T, Numeric U, usize N>
constexpr auto operator+ (const Vec< T, N > &a, const Vec< U, N > &b) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator- (const Vec< T, N > &a, const Vec< U, N > &b) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator* (const Vec< T, N > &a, const Vec< U, N > &b) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator/ (const Vec< T, N > &a, const Vec< U, N > &b) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator* (const Vec< T, N > &v, U scalar) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator* (U scalar, const Vec< T, N > &v) -> VecCommon< T, U, N >
template<Numeric T, Numeric U, usize N>
constexpr auto operator/ (const Vec< T, N > &v, U scalar) -> VecCommon< T, U, N >
template<FlagsEnum T>
constexpr T operator| (T a, T b)
template<FlagsEnum T>
constexpr T operator& (T a, T b)
template<FlagsEnum T>
constexpr T operator^ (T a, T b)
template<FlagsEnum T>
constexpr T operator~ (T a)
template<FlagsEnum T>
constexpr T & operator|= (T &a, T b)
template<FlagsEnum T>
constexpr T & operator&= (T &a, T b)
template<FlagsEnum T>
constexpr T & operator^= (T &a, T b)
template<FlagsEnum T>
constexpr bool HasFlag (T value, T flag)
template<typename T>
consteval auto TypeName ()
std::string ResolveModuleForAddress (uintptr_t addr, const std::vector< ModuleRange > &modules)
std::filesystem::path GetExecutablePath ()
std::string GetExecutableName ()
std::vector< ModuleRange > GetLoadedModules ()

Typedef Documentation

◆ byte

using Nexus::byte = std::byte
export

◆ ColumnMajor

using Nexus::ColumnMajor = std::layout_left
export

◆ float32

using Nexus::float32 = float
export

◆ float64

using Nexus::float64 = double
export

◆ int16

using Nexus::int16 = std::int16_t
export

◆ int32

using Nexus::int32 = std::int32_t
export

◆ int64

using Nexus::int64 = std::int64_t
export

◆ int8

using Nexus::int8 = std::int8_t
export

◆ iptr

using Nexus::iptr = std::intptr_t
export

◆ isize

using Nexus::isize = std::ptrdiff_t
export

◆ Mat2

template<Numeric T>
using Nexus::Mat2 = Mat<T, 2, 2>
export

◆ Mat2ColumnMajor

template<Numeric T>
using Nexus::Mat2ColumnMajor = Mat<T, 2, 2, ColumnMajor>
export

◆ Mat2d

using Nexus::Mat2d = Mat2<float64>
export

◆ Mat2dColumnMajor

using Nexus::Mat2dColumnMajor = Mat2ColumnMajor<float64>
export

◆ Mat2f

using Nexus::Mat2f = Mat2<float32>
export

◆ Mat2fColumnMajor

using Nexus::Mat2fColumnMajor = Mat2ColumnMajor<float32>
export

◆ Mat2i

using Nexus::Mat2i = Mat2<int>
export

◆ Mat2iColumnMajor

using Nexus::Mat2iColumnMajor = Mat2ColumnMajor<int>
export

◆ Mat2u

using Nexus::Mat2u = Mat2<unsigned int>
export

◆ Mat2uColumnMajor

using Nexus::Mat2uColumnMajor = Mat2ColumnMajor<unsigned int>
export

◆ Mat3

template<Numeric T>
using Nexus::Mat3 = Mat<T, 3, 3>
export

◆ Mat3ColumnMajor

template<Numeric T>
using Nexus::Mat3ColumnMajor = Mat<T, 3, 3, ColumnMajor>
export

◆ Mat3d

using Nexus::Mat3d = Mat3<float64>
export

◆ Mat3dColumnMajor

using Nexus::Mat3dColumnMajor = Mat3ColumnMajor<float64>
export

◆ Mat3f

using Nexus::Mat3f = Mat3<float32>
export

◆ Mat3fColumnMajor

using Nexus::Mat3fColumnMajor = Mat3ColumnMajor<float32>
export

◆ Mat3i

using Nexus::Mat3i = Mat3<int>
export

◆ Mat3iColumnMajor

using Nexus::Mat3iColumnMajor = Mat3ColumnMajor<int>
export

◆ Mat3u

using Nexus::Mat3u = Mat3<unsigned int>
export

◆ Mat3uColumnMajor

using Nexus::Mat3uColumnMajor = Mat3ColumnMajor<unsigned int>
export

◆ Mat4

template<Numeric T>
using Nexus::Mat4 = Mat<T, 4, 4>
export

◆ Mat4ColumnMajor

template<Numeric T>
using Nexus::Mat4ColumnMajor = Mat<T, 4, 4, ColumnMajor>
export

◆ Mat4d

using Nexus::Mat4d = Mat4<float64>
export

◆ Mat4dColumnMajor

using Nexus::Mat4dColumnMajor = Mat4ColumnMajor<float64>
export

◆ Mat4f

using Nexus::Mat4f = Mat4<float32>
export

◆ Mat4fColumnMajor

using Nexus::Mat4fColumnMajor = Mat4ColumnMajor<float32>
export

◆ Mat4i

using Nexus::Mat4i = Mat4<int>
export

◆ Mat4iColumnMajor

using Nexus::Mat4iColumnMajor = Mat4ColumnMajor<int>
export

◆ Mat4u

using Nexus::Mat4u = Mat4<unsigned int>
export

◆ Mat4uColumnMajor

using Nexus::Mat4uColumnMajor = Mat4ColumnMajor<unsigned int>
export

◆ MatColumnMajor

template<Numeric T, usize RowCount, usize ColCount>
using Nexus::MatColumnMajor = Mat<T, RowCount, ColCount, ColumnMajor>
export

◆ MatCommon

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
using Nexus::MatCommon = Mat<std::common_type_t<T, U>, RowCount, ColCount, Layout>
export

◆ MatRowMajor

template<Numeric T, usize RowCount, usize ColCount>
using Nexus::MatRowMajor = Mat<T, RowCount, ColCount, RowMajor>
export

◆ QuaternionCommon

template<std::floating_point T, std::floating_point U>
using Nexus::QuaternionCommon = Quaternion<std::common_type_t<T, U>>
export

◆ Quaterniond

using Nexus::Quaterniond = Quaternion<float64>
export

◆ Quaternionf

using Nexus::Quaternionf = Quaternion<float32>
export

◆ RowMajor

using Nexus::RowMajor = std::layout_right
export

◆ SquareMatrix

template<Numeric T, usize N>
using Nexus::SquareMatrix = Mat<T, N, N>
export

◆ SquareMatrixColumnMajor

template<Numeric T, usize N>
using Nexus::SquareMatrixColumnMajor = Mat<T, N, N, ColumnMajor>
export

◆ SquareMatrixRowMajor

template<Numeric T, usize N>
using Nexus::SquareMatrixRowMajor = Mat<T, N, N, RowMajor>
export

◆ uint16

using Nexus::uint16 = std::uint16_t
export

◆ uint32

using Nexus::uint32 = std::uint32_t
export

◆ uint64

using Nexus::uint64 = std::uint64_t
export

◆ uint8

using Nexus::uint8 = std::uint8_t
export

◆ uptr

using Nexus::uptr = std::uintptr_t
export

◆ usize

using Nexus::usize = std::size_t
export

◆ Vec2

template<Numeric T>
using Nexus::Vec2 = Vec<T, 2>
export

◆ Vec2d

using Nexus::Vec2d = Vec2<float64>
export

◆ Vec2f

using Nexus::Vec2f = Vec2<float32>
export

◆ Vec2i

using Nexus::Vec2i = Vec2<int>
export

◆ Vec2u

using Nexus::Vec2u = Vec2<unsigned int>
export

◆ Vec3

template<Numeric T>
using Nexus::Vec3 = Vec<T, 3>
export

◆ Vec3d

using Nexus::Vec3d = Vec3<float64>
export

◆ Vec3f

using Nexus::Vec3f = Vec3<float32>
export

◆ Vec3i

using Nexus::Vec3i = Vec3<int>
export

◆ Vec3u

using Nexus::Vec3u = Vec3<unsigned int>
export

◆ Vec4

template<Numeric T>
using Nexus::Vec4 = Vec<T, 4>
export

◆ Vec4d

using Nexus::Vec4d = Vec4<float64>
export

◆ Vec4f

using Nexus::Vec4f = Vec4<float32>
export

◆ Vec4i

using Nexus::Vec4i = Vec4<int>
export

◆ Vec4u

using Nexus::Vec4u = Vec4<unsigned int>
export

◆ VecCommon

template<Numeric T, Numeric U, usize N>
using Nexus::VecCommon = Vec<std::common_type_t<T, U>, N>
export

Enumeration Type Documentation

◆ LogLevel

enum class Nexus::LogLevel
exportstrong
Enumerator
Trace 
Debug 
Info 
Warn 
Error 
Fatal 

Function Documentation

◆ ANSI()

std::string Nexus::ANSI ( int code,
bool bold )

◆ ANSI_RGB()

std::string Nexus::ANSI_RGB ( int r,
int g,
int b,
bool bold )

◆ Dot()

template<std::floating_point T>
T Nexus::Dot ( const Quaternion< T > & a,
const Quaternion< T > & b )
constexprexport

◆ EnableAnsiColors()

bool Nexus::EnableAnsiColors ( )

◆ GetExecutableName()

std::string Nexus::GetExecutableName ( )

◆ GetExecutablePath()

std::filesystem::path Nexus::GetExecutablePath ( )

◆ GetLoadedModules()

std::vector< ModuleRange > Nexus::GetLoadedModules ( )

◆ HasFlag()

template<FlagsEnum T>
bool Nexus::HasFlag ( T value,
T flag )
constexprexport

◆ Lerp()

template<std::floating_point T>
Quaternion< T > Nexus::Lerp ( const Quaternion< T > & a,
const Quaternion< T > & b,
T t )
constexprexport

◆ MatCastLayout()

template<Numeric T, usize RowCount, usize ColCount, typename FromLayout, typename ToLayout>
Mat< T, RowCount, ColCount, ToLayout > Nexus::MatCastLayout ( const Mat< T, RowCount, ColCount, FromLayout > & mat)
constexprexport

◆ operator&()

template<FlagsEnum T>
T Nexus::operator& ( T a,
T b )
constexprexport

◆ operator&=()

template<FlagsEnum T>
T & Nexus::operator&= ( T & a,
T b )
constexprexport

◆ operator*() [1/10]

template<Numeric T, Numeric U, usize A, usize B, usize C, typename Layout>
auto Nexus::operator* ( const Mat< T, A, B, Layout > & lhs,
const Mat< U, B, C, Layout > & rhs ) -> MatCommon< T, U, A, C, Layout >
constexprexport

◆ operator*() [2/10]

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
auto Nexus::operator* ( const Mat< T, RowCount, ColCount, Layout > & mat,
U scalar ) -> MatCommon< T, U, RowCount, ColCount, Layout >
constexprexport

◆ operator*() [3/10]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator* ( const Quaternion< T > & a,
const Quaternion< U > & b ) -> QuaternionCommon< T, U >
constexprexport

◆ operator*() [4/10]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator* ( const Quaternion< T > & q,
const Vec3< U > & v ) -> Vec3< std::common_type_t< T, U > >
constexprexport

◆ operator*() [5/10]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator* ( const Quaternion< T > & q,
U scalar ) -> QuaternionCommon< T, U >
constexprexport

◆ operator*() [6/10]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator* ( const Vec< T, N > & a,
const Vec< U, N > & b ) -> VecCommon< T, U, N >
constexprexport

◆ operator*() [7/10]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator* ( const Vec< T, N > & v,
U scalar ) -> VecCommon< T, U, N >
constexprexport

◆ operator*() [8/10]

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
auto Nexus::operator* ( U scalar,
const Mat< T, RowCount, ColCount, Layout > & mat ) -> MatCommon< T, U, RowCount, ColCount, Layout >
constexprexport

◆ operator*() [9/10]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator* ( U scalar,
const Quaternion< T > & q ) -> QuaternionCommon< T, U >
constexprexport

◆ operator*() [10/10]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator* ( U scalar,
const Vec< T, N > & v ) -> VecCommon< T, U, N >
constexprexport

◆ operator+() [1/3]

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
auto Nexus::operator+ ( const Mat< T, RowCount, ColCount, Layout > & a,
const Mat< U, RowCount, ColCount, Layout > & b ) -> MatCommon< T, U, RowCount, ColCount, Layout >
constexprexport

◆ operator+() [2/3]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator+ ( const Quaternion< T > & a,
const Quaternion< U > & b ) -> QuaternionCommon< T, U >
constexprexport

◆ operator+() [3/3]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator+ ( const Vec< T, N > & a,
const Vec< U, N > & b ) -> VecCommon< T, U, N >
constexprexport

◆ operator-() [1/3]

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
auto Nexus::operator- ( const Mat< T, RowCount, ColCount, Layout > & a,
const Mat< U, RowCount, ColCount, Layout > & b ) -> MatCommon< T, U, RowCount, ColCount, Layout >
constexprexport

◆ operator-() [2/3]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator- ( const Quaternion< T > & a,
const Quaternion< U > & b ) -> QuaternionCommon< T, U >
constexprexport

◆ operator-() [3/3]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator- ( const Vec< T, N > & a,
const Vec< U, N > & b ) -> VecCommon< T, U, N >
constexprexport

◆ operator/() [1/4]

template<Numeric T, Numeric U, usize RowCount, usize ColCount, typename Layout>
auto Nexus::operator/ ( const Mat< T, RowCount, ColCount, Layout > & mat,
U scalar ) -> MatCommon< T, U, RowCount, ColCount, Layout >
constexprexport

◆ operator/() [2/4]

template<std::floating_point T, std::floating_point U>
auto Nexus::operator/ ( const Quaternion< T > & q,
U scalar ) -> QuaternionCommon< T, U >
constexprexport

◆ operator/() [3/4]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator/ ( const Vec< T, N > & a,
const Vec< U, N > & b ) -> VecCommon< T, U, N >
constexprexport

◆ operator/() [4/4]

template<Numeric T, Numeric U, usize N>
auto Nexus::operator/ ( const Vec< T, N > & v,
U scalar ) -> VecCommon< T, U, N >
constexprexport

◆ operator^()

template<FlagsEnum T>
T Nexus::operator^ ( T a,
T b )
constexprexport

◆ operator^=()

template<FlagsEnum T>
T & Nexus::operator^= ( T & a,
T b )
constexprexport

◆ operator|()

template<FlagsEnum T>
T Nexus::operator| ( T a,
T b )
constexprexport

◆ operator|=()

template<FlagsEnum T>
T & Nexus::operator|= ( T & a,
T b )
constexprexport

◆ operator~()

template<FlagsEnum T>
T Nexus::operator~ ( T a)
constexprexport

◆ ResolveModuleForAddress()

std::string Nexus::ResolveModuleForAddress ( uintptr_t addr,
const std::vector< ModuleRange > & modules )

◆ Slerp()

template<std::floating_point T>
Quaternion< T > Nexus::Slerp ( const Quaternion< T > & a,
const Quaternion< T > & b,
T t )
constexprexport

◆ TypeName()

template<typename T>
auto Nexus::TypeName ( )
constevalexport