include/crbn/basic/vec2.hpp

#ifndef __vec2d_hpp__
#define __vec2d_hpp__

#include <crbn/basic/scalar.hpp>

typedef struct vec2 {
  union {
    struct { float x, y; };
    float data[2];
  };

  vec2() : x(0.0), y(0.0) {}
  vec2( const float& a ) : x(a), y(a) {}
  vec2( const float& a, const float& b ) : x(a), y(b) {}
  vec2( const vec2& v ) : x(v.x), y(v.y) {};
};

// a = b + c
inline void vadd( vec2& a, vec2& b, vec2& c ) {
  a.x = b.x + c.x;
  a.y = b.y + c.y;
}
// a += b
inline void vadd( vec2& a, vec2& b ) {
  a.x += b.x;
  a.y += b.y;
}
// a = b - c
inline void vsub( vec2& a, vec2& b, vec2& c ) {
  a.x = b.x - c.x;
  a.y = b.y - c.y;
}
// a -= b
inline void vsub( vec2& a, vec2& b ) {
  a.x -= b.x;
  a.y -= b.y;
}

// a = -b
inline void vneg( vec2& a, vec2& b ){
  a.x = - b.x;
  a.y = - b.y;
} 
// a = -a
inline void vneg( vec2& a ) {
  a.x = - a.x;
  a.y = - a.y;
}

//  a = d * b
inline void vmul( vec2& a, float f, vec2& b ) {
  a.x = f * b.x;
  a.y = f * b.y;
}

//  a *= d
inline void vmul( vec2& a, const float f ) {
  a.x *= f;
  a.y *= f;
}
// a_i *= b_i for each component
inline void vmul( vec2& a, vec2& b ) {
  a.x *= b.x;
  a.y *= b.y;
}

//  a = b / d
inline void vdiv( vec2& a, vec2& b, float f ) {
  f = 1.0f / f;
  a.x = f * b.x;
  a.y = f * b.y;
}
//  a /= d
inline void vdiv( vec2& a, float f ) {
  f = 1.0f / f;
  a.x *= f;
  a.y *= f;
}

// a += b + f * c
inline void vaddfmul( vec2& a,  vec2& b, float f,  vec2& c ) {
  a.x += b.x + f * c.x;
  a.y += b.y + f * c.y;
}

// a += f * b
inline void vaddfmul( vec2& a, float f,  vec2& b ) {
  a.x += f * b.x;
  a.y += f * b.y;
}

// a = normalize( b )
inline void vnormalize( vec2& a,  vec2& b ) {
  float l = 1.0f / sqrtf( sqr( b.x ) + sqr( b.y ) );
  a.x = b.x * l;
  a.y = b.y * l;
}
// a = normalize( a )
inline void vnormalize( vec2& a ) {
  float l = 1.0f / sqrtf( sqr( a.x ) + sqr( a.y ) );
  a.x *= l;
  a.y *= l;
}

// ret = norm( v )
inline float vlength( vec2& v ) {
  return sqrtf( sqr( v.x ) + sqr( v.y ) );
}
// ret = norm( v ) ^ 2
inline float vlength2( vec2& v ) {
  return sqr( v.x ) + sqr( v.y );
}

// ret = distance( a, b )
inline float vdistance( vec2& a, vec2& b ) {
  return sqrtf( sqr( a.x - b.x ) + sqr( a.y - b.y ) );
}
// ret = distance( a, b ) ^ 2
inline float vdistance2( vec2& a, vec2& b ) {
  return sqr( a.x - b.x ) + sqr( a.y - b.y );
}

// ret = a . b
inline float vdot( vec2& a, vec2& b ) {
  return a.x * b.x + a.x * b.x;
}
//            o
// ret = a . b
inline float vdoto( vec2& a, vec2& b ) {
  return a.y * b.x - a.x * b.y;
}
// ret = b ^ c
inline float vcross( vec2& a, vec2& b ) {
  return a.x * b.y - b.x * a.y;
}

// v_i = min( a_i, b_i ) for each component
inline void vmin( vec2& v, vec2& a, vec2& b ) {
  v.x = min( a.x, b.x );
  v.y = min( a.y, b.y );
}
// v_i = max( a_i, b_i ) for each component
inline void vmax( vec2& v, vec2& a, vec2& b ) {
  v.x = max( a.x, b.x );
  v.y = max( a.y, b.y );
}

#endif // __vec2d_hpp__

---