Vec3f.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API 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 2 of the License, or
//    (at your option) any later version.
//
//    H3D API 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 H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//

#ifndef __VEC3F_H__
#define __VEC3F_H__

#include "H3DApi.h"
#include "H3DMath.h"
#include "H3DBasicTypes.h"
#include "H3DTemplateOperators.h"
#include "Exception.h"

namespace H3D {
  namespace ArithmeticTypes {
    struct Vec3d;

    struct H3DAPI_API Vec3f {

      H3D_API_EXCEPTION( Vec3fNormalizeError );

      Vec3f(): x(0), y(0), z(0) {}

      Vec3f( H3DFloat _x,
             H3DFloat _y,
             H3DFloat _z ) : x(_x), y(_y), z(_z) {}

      explicit Vec3f( const Vec3d &v );

      inline H3DFloat dotProduct( const Vec3f &v ) const {
        return x*v.x + y*v.y + z*v.z;
      }

      inline Vec3f crossProduct( const Vec3f &v ) const {
        return  Vec3f( y*v.z - z*v.y,
                       z*v.x - x*v.z,
                       x*v.y - y*v.x );
      }
                                
      inline void normalize() {
        H3DFloat l2 = x*x+y*y+z*z;
        // if the length already is 1 we don't have to do anything
        if( H3DAbs(l2-1) > Constants::f_epsilon ) {
          H3DFloat l = H3DSqrt( l2 );
          if( H3DAbs(l) < Constants::f_epsilon ) {
            string s = "Trying to normalize zero length Vec3f.";
            throw Vec3fNormalizeError( s );
          } else {
            x /= l; 
            y /= l;
            z /= l;
          }
        }
      }

      inline void normalizeSafe() {
        H3DFloat l2 = x*x+y*y+z*z;
        // if the length already is 1 we don't have to do anything
        if( H3DAbs(l2-1) > Constants::f_epsilon ) {
          H3DFloat l = H3DSqrt( l2 );
          if( H3DAbs(l) >= Constants::f_epsilon ) {
            x /= l; 
            y /= l;
            z /= l;
          }
        }
      }
      
      inline H3DFloat lengthSqr() {
        return x*x + y*y + z*z;
      }
                
      inline H3DFloat length() {
        return H3DSqrt( x*x + y*y + z*z );
      }
                
      inline H3DFloat &operator[]( int i ) { 
        if( i == 0 ) return x;
        if( i == 1 ) return y;
        if( i == 2 ) return z;
        
        throw Exception::H3DAPIException( "Invalid index", 
                                          H3D_FULL_LOCATION );
      }

      inline const H3DFloat &operator[]( int i ) const { 
        if( i == 0 ) return x;
        if( i == 1 ) return y;
        if( i == 2 ) return z;
        
        throw Exception::H3DAPIException( "Invalid index", 
                                          H3D_FULL_LOCATION );
      }

      H3DFloat x, y, z;
    };
    
    
    inline bool operator==( const Vec3f &v1, const Vec3f &v2 ) {
      return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;
    }
    inline Vec3f operator+( const Vec3f &v1, const Vec3f &v2 ) {
      return Vec3f( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z );
    }

    inline Vec3f operator*( const Vec3f &v, const int &i ) {
      return Vec3f( v.x * i, v.y * i, v.z * i );
    }

    inline Vec3f operator*( const Vec3f &v, const long &i ) {
      return Vec3f( v.x * i, v.y * i, v.z * i );
    }

    inline Vec3f operator*( const Vec3f &v, const unsigned long &i ) {
      return Vec3f( v.x * i, v.y * i, v.z * i );
    }

    inline Vec3f operator*( const Vec3f &v, const float &f ) {
      return Vec3f( v.x * f, v.y * f, v.z * f );
    }

    inline Vec3f operator*( const Vec3f &v, const double &d ) {
      return Vec3f( (H3DFloat)(v.x * d),
                    (H3DFloat)(v.y * d), 
                    (H3DFloat)(v.z * d) );
    }

    inline H3DFloat operator*( const Vec3f &v1, const Vec3f &v2 ) {
      return v1.dotProduct( v2 );
    }

    inline Vec3f operator%( const Vec3f &v1, const Vec3f &v2 ) {
      return v1.crossProduct( v2 );
    }
    
          inline ostream& operator<<( ostream &os, const Vec3f &v ) {
                  os << v.x << " " << v.y << " " << v.z;
                  return os;
          }

    inline Vec3f operator*( const float &a, const Vec3f &b ) { return b * a; }

    inline Vec3f operator*( const double &a, const Vec3f &b ) { return b * a; }

    inline Vec3f operator*( const int &a, const Vec3f &b ) { return b * a; }

    inline Vec3f operator*( const long &a, const Vec3f &b ) { return b * a; }

    inline Vec3f operator*( const unsigned long &a, const Vec3f &b ) { 
      return b * a; }

    inline Vec3f operator-( const Vec3f &b ) { return b * (H3DFloat)-1; }

    inline Vec3f operator-( const Vec3f &a, const Vec3f &b ) { return a + (-b); }
                                

  }
}

#endif

---