Harlinn.Windows 0.1
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Public Attributes | Static Public Attributes | List of all members
Harlinn::Math::Plane< T > Class Template Reference

#include <VectorMath.h>

Inheritance diagram for Harlinn::Math::Plane< T >:
[legend]
Collaboration diagram for Harlinn::Math::Plane< T >:
[legend]

Public Types

using value_type = T
 
using size_type = size_t
 
using ValueType = value_type
 
using SizeType = size_type
 
using Traits = SIMD::Traits<ValueType, Size>
 
using SIMDType = typename Traits::SIMDType
 
using ArrayType = typename Traits::ArrayType
 
using reference = typename ArrayType::reference
 
using const_reference = typename ArrayType::const_reference
 
using pointer = typename ArrayType::pointer
 
using const_pointer = typename ArrayType::const_pointer
 
using iterator = typename ArrayType::iterator
 
using const_iterator = typename ArrayType::const_iterator
 
using reverse_iterator = typename ArrayType::reverse_iterator
 
using const_reverse_iterator = typename ArrayType::const_reverse_iterator
 
using Simd = PlaneSimd<Plane>
 
using Vector = Math::Vector<ValueType, 3>
 

Public Member Functions

constexpr Plane () noexcept
 
constexpr Plane (ValueType x, ValueType y, ValueType z, ValueType distance) noexcept
 
constexpr Plane (const ArrayType &plane) noexcept
 
template<TupleType T>
requires IsCompatible<T, Vector>
constexpr Plane (const T &normal, ValueType distance) noexcept
 
template<SimdType T>
requires IsCompatible<T, Vector>
constexpr Plane (const T &normal, ValueType distance) noexcept
 
 Plane (const Simd &plane) noexcept
 
Plane & operator= (const Simd &plane) noexcept
 
Plane & operator= (const Plane &other) noexcept
 
Simd ToSimd () const noexcept
 
 operator Simd () const noexcept
 
bool operator== (const Simd &other) const noexcept
 
bool operator!= (const Simd &other) const noexcept
 
bool operator== (const Plane &other) const noexcept
 
bool operator!= (const Plane &other) const noexcept
 
Simd operator- () const noexcept
 
const_reference operator[] (size_t index) const noexcept
 
reference operator[] (size_t index) noexcept
 
const_pointer data () const noexcept
 
pointer data () noexcept
 
constexpr size_t size () const noexcept
 
const_reference front () const noexcept
 
reference front () noexcept
 
const_reference back () const noexcept
 
reference back () noexcept
 
const_iterator begin () const noexcept
 
const_iterator cbegin () const noexcept
 
iterator begin () noexcept
 
const_iterator end () const noexcept
 
const_iterator cend () const noexcept
 
iterator end () noexcept
 
const_reverse_iterator rbegin () const noexcept
 
reverse_iterator rbegin () noexcept
 
const_reverse_iterator rend () const noexcept
 
reverse_iterator rend () noexcept
 

Public Attributes

union { 
 
   ArrayType   values 
 
   struct { 
 
      Vector   Normal 
 The normal vector of the plane. More...
 
      ValueType   Distance 
 The distance of the plane along its normal from the origin. More...
 
   }  
 
};  
 

Static Public Attributes

static constexpr size_type Size = 4
 
static constexpr size_type Capacity = Size
 
static constexpr float NormalizeEpsilon = 1.192092896e-07f
 

Member Typedef Documentation

◆ ArrayType

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::ArrayType = typename Traits::ArrayType

◆ const_iterator

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::const_iterator = typename ArrayType::const_iterator

◆ const_pointer

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::const_pointer = typename ArrayType::const_pointer

◆ const_reference

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::const_reference = typename ArrayType::const_reference

◆ const_reverse_iterator

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::const_reverse_iterator = typename ArrayType::const_reverse_iterator

◆ iterator

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::iterator = typename ArrayType::iterator

◆ pointer

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::pointer = typename ArrayType::pointer

◆ reference

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::reference = typename ArrayType::reference

◆ reverse_iterator

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::reverse_iterator = typename ArrayType::reverse_iterator

◆ Simd

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::Simd = PlaneSimd<Plane>

◆ SIMDType

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::SIMDType = typename Traits::SIMDType

◆ size_type

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::size_type = size_t

◆ SizeType

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::SizeType = size_type

◆ Traits

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::Traits = SIMD::Traits<ValueType, Size>

◆ value_type

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::value_type = T

◆ ValueType

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::ValueType = value_type

◆ Vector

template<FloatingPointType T>
using Harlinn::Math::Plane< T >::Vector = Math::Vector<ValueType, 3>

Constructor & Destructor Documentation

◆ Plane() [1/6]

template<FloatingPointType T>
Harlinn::Math::Plane< T >::Plane ( )
inlineconstexprnoexcept

◆ Plane() [2/6]

template<FloatingPointType T>
Harlinn::Math::Plane< T >::Plane ( ValueType x,
ValueType y,
ValueType z,
ValueType distance )
inlineconstexprnoexcept

◆ Plane() [3/6]

template<FloatingPointType T>
Harlinn::Math::Plane< T >::Plane ( const ArrayType & plane)
inlineconstexprnoexcept

◆ Plane() [4/6]

template<FloatingPointType T>
template<TupleType T>
requires IsCompatible<T, Vector>
Harlinn::Math::Plane< T >::Plane ( const T & normal,
ValueType distance )
inlineconstexprnoexcept

◆ Plane() [5/6]

template<FloatingPointType T>
template<SimdType T>
requires IsCompatible<T, Vector>
Harlinn::Math::Plane< T >::Plane ( const T & normal,
ValueType distance )
inlineconstexprnoexcept

◆ Plane() [6/6]

template<FloatingPointType T>
Harlinn::Math::Plane< T >::Plane ( const Simd & plane)
inlinenoexcept

Member Function Documentation

◆ back() [1/2]

template<FloatingPointType T>
const_reference Harlinn::Math::Plane< T >::back ( ) const
inlinenoexcept

◆ back() [2/2]

template<FloatingPointType T>
reference Harlinn::Math::Plane< T >::back ( )
inlinenoexcept

◆ begin() [1/2]

template<FloatingPointType T>
const_iterator Harlinn::Math::Plane< T >::begin ( ) const
inlinenoexcept

◆ begin() [2/2]

template<FloatingPointType T>
iterator Harlinn::Math::Plane< T >::begin ( )
inlinenoexcept

◆ cbegin()

template<FloatingPointType T>
const_iterator Harlinn::Math::Plane< T >::cbegin ( ) const
inlinenoexcept

◆ cend()

template<FloatingPointType T>
const_iterator Harlinn::Math::Plane< T >::cend ( ) const
inlinenoexcept

◆ data() [1/2]

template<FloatingPointType T>
const_pointer Harlinn::Math::Plane< T >::data ( ) const
inlinenoexcept

◆ data() [2/2]

template<FloatingPointType T>
pointer Harlinn::Math::Plane< T >::data ( )
inlinenoexcept

◆ end() [1/2]

template<FloatingPointType T>
const_iterator Harlinn::Math::Plane< T >::end ( ) const
inlinenoexcept

◆ end() [2/2]

template<FloatingPointType T>
iterator Harlinn::Math::Plane< T >::end ( )
inlinenoexcept

◆ front() [1/2]

template<FloatingPointType T>
const_reference Harlinn::Math::Plane< T >::front ( ) const
inlinenoexcept

◆ front() [2/2]

template<FloatingPointType T>
reference Harlinn::Math::Plane< T >::front ( )
inlinenoexcept

◆ operator Simd()

template<FloatingPointType T>
Harlinn::Math::Plane< T >::operator Simd ( ) const
inlinenoexcept

◆ operator!=() [1/2]

template<FloatingPointType T>
bool Harlinn::Math::Plane< T >::operator!= ( const Plane< T > & other) const
inlinenoexcept

◆ operator!=() [2/2]

template<FloatingPointType T>
bool Harlinn::Math::Plane< T >::operator!= ( const Simd & other) const
inlinenoexcept

◆ operator-()

template<FloatingPointType T>
Simd Harlinn::Math::Plane< T >::operator- ( ) const
inlinenoexcept

◆ operator=() [1/2]

template<FloatingPointType T>
Plane & Harlinn::Math::Plane< T >::operator= ( const Plane< T > & other)
inlinenoexcept

◆ operator=() [2/2]

template<FloatingPointType T>
Plane & Harlinn::Math::Plane< T >::operator= ( const Simd & plane)
inlinenoexcept

◆ operator==() [1/2]

template<FloatingPointType T>
bool Harlinn::Math::Plane< T >::operator== ( const Plane< T > & other) const
inlinenoexcept

◆ operator==() [2/2]

template<FloatingPointType T>
bool Harlinn::Math::Plane< T >::operator== ( const Simd & other) const
inlinenoexcept

◆ operator[]() [1/2]

template<FloatingPointType T>
const_reference Harlinn::Math::Plane< T >::operator[] ( size_t index) const
inlinenoexcept

◆ operator[]() [2/2]

template<FloatingPointType T>
reference Harlinn::Math::Plane< T >::operator[] ( size_t index)
inlinenoexcept

◆ rbegin() [1/2]

template<FloatingPointType T>
const_reverse_iterator Harlinn::Math::Plane< T >::rbegin ( ) const
inlinenoexcept

◆ rbegin() [2/2]

template<FloatingPointType T>
reverse_iterator Harlinn::Math::Plane< T >::rbegin ( )
inlinenoexcept

◆ rend() [1/2]

template<FloatingPointType T>
const_reverse_iterator Harlinn::Math::Plane< T >::rend ( ) const
inlinenoexcept

◆ rend() [2/2]

template<FloatingPointType T>
reverse_iterator Harlinn::Math::Plane< T >::rend ( )
inlinenoexcept

◆ size()

template<FloatingPointType T>
size_t Harlinn::Math::Plane< T >::size ( ) const
inlineconstexprnoexcept

◆ ToSimd()

template<FloatingPointType T>
Simd Harlinn::Math::Plane< T >::ToSimd ( ) const
inlinenoexcept

Member Data Documentation

◆ [union]

union { ... } Harlinn::Math::Plane< T >

◆ Capacity

template<FloatingPointType T>
size_type Harlinn::Math::Plane< T >::Capacity = Size
staticconstexpr

◆ Distance

template<FloatingPointType T>
ValueType Harlinn::Math::Plane< T >::Distance

The distance of the plane along its normal from the origin.

◆ Normal

template<FloatingPointType T>
Vector Harlinn::Math::Plane< T >::Normal

The normal vector of the plane.

◆ NormalizeEpsilon

template<FloatingPointType T>
float Harlinn::Math::Plane< T >::NormalizeEpsilon = 1.192092896e-07f
staticconstexpr

◆ Size

template<FloatingPointType T>
size_type Harlinn::Math::Plane< T >::Size = 4
staticconstexpr

◆ values

template<FloatingPointType T>
ArrayType Harlinn::Math::Plane< T >::values
The documentation for this class was generated from the following file: