move::vectormath namespace

Namespaces

namespace wrappers

Classes

template<typename vector_type>

struct generic_bounds

struct gpumat4

A 4D vector that is guaranteed to be correctly laid out for GPU usage.

struct gpuvec2

A 2D vector that is guaranteed to be correctly laid out for GPU usage.

struct gpuvec3

A 3D vector that is guaranteed to be correctly laid out for GPU usage.

struct gpuvec4

A 4D vector that is guaranteed to be correctly laid out for GPU usage.

template<typename value_type, typename vector3_type_raw, typename vector4_type_raw, typename quat_type_raw, typename matrix3x4_type_raw, typename matrix4x4_type_raw>

struct generic_mat4_rtm

class generic_normal

class generic_point

template<typename value_type, typename quat_type_raw, typename underlying_matrix3x4_type_raw, typename underlying_matrix4x4_type_raw, typename vec3_type, typename mat4x4_type>

struct generic_quat

template<typename value_type>

struct generic_vec2_scalar

A two component vector that can store either floats or doubles. The underlying implementation is scalar.

template<typename value_type, typename vector_type_raw>

struct generic_vec3_rtm

A three component vector that can store either floats or doubles. The underlying implementation is RTM's vector4f or vector4d.

template<typename value_type>

struct generic_vec3_scalar

A three component vector that can store either floats or doubles. The underlying implementation is basic scalar math.

template<typename value_type, typename vector_type_raw>

struct generic_vec4_rtm

A four component vector that can store either floats or doubles. The underlying implementation is RTM's vector4f or vector4d.

template<typename T, size_t L>

struct json_serializer_template

Typedefs

using bounds2f32 = generic_bounds<vec2f32>

using bounds2f64 = generic_bounds<vec2f64>

using bounds2i8 = generic_bounds<vec2i8>

using bounds2i16 = generic_bounds<vec2i16>

using bounds2i32 = generic_bounds<vec2i32>

using bounds2i64 = generic_bounds<vec2i64>

using bounds2u8 = generic_bounds<vec2u8>

using bounds2u16 = generic_bounds<vec2u16>

using bounds2u32 = generic_bounds<vec2u32>

using bounds2u64 = generic_bounds<vec2u64>

using bounds2f = generic_bounds<vec2f>

using bounds2d = generic_bounds<vec2d>

using bounds2i = generic_bounds<vec2i>

using bounds2u = generic_bounds<vec2u>

using rectf = bounds2f

using rect2 = bounds2d

using bounds3f = generic_bounds<vec3f>

using bounds3d = generic_bounds<vec3d>

using aabbf = bounds3f

using aabbd = bounds3d

using bounds4f = generic_bounds<vec4f>

using bounds4d = generic_bounds<vec4d>

using bounds2 = bounds2f

using bounds3 = bounds3f

using bounds4 = bounds4f

using rect = bounds2

using aabb = bounds3

using mat4f = generic_mat4_rtm<float, wrappers::v4f, wrappers::v4f, wrappers::qf, wrappers::m3x4f, wrappers::m4x4f>

using mat4d = generic_mat4_rtm<double, wrappers::v4d, wrappers::v4d, wrappers::qd, wrappers::m3x4d, wrappers::m4x4d>

using mat4 = mat4f

using vector3_type = vec3f

using normalf = generic_normal

using normald = generic_normal

using normal = generic_normal

using pointf = generic_point

using pointd = generic_point

using point = pointf

using quatf = generic_quat<float, wrappers::qf, wrappers::m3x4f, wrappers::m4x4f, vec3f, mat4f>

using quatd = generic_quat<double, wrappers::qd, wrappers::m3x4d, wrappers::m4x4d, vec3d, mat4d>

using quat = quatf

using vec2f32 = generic_vec2_scalar<float>

using vec2f64 = generic_vec2_scalar<double>

using vec2i8 = generic_vec2_scalar<int8_t>

using vec2i16 = generic_vec2_scalar<int16_t>

using vec2i32 = generic_vec2_scalar<int32_t>

using vec2i64 = generic_vec2_scalar<int64_t>

using vec2u8 = generic_vec2_scalar<uint8_t>

using vec2u16 = generic_vec2_scalar<uint16_t>

using vec2u32 = generic_vec2_scalar<uint32_t>

using vec2u64 = generic_vec2_scalar<uint64_t>

using vec2f = vec2f32

using vec2d = vec2f64

using vec2i = vec2i32

using vec2u = vec2u32

using vec2 = vec2f

using vec3f32 = vec3f_rtm

using vec3f64 = vec3d_rtm

using vec3i8 = vec3i8_scalar

using vec3i16 = vec3i16_scalar

using vec3i32 = vec3i32_scalar

using vec3i64 = vec3i64_scalar

using vec3u8 = vec3u8_scalar

using vec3u16 = vec3u16_scalar

using vec3u32 = vec3u32_scalar

using vec3u64 = vec3u64_scalar

using vec3f = vec3f32

using vec3d = vec3f64

using vec3i = vec3i32

using vec3u = vec3u32

using vec3 = vec3f

using vec3f32_rtm = generic_vec3_rtm<float, wrappers::v4f>

using vec3f64_rtm = generic_vec3_rtm<double, wrappers::v4d>

using vec3f_rtm = vec3f32_rtm

using vec3d_rtm = vec3f64_rtm

using vec3f32_scalar = generic_vec3_scalar<float>

using vec3f64_scalar = generic_vec3_scalar<double>

using vec3i8_scalar = generic_vec3_scalar<int8_t>

using vec3i16_scalar = generic_vec3_scalar<int16_t>

using vec3i32_scalar = generic_vec3_scalar<int32_t>

using vec3i64_scalar = generic_vec3_scalar<int64_t>

using vec3u8_scalar = generic_vec3_scalar<uint8_t>

using vec3u16_scalar = generic_vec3_scalar<uint16_t>

using vec3u32_scalar = generic_vec3_scalar<uint32_t>

using vec3u64_scalar = generic_vec3_scalar<uint64_t>

using vec3f_scalar = vec3f32_scalar

using vec3d_scalar = vec3f64_scalar

using vec3i_scalar = vec3i32_scalar

using vec3u_scalar = vec3u32_scalar

using vec4f = generic_vec4_rtm<float, wrappers::v4f>

A vector with four 32 bit floating point components.

using vec4d = generic_vec4_rtm<double, wrappers::v4d>

A vector with four 64 bit floating point components.

using vec4 = vec4f

Functions

auto deg_to_rad(float deg) -> float

auto rad_to_deg(float rad) -> float

template<typename matrix_type>

static auto operator*(const typename matrix_type::vec4_type& v, const matrix_type& m) -> MVM_INLINE_NODISCARD matrix_type::vec4_type noexcept

template<typename matrix_type>

static auto operator*(const matrix_type& m, const typename matrix_type::vec4_type& v) -> MVM_INLINE_NODISCARD matrix_type::vec4_type noexcept

template<typename value_type, typename quat_type_raw, typename underlying_matrix3x4_type_raw, typename underlying_matrix4x4_type_raw, typename vec3_type, typename mat4x4_type>

auto operator<<(std::ostream& os, const move::vectormath::generic_quat<value_type, quat_type_raw, underlying_matrix3x4_type_raw, underlying_matrix4x4_type_raw, vec3_type, mat4x4_type>& v) -> std::ostream&

template<typename value_type>

auto operator<<(std::ostream& os, const move::vectormath::generic_vec2_scalar<value_type>& v) -> std::ostream&

template<typename value_type, typename vector_type>

auto operator<<(std::ostream& os, const move::vectormath::generic_vec3_rtm<value_type, vector_type>& v) -> std::ostream&

template<typename value_type>

auto operator*(value_type v, const generic_vec3_scalar<value_type>& vec) -> MVM_INLINE_NODISCARD generic_vec3_scalar<value_type> noexcept

template<typename value_type, typename vector_type>

auto operator<<(std::ostream& os, const move::vectormath::generic_vec4_rtm<value_type, vector_type>& v) -> std::ostream&

Typedef documentation

Function documentation