Doxygen/html/common_2_honey_2_math_2_alge_2_vec_2_vec3_8h_source.html

 // Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.

 #pragma once


 #include "Honey/Math/Alge/Vec/Swiz.h"

 #include "Honey/Math/Alge/Vec/Vec2.h"


 namespace honey

 {


 template<class Real, int Options>

 struct matrix::priv::Traits<Vec<3,Real,Options>> : vec::priv::Traits<3,Real,Options,std::allocator<int8>>

 {

     typedef vec::priv::StorageFields<Vec<3,Real,Options>> Storage;

 };


 namespace vec { namespace priv

 {

     template<class Real, szt Align>

     struct StorageFieldsMixin<Real, 3, Align>

     {

         Real x;

         Real y;

         Real z;

     };

 } }


 namespace matrix { namespace priv

 {

     template<class R, int O>

     void storageCopy(const R* a, Vec<3,R,O>& v)                     { v.x = a[0]; v.y = a[1]; v.z = a[2]; }

     template<class R, int O>

     void storageCopy(const Vec<3,R,O>& v, R* a)                     { a[0] = v.x; a[1] = v.y; a[2] = v.z; }


     template<class R, int O>

     void storageFill(Vec<3,R,O>& v, R f)                            { v.x = f; v.y = f; v.z = f; }

     template<class R, int O>

     void storageFillZero(Vec<3,R,O>& v)                             { v.x = 0; v.y = 0; v.z = 0; }


     template<class R, int O>

     bool storageEqual(const Vec<3,R,O>& lhs, const Vec<3,R,O>& rhs) { return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z; }

 } }


 template<class Real, int Options>

 class Vec<3,Real,Options> : public VecBase<Vec<3,Real,Options>>

 {

     typedef VecBase<Vec<3,Real,Options>> Super;

     using typename Super::Alge;

 protected:

     typedef Vec<2,Real>                 Vec2;

     typedef Vec                         Vec3;

     typedef Vec<4,Real>                 Vec4;

     typedef VecSwizCon<2,Real,Options>  VecSwizCon2;

     typedef VecSwizCon<3,Real,Options>  VecSwizCon3;

     typedef VecSwizCon<4,Real,Options>  VecSwizCon4;

     typedef VecSwizRef<2,Real,Options>  VecSwizRef2;

     typedef VecSwizRef<3,Real,Options>  VecSwizRef3;

 public:

     using Super::dot;

     using Super::x;

     using Super::y;

     using Super::z;


     Vec()                                                           {}

     Vec(Real x, Real y, Real z)                                     { this->x = x; this->y = y; this->z = z; }

     explicit Vec(Real scalar)                                       { this->fromScalar(scalar); }

     explicit Vec(const Vec2& v, Real z = 0)                         { x = v.x; y = v.y; this->z = z; }

     explicit Vec(const Vec4& v)                                     { x = v.x; y = v.y; z = v.z; }

     template<class T>

     Vec(const MatrixBase<T>& rhs)                                   { operator=(rhs); }


     template<class T>

     Vec& operator=(const MatrixBase<T>& rhs)                        { Super::operator=(rhs); return *this; }


     Real lengthSqr() const                                          { return x*x + y*y + z*z; }

     Real dot(const Vec& v) const                                    { return x*v.x + y*v.y + z*v.z; }


     Vec3 cross(const Vec3& v) const                                 { return Vec3(y*v.z - z*v.y, z*v.x - x*v.z, x*v.y - y*v.x); }

     Vec3 crossUnit(const Vec3& v) const                             { return cross(v).normalize(); }


     static void orthonormalize(Vec3& u, Vec3& v, Vec3& w)

     {

         u = u.normalize();


         Real dot0 = u.dot(v);

         v -= dot0*u;

         v = v.normalize();


         Real dot1 = v.dot(w);

         dot0 = u.dot(w);

         w -= dot0*u + dot1*v;

         w = w.normalize();

     }


     tuple<Vec3,Vec3> orthonormalBasis() const

     {

         Vec u,v;

         const Vec3& w = *this;


         if (Alge::abs(w[0]) >= Alge::abs(w[1]))

         {

             // w.x or w.z is the largest magnitude component, swap them

             Real invLength = Alge::sqrtInv(w[0]*w[0] + w[2]*w[2]);

             u[0] = -w[2]*invLength;

             u[1] = 0;

             u[2] = +w[0]*invLength;

             v[0] = w[1]*u[2];

             v[1] = w[2]*u[0] - w[0]*u[2];

             v[2] = -w[1]*u[0];

         }

         else

         {

             // w.y or w.z is the largest magnitude component, swap them

             Real invLength = Alge::sqrtInv(w[1]*w[1] + w[2]*w[2]);

             u[0] = 0;

             u[1] = +w[2]*invLength;

             u[2] = -w[1]*invLength;

             v[0] = w[1]*u[2] - w[2]*u[1];

             v[1] = -w[0]*u[2];

             v[2] = w[0]*u[1];

         }

         return make_tuple(u,v);

     }


 public:

     static const Vec zero;

     static const Vec one;

     static const Vec axisX;

     static const Vec axisY;

     static const Vec axisZ;

     static const Vec axis[3];


 public:

     VecSwizCon2 xx() const                                          { return VecSwizCon2(x,x); }

     VecSwizCon3 xxx() const                                         { return VecSwizCon3(x,x,x); }

     VecSwizCon4 xxxx() const                                        { return VecSwizCon4(x,x,x,x); }

     VecSwizCon4 xxxy() const                                        { return VecSwizCon4(x,x,x,y); }

     VecSwizCon4 xxxz() const                                        { return VecSwizCon4(x,x,x,z); }

     VecSwizCon3 xxy() const                                         { return VecSwizCon3(x,x,y); }

     VecSwizCon4 xxyx() const                                        { return VecSwizCon4(x,x,y,x); }

     VecSwizCon4 xxyy() const                                        { return VecSwizCon4(x,x,y,y); }

     VecSwizCon4 xxyz() const                                        { return VecSwizCon4(x,x,y,z); }

     VecSwizCon3 xxz() const                                         { return VecSwizCon3(x,x,z); }

     VecSwizCon4 xxzx() const                                        { return VecSwizCon4(x,x,z,x); }

     VecSwizCon4 xxzy() const                                        { return VecSwizCon4(x,x,z,y); }

     VecSwizCon4 xxzz() const                                        { return VecSwizCon4(x,x,z,z); }

     VecSwizCon2 xy() const                                          { return VecSwizCon2(x,y); }

     VecSwizCon3 xyx() const                                         { return VecSwizCon3(x,y,x); }

     VecSwizCon4 xyxx() const                                        { return VecSwizCon4(x,y,x,x); }

     VecSwizCon4 xyxy() const                                        { return VecSwizCon4(x,y,x,y); }

     VecSwizCon4 xyxz() const                                        { return VecSwizCon4(x,y,x,z); }

     VecSwizCon3 xyy() const                                         { return VecSwizCon3(x,y,y); }

     VecSwizCon4 xyyx() const                                        { return VecSwizCon4(x,y,y,x); }

     VecSwizCon4 xyyy() const                                        { return VecSwizCon4(x,y,y,y); }

     VecSwizCon4 xyyz() const                                        { return VecSwizCon4(x,y,y,z); }

     VecSwizCon3 xyz() const                                         { return VecSwizCon3(x,y,z); }

     VecSwizCon4 xyzx() const                                        { return VecSwizCon4(x,y,z,x); }

     VecSwizCon4 xyzy() const                                        { return VecSwizCon4(x,y,z,y); }

     VecSwizCon4 xyzz() const                                        { return VecSwizCon4(x,y,z,z); }

     VecSwizCon2 xz() const                                          { return VecSwizCon2(x,z); }

     VecSwizCon3 xzx() const                                         { return VecSwizCon3(x,z,x); }

     VecSwizCon4 xzxx() const                                        { return VecSwizCon4(x,z,x,x); }

     VecSwizCon4 xzxy() const                                        { return VecSwizCon4(x,z,x,y); }

     VecSwizCon4 xzxz() const                                        { return VecSwizCon4(x,z,x,z); }

     VecSwizCon3 xzy() const                                         { return VecSwizCon3(x,z,y); }

     VecSwizCon4 xzyx() const                                        { return VecSwizCon4(x,z,y,x); }

     VecSwizCon4 xzyy() const                                        { return VecSwizCon4(x,z,y,y); }

     VecSwizCon4 xzyz() const                                        { return VecSwizCon4(x,z,y,z); }

     VecSwizCon3 xzz() const                                         { return VecSwizCon3(x,z,z); }

     VecSwizCon4 xzzx() const                                        { return VecSwizCon4(x,z,z,x); }

     VecSwizCon4 xzzy() const                                        { return VecSwizCon4(x,z,z,y); }

     VecSwizCon4 xzzz() const                                        { return VecSwizCon4(x,z,z,z); }

     VecSwizCon2 yx() const                                          { return VecSwizCon2(y,x); }

     VecSwizCon3 yxx() const                                         { return VecSwizCon3(y,x,x); }

     VecSwizCon4 yxxx() const                                        { return VecSwizCon4(y,x,x,x); }

     VecSwizCon4 yxxy() const                                        { return VecSwizCon4(y,x,x,y); }

     VecSwizCon4 yxxz() const                                        { return VecSwizCon4(y,x,x,z); }

     VecSwizCon3 yxy() const                                         { return VecSwizCon3(y,x,y); }

     VecSwizCon4 yxyx() const                                        { return VecSwizCon4(y,x,y,x); }

     VecSwizCon4 yxyy() const                                        { return VecSwizCon4(y,x,y,y); }

     VecSwizCon4 yxyz() const                                        { return VecSwizCon4(y,x,y,z); }

     VecSwizCon3 yxz() const                                         { return VecSwizCon3(y,x,z); }

     VecSwizCon4 yxzx() const                                        { return VecSwizCon4(y,x,z,x); }

     VecSwizCon4 yxzy() const                                        { return VecSwizCon4(y,x,z,y); }

     VecSwizCon4 yxzz() const                                        { return VecSwizCon4(y,x,z,z); }

     VecSwizCon2 yy() const                                          { return VecSwizCon2(y,y); }

     VecSwizCon3 yyx() const                                         { return VecSwizCon3(y,y,x); }

     VecSwizCon4 yyxx() const                                        { return VecSwizCon4(y,y,x,x); }

     VecSwizCon4 yyxy() const                                        { return VecSwizCon4(y,y,x,y); }

     VecSwizCon4 yyxz() const                                        { return VecSwizCon4(y,y,x,z); }

     VecSwizCon3 yyy() const                                         { return VecSwizCon3(y,y,y); }

     VecSwizCon4 yyyx() const                                        { return VecSwizCon4(y,y,y,x); }

     VecSwizCon4 yyyy() const                                        { return VecSwizCon4(y,y,y,y); }

     VecSwizCon4 yyyz() const                                        { return VecSwizCon4(y,y,y,z); }

     VecSwizCon3 yyz() const                                         { return VecSwizCon3(y,y,z); }

     VecSwizCon4 yyzx() const                                        { return VecSwizCon4(y,y,z,x); }

     VecSwizCon4 yyzy() const                                        { return VecSwizCon4(y,y,z,y); }

     VecSwizCon4 yyzz() const                                        { return VecSwizCon4(y,y,z,z); }

     VecSwizCon2 yz() const                                          { return VecSwizCon2(y,z); }

     VecSwizCon3 yzx() const                                         { return VecSwizCon3(y,z,x); }

     VecSwizCon4 yzxx() const                                        { return VecSwizCon4(y,z,x,x); }

     VecSwizCon4 yzxy() const                                        { return VecSwizCon4(y,z,x,y); }

     VecSwizCon4 yzxz() const                                        { return VecSwizCon4(y,z,x,z); }

     VecSwizCon3 yzy() const                                         { return VecSwizCon3(y,z,y); }

     VecSwizCon4 yzyx() const                                        { return VecSwizCon4(y,z,y,x); }

     VecSwizCon4 yzyy() const                                        { return VecSwizCon4(y,z,y,y); }

     VecSwizCon4 yzyz() const                                        { return VecSwizCon4(y,z,y,z); }

     VecSwizCon3 yzz() const                                         { return VecSwizCon3(y,z,z); }

     VecSwizCon4 yzzx() const                                        { return VecSwizCon4(y,z,z,x); }

     VecSwizCon4 yzzy() const                                        { return VecSwizCon4(y,z,z,y); }

     VecSwizCon4 yzzz() const                                        { return VecSwizCon4(y,z,z,z); }

     VecSwizCon2 zx() const                                          { return VecSwizCon2(z,x); }

     VecSwizCon3 zxx() const                                         { return VecSwizCon3(z,x,x); }

     VecSwizCon4 zxxx() const                                        { return VecSwizCon4(z,x,x,x); }

     VecSwizCon4 zxxy() const                                        { return VecSwizCon4(z,x,x,y); }

     VecSwizCon4 zxxz() const                                        { return VecSwizCon4(z,x,x,z); }

     VecSwizCon3 zxy() const                                         { return VecSwizCon3(z,x,y); }

     VecSwizCon4 zxyx() const                                        { return VecSwizCon4(z,x,y,x); }

     VecSwizCon4 zxyy() const                                        { return VecSwizCon4(z,x,y,y); }

     VecSwizCon4 zxyz() const                                        { return VecSwizCon4(z,x,y,z); }

     VecSwizCon3 zxz() const                                         { return VecSwizCon3(z,x,z); }

     VecSwizCon4 zxzx() const                                        { return VecSwizCon4(z,x,z,x); }

     VecSwizCon4 zxzy() const                                        { return VecSwizCon4(z,x,z,y); }

     VecSwizCon4 zxzz() const                                        { return VecSwizCon4(z,x,z,z); }

     VecSwizCon2 zy() const                                          { return VecSwizCon2(z,y); }

     VecSwizCon3 zyx() const                                         { return VecSwizCon3(z,y,x); }

     VecSwizCon4 zyxx() const                                        { return VecSwizCon4(z,y,x,x); }

     VecSwizCon4 zyxy() const                                        { return VecSwizCon4(z,y,x,y); }

     VecSwizCon4 zyxz() const                                        { return VecSwizCon4(z,y,x,z); }

     VecSwizCon3 zyy() const                                         { return VecSwizCon3(z,y,y); }

     VecSwizCon4 zyyx() const                                        { return VecSwizCon4(z,y,y,x); }

     VecSwizCon4 zyyy() const                                        { return VecSwizCon4(z,y,y,y); }

     VecSwizCon4 zyyz() const                                        { return VecSwizCon4(z,y,y,z); }

     VecSwizCon3 zyz() const                                         { return VecSwizCon3(z,y,z); }

     VecSwizCon4 zyzx() const                                        { return VecSwizCon4(z,y,z,x); }

     VecSwizCon4 zyzy() const                                        { return VecSwizCon4(z,y,z,y); }

     VecSwizCon4 zyzz() const                                        { return VecSwizCon4(z,y,z,z); }

     VecSwizCon2 zz() const                                          { return VecSwizCon2(z,z); }

     VecSwizCon3 zzx() const                                         { return VecSwizCon3(z,z,x); }

     VecSwizCon4 zzxx() const                                        { return VecSwizCon4(z,z,x,x); }

     VecSwizCon4 zzxy() const                                        { return VecSwizCon4(z,z,x,y); }

     VecSwizCon4 zzxz() const                                        { return VecSwizCon4(z,z,x,z); }

     VecSwizCon3 zzy() const                                         { return VecSwizCon3(z,z,y); }

     VecSwizCon4 zzyx() const                                        { return VecSwizCon4(z,z,y,x); }

     VecSwizCon4 zzyy() const                                        { return VecSwizCon4(z,z,y,y); }

     VecSwizCon4 zzyz() const                                        { return VecSwizCon4(z,z,y,z); }

     VecSwizCon3 zzz() const                                         { return VecSwizCon3(z,z,z); }

     VecSwizCon4 zzzx() const                                        { return VecSwizCon4(z,z,z,x); }

     VecSwizCon4 zzzy() const                                        { return VecSwizCon4(z,z,z,y); }

     VecSwizCon4 zzzz() const                                        { return VecSwizCon4(z,z,z,z); }


     VecSwizRef2 xy()                                                { return VecSwizRef2(x,y); }

     VecSwizRef3 xyz()                                               { return VecSwizRef3(x,y,z); }

     VecSwizRef2 xz()                                                { return VecSwizRef2(x,z); }

     VecSwizRef3 xzy()                                               { return VecSwizRef3(x,z,y); }

     VecSwizRef2 yx()                                                { return VecSwizRef2(y,x); }

     VecSwizRef3 yxz()                                               { return VecSwizRef3(y,x,z); }

     VecSwizRef2 yz()                                                { return VecSwizRef2(y,z); }

     VecSwizRef3 yzx()                                               { return VecSwizRef3(y,z,x); }

     VecSwizRef2 zx()                                                { return VecSwizRef2(z,x); }

     VecSwizRef3 zxy()                                               { return VecSwizRef3(z,x,y); }

     VecSwizRef2 zy()                                                { return VecSwizRef2(z,y); }

     VecSwizRef3 zyx()                                               { return VecSwizRef3(z,y,x); }

 };


 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::zero          (0);

 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::one           (1);

 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::axisX         (1, 0, 0);

 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::axisY         (0, 1, 0);

 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::axisZ         (0, 0, 1);

 template<class R, int O> const Vec<3,R,O> Vec<3,R,O>::axis[3]       = { axisX, axisY, axisZ };


 template<class R, int Opt>

 struct priv::map_impl<Vec<3,R,Opt>, Vec<3,R,Opt>>

 {

     template<class T, class O, class Func>

     static O&& func(T&& v, O&& o, Func&& f)                         { o.x = f(v.x); o.y = f(v.y); o.z = f(v.z); return forward<O>(o); }

 };


 template<class R, int Opt>

 struct priv::map_impl<Vec<3,R,Opt>, Vec<3,R,Opt>, Vec<3,R,Opt>>

 {

     template<class T, class T2, class O, class Func>

     static O&& func(T&& v, T2&& rhs, O&& o, Func&& f)               { o.x = f(v.x,rhs.x); o.y = f(v.y,rhs.y); o.z = f(v.z,rhs.z); return forward<O>(o); }

 };


 template<class R, int O, class Accum_>

 struct priv::reduce_impl<Vec<3,R,O>, Accum_>

 {

     template<class T, class Accum, class Func>

     static Accum_ func(T&& v, Accum&& initVal, Func&& f)            { return f(f(f(forward<Accum>(initVal), v.x), v.y), v.z); }

 };


 template<class R, int O, class Accum_>

 struct priv::reduce_impl<Vec<3,R,O>, Accum_, Vec<3,R,O>>

 {

     template<class T, class T2, class Accum, class Func>

     static Accum_ func(T&& v, T2&& rhs, Accum&& initVal, Func&& f)  { return f(f(f(forward<Accum>(initVal), v.x, rhs.x), v.y, rhs.y), v.z, rhs.z); }

 };


 template<class Real, int Options>

 class VecSwizCon<3,Real,Options> : public VecSwizConBase<VecSwizCon<3,Real,Options>>

 {

 public:

     VecSwizCon(Real x, Real y, Real z)                              { this->x = x; this->y = y; this->z = z; }

 };


 template<class Real, int Options>

 class VecSwizRef<3,Real,Options> : public VecSwizRefBase<VecSwizRef<3,Real,Options>>

 {

     template<class> friend class VecSwizRefBase;

 public:

     typedef VecSwizRefBase<VecSwizRef<3,Real,Options>> Super;

     using Super::operator=;

     using Super::x;

     using Super::y;

     using Super::z;


     VecSwizRef(Real& x, Real& y, Real& z)                           : rx(x), ry(y), rz(z) { this->x = x; this->y = y; this->z = z; }


     VecSwizRef& commit()                                            { rx = x; ry = y; rz = z; return *this; }


 private:

     Real& rx;

     Real& ry;

     Real& rz;

 };


 typedef Vec<3>                                  Vec3;

 typedef Vec<3,Float>                            Vec3_f;

 typedef Vec<3,Double>                           Vec3_d;


 typedef Vec<3,Real,matrix::Option::vecRow>      VecRow3;

 typedef Vec<3,Float,matrix::Option::vecRow>     VecRow3_f;

 typedef Vec<3,Double,matrix::Option::vecRow>    VecRow3_d;


 }


 #include "Honey/Math/Alge/Vec/platform/Vec3.h"

honey::MatrixBase< Vec< Dim, Real, Options, Alloc > >::fromScalar
MatrixS & fromScalar(Real f)
Initialize with scalar in every element.
Definition: Base.h:72

honey::Vec< 3, Real, Options >::zy
VecSwizCon2 zy() const
Definition: Vec3.h:239

honey::Vec< 3, Real, Options >::lengthSqr
Real lengthSqr() const
Definition: Vec3.h:82

honey::Vec< 3, Real, Options >::zzxz
VecSwizCon4 zzxz() const
Definition: Vec3.h:256

honey::Vec< 3, Real, Options >::yx
VecSwizCon2 yx() const
Definition: Vec3.h:187

honey::Vec< 3, Real, Options >::yxxy
VecSwizCon4 yxxy() const
Definition: Vec3.h:190

honey::vec::priv::StorageFields
Automatic (stack-compatible) vector storage that allows direct access to dimension fields...
Definition: Storage.h:13

honey::VecBase< Vec< Dim, Real, Options, Alloc > >::operator=
VecBase & operator=(const MatrixBase< T > &rhs)
Assign to row or column vector of any dimension. Asserts that if this vector has a fixed dimension th...
Definition: Base.h:35

honey::matrix::priv::storageFillZero
void storageFillZero(StorageBlock< T > &store)
Fill block storage with zeros.
Definition: Block.h:136

honey::Vec< 3, Real, Options >::zxxy
VecSwizCon4 zxxy() const
Definition: Vec3.h:229

honey::Vec< 3, Real, Options >::zxzz
VecSwizCon4 zxzz() const
Definition: Vec3.h:238

honey::Vec< 3, Real, Options >::axisZ
static const Vec axisZ
Definition: Vec3.h:142

honey::Vec< 3, Real, Options >::yxyx
VecSwizCon4 yxyx() const
Definition: Vec3.h:193

honey::Vec< 3, Real, Options >::cross
Vec3 cross(const Vec3 &v) const
Vector cross product.
Definition: Vec3.h:87

honey::Vec< 3, Real, Options >::xzy
VecSwizRef3 xzy()
Definition: Vec3.h:272

honey::vec::priv::Traits
N-dimensional vector traits.
Definition: Vec.h:14

honey::VecSwizRef< 3, Real, Options >::commit
VecSwizRef & commit()
Definition: Vec3.h:346

honey::Vec< 3, Real, Options >::VecSwizRef3
VecSwizRef< 3, Real, Options > VecSwizRef3
Definition: Vec3.h:57

honey::Vec< 3, Real, Options >::axisY
static const Vec axisY
Definition: Vec3.h:141

honey::Vec< 3, Real, Options >::xzzx
VecSwizCon4 xzzx() const
Definition: Vec3.h:184

honey::Vec< 3, Real, Options >::yzzx
VecSwizCon4 yzzx() const
Definition: Vec3.h:223

honey::Vec< 3, Real, Options >::yxz
VecSwizCon3 yxz() const
Definition: Vec3.h:196

honey::VecBase< Vec< Dim, Real, Options, Alloc > >::dot
Real dot(const VecBase< T > &v) const
Vector dot product.
Definition: Base.h:91

honey::Vec< 3, Real, Options >::xyzy
VecSwizCon4 xyzy() const
Definition: Vec3.h:172

honey::Vec< 3, Real, Options >::zxyx
VecSwizCon4 zxyx() const
Definition: Vec3.h:232

honey::Vec< 3, Real, Options >::xxy
VecSwizCon3 xxy() const
Definition: Vec3.h:153

honey::Vec< 3, Real, Options >::xz
VecSwizRef2 xz()
Definition: Vec3.h:271

honey::Vec< 3, Real, Options >::zy
VecSwizRef2 zy()
Definition: Vec3.h:279

honey::Vec< 3, Real, Options >::yyyy
VecSwizCon4 yyyy() const
Definition: Vec3.h:207

honey::Vec< 3, Real, Options >::yzz
VecSwizCon3 yzz() const
Definition: Vec3.h:222

honey::Vec< 3, Real, Options >::xzz
VecSwizCon3 xzz() const
Definition: Vec3.h:183

honey::Vec< 3, Real, Options >::xzzy
VecSwizCon4 xzzy() const
Definition: Vec3.h:185

honey::Vec3_f
Vec< 3, Float > Vec3_f
Definition: Vec3.h:357

honey::Vec< 3, Real, Options >::xyyy
VecSwizCon4 xyyy() const
Definition: Vec3.h:168

honey::Vec3_d
Vec< 3, Double > Vec3_d
Definition: Vec3.h:358

honey::Vec< 3, Real, Options >::zxyy
VecSwizCon4 zxyy() const
Definition: Vec3.h:233

honey::Vec< 3, Real, Options >::zzy
VecSwizCon3 zzy() const
Definition: Vec3.h:257

honey::Vec< 3, Real, Options >::zzx
VecSwizCon3 zzx() const
Definition: Vec3.h:253

honey::Vec< 3, Real, Options >::yzyz
VecSwizCon4 yzyz() const
Definition: Vec3.h:221

honey::Vec< 3, Real, Options >::xyxy
VecSwizCon4 xyxy() const
Definition: Vec3.h:164

honey::VecBase::normalize
VecS normalize(optional< Real & > len=optnull) const
Get unit vector. The pre-normalized length will be returned in len if specified.
Definition: Base.h:77

honey::Vec< 3, Real, Options >::yyxx
VecSwizCon4 yyxx() const
Definition: Vec3.h:202

honey::Vec< 3, Real, Options >::zxz
VecSwizCon3 zxz() const
Definition: Vec3.h:235

honey::VecSwizRef< 3, Real, Options >::VecSwizRef
VecSwizRef(Real &x, Real &y, Real &z)
Definition: Vec3.h:344

honey::Vec< 3, Real, Options >::Vec
Vec(Real x, Real y, Real z)
Definition: Vec3.h:66

honey::Vec< 3, Real, Options >::xxyy
VecSwizCon4 xxyy() const
Definition: Vec3.h:155

honey::matrix::priv::storageEqual
bool storageEqual(const StorageBlock< T > &lhs, const StorageBlock< T2 > &rhs)
Test between block storages.
Definition: Block.h:157

honey::Vec< 3, Real, Options >::xyxz
VecSwizCon4 xyxz() const
Definition: Vec3.h:165

honey::Vec< 3, Real, Options >::yxz
VecSwizRef3 yxz()
Definition: Vec3.h:274

honey::VecSwizCon< 3, Real, Options >
3D const swizzle vector
Definition: Vec3.h:326

honey::VecBase< Vec< Dim, Real, Options, Alloc > >::Alge
Alge_< Real > Alge
Definition: Base.h:28

honey::Vec< 3, Real, Options >::orthonormalBasis
tuple< Vec3, Vec3 > orthonormalBasis() const
Generate an orthonormal basis {u,v,this} (all unit length and perpendicular). Returns (Vec3 u...
Definition: Vec3.h:107

honey::Vec< 3, Real, Options >::zyx
VecSwizCon3 zyx() const
Definition: Vec3.h:240

honey::Vec< 3, Real, Options >::zyyz
VecSwizCon4 zyyz() const
Definition: Vec3.h:247

honey::VecSwizConBase
Definition: Swiz.h:16

honey::Vec< 3, Real, Options >::yzxz
VecSwizCon4 yzxz() const
Definition: Vec3.h:217

honey::Vec< 3, Real, Options >::operator=
Vec & operator=(const MatrixBase< T > &rhs)
Definition: Vec3.h:78

honey::VecSwizCon
Vector for const swizzle operators.
Definition: Swiz.h:10

honey::Vec< 3, Real, Options >::dot
Real dot(const Vec &v) const
Definition: Vec3.h:83

honey::Alge_::sqrtInv
static Real sqrtInv(Real x)
Inverse Square Root.
Definition: Alge.h:65

honey::Vec< 3, Real, Options >::xyz
VecSwizRef3 xyz()
Definition: Vec3.h:270

honey::VecSwizCon< 2, Real, Options >
2D const swizzle vector
Definition: Vec2.h:175

honey::Vec< 3, Real, Options >::VecSwizCon4
VecSwizCon< 4, Real, Options > VecSwizCon4
Definition: Vec3.h:55

honey::Vec< 3, Real, Options >::VecSwizCon3
VecSwizCon< 3, Real, Options > VecSwizCon3
Definition: Vec3.h:54

honey::Vec< 3, Real, Options >::xy
VecSwizCon2 xy() const
Definition: Vec3.h:161

honey::Vec< 3, Real, Options >::one
static const Vec one
Definition: Vec3.h:139

honey::Vec< 3, Real, Options >::xx
VecSwizCon2 xx() const
Definition: Vec3.h:148

honey::Vec< 3, Real, Options >::zxx
VecSwizCon3 zxx() const
Definition: Vec3.h:227

honey::Vec< 3, Real, Options >::yz
VecSwizRef2 yz()
Definition: Vec3.h:275

honey::Vec< 3, Real, Options >::xxxz
VecSwizCon4 xxxz() const
Definition: Vec3.h:152

honey::Vec< 3, Real, Options >::xyz
VecSwizCon3 xyz() const
Definition: Vec3.h:170

honey::Vec< 3, Real, Options >::Vec
Vec(Real scalar)
Construct uniform vector.
Definition: Vec3.h:68

honey::Vec< 3, Real, Options >::zxy
VecSwizCon3 zxy() const
Definition: Vec3.h:231

honey::Vec< 3, Real, Options >::Vec
Vec(const MatrixBase< T > &rhs)
Construct from vector of same dimension.
Definition: Vec3.h:75

honey::Vec< 3, Real, Options >::zzzx
VecSwizCon4 zzzx() const
Definition: Vec3.h:262

honey::Vec< 3, Real, Options >::zyy
VecSwizCon3 zyy() const
Definition: Vec3.h:244

honey::Vec< 3, Real, Options >::xzxx
VecSwizCon4 xzxx() const
Definition: Vec3.h:176

honey::Vec< 3, Real, Options >::xzxz
VecSwizCon4 xzxz() const
Definition: Vec3.h:178

honey::Vec< 3, Real, Options >::yxxz
VecSwizCon4 yxxz() const
Definition: Vec3.h:191

honey::Vec< 3, Real, Options >::yyzx
VecSwizCon4 yyzx() const
Definition: Vec3.h:210

honey::Vec< 3, Real, Options >::yzxx
VecSwizCon4 yzxx() const
Definition: Vec3.h:215

honey::Vec< 3, Real, Options >::zzz
VecSwizCon3 zzz() const
Definition: Vec3.h:261

honey::Vec< 3, Real, Options >::yxy
VecSwizCon3 yxy() const
Definition: Vec3.h:192

honey::vec::priv::StorageFieldsMixin
Definition: Storage.h:9

honey::Vec< 3, Real, Options >::xy
VecSwizRef2 xy()
Definition: Vec3.h:269

honey::Vec< 3, Real, Options >::zzxx
VecSwizCon4 zzxx() const
Definition: Vec3.h:254

honey::Vec< 3, Real, Options >::zyyx
VecSwizCon4 zyyx() const
Definition: Vec3.h:245

honey::Vec< 3, Real, Options >::yxxx
VecSwizCon4 yxxx() const
Definition: Vec3.h:189

honey::Vec< 3, Real, Options >::xyx
VecSwizCon3 xyx() const
Definition: Vec3.h:162

honey::VecSwizRef< 3, Real, Options >
3D mutable swizzle vector
Definition: Vec3.h:334

honey::Vec< 3, Real, Options >::xyyx
VecSwizCon4 xyyx() const
Definition: Vec3.h:167

honey::Vec< 3, Real, Options >::yzx
VecSwizRef3 yzx()
Definition: Vec3.h:276

honey::Alge_::abs
static Int abs(Int x)
Get absolute value of signed integer.
Definition: Alge.h:21

honey::Vec< 3, Real, Options >::zero
static const Vec zero
Definition: Vec3.h:138

honey::Vec< 3, Real, Options >::zzyx
VecSwizCon4 zzyx() const
Definition: Vec3.h:258

honey::Vec< 3, Real, Options >::xxxx
VecSwizCon4 xxxx() const
Definition: Vec3.h:150

honey::Vec< 3, Real, Options >::yx
VecSwizRef2 yx()
Definition: Vec3.h:273

honey::Vec< 3, Real, Options >::zyyy
VecSwizCon4 zyyy() const
Definition: Vec3.h:246

honey::Vec< 3, Real, Options >::zxxz
VecSwizCon4 zxxz() const
Definition: Vec3.h:230

honey::vec::priv::Traits< 3, Real, Options, std::allocator< int8 > >::Real
Real Real
Definition: Vec.h:17

honey::Vec< 3, Real, Options >::yyy
VecSwizCon3 yyy() const
Definition: Vec3.h:205

honey::Vec
N-dimensional vector.
Definition: Traits.h:12

honey::Vec< 3, Real, Options >::xz
VecSwizCon2 xz() const
Definition: Vec3.h:174

honey::Vec< 3, Real, Options >::zyx
VecSwizRef3 zyx()
Definition: Vec3.h:280

honey::Vec< 3, Real, Options >::yyzy
VecSwizCon4 yyzy() const
Definition: Vec3.h:211

honey::Vec< 3, Real, Options >::yyzz
VecSwizCon4 yyzz() const
Definition: Vec3.h:212

honey::Vec< 3, Real, Options >::yyyx
VecSwizCon4 yyyx() const
Definition: Vec3.h:206

honey::matrix::priv::Traits
Definition: Traits.h:20

honey::Vec< 3, Real, Options >::zzyz
VecSwizCon4 zzyz() const
Definition: Vec3.h:260

honey::Vec< 3, Real, Options >::yzy
VecSwizCon3 yzy() const
Definition: Vec3.h:218

honey::Vec< 3, Real, Options >::zz
VecSwizCon2 zz() const
Definition: Vec3.h:252

honey::Vec< 3, Real, Options >::Vec
Vec(const Vec4 &v)
Construct from vector ignoring the extra components.
Definition: Vec3.h:72

honey::Vec< 3, Real, Options >::yxzx
VecSwizCon4 yxzx() const
Definition: Vec3.h:197

honey::Vec< 3, Real, Options >::yyxz
VecSwizCon4 yyxz() const
Definition: Vec3.h:204

honey::Vec< 3, Real, Options >::xyy
VecSwizCon3 xyy() const
Definition: Vec3.h:166

honey::VecSwizCon< 4, Real, Options >
4D const swizzle vector
Definition: Vec4.h:641

honey::Vec< 3, Real, Options >::xyzx
VecSwizCon4 xyzx() const
Definition: Vec3.h:171

honey::Real
float Real
Real number type. See Real_ for real number operations and constants.
Definition: Real.h:21

honey::Vec< 3, Real, Options >::xxz
VecSwizCon3 xxz() const
Definition: Vec3.h:157

honey::Vec< 3, Real, Options >::zxy
VecSwizRef3 zxy()
Definition: Vec3.h:278

honey::Vec< 3, Real, Options >::Vec
Vec()
No init.
Definition: Vec3.h:65

honey::Vec< 3, Real, Options >::zx
VecSwizRef2 zx()
Definition: Vec3.h:277

honey::Vec3
Vec< 3 > Vec3
3D column vector types
Definition: Vec3.h:356

honey::Vec< 3, Real, Options >::VecSwizRef2
VecSwizRef< 2, Real, Options > VecSwizRef2
Definition: Vec3.h:56

honey::Vec< 3, Real, Options >::yxzy
VecSwizCon4 yxzy() const
Definition: Vec3.h:198

honey::Vec< 3, Real, Options >::yxx
VecSwizCon3 yxx() const
Definition: Vec3.h:188

honey::Vec< 3, Real, Options >::zyxx
VecSwizCon4 zyxx() const
Definition: Vec3.h:241

honey::VecBase
Vector base class.
Definition: Base.h:11

honey::Vec< 3, Real, Options >::yzx
VecSwizCon3 yzx() const
Definition: Vec3.h:214

honey::Vec< 3, Real, Options >::zzyy
VecSwizCon4 zzyy() const
Definition: Vec3.h:259

honey::Vec::operator=
Vec & operator=(const MatrixBase< T > &rhs)
Assign to row or column vector of any dimension. Asserts that if this vector has a fixed dimension th...
Definition: Vec.h:56

honey::Vec< 3, Real, Options >::Vec2
Vec< 2, Real > Vec2
Definition: Vec3.h:50

honey::matrix::priv::storageFill
void storageFill(StorageBlock< T > &store, typename StorageBlock< T >::Real f)
Fill block storage with scalar.
Definition: Block.h:128

Vec2.h

honey::Vec< 3, Real, Options >::yz
VecSwizCon2 yz() const
Definition: Vec3.h:213

honey::Vec< 3, Real, Options >::zyxz
VecSwizCon4 zyxz() const
Definition: Vec3.h:243

honey::Vec< 3, Real, Options >::yyyz
VecSwizCon4 yyyz() const
Definition: Vec3.h:208

honey::VecSwizRef< 3, Real, Options >::Super
VecSwizRefBase< VecSwizRef< 3, Real, Options > > Super
Definition: Vec3.h:338

honey::Vec< 3, Real, Options >::xyzz
VecSwizCon4 xyzz() const
Definition: Vec3.h:173

Swiz.h

honey::VecRow3_f
Vec< 3, Float, matrix::Option::vecRow > VecRow3_f
Definition: Vec3.h:362

honey::Vec< 3, Real, Options >::xzyz
VecSwizCon4 xzyz() const
Definition: Vec3.h:182

honey::Vec< 3, Real, Options >::yzyx
VecSwizCon4 yzyx() const
Definition: Vec3.h:219

honey::Vec< 3, Real, Options >::yxzz
VecSwizCon4 yxzz() const
Definition: Vec3.h:199

honey::Vec< 3, Real, Options >::xzx
VecSwizCon3 xzx() const
Definition: Vec3.h:175

honey::vec::priv::StorageFieldsMixin< Real, 3, Align >::z
Real z
Definition: Vec3.h:23

honey::Vec< 3, Real, Options >::yyz
VecSwizCon3 yyz() const
Definition: Vec3.h:209

honey::Vec< 3, Real, Options >::yy
VecSwizCon2 yy() const
Definition: Vec3.h:200

honey::Vec< 3, Real, Options >::zzxy
VecSwizCon4 zzxy() const
Definition: Vec3.h:255

honey::VecSwizRefBase
Definition: Swiz.h:60

honey::VecRow3_d
Vec< 3, Double, matrix::Option::vecRow > VecRow3_d
Definition: Vec3.h:363

honey::Vec< 3, Real, Options >::yyxy
VecSwizCon4 yyxy() const
Definition: Vec3.h:203

honey::Vec< 3, Real, Options >::crossUnit
Vec3 crossUnit(const Vec3 &v) const
Vector cross product, result is normalized unit vector.
Definition: Vec3.h:89

honey::Vec< 3, Real, Options >::zxxx
VecSwizCon4 zxxx() const
Definition: Vec3.h:228

honey::Vec< 3, Real, Options >::xxzz
VecSwizCon4 xxzz() const
Definition: Vec3.h:160

honey::Vec< 3, Real, Options >::zyzz
VecSwizCon4 zyzz() const
Definition: Vec3.h:251

honey::Vec< 3, Real, Options >::zyz
VecSwizCon3 zyz() const
Definition: Vec3.h:248

honey::Vec< 3, Real, Options >::yxyy
VecSwizCon4 yxyy() const
Definition: Vec3.h:194

honey::Vec< 3, Real, Options >::zxzx
VecSwizCon4 zxzx() const
Definition: Vec3.h:236

honey::VecSwizCon< 3, Real, Options >::VecSwizCon
VecSwizCon(Real x, Real y, Real z)
Definition: Vec3.h:329

honey::Vec< 3, Real, Options >::Vec
Vec(const Vec2 &v, Real z=0)
Construct from 2D vector.
Definition: Vec3.h:70

honey::Vec< 3, Real, Options >::orthonormalize
static void orthonormalize(Vec3 &u, Vec3 &v, Vec3 &w)
Gram-Schmidt orthonormalization. Useful for re-normalizing an orthonormal basis to eliminate rounding...
Definition: Vec3.h:92

honey::Vec< 3, Real, Options >::yxyz
VecSwizCon4 yxyz() const
Definition: Vec3.h:195

honey::Vec< 3, Real, Options >::xxzy
VecSwizCon4 xxzy() const
Definition: Vec3.h:159

honey::Vec< 3, Real, Options >::yzxy
VecSwizCon4 yzxy() const
Definition: Vec3.h:216

honey::Vec< 3, Real, Options >::xzzz
VecSwizCon4 xzzz() const
Definition: Vec3.h:186

honey::Vec< 3, Real, Options >::zx
VecSwizCon2 zx() const
Definition: Vec3.h:226

honey::Vec< 3, Real, Options >::xxx
VecSwizCon3 xxx() const
Definition: Vec3.h:149

honey::Vec< 3, Real, Options >::xxxy
VecSwizCon4 xxxy() const
Definition: Vec3.h:151

honey::Vec< 3, Real, Options >::Vec3
Vec Vec3
Definition: Vec3.h:51

honey::Vec< 3, Real, Options >::zyzx
VecSwizCon4 zyzx() const
Definition: Vec3.h:249

honey::matrix::priv::storageCopy
void storageCopy(const StorageBlock< Src > &src, StorageBlock< Dst > &dst)
Copy between block and dense storages.
Definition: Block.h:84

honey::Vec< 3, Real, Options >::xyyz
VecSwizCon4 xyyz() const
Definition: Vec3.h:169

honey::Vec< 3, Real, Options >::xyxx
VecSwizCon4 xyxx() const
Definition: Vec3.h:163

honey::vec::priv::StorageFieldsMixin< Real, 3, Align >::y
Real y
Definition: Vec3.h:22

honey::Vec< 3, Real, Options >::zzzz
VecSwizCon4 zzzz() const
Definition: Vec3.h:264

honey::Vec< 3, Real, Options >::xxyx
VecSwizCon4 xxyx() const
Definition: Vec3.h:154

honey::Vec< 3, Real, Options >::zzzy
VecSwizCon4 zzzy() const
Definition: Vec3.h:263

honey::vec::priv::StorageFieldsMixin< Real, 3, Align >::x
Real x
Definition: Vec3.h:21

honey::Vec< 3, Real, Options >::xzyy
VecSwizCon4 xzyy() const
Definition: Vec3.h:181

honey::MatrixBase
Matrix base class.
Definition: Base.h:17

honey::Vec< 3, Real, Options >::yzzz
VecSwizCon4 yzzz() const
Definition: Vec3.h:225

honey::VecRow3
Vec< 3, Real, matrix::Option::vecRow > VecRow3
3D row vector types
Definition: Vec3.h:361

honey::Vec< 3, Real, Options >::zyzy
VecSwizCon4 zyzy() const
Definition: Vec3.h:250

honey::Vec< 3, Real, Options >::yyx
VecSwizCon3 yyx() const
Definition: Vec3.h:201

honey::Vec< 3, Real, Options >::zxyz
VecSwizCon4 zxyz() const
Definition: Vec3.h:234

honey::Vec< 3, Real, Options >::xxyz
VecSwizCon4 xxyz() const
Definition: Vec3.h:156

honey::Vec< 3, Real, Options >::yzyy
VecSwizCon4 yzyy() const
Definition: Vec3.h:220

honey::Vec< 3, Real, Options >::xxzx
VecSwizCon4 xxzx() const
Definition: Vec3.h:158

honey::Vec< 3, Real, Options >::VecSwizCon2
VecSwizCon< 2, Real, Options > VecSwizCon2
Definition: Vec3.h:53

honey::VecSwizRef
Vector reference holder for mutable swizzle operators.
Definition: Swiz.h:54

honey
Global Honeycomb namespace.

honey::Vec< 3, Real, Options >::Vec4
Vec< 4, Real > Vec4
Definition: Vec3.h:52

honey::Vec< 3, Real, Options >::axisX
static const Vec axisX
Definition: Vec3.h:140

honey::matrix::priv::Traits< Vec< 3, Real, Options > >::Storage
vec::priv::StorageFields< Vec< 3, Real, Options > > Storage
Definition: Vec3.h:13

honey::VecSwizRef< 2, Real, Options >
2D mutable swizzle vector
Definition: Vec2.h:183

honey::Vec< 3, Real, Options >::zxzy
VecSwizCon4 zxzy() const
Definition: Vec3.h:237

honey::Vec< 3, Real, Options >::zyxy
VecSwizCon4 zyxy() const
Definition: Vec3.h:242

honey::Vec< 3, Real, Options >::xzxy
VecSwizCon4 xzxy() const
Definition: Vec3.h:177

honey::Vec< 3, Real, Options >::xzyx
VecSwizCon4 xzyx() const
Definition: Vec3.h:180

honey::Vec< 3, Real, Options >::xzy
VecSwizCon3 xzy() const
Definition: Vec3.h:179

honey::Vec< 3, Real, Options >::yzzy
VecSwizCon4 yzzy() const
Definition: Vec3.h:224