Main Page   Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

Matnnf.h

Go to the documentation of this file.
00001 // Copyright NVIDIA Corporation 2002-2004
00002 // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
00003 // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
00004 // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
00005 // AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
00006 // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
00007 // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
00008 // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
00009 // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
00010 // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 
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   // non-member functions
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   // "inlines"
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 } // end namspace nvmath

Generated on Tue Mar 1 13:19:18 2005 for NVSGSDK by NVIDIA