Vec3.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 Jon Macey

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef VEC3_H_
#define VEC3_H_
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
// must include types.h first for Real and GLEW if required
#include "Types.h"
#include <array>
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------


namespace ngl
{
// pre-declare the vector class
class Vec4;
class Mat3;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------


class NGL_DLLEXPORT Vec3
{

public:

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3() : m_x(0.0f),m_y(0.0f),m_z(0.0f) {}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3(const Vec3& _v)=default;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3(Real _x,  Real _y, Real _z) noexcept:
        m_x(_x),m_y(_y),m_z(_z){}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( Real _x,  Real _y,  Real _z) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( const Vec3& _v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( const Vec4& _v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real dot(const Vec3 &_b  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void null() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real& operator[]( size_t & _i )  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Real& operator[]( size_t & _i ) const  noexcept{ return m_openGL[_i]; }

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void normalize() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real inner(const Vec3& _v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------

  Mat3 outer(const Vec3 &_v)  const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real length() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real lengthSquared() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator+=(const Vec3& _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator-=( const Vec3& _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator *( Real _i )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator +(const Vec3 &_v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator/(Real _v  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator/=( Real _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator*=( Real _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator-(const Vec3  &_v   )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator*( const Vec3 &_v  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 &operator =( const Vec3 &_v )=default;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 &operator =(const Vec4 &_v  ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 &operator =(Real _v ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator*(const Mat3 &_m  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator-() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator==( const Vec3 &_v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator!=( const Vec3 &_v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator/( const Vec3& _v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void cross(const Vec3& _v1, const Vec3& _v2 ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 cross(const Vec3& _b )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void clamp(float _min, float _max) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void clamp(float _max) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 reflect(const Vec3 & _n) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  inline Real* openGL() noexcept{return &m_openGL[0];}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 up()  {return Vec3(0.0f,1.0f,0.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 down()  {return Vec3(0.0f,-1.0f,0.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 left()  {return Vec3(-1.0f,0.0f,0.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 right()  {return Vec3(1.0f,0.0f,0.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 in()  {return Vec3(0.0f,0.0f,1.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 out()  {return Vec3(0.0f,0.0f,-1.0f); }
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  static Vec3 zero()  {return Vec3(0.0f,0.0f,0.0f); }

public :
#pragma pack(push,1)

  union
  {
    struct
    {
      Real m_x; 
      Real m_y; 
      Real m_z; 

    };
    struct
    {
      Real m_r; 
      Real m_g; 
      Real m_b; 

    };
#pragma pack(pop)
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  // we have to set the values here rather than above due to C++ spec
  // see section implicitly declared as defaulted (8.4).
  std::array<Real,3> m_openGL;
  };
};
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
inline Vec3 operator *(Real _k, const Vec3 &_v) noexcept
{
  return Vec3(_k*_v.m_x, _k*_v.m_y, _k*_v.m_z);
}


} // end namespace ngl
#endif

//----------------------------------------------------------------------------------------------------------------------