00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #pragma once
00013
00015 #include "nvsgcommon.h"
00016
00017 #include "nvmath/Vecnf.h"
00018
00019 namespace nvmath
00020 {
00022 template<unsigned char n> class Matnnf
00023 {
00024 public:
00026
00027 Matnnf<n>( void );
00028
00030
00031 Vecnf<n> & operator[]( size_t i
00032 );
00033
00035
00036 const Vecnf<n> & operator[]( size_t i
00037 ) const;
00038
00040
00041 Matnnf<n> operator~( void ) const;
00042
00044
00045 Matnnf<n> operator-( void ) const;
00046
00048
00049 Matnnf<n> operator*( float f
00050 ) const;
00051
00053
00054 Vecnf<n> operator*( const Vecnf<n>& v
00055 ) const;
00056
00058
00059 Matnnf<n> operator/( float f
00060 ) const;
00061
00063
00064 Matnnf<n> operator+( const Matnnf<n> &v
00065 ) const;
00066
00068
00069 Matnnf<n> operator-( const Matnnf<n> &v
00070 ) const;
00071
00073
00074 bool operator==( const Matnnf<n> &m
00075 ) const;
00076
00078
00079 bool operator!=( const Matnnf<n> &m
00080 ) const;
00081
00083
00084 Matnnf<n> & operator=( const Matnnf<n> &m
00085 );
00086
00088
00089 Matnnf<n> & operator*=( float f
00090 );
00091
00093
00094 Matnnf<n> & operator*=( const Matnnf<n> &m
00095 );
00096
00098
00099 Matnnf<n> & operator/=( float f
00100 );
00101
00103
00104 Matnnf<n> & operator+=( const Matnnf<n> &m
00105 );
00106
00108
00109 Matnnf<n> & operator-=( const Matnnf<n> &m
00110 );
00111
00113
00114 const float* getPtr( void ) const;
00115
00116 private:
00117 Vecnf<n> m_mat[n];
00118 };
00119
00120
00121
00122
00126 template<unsigned char n> bool isIdentity( const Matnnf<n> &m
00127 )
00128 {
00129 bool identity = true;
00130 for ( size_t i=0 ; identity && i<n ; i++ )
00131 {
00132 for ( size_t j=0 ; identity && j<i ; j++ )
00133 {
00134 identity = ( fabsf( m[i][j] ) <= FLT_EPSILON );
00135 }
00136 if ( identity )
00137 {
00138 identity = ( fabsf( m[i][i] - 1.0f ) <= FLT_EPSILON );
00139 }
00140 for ( size_t j=i+1 ; identity && j<n ; j++ )
00141 {
00142 identity = ( fabsf( m[i][j] ) <= FLT_EPSILON );
00143 }
00144 }
00145 return( identity );
00146 }
00147
00152 template<unsigned char n> bool isNormalized( const Matnnf<n> &mat
00153 )
00154 {
00155 bool normalized = true;
00156 for ( size_t i=0 ; normalized && i<n ; i++ )
00157 {
00158 normalized = isNormalized( mat[i] );
00159 }
00160 for ( size_t i=0 ; normalized && i<n ; i++ )
00161 {
00162 Vecnf<n> v;
00163 for ( size_t j=0 ; j<n ; j++ )
00164 {
00165 v[j] = mat[j][i];
00166 }
00167 normalized = isNormalized( v );
00168 }
00169 return( normalized );
00170 }
00171
00177 template<unsigned char n> bool isOrthogonal( const Matnnf<n> &mat
00178 )
00179 {
00180 bool orthogonal = true;
00181 for ( size_t i=0 ; orthogonal && i<n-1 ; i++ )
00182 {
00183 for ( size_t j=i+1 ; orthogonal && j<n ; j++ )
00184 {
00185 orthogonal = areOrthogonal( mat[i], mat[j] );
00186 }
00187 }
00188 if ( orthogonal )
00189 {
00190 Matnnf<n> tmp = ~mat;
00191 for ( size_t i=0 ; orthogonal && i<n-1 ; i++ )
00192 {
00193 for ( size_t j=i+1 ; orthogonal && j<n ; j++ )
00194 {
00195 orthogonal = areOrthogonal( tmp[i], tmp[j] );
00196 }
00197 }
00198 }
00199 return( orthogonal );
00200 }
00201
00205 template<unsigned char n> Matnnf<n> operator*( const Matnnf<n> &m0, const Matnnf<n> &m1 )
00206 {
00207 Matnnf<n> ret;
00208 for ( size_t i=0 ; i<n ; i++ )
00209 {
00210 for ( size_t j=0 ; j<n ; j++ )
00211 {
00212 float f = 0.0f;
00213 for ( size_t k=0 ; k<n ; k++ )
00214 {
00215 f += m0[i][k] * m1[k][j];
00216 }
00217 ret[i][j] = f;
00218 }
00219 }
00220 return( ret );
00221 }
00222
00223
00224
00225
00226 template<unsigned char n> Matnnf<n>::Matnnf( void )
00227 {
00228 }
00229
00230 template<unsigned char n> Vecnf<n> & Matnnf<n>::operator[]( size_t i )
00231 {
00232 __ASSERT( 0 <= i && i < n );
00233 return( m_mat[i] );
00234 }
00235
00236 template<unsigned char n> const Vecnf<n> & Matnnf<n>::operator[]( size_t i ) const
00237 {
00238 __ASSERT( 0 <= i && i < n );
00239 return( m_mat[i] );
00240 }
00241
00242 template<unsigned char n> Matnnf<n> Matnnf<n>::operator~( void ) const
00243 {
00244 Matnnf<n> ret;
00245 for ( size_t i=0 ; i<n ; i++ )
00246 {
00247 for ( size_t j=0 ; j<n ; j++ )
00248 {
00249 ret[i][j] = m_mat[j][i];
00250 }
00251 }
00252 return( ret );
00253 }
00254
00255 template<unsigned char n> Matnnf<n> Matnnf<n>::operator-( void ) const
00256 {
00257 Matnnf<n> ret;
00258 for ( size_t i=0 ; i<n ; i++ )
00259 {
00260 ret[i] = - m_mat[i];
00261 }
00262 }
00263
00264 template<unsigned char n> Matnnf<n> Matnnf<n>::operator*( float f ) const
00265 {
00266 Matnnf<n> ret( *this );
00267 return( ret *= f );
00268 }
00269
00270 template<unsigned char n> Vecnf<n> Matnnf<n>::operator*( const Vecnf<n> &v ) const
00271 {
00272 Vecnf<n> ret;
00273 for ( size_t i=0 ; i<n ; i++ )
00274 {
00275 ret[i] = m_mat[i] * v;
00276 }
00277 return( ret );
00278 }
00279
00280 template<unsigned char n> Matnnf<n> Matnnf<n>::operator/( float f ) const
00281 {
00282 __ASSERT( fabs( f ) > FLT_EPSILON );
00283 Matnnf<n> ret( *this );
00284 return( ret /= f );
00285 }
00286
00287 template<unsigned char n> Matnnf<n> Matnnf<n>::operator+( const Matnnf<n> &m ) const
00288 {
00289 Matnnf<n> ret( *this );
00290 return( ret += m );
00291 }
00292
00293 template<unsigned char n> Matnnf<n> Matnnf<n>::operator-( const Matnnf<n> &m ) const
00294 {
00295 Matnnf<n> ret( *this );
00296 return( ret -= m );
00297 }
00298
00299 template<unsigned char n> bool Matnnf<n>::operator==( const Matnnf<n> &m ) const
00300 {
00301 bool equal = true;
00302 for ( unsigned char i=0 ; equal && i<n ; i++ )
00303 {
00304 equal = ( m_mat[i] == m[i] );
00305 }
00306 return( equal );
00307 }
00308
00309 template<unsigned char n> bool Matnnf<n>::operator!=( const Matnnf<n> &m ) const
00310 {
00311 return( ! ( *this == m ) );
00312 }
00313
00314 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator=( const Matnnf<n> &m )
00315 {
00316 for ( size_t i=0 ; i<n ; i++ )
00317 {
00318 m_mat[i] = m[i];
00319 }
00320 return( *this );
00321 }
00322
00323 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator*=( float f )
00324 {
00325 for ( size_t i=0 ; i<n ; i++ )
00326 {
00327 m_mat[i] *= f;
00328 }
00329 return( *this );
00330 }
00331
00332 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator*=( const Matnnf<n> &m )
00333 {
00334 *this = *this * m;
00335 return( *this );
00336 }
00337
00338 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator/=( float f )
00339 {
00340 __ASSERT( fabs( f ) > FLT_EPSILON );
00341 for ( size_t i=0 ; i<n ; i++ )
00342 {
00343 m_mat[i] /= f;
00344 }
00345 return( *this );
00346 }
00347
00348 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator+=( const Matnnf<n> &m )
00349 {
00350 for ( size_t i=0 ; i<n ; i++ )
00351 {
00352 m_mat[i] += m[i];
00353 }
00354 return( *this );
00355 }
00356
00357 template<unsigned char n> Matnnf<n> & Matnnf<n>::operator-=( const Matnnf<n> &m )
00358 {
00359 for ( size_t i=0 ; i<n ; i++ )
00360 {
00361 m_mat[i] -= m[i];
00362 }
00363 return( *this );
00364 }
00365
00366 template<unsigned char n> const float * Matnnf<n>::getPtr( void ) const
00367 {
00368 return( m_mat[0].getPtr() );
00369 }
00370
00371 }