Vec4.h

Go to the documentation of this file.

/*
  Copyright (C) 2009 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 VEC4_H_
#define VEC4_H_
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

// must include types.h first for Real and GLEW if required
#include "Types.h"
#include "Vec2.h"
#include "Vec3.h"
#include <array>
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------


namespace ngl
{
// pre-declare the matrix class

class Mat4;

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


class NGL_DLLEXPORT Vec4
{
// added after clang++ build
friend class Mat4;
friend class VBOPrimitives;
friend class Transformation;
friend class Quaternion;
friend class Obj;

public:
  Vec4() : m_x(0.0f),m_y(0.0f),m_z(0.0f),m_w(1.0f){}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4(const Vec4& _v)=default;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4(const Vec3& _v, float _w=1.0f)  noexcept:
  m_x(_v.m_x),
  m_y(_v.m_y),
  m_z(_v.m_z),
  m_w(_w){;}

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
   Vec4( Real _x, Real _y, Real _z,  Real _w=1.0f ) noexcept:
   m_x(_x),
   m_y(_y),
   m_z(_z),
   m_w(_w){;}

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real dot( const Vec4 &_b )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set(Real _x, Real _y,  Real _z, Real _w=1.0) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set(const Vec4& _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( const Vec3 &_v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void null() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 toVec3() const  noexcept{ return Vec3(m_x,m_y,m_z);}

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 toVec2() const  noexcept{ return Vec2(m_x,m_y);}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real& operator[](  int _i  )  noexcept;
  const Real& operator[](  int _i ) const  noexcept{ return m_openGL[_i]; }

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real length() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 &normalize() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void cross(const Vec4& _v1, const Vec4& _v2) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 cross(const Vec4& _b)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator+=( const Vec4& _v) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator-=(const Vec4& _v ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator *(Real _i)const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator +(const Vec4 &_v)const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator/(Real _v)const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator/=(Real _v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void operator*=( Real _v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator-(const Vec4& _v)const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator*( const Vec4 &_v)const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 &operator =( const Vec4 &_v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 &operator =(const Vec3 &_v) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 &operator =( Real _v) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 &operator-() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator==( const Vec4 &_v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator!=(  const Vec4 &_v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator/( const Vec4& _v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real angleBetween( const Vec4 &_v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real inner( const Vec4& _v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 outer(const Vec4& _v)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real lengthSquared() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator*( const Mat4 &_m)const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real* openGL() noexcept{return &m_openGL[0];}

  static Vec4 up()  {return Vec4(0.0f,1.0f,0.0f,0.0f); }
  static Vec4 down()  {return Vec4(0.0f,-1.0f,0.0f,0.0f); }

  static Vec4 left()  {return Vec4(-1.0f,0.0f,0.0f,0.0f); }
  static Vec4 right()  {return Vec4(1.0f,0.0f,0.0f,0.0f); }

  static Vec4 in()  {return Vec4(0.0f,0.0f,1.0f,0.0f); }
  static Vec4 out()  {return Vec4(0.0f,0.0f,-1.0f,0.0f); }

  static Vec4 zero()  {return Vec4(0.0f,0.0f,0.0f,0.0f); }


public :
#pragma pack(push,1)

  union
  {
    struct
    {
      Real m_x; 
      Real m_y; 
      Real m_z; 
      Real m_w; 
    };
    struct
    {
      Real m_r; 
      Real m_g; 
      Real m_b; 
      Real m_a; 
    };
#pragma pack(pop)
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  std::array <Real,4> m_openGL;
  };

};



//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
inline Vec4 operator *(Real _k, const Vec4 &_v) noexcept
{
  return Vec4(_k*_v.m_x, _k*_v.m_y, _k*_v.m_z,_v.m_w);
}

}
#endif

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