/disk1/scratch/aselle/projects/seexpr/SeExpr/src/SeExpr/SeVec3d.h

Go to the documentation of this file.

/*
* (c) Disney Enterprises, Inc.  All rights reserved.
*
* This file is licensed under the terms of the Microsoft Public License (MS-PL)
* as defined at: http://opensource.org/licenses/MS-PL.
*
* A complete copy of this license is included in this distribution as the file
* LICENSE.
*/

#ifndef SeVec3d_h
#define SeVec3d_h

#ifndef MAKEDEPEND
#include <iostream>
#include <math.h>
#endif

class SeVec3d
{
 public:

    SeVec3d() {}

    SeVec3d( double v )
    { setValue( v, v, v ); }

    SeVec3d( double x, double y, double z )
    { setValue( x, y, z ); }

    SeVec3d( const double* v )
    { setValue( v[0], v[1], v[2] ); }

    SeVec3d( const float* v )
    { setValue( v[0], v[1], v[2] ); }

    typedef double array[3];
    operator array&() { return _vec; }

    double       &operator []( int i )          { return (_vec[i]); }

    double operator []( int i ) const    { return (_vec[i]); }

    SeVec3d &operator =( const SeVec3d &v )
    { _vec[0]=v[0]; _vec[1]=v[1]; _vec[2]=v[2]; return *this; }

    SeVec3d &operator *=( double d )
    { _vec[0]*=d; _vec[1]*=d; _vec[2]*=d; return *this; }

    SeVec3d &operator /=( double d )
    { *this *= 1/d; return *this; }

    SeVec3d &operator +=( const SeVec3d &v )
    { _vec[0]+=v[0]; _vec[1]+=v[1]; _vec[2]+=v[2]; return *this; } 

    SeVec3d &operator -=( const SeVec3d &v )
    { _vec[0]-=v[0]; _vec[1]-=v[1]; _vec[2]-=v[2]; return *this; } 
    
    SeVec3d operator -() const
    { return SeVec3d( -_vec[0], -_vec[1], -_vec[2] ); }

    bool operator ==( const SeVec3d &v ) const
    { return (_vec[0] == v[0] && _vec[1] == v[1] && _vec[2] == v[2]); }

    bool operator !=( const SeVec3d &v ) const
    { return !(*this == v); }

    SeVec3d operator *( double d ) const
    { return SeVec3d( _vec[0]*d, _vec[1]*d, _vec[2]*d ); }
    
    SeVec3d operator /( double d ) const
    { return *this * (1/d); }
    
    friend SeVec3d operator *( double d, const SeVec3d &v )
    { return v * d; }
    
    SeVec3d operator *( const SeVec3d &v ) const
    { return SeVec3d(_vec[0]*v[0], _vec[1]*v[1], _vec[2]*v[2]); }

    SeVec3d operator /( const SeVec3d &v ) const
    { return SeVec3d(_vec[0]/v[0], _vec[1]/v[1], _vec[2]/v[2]); }

    SeVec3d operator +( const SeVec3d &v ) const
    { return SeVec3d( _vec[0]+v[0], _vec[1]+v[1], _vec[2]+v[2] ); }

    SeVec3d operator -( const SeVec3d &v ) const
    { return SeVec3d( _vec[0]-v[0], _vec[1]-v[1], _vec[2]-v[2]); }

    friend std::ostream & operator <<( std::ostream  &os, const SeVec3d &v )
    { os << "(" << v[0] << "," << v[1] << "," << v[2] << ")"; return os; }

    void getValue( double &x, double &y, double &z ) const
    { x = _vec[0]; y = _vec[1]; z = _vec[2]; }
    
    const double *getValue() const
    { return _vec; }

    void setValue( double x, double y, double z )
    { _vec[0] = x; _vec[1] = y; _vec[2] = z; }
    
    void setValue( const double* v )
    { _vec[0] = v[0]; _vec[1] = v[1]; _vec[2] = v[2]; }

    double dot( const SeVec3d &v ) const
    { return _vec[0]*v[0] + _vec[1]*v[1] + _vec[2]*v[2]; }

    SeVec3d cross( const SeVec3d &v ) const
    { return SeVec3d(_vec[1]*v[2] - _vec[2]*v[1],
                     _vec[2]*v[0] - _vec[0]*v[2],
                     _vec[0]*v[1] - _vec[1]*v[0]); }
    
    void negate()
    { _vec[0]*=-1; _vec[1]*=-1; _vec[2]*=-1; }

    double length() const
    { return sqrt( _vec[0]*_vec[0]+_vec[1]*_vec[1]+_vec[2]*_vec[2] ); }

    SeVec3d normalized() const 
    {
        double len = length();
        if ( len ) return *this / len;
        else return 0.0;
    }

    void normalize()
    {
        double len = length();
        if ( len ) *this /= len;
    }

    SeVec3d orthogonal() const {
        return SeVec3d( _vec[1]+_vec[2], _vec[2]-_vec[0], -_vec[0]-_vec[1] );
    }

    double angle( const SeVec3d &v ) const
    {   double len = this->length()*v.length();
        if (len == 0) return 0;
        return acos(this->dot(v) / len);
    }

    SeVec3d rotateBy( const SeVec3d &axis, double angle_ ) const
    {
        double c = cos(angle_), s = sin(angle_);
        const SeVec3d& v = *this;
        return c*v + (1-c)*v.dot(axis)*axis - s*v.cross(axis);
    }
    
 private:

    double  _vec[3];
};


#endif

---