Mat3.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 MAT3_H_
#define MAT3_H_
//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
// must include types.h first for Real and GLEW if required
#include "Types.h"
#include <array>
#include <ostream>

namespace ngl
{
class Quaternion;
class Mat4;
class Vec3;

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


class NGL_DLLEXPORT Mat3
{
        // added after clang++ build
public:

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3(Real _00,Real _01,Real _02,Real _10,Real _11,Real _12,Real _20,Real _21,Real _22) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3( const Mat4 &_m ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3( const Mat3& _m ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3( const Real _m ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setAtXY( GLint _x,GLint _y,Real _equals ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& null() noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& identity() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3 operator*( const Mat3 &_m  ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& operator*=( const Mat3 &_m ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3 operator+( const Mat3 &_m ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& operator+=( const Mat3 &_m ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3 operator*(  Real _i ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& operator*=( Real _i ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 operator * ( const Vec3 &_v ) const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  const Mat3& transpose() noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotateX( Real _deg) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void rotateY(Real _deg) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
   void rotateZ( Real _deg ) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void scale( Real _x, Real _y, Real _z ) noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real determinant() const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat3 inverse() noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void euler( Real _angle, Real _x, Real _y, Real _z) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real * openGL() noexcept{return &m_openGL[0];}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getLeftVector() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getRightVector() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getUpVector() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getDownVector() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getForwardVector() const  noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec3 getBackVector() const  noexcept;

public :
 //----------------------------------------------------------------------------------------------------------------------
 // allow access to some of the other classes
 friend class Transformation;
 friend class Quaternion;
 friend class Camera;
 //----------------------------------------------------------------------------------------------------------------------

#ifndef BUILDING_DOCS
#pragma pack(push,1)

  union
  {
#endif
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    Real m_m[3][3];
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    //Real m_openGL[9];
    std::array<Real,9> m_openGL={{
                                 1.0f,0.0f,0.0f,
                                 0.0f,1.0f,0.0f,
                                 0.0f,0.0f,1.0f
                                 }};
#ifndef BUILDING_DOCS

    struct
    {
#endif
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_00;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_01;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_02;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_10;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_11;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_12;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_20;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_21;
      //----------------------------------------------------------------------------------------------------------------------
      //----------------------------------------------------------------------------------------------------------------------
      Real m_22;
      #ifndef BUILDING_DOCS
    };
#pragma pack(pop)

   };
#endif
  }; // end of class
// free function for matrix comparison use in unit tests etc
inline bool operator==(const ngl::Mat3 &_m1 , const ngl::Mat3 &_m2)
{
  for(size_t i=0; i<_m1.m_openGL.size(); ++i)
  {
    if(!( FCompare(_m1.m_openGL[i] , _m2.m_openGL[i] )))
    {
      return false;
    }
  }
  return true;
}
}// end of namespace

#endif
//----------------------------------------------------------------------------------------------------------------------