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

Go to the documentation of this file.

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

#ifndef inlib_vec2f
#define inlib_vec2f

#include "a2"

#include "fmath"

namespace inlib {

class vec2f : public inlib::a2::vec<float> {
public:
  vec2f(): inlib::a2::vec<float>() {}
  vec2f(const float a_vec[2]): inlib::a2::vec<float>(a_vec) {}
  vec2f(float a0,float a1)
  : inlib::a2::vec<float>(a0,a1){}
  virtual ~vec2f() {}
public:
  vec2f(const vec2f& a_from): inlib::a2::vec<float>(a_from){}
  vec2f& operator=(const vec2f& a_from){
    inlib::a2::vec<float>::operator=(a_from);
    return *this;
  }
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];
  }
  vec2f operator*(float a_v) const {
    return vec2f(m_vector[0]*a_v,
                 m_vector[1]*a_v);
  }    
  vec2f operator+(const vec2f& a_v) const {
    return vec2f(m_vector[0]+a_v[0],
                 m_vector[1]+a_v[1]);
  }    
  vec2f operator-(const vec2f& a_v) const {
    return vec2f(m_vector[0]-a_v[0],
                 m_vector[1]-a_v[1]);
  }    
  vec2f& operator+=(const vec2f& a_v) {   
    m_vector[0] += a_v[0];
    m_vector[1] += a_v[1];
    return *this;
  }    
  vec2f& operator*=(float a_v) {   
    m_vector[0] *= a_v;
    m_vector[1] *= a_v;
    return *this;
  }    
  vec2f operator-() const {
    return vec2f(-m_vector[0],-m_vector[1]);
  }
  bool operator==(const vec2f& a_v) const {return equal(a_v);}
  bool operator!=(const vec2f& a_v) const {return !operator==(a_v);}
public:
  float x() const {return m_vector[0];}
  float y() const {return m_vector[1];}
  float length() const {
    return fsqrt(m_vector[0] * m_vector[0] + 
                 m_vector[1] * m_vector[1]);
  }
  float normalize() {
    float norme = length();
    if(norme==0) return 0;
    divide(norme);
    return norme;
  }
  float cross(const vec2f& aV) const {
    return (m_vector[0] * aV.m_vector[1] - m_vector[1] * aV.m_vector[0]);
  }    
  float dot(const vec2f& aV) const {
    return (m_vector[0] * aV.m_vector[0] + 
            m_vector[1] * aV.m_vector[1]);
  }    
public:
  //NOTE : don't handle a static object because of mem balance.
  //static const vec2f& x_axis() {
  //  static const vec2f s_v(1,0);
  //  return s_v;
  //}
  //static const vec2f& y_axis() {
  //  static const vec2f s_v(0,1);
  //  return s_v;
  //}
private:
  static void check_instantiation() {
    vec2f dummy(0,0);
    dummy.set_value(1,1);
  }
};

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

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

}

#endif