shz::vecN< CRTP, C, R > Struct Template Reference

#include <shz_vector.hpp>

Inheritance diagram for shz::vecN< CRTP, C, R >:

Collaboration diagram for shz::vecN< CRTP, C, R >:

Public Types
using	CppType
using	CType

Public Member Functions
	vecN () noexcept=default
	vecN (const vecN &other) noexcept=default
	vecN (const CType &other) noexcept
	vecN (const volatile CType &other) noexcept
template<typename T>
T	to () const noexcept
CppType &	deref (const auto *raw) noexcept
volatile CppType &	operator= (volatile CType other) volatile noexcept
CppType &	operator+= (CppType other) noexcept
CppType &	operator-= (CppType other) noexcept
CppType &	operator*= (CppType other) noexcept
CppType &	operator/= (CppType other) noexcept
CppType &	operator*= (float other) noexcept
CppType &	operator/= (float other) noexcept
template<unsigned... Indices>
CppType	swizzle () const noexcept
CppType	abs () const noexcept
CppType	neg () const noexcept
CppType	inv () const noexcept
float	max () const noexcept
float	min () const noexcept
CppType	clamp (float min, float max) const noexcept
CppType	floor () const noexcept
CppType	ceil () const noexcept
CppType	round () const noexcept
CppType	fract () const noexcept
CppType	sign () const noexcept
CppType	saturate () const noexcept
CppType	minv (CppType other) const noexcept
CppType	maxv (CppType other) const noexcept
float	dot (CppType other) const noexcept
vec2	dot (CppType v1, CppType v2) const noexcept
vec3	dot (CppType v1, CppType v2, CppType v3) const noexcept
float	magnitude () const noexcept
float	magnitude_sqr () const noexcept
float	magnitude_inv () const noexcept
CppType	direction () const noexcept
void	normalize () noexcept
CppType	direction_safe () const noexcept
void	normalize_safe () noexcept
float	distance (const CppType &other) const noexcept
float	distance_sqr (const CppType &other) const noexcept
CppType	move (CppType target, float maxdist) const noexcept
CppType	reflect (CppType normal) const noexcept
CppType	refract (CppType normal, float eta) const noexcept
CppType	project (CppType onto) const noexcept
CppType	project_safe (CppType onto) const noexcept
float	angle_between (CppType other) const noexcept
auto	angles () const noexcept

Static Public Member Functions
static CppType	from (const auto &raw) noexcept
static CppType	lerp (CppType start, CppType end, float t) noexcept
template<typename T>
static CppType	step (CppType vec, T edge) noexcept
template<typename T>
static CppType	smoothstep (CppType vec, T edge0, T edge1) noexcept
template<typename T>
static CppType	smoothstep_safe (CppType vec, T edge0, T edge1) noexcept

Static Public Attributes
static constexpr size_t	Rows
static constexpr size_t	Cols

Friends
bool	operator== (CppType lhs, CppType rhs) noexcept
CppType	operator- (CppType vec) noexcept

Detailed Description

template<typename CRTP, typename C, size_t R>
struct shz::vecN< CRTP, C, R >

Common C++ base structure inherited by all vector types.

This struct template serves as the base class for all concrete vector types, providing:

• Common API routines
• Adaptor between C and C++ types
• Convenience overloaded operators and STL iterators.

See also

shz::vec2, shz::vec3, shz::vec4

Definition at line 43 of file shz_vector.hpp.

Member Typedef Documentation

CppType

template<typename CRTP, typename C, size_t R>

using shz::vecN< CRTP, C, R >::CppType

Cpp derived type.

Definition at line 44 of file shz_vector.hpp.

CType

template<typename CRTP, typename C, size_t R>

using shz::vecN< CRTP, C, R >::CType

C base type.

Definition at line 45 of file shz_vector.hpp.

Constructor & Destructor Documentation

vecN() [1/4]

template<typename CRTP, typename C, size_t R>

shz::vecN< CRTP, C, R >::vecN ( )

defaultnoexcept

Default constructor, does nothing.

vecN() [2/4]

template<typename CRTP, typename C, size_t R>

shz::vecN< CRTP, C, R >::vecN ( const vecN< CRTP, C, R > & other )

defaultnoexcept

Default copy constructor.

vecN() [3/4]

template<typename CRTP, typename C, size_t R>

shz::vecN< CRTP, C, R >::vecN ( const CType & other )

inlinenoexcept

Converting constructor from existing C instance.

Definition at line 57 of file shz_vector.hpp.

                                                      :
        CType(other) {}

vecN() [4/4]

template<typename CRTP, typename C, size_t R>

shz::vecN< CRTP, C, R >::vecN ( const volatile CType & other )

inlinenoexcept

Converting constructor from existing volatile C instance.

Definition at line 61 of file shz_vector.hpp.

                                                               :
        CType(const_cast<const CType&>(other)) {}

Member Function Documentation

from()

template<typename CRTP, typename C, size_t R>

static CppType shz::vecN< CRTP, C, R >::from ( const auto & raw )

inlinestaticnoexcept

Conversion operator for going from a layout-compatible vector type to a SH4ZAM vector type.

Definition at line 65 of file shz_vector.hpp.

                                                                   {
        return *reinterpret_cast<const CppType*>(&raw);
    }

to()

template<typename CRTP, typename C, size_t R>

template<typename T>

T shz::vecN< CRTP, C, R >::to ( ) const

inlinenoexcept

Conversion operator for going from a SH4ZAM vector type to another layout-compatible type.

Definition at line 71 of file shz_vector.hpp.

                                           {
        return *reinterpret_cast<const T*>(this);
    }

deref()

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::deref ( const auto * raw )

inlinenoexcept

Conversion operator for accessing an existing pointer type as though it were a refrence to a SH4ZAM type.

Definition at line 76 of file shz_vector.hpp.

                                                              {
        return *const_cast<CppType*>(reinterpret_cast<const CppType*>(raw));
    }

lerp()

template<typename CRTP, typename C, size_t R>

static CppType shz::vecN< CRTP, C, R >::lerp ( CppType start, CppType end, float t )

inlinestaticnoexcept

Returns the vector that is linearly interpolated between the two given vectors by the 0.0f-1.0f factor, t.

Definition at line 81 of file shz_vector.hpp.

                                                                                       {
        return shz_vec_lerp(start, end, t);
    }

step()

template<typename CRTP, typename C, size_t R>

template<typename T>

static CppType shz::vecN< CRTP, C, R >::step ( CppType vec, T edge )

inlinestaticnoexcept

Compares each component of the vector to the edge. 0 returned in that component if x[i] < edge. Otherwise the component is 1.

Definition at line 87 of file shz_vector.hpp.

                                                                       {
        return shz_vec_step(vec, edge);
    }

smoothstep()

template<typename CRTP, typename C, size_t R>

template<typename T>

static CppType shz::vecN< CRTP, C, R >::smoothstep ( CppType vec, T edge0, T edge1 )

inlinestaticnoexcept

Returns a vector where each component is smoothly interpolated from 0 to 1 between edge0 and edge1.

Definition at line 93 of file shz_vector.hpp.

                                                                                       {
        return shz_vec_smoothstep(vec, edge0, edge1);
    }

smoothstep_safe()

template<typename CRTP, typename C, size_t R>

template<typename T>

static CppType shz::vecN< CRTP, C, R >::smoothstep_safe ( CppType vec, T edge0, T edge1 )

inlinestaticnoexcept

Returns a vector where each component is smoothly interpolated from 0 to 1 between edge0 and edge1.

Definition at line 99 of file shz_vector.hpp.

                                                                                            {
        return shz_vec_smoothstep_safe(vec, edge0, edge1);
    }

operator=()

template<typename CRTP, typename C, size_t R>

volatile CppType & shz::vecN< CRTP, C, R >::operator= ( volatile CType other ) volatile

inlinenoexcept

Overloaded operator for assigning to volatile reference to base C type.

Definition at line 141 of file shz_vector.hpp.

                                                                        {
        *static_cast<CppType*>(const_cast<vecN*>(this)) = CppType(const_cast<CType&>(other));
        return *static_cast<volatile CppType*>(this);
    }

operator+=()

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator+= ( CppType other )

inlinenoexcept

Overloaded operator for adding and accumulating a vector onto another.

Definition at line 147 of file shz_vector.hpp.

                                                                 {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) + other;
        return *static_cast<CppType*>(this);
    }

operator-=()

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator-= ( CppType other )

inlinenoexcept

Overloaded subtraction assignment operator, subtracts a vector from the left-hand vector.

Definition at line 153 of file shz_vector.hpp.

                                                                 {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) - other;
        return *static_cast<CppType*>(this);
    }

operator*=() [1/2]

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator*= ( CppType other )

inlinenoexcept

Overloaded multiplication assignment operator, multiplies and accumulates a vector onto the left-hand vector.

Definition at line 159 of file shz_vector.hpp.

                                                                 {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) * other;
        return *static_cast<CppType*>(this);
    }

operator/=() [1/2]

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator/= ( CppType other )

inlinenoexcept

Overloaded division assignment operator, divides the left vector by the right, assigning the left to the result.

Definition at line 165 of file shz_vector.hpp.

                                                                 {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) / other;
        return *static_cast<CppType*>(this);
    }

operator*=() [2/2]

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator*= ( float other )

inlinenoexcept

Overloaded multiplication assignment operator, multiplies and accumulates each vector component by the given scalar.

Definition at line 171 of file shz_vector.hpp.

                                                               {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) * other;
        return *static_cast<CppType*>(this);
    }

operator/=() [2/2]

template<typename CRTP, typename C, size_t R>

CppType & shz::vecN< CRTP, C, R >::operator/= ( float other )

inlinenoexcept

Overloaded division assignment operator, dividing and assigning each vector component by the given scalar value.

Definition at line 177 of file shz_vector.hpp.

                                                               {
        *static_cast<CppType*>(this) = *static_cast<CppType*>(this) / other;
        return *static_cast<CppType*>(this);
    }

swizzle()

template<typename CRTP, typename C, size_t R>

template<unsigned... Indices>

CppType shz::vecN< CRTP, C, R >::swizzle ( ) const

inlinenoexcept

Swizzle oeprator which takes a compile-time list of indices as non-type template arguments for the index each element should use as its new value.

Definition at line 184 of file shz_vector.hpp.

                                                      {
        return shz_vec_swizzle(*static_cast<const CppType*>(this), Indices...);
    }

abs()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::abs ( ) const

inlinenoexcept

Returns a new vector whose components are the absolute value of the given vector.

Definition at line 189 of file shz_vector.hpp.

                                                  {
        return shz_vec_abs(*static_cast<const CppType*>(this));
    }

neg()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::neg ( ) const

inlinenoexcept

Returns a new vector whose components are the negative values of the given vector.

Definition at line 194 of file shz_vector.hpp.

                                                  {
        return shz_vec_neg(*static_cast<const CppType*>(this));
    }

inv()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::inv ( ) const

inlinenoexcept

Returns a new vector whose components are the reciprocal values of the given vector.

Definition at line 199 of file shz_vector.hpp.

                                                  {
        return shz_vec_inv(*static_cast<const CppType*>(this));
    }

max()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::max ( ) const

inlinenoexcept

Returns the maximum value of every element within the vector.

Definition at line 204 of file shz_vector.hpp.

                                                {
        return shz_vec_max(*static_cast<const CppType*>(this));
    }

min()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::min ( ) const

inlinenoexcept

Returns the minimum value of every element within the vector.

Definition at line 209 of file shz_vector.hpp.

                                                {
        return shz_vec_min(*static_cast<const CppType*>(this));
    }

clamp()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::clamp ( float min, float max ) const

inlinenoexcept

Returns a new vector whose values are the clamped components of the given vector.

Definition at line 214 of file shz_vector.hpp.

                                                                        {
        return shz_vec_clamp(*static_cast<const CppType*>(this), min, max);
    }

floor()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::floor ( ) const

inlinenoexcept

Returns a new vector with the component-wise floor of the given vector.

Definition at line 219 of file shz_vector.hpp.

                                                    {
        return shz_vec_floor(*static_cast<const CppType*>(this));
    }

ceil()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::ceil ( ) const

inlinenoexcept

Returns a new vector with the component-wise ceil of the given vector.

Definition at line 224 of file shz_vector.hpp.

                                                   {
        return shz_vec_ceil(*static_cast<const CppType*>(this));
    }

round()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::round ( ) const

inlinenoexcept

Returns a new vector with the component-wise rounding of the given vector.

Definition at line 229 of file shz_vector.hpp.

                                                    {
        return shz_vec_round(*static_cast<const CppType*>(this));
    }

fract()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::fract ( ) const

inlinenoexcept

Returns a new vector with the fractional part of each component.

Definition at line 234 of file shz_vector.hpp.

                                                    {
        return shz_vec_fract(*static_cast<const CppType*>(this));
    }

sign()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::sign ( ) const

inlinenoexcept

Returns a new vector with the sign of each component (-1, 0, or 1).

Definition at line 239 of file shz_vector.hpp.

                                                   {
        return shz_vec_sign(*static_cast<const CppType*>(this));
    }

saturate()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::saturate ( ) const

inlinenoexcept

Returns a new vector with each component clamped to [0, 1].

Definition at line 244 of file shz_vector.hpp.

                                                       {
        return shz_vec_saturate(*static_cast<const CppType*>(this));
    }

minv()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::minv ( CppType other ) const

inlinenoexcept

Returns a new vector with the component-wise minimum of two vectors.

Definition at line 249 of file shz_vector.hpp.

                                                                {
        return shz_vec_minv(*static_cast<const CppType*>(this), other);
    }

maxv()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::maxv ( CppType other ) const

inlinenoexcept

Returns a new vector with the component-wise maximum of two vectors.

Definition at line 254 of file shz_vector.hpp.

                                                                {
        return shz_vec_maxv(*static_cast<const CppType*>(this), other);
    }

dot() [1/3]

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::dot ( CppType other ) const

inlinenoexcept

Returns the dot product of the given vector and another.

Definition at line 259 of file shz_vector.hpp.

                                                             {
        return shz_vec_dot(*static_cast<const CppType*>(this), other);
    }

dot() [2/3]

template<typename CRTP, typename C, size_t R>

vec2 shz::vecN< CRTP, C, R >::dot ( CppType v1, CppType v2 ) const

noexcept

Returns the dot product of the given vector against two others.

Definition at line 626 of file shz_vector.hpp.

                                                                                 {
    return shz_vec_dot2(*static_cast<const CRTP*>(this), v1, v2);
}

dot() [3/3]

template<typename CRTP, typename C, size_t R>

vec3 shz::vecN< CRTP, C, R >::dot ( CppType v1, CppType v2, CppType v3 ) const

noexcept

Returns the dot product of the given vector against three others.

Definition at line 631 of file shz_vector.hpp.

                                                                                             {
    return shz_vec_dot3(*static_cast<const CRTP*>(this), v1, v2, v3);
}

magnitude()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::magnitude ( ) const

inlinenoexcept

Returns the magnitude of the given vector.

Definition at line 270 of file shz_vector.hpp.

                                                      {
        return shz_vec_magnitude(*static_cast<const CppType*>(this));
    }

magnitude_sqr()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::magnitude_sqr ( ) const

inlinenoexcept

Returns the squared magnitude of the given vector.

Definition at line 275 of file shz_vector.hpp.

                                                          {
        return shz_vec_magnitude_sqr(*static_cast<const CppType*>(this));
    }

magnitude_inv()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::magnitude_inv ( ) const

inlinenoexcept

Returns the inverse magnitude of the given vector.

Definition at line 280 of file shz_vector.hpp.

                                                          {
        return shz_vec_magnitude_inv(*static_cast<const CppType*>(this));
    }

direction()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::direction ( ) const

inlinenoexcept

Returns the direction vector resulting from normalizing the given vector.

Definition at line 285 of file shz_vector.hpp.

                                                        {
        return shz_vec_normalize(*static_cast<const CppType*>(this));
    }

normalize()

template<typename CRTP, typename C, size_t R>

void shz::vecN< CRTP, C, R >::normalize ( )

inlinenoexcept

Normalizes the given vector.

Definition at line 290 of file shz_vector.hpp.

                                               {
        *static_cast<CppType*>(this) = shz_vec_normalize(*static_cast<const CppType*>(this));
    }

direction_safe()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::direction_safe ( ) const

inlinenoexcept

Returns the direction vector of a given vector, safely protecting against division-by-zero.

Definition at line 295 of file shz_vector.hpp.

                                                             {
        return shz_vec_normalize_safe(*static_cast<const CppType*>(this));
    }

normalize_safe()

template<typename CRTP, typename C, size_t R>

void shz::vecN< CRTP, C, R >::normalize_safe ( )

inlinenoexcept

Normalizes the given vector, safely protecting against division-by-zero.

Definition at line 300 of file shz_vector.hpp.

                                                    {
        *static_cast<CppType*>(this) = shz_vec_normalize_safe(*static_cast<const CppType*>(this));
    }

distance()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::distance ( const CppType & other ) const

inlinenoexcept

Returns the magnitude of the difference between two vectors as their distance.

Definition at line 305 of file shz_vector.hpp.

                                                                         {
        return shz_vec_distance(*static_cast<const CppType*>(this), other);
    }

distance_sqr()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::distance_sqr ( const CppType & other ) const

inlinenoexcept

Returns the value of the distance between two vectors squared (faster than actual distance)

Definition at line 310 of file shz_vector.hpp.

                                                                             {
        return shz_vec_distance_sqr(*static_cast<const CppType*>(this), other);
    }

move()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::move ( CppType target, float maxdist ) const

inlinenoexcept

Moves the given vector towards the target by the given maxdist.

Definition at line 315 of file shz_vector.hpp.

                                                                                {
        return shz_vec_move(*static_cast<const CppType*>(this), target, maxdist);
    }

reflect()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::reflect ( CppType normal ) const

inlinenoexcept

Returns the vector created from reflecting the given vector over the normal of a surface.

Definition at line 320 of file shz_vector.hpp.

                                                                    {
        return shz_vec_reflect(*static_cast<const CppType*>(this), normal);
    }

refract()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::refract ( CppType normal, float eta ) const

inlinenoexcept

Returns the vector create from refracting the given incidence vector over the normal of a surface, using the given refraction ratio index.

Definition at line 325 of file shz_vector.hpp.

                                                                               {
        return shz_vec_refract(*static_cast<const CppType*>(this), normal, eta);
    }

project()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::project ( CppType onto ) const

inlinenoexcept

Returns the vector created from projecting the given vector onto another.

Definition at line 330 of file shz_vector.hpp.

                                                                  {
        return shz_vec_project(*static_cast<const CppType*>(this), onto);
    }

project_safe()

template<typename CRTP, typename C, size_t R>

CppType shz::vecN< CRTP, C, R >::project_safe ( CppType onto ) const

inlinenoexcept

Returns the vector created from projecting the given vector onto another, safely protecting against division-by-zero.

Definition at line 335 of file shz_vector.hpp.

                                                                       {
        return shz_vec_project_safe(*static_cast<const CppType*>(this), onto);
    }

angle_between()

template<typename CRTP, typename C, size_t R>

float shz::vecN< CRTP, C, R >::angle_between ( CppType other ) const

inlinenoexcept

Returns the angle between the given vector and another, in radians.

Definition at line 340 of file shz_vector.hpp.

                                                                       {
        return shz_vec_angle_between(*static_cast<const CppType*>(this), other);
    }

angles()

template<typename CRTP, typename C, size_t R>

auto shz::vecN< CRTP, C, R >::angles ( ) const

inlinenoexcept

Returns the angle(s) created between the given vector axis and the +X axis, in radians.

Definition at line 345 of file shz_vector.hpp.

                                                  {
        return shz_vec_angles(*static_cast<const CppType*>(this));
    }

Friends And Related Symbol Documentation

operator==

template<typename CRTP, typename C, size_t R>

bool operator== ( CppType lhs, CppType rhs )

friend

Overloaded equality operator, for comparing vectors.

Definition at line 131 of file shz_vector.hpp.

                                                              {
        return shz_vec_equal(lhs, rhs);
    }

operator-

template<typename CRTP, typename C, size_t R>

CppType operator- ( CppType vec )

friend

Overloaded unary negation operator, returns the negated vector.

Definition at line 136 of file shz_vector.hpp.

                                                   {
        return vec.neg();
    }

Field Documentation

Rows

template<typename CRTP, typename C, size_t R>

size_t shz::vecN< CRTP, C, R >::Rows

staticconstexpr

Number of rows.

Definition at line 47 of file shz_vector.hpp.

Cols

template<typename CRTP, typename C, size_t R>

size_t shz::vecN< CRTP, C, R >::Cols

staticconstexpr

Number of columns.

Definition at line 48 of file shz_vector.hpp.

---

The documentation for this struct was generated from the following file:

• shz_vector.hpp