Vec2.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 VEC2_H_
#define VEC2_H_
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------

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


namespace ngl
{

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

class Vec4;
class NGL_DLLEXPORT Vec2
{

public:

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( Real _x, Real _y  ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set(const Vec2& _v ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set(const Vec4& _v) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void set( const Vec2* _v) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2( const Vec2& _v)  noexcept :
        m_x(_v.m_x),
        m_y(_v.m_y){;}

   //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
   Vec2(Real _x=0.0, Real _y=0.0 )  noexcept:
   m_x(_x),
   m_y(_y){;}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2( Real _x  )  noexcept:
  m_x(_x),
  m_y(_x){;}

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void null() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real& operator[]( int _i )  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------

  const Real& operator[]( int _i ) const  noexcept{ return m_openGL[_i]; }


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

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

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 operator *(const Real &_i  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real length() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real lengthSquared() const noexcept;


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

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

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

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

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 &operator =( const Vec2 &_v ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 operator-() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator==( const Vec2 &_v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  bool operator!=( const Vec2 &_v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 operator/( const Vec2& _v )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec2 operator *(  Real _i )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void normalize() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real dot( const Vec2 &_b  )const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real* openGL() noexcept{return &m_openGL[0];}

public :
#pragma pack(push,1)

#ifndef BUILDING_DOCS
  union
  {
    struct
    {
#endif
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_x;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_y;

#ifndef BUILDING_DOCS
    };
#endif
#pragma pack(pop)
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------

  std::array <Real,2> m_openGL;
#ifndef BUILDING_DOCS
  };
#endif

};

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



} // end namespace ngl
#endif

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