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

namespace ngl
{
class Vec4;
class Vec3;
class Quaternion;



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


class NGL_DLLEXPORT Mat4
{
  // added after clang++ build
  friend class Vec4;
public:

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4(Real _m[4][4]) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4(Real _00,Real _01,Real _02,Real _03,
       Real _10,Real _11,Real _12,Real _13,
       Real _20,Real _21,Real _22,Real _23,
       Real _30,Real _31,Real _32,Real _33) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4(const Mat4& _m) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4(Real _m) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4& operator =(const Mat4& _m) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void setAtXY(GLint _x, GLint _y, Real _equals) noexcept;

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

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

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

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

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void subMatrix3x3(const int _i,const int _j,Real o_mat[]) const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void as3x3Array(Real _d[9]) const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4 inverse() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Quaternion asQuaternion() const noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Vec4 operator * (const Vec4 &_v) const noexcept;

  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  void euler(const Real _angle, const Real _x, const Real _y, const Real _z) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Real * openGL() noexcept{return &m_openGL[0];}
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4 Adjacent(const Mat4 &_mat) noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  Mat4 Adjacent() noexcept;
  //----------------------------------------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------------------------------------
  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;
 //----------------------------------------------------------------------------------------------------------------------
#pragma pack(push,1)

  union
  {
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    Real m_m[4][4];
    //----------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------
    std::array<Real,16> m_openGL={{
                                    1.0f,0.0f,0.0f,0.0f,
                                    0.0f,1.0f,0.0f,0.0f,
                                    0.0f,0.0f,1.0f,0.0f,
                                    0.0f,0.0f,0.0f,1.0f
                                  }};

    struct
    {
        struct
        {
          Real m_00; 
          Real m_01; 
          Real m_02; 
          Real m_03; 
          Real m_10; 
          Real m_11; 
          Real m_12; 
          Real m_13; 
          Real m_20; 
          Real m_21; 
          Real m_22; 
          Real m_23; 
          Real m_30; 
          Real m_31; 
          Real m_32; 
          Real m_33; 
        };
    };
   };
#pragma pack(pop)
  }; // end of class


// free function for matrix comparison use in unit tests etc
inline bool operator==(const ngl::Mat4 &_m1 , const ngl::Mat4 &_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
//----------------------------------------------------------------------------------------------------------------------