LCOV - code coverage report
Current view: top level - algs/Qslim - Mat4.h (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 27 33 81.8 %
Date: 2020-07-01 15:24:36 Functions: 10 13 76.9 %
Branches: 17 44 38.6 %

           Branch data     Line data    Source code
       1                 :            : #ifndef GFXMATH_MAT4_INCLUDED // -*- C++ -*-
       2                 :            : #define GFXMATH_MAT4_INCLUDED
       3                 :            : 
       4                 :            : /************************************************************************
       5                 :            : 
       6                 :            :   4x4 Matrix class
       7                 :            : 
       8                 :            :   $Id: Mat4.h,v 1.14 1997/06/18 15:55:22 garland Exp $
       9                 :            : 
      10                 :            :  ************************************************************************/
      11                 :            : 
      12                 :            : #include "Vec3.h"
      13                 :            : #include "Vec4.h"
      14                 :            : 
      15                 :            : class Mat4
      16                 :            : {
      17                 :            : private:
      18                 :            :     Vec4 row[4];
      19                 :            : 
      20                 :            : protected:
      21                 :            : 
      22                 :            :     inline void copy(const Mat4& m);
      23                 :          0 :     inline Vec4 col(int i) const
      24                 :          0 :         { return Vec4(row[0][i],row[1][i],row[2][i],row[3][i]); }
      25                 :            : 
      26                 :            : public:
      27                 :            :     // Standard matrices
      28                 :            :     static Mat4 identity;
      29                 :            :     static Mat4 zero;
      30                 :            :     static Mat4 unit;
      31                 :            : 
      32                 :            :     static Mat4 trans(double,double,double);
      33                 :            :     static Mat4 scale(double,double,double);
      34                 :            :     static Mat4 xrot(double); //
      35                 :            :     static Mat4 yrot(double); // Arguments are in radians
      36                 :            :     static Mat4 zrot(double); //
      37                 :            : 
      38                 :            : 
      39                 :            :     // Standard constructors
      40         [ +  + ]:     363696 :     Mat4() { copy(zero); }
      41                 :      60850 :     Mat4(const Vec4& r0,const Vec4& r1,const Vec4& r2,const Vec4& r3)
      42         [ +  + ]:     304250 :     { row[0]=r0; row[1]=r1; row[2]=r2; row[3]=r3; }
      43         [ +  + ]:     823404 :     Mat4(const Mat4& m) { copy(m); }
      44                 :            : 
      45                 :            :     // Access methods
      46                 :            :     // M(i, j) == row i;col j
      47                 :   30469028 :     double& operator()(int i, int j)       { return row[i][j]; }
      48                 :    1212320 :     double  operator()(int i, int j) const { return row[i][j]; }
      49                 :            :     const Vec4& operator[](int i) const { return row[i]; }
      50                 :            : 
      51                 :            :     // Comparison methods
      52                 :            :     inline int operator==(const Mat4&);
      53                 :            : 
      54                 :            :     // Assignment methods
      55                 :          0 :     inline Mat4& operator=(const Mat4& m) { copy(m); return *this; }
      56                 :            :     inline Mat4& operator+=(const Mat4& m);
      57                 :            :     inline Mat4& operator-=(const Mat4& m);
      58                 :            : 
      59                 :            :     inline Mat4& operator*=(double s);
      60                 :            :     inline Mat4& operator/=(double s);
      61                 :            : 
      62                 :            : 
      63                 :            :     // Arithmetic methods
      64                 :            :     inline Mat4 operator+(const Mat4& m) const;
      65                 :            :     inline Mat4 operator-(const Mat4& m) const;
      66                 :            :     inline Mat4 operator-() const;
      67                 :            : 
      68                 :            :     inline Mat4 operator*(double s) const;
      69                 :            :     inline Mat4 operator/(double s) const;
      70                 :            :     Mat4 operator*(const Mat4& m) const;
      71                 :            : 
      72                 :            :     inline Vec4 operator*(const Vec4& v) const; // [x y z w]
      73                 :            :     inline Vec3 operator*(const Vec3& v) const; // [x y z w]
      74                 :            : 
      75                 :            :     // Matrix operations
      76                 :            :     double det() const;
      77                 :            :     Mat4 transpose() const;
      78                 :            :     Mat4 adjoint() const;
      79                 :            :     double inverse(Mat4&) const;
      80                 :            :     double cramerInverse(Mat4&) const;
      81                 :            : 
      82                 :            :     // Output methods
      83                 :            :     friend std::ostream& operator<<(std::ostream&, const Mat4&);
      84                 :            : };
      85                 :            : 
      86                 :            : 
      87                 :            : 
      88                 :     197850 : inline void Mat4::copy(const Mat4& m)
      89                 :            : {
      90                 :     197850 :     row[0] = m.row[0]; row[1] = m.row[1];
      91                 :     197850 :     row[2] = m.row[2]; row[3] = m.row[3];
      92                 :     197850 : }
      93                 :            : 
      94                 :            : inline int Mat4::operator==(const Mat4& m)
      95                 :            : {
      96                 :            :     return row[0]==m.row[0] &&
      97                 :            :            row[1]==m.row[1] &&
      98                 :            :            row[2]==m.row[2] &&
      99                 :            :            row[3]==m.row[3] ;
     100                 :            : }
     101                 :            : 
     102                 :      31744 : inline Mat4& Mat4::operator+=(const Mat4& m)
     103                 :            : {
     104                 :      31744 :     row[0] += m.row[0]; row[1] += m.row[1];
     105                 :      31744 :     row[2] += m.row[2]; row[3] += m.row[3];
     106                 :      31744 :     return *this;
     107                 :            : }
     108                 :            : 
     109                 :            : inline Mat4& Mat4::operator-=(const Mat4& m)
     110                 :            : {
     111                 :            :     row[0] -= m.row[0]; row[1] -= m.row[1];
     112                 :            :     row[2] -= m.row[2]; row[3] -= m.row[3];
     113                 :            :     return *this;
     114                 :            : }
     115                 :            : 
     116                 :        400 : inline Mat4& Mat4::operator*=(double s)
     117                 :            : {
     118                 :        400 :     row[0] *= s; row[1] *= s; row[2] *= s; row[3] *= s;
     119                 :        400 :     return *this;
     120                 :            : }
     121                 :            : 
     122                 :            : inline Mat4& Mat4::operator/=(double s)
     123                 :            : {
     124                 :            :     row[0] /= s; row[1] /= s; row[2] /= s; row[3] /= s;
     125                 :            :     return *this;
     126                 :            : }
     127                 :            : 
     128                 :      60616 : inline Mat4 Mat4::operator+(const Mat4& m) const
     129                 :            : {
     130         [ +  - ]:      60616 :     return Mat4(row[0]+m.row[0],
     131         [ +  - ]:      60616 :                 row[1]+m.row[1],
     132         [ +  - ]:      60616 :                 row[2]+m.row[2],
     133         [ +  - ]:     121232 :                 row[3]+m.row[3]);
     134                 :            : }
     135                 :            : 
     136                 :            : inline Mat4 Mat4::operator-(const Mat4& m) const
     137                 :            : {
     138                 :            :     return Mat4(row[0]-m.row[0],
     139                 :            :                 row[1]-m.row[1],
     140                 :            :                 row[2]-m.row[2],
     141                 :            :                 row[3]-m.row[3]);
     142                 :            : }
     143                 :            : 
     144                 :            : inline Mat4 Mat4::operator-() const
     145                 :            : {
     146                 :            :     return Mat4(-row[0], -row[1], -row[2], -row[3]);
     147                 :            : }
     148                 :            : 
     149                 :            : inline Mat4 Mat4::operator*(double s) const
     150                 :            : {
     151                 :            :     return Mat4(row[0]*s, row[1]*s, row[2]*s, row[3]*s);
     152                 :            : }
     153                 :            : 
     154                 :          0 : inline Mat4 Mat4::operator/(double s) const
     155                 :            : {
     156 [ #  # ][ #  # ]:          0 :     return Mat4(row[0]/s, row[1]/s, row[2]/s, row[3]/s);
         [ #  # ][ #  # ]
     157                 :            : }
     158                 :            : 
     159                 :            : inline Vec4 Mat4::operator*(const Vec4& v) const
     160                 :            : {
     161                 :            :     return Vec4(row[0]*v, row[1]*v, row[2]*v, row[3]*v);
     162                 :            : }
     163                 :            : 
     164                 :            : //
     165                 :            : // Transform a homogeneous 3-vector and reproject into normal 3-space
     166                 :            : //
     167                 :          4 : inline Vec3 Mat4::operator*(const Vec3& v) const
     168                 :            : {
     169         [ +  - ]:          4 :     Vec4 u=Vec4(v,1);
     170         [ +  - ]:          4 :     double w=row[3]*u;
     171                 :            : 
     172         [ -  + ]:          4 :     if(w==0.0)
     173 [ #  # ][ #  # ]:          0 :         return Vec3(row[0]*u, row[1]*u, row[2]*u);
         [ #  # ][ #  # ]
     174                 :            :     else
     175 [ +  - ][ +  - ]:          4 :         return Vec3(row[0]*u/w, row[1]*u/w, row[2]*u/w);
         [ +  - ][ +  - ]
     176                 :            : }
     177                 :            : 
     178                 :            : inline std::ostream& operator<<(std::ostream& out, const Mat4& M)
     179                 :            : {
     180                 :            :     return out<<M.row[0]<<std::endl<<M.row[1]<<std::endl<<M.row[2]<<std::endl<<M.row[3];
     181                 :            : }
     182                 :            : 
     183                 :            : 
     184                 :            : // GFXMATH_MAT4_INCLUDED
     185                 :            : #endif

Generated by: LCOV version 1.11