topical media & game development

topical media & game development

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

lib-of-vs-addons-ofxVectorMath-src-ofxVec3f.h / h


  ifndef _OFX_VEC3f
  define _OFX_VEC3f
  
  include <ofConstants.h>
  include <ofTypes.h>
  
  class ofxVec3f : public ofPoint {
  
    public:
  
      ofxVec3f( float _x=0.0f,
                float _y=0.0f,
                float _z=0.0f );
  
      ofxVec3f( const ofPoint& pnt );
  
      // Getters and Setters.
      //
      //
      void set( float _x, float _y, float _z );
  
      void set( const ofPoint& vec );
  
      float &operator[]( const int& i );
  
      // Check similarity/equality.
      //
      //
      bool operator==( const ofPoint& vec );
  
      bool operator!=( const ofPoint& vec );
  
      bool match( const ofPoint& vec, float tollerance=0.0001 );

Checks if vectors look in the same direction.


  
      bool align( const ofxVec3f& vec, float tollerance=0.0001 ) const;
      bool alignRad( const ofxVec3f& vec, float tollerance=0.0001 ) const;
  
      // Operator overloading for ofPoint
      //
      //
  
      void           operator=( const ofPoint& vec );
  
      ofxVec3f  operator+( const ofPoint& pnt ) const;
  
      ofxVec3f& operator+=( const ofPoint& pnt );
  
      ofxVec3f  operator-( const ofPoint& vec ) const;
  
      ofxVec3f& operator-=( const ofPoint& vec );
  
      ofxVec3f  operator*( const ofPoint& vec ) const;
  
      ofxVec3f& operator*=( const ofPoint& vec );
  
      ofxVec3f  operator/( const ofPoint& vec ) const;
  
      ofxVec3f& operator/=( const ofPoint& vec );
  
      ofxVec3f  operator-() const;
  
      //operator overloading for float
      //
      //
      void           operator=( const float f);
  
      ofxVec3f  operator+( const float f ) const;
  
      ofxVec3f& operator+=( const float f );
  
           ofxVec3f  operator-( const float f ) const;
  
      ofxVec3f& operator-=( const float f );
  
      ofxVec3f  operator*( const float f ) const;
  
      ofxVec3f& operator*=( const float f );
  
      ofxVec3f  operator/( const float f ) const;
  
      ofxVec3f& operator/=( const float f );
  
      //Scale
      //
      //
      ofxVec3f  getScaled( const float length ) const;
  
      ofxVec3f& scale( const float length );
  
      // Rotation
      //
      //
      ofxVec3f  getRotated( float angle, const ofxVec3f& axis ) const;
      ofxVec3f  getRotatedRad( float angle, const ofxVec3f& axis ) const;
  
      ofxVec3f& rotate( float angle, const ofxVec3f& axis );
      ofxVec3f& rotateRad( float angle, const ofxVec3f& axis );
  
      ofxVec3f  getRotated(float ax, float ay, float az) const;
      ofxVec3f  getRotatedRad(float ax, float ay, float az) const;
  
      ofxVec3f& rotate(float ax, float ay, float az);
      ofxVec3f& rotateRad(float ax, float ay, float az);
  
      // Normalization
      //
      //
      ofxVec3f  getNormalized() const;
  
      ofxVec3f& normalize();
  
      // Limit length.
      //
      //
  
      ofxVec3f  getLimited(float max) const;
  
      ofxVec3f& limit(float max);
  
      // Perpendicular vector.
      //
      //
      ofxVec3f  getCrossed( const ofxVec3f& vec ) const;
  
      ofxVec3f& cross( const ofxVec3f& vec );

Normalized perpendicular.


  
      ofxVec3f  getPerpendicular( const ofxVec3f& vec ) const;
  
      ofxVec3f& perpendicular( const ofxVec3f& vec );
  
      // Length
      //
      //
      float length() const;
  
      float squareLength() const;

Angle (deg) between two vectors. This is an unsigned relative angle from 0 to 180. http://www.euclideanspace.com/maths/algebra/vectors/angleBetween/index.htm


  
      float angle( const ofxVec3f& vec ) const;
      float angleRad( const ofxVec3f& vec ) const;

Dot Product.


  
      float dot( const ofxVec3f& vec ) const;
  
      //-----------------------------------------------
      // this methods are deprecated in 006 please use:
  
      // getScaled
      ofxVec3f rescaled( const float length ) const;
  
      // scale
      ofxVec3f& rescale( const float length );
  
      // getRotated
      ofxVec3f rotated( float angle, const ofxVec3f& axis ) const;
  
      // getRotated should this be const???
      ofxVec3f rotated(float ax, float ay, float az);
  
      // getNormalized
      ofxVec3f normalized() const;
  
      // getLimited
      ofxVec3f limited(float max) const;
  
      // getCrossed
      ofxVec3f crossed( const ofxVec3f& vec ) const;
  
      // getPerpendicular
      ofxVec3f perpendiculared( const ofxVec3f& vec ) const;
  
      // squareLength
      float lengthSquared() const;
  };
  
  // Non-Member operators
  //
  //
  ofxVec3f operator+( float f, const ofxVec3f& vec );
  
  ofxVec3f operator-( float f, const ofxVec3f& vec );
  
  ofxVec3f operator*( float f, const ofxVec3f& vec );
  
  ofxVec3f operator/( float f, const ofxVec3f& vec );
  
  endif

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.