/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/vec3f

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_vec3f
#define inlib_vec3f

#include "a3"

//#include "fmath"

namespace inlib {

class vec3f : public inlib::a3::vec<float> {
public:
  vec3f(): inlib::a3::vec<float>() {}
  vec3f(const float a_vec[3]): inlib::a3::vec<float>(a_vec) {}
  vec3f(float a0,float a1,float a2)
  : inlib::a3::vec<float>(a0,a1,a2){}
  virtual ~vec3f() {}
public:
  vec3f(const vec3f& a_from): inlib::a3::vec<float>(a_from){}
  vec3f& operator=(const vec3f& a_from){
    inlib::a3::vec<float>::operator=(a_from);
    return *this;
  }

  vec3f(const inlib::a3::vec<float>& a_from)
  : inlib::a3::vec<float>(a_from){}

public: //operators
  float& operator[](unsigned int a_index) {
    //WARNING : no check on a_index.
    return m_vector[a_index];
  }
  const float& operator[](unsigned int a_index) const {
    //WARNING : no check on a_index.
    return m_vector[a_index];
  }
  vec3f operator*(float a_v) const {
    return vec3f(m_vector[0]*a_v,
                 m_vector[1]*a_v,
                 m_vector[2]*a_v);
  }    
  vec3f operator+(const vec3f& a_v) const {
    return vec3f(m_vector[0]+a_v[0],
                 m_vector[1]+a_v[1],
                 m_vector[2]+a_v[2]);
  }    
  vec3f operator-(const vec3f& a_v) const {
    return vec3f(m_vector[0]-a_v[0],
                 m_vector[1]-a_v[1],
                 m_vector[2]-a_v[2]);
  }    
  vec3f& operator+=(const vec3f& a_v) {   
    m_vector[0] += a_v[0];
    m_vector[1] += a_v[1];
    m_vector[2] += a_v[2];
    return *this;
  }    
  vec3f& operator*=(float a_v) {   
    m_vector[0] *= a_v;
    m_vector[1] *= a_v;
    m_vector[2] *= a_v;
    return *this;
  }    
  vec3f operator-() const {
    return vec3f(-m_vector[0],-m_vector[1],-m_vector[2]);
  }
  bool operator==(const vec3f& a_v) const {return equal(a_v);}
  bool operator!=(const vec3f& a_v) const {return !operator==(a_v);}
public:
  float x() const {return m_vector[0];}
  float y() const {return m_vector[1];}
  float z() const {return m_vector[2];}
  /*float length() const {
    return fsqrt(m_vector[0] * m_vector[0] + 
                 m_vector[1] * m_vector[1] + 
                 m_vector[2] * m_vector[2]); 
  }
  float normalize() {
    float norme = length();
    if(norme==0) return 0;
    divide(norme);
    return norme;
  }*/
  vec3f cross(const vec3f& aV) const {
    return vec3f(m_vector[1] * aV.m_vector[2] - m_vector[2] * aV.m_vector[1],
                 m_vector[2] * aV.m_vector[0] - m_vector[0] * aV.m_vector[2],
                 m_vector[0] * aV.m_vector[1] - m_vector[1] * aV.m_vector[0]);
  }    
  float dot(const vec3f& aV) const {
    return (m_vector[0] * aV.m_vector[0] + 
            m_vector[1] * aV.m_vector[1] + 
            m_vector[2] * aV.m_vector[2]);
  }    
public:
  //NOTE : don't handle a static object because of mem balance.
  //static const vec3f& x_axis() {
  //  static const vec3f s_v(1,0,0);
  //  return s_v;
  //}
  //static const vec3f& y_axis() {
  //  static const vec3f s_v(0,1,0);
  //  return s_v;
  //}
  //static const vec3f& z_axis() {
  //  static const vec3f s_v(0,0,1);
  //  return s_v;
  //}
private:
  static void check_instantiation() {
    vec3f dummy(0,0,0);
    dummy.set_value(1,1,1);
  }
};

inline vec3f operator*(float a_f,const vec3f& a_v) {
  vec3f res(a_v);
  res *= a_f;
  return res;
}

inline std::ostream& operator<<(std::ostream& a_out,const vec3f& a_this){
  a_out << "x = " << a_this[0]
        << ",y = " << a_this[1]
        << ",z = " << a_this[2]
        << std::endl;
  return a_out;
}

}

#endif