include/crbn/basic/vec3_c.hpp

#ifndef __vec3d_c_hpp__
#define __vec3d_c_hpp__

#include <crbn/basic/scalar.hpp>

struct vec3 {
  // Force data alignement
  union{
    float data[ 3 ];
    struct { float x, y, z; };
  };

  vec3() : x( 0.f ), y( 0.f ), z( 0.f ) {}
  vec3( const float& a ) : x( a ), y( a ), z( a ) {}
  vec3( const float& a, const float& b, const float& c ) : x( a ), y( b ), z( c ) {}
  vec3( const vec3& v ) : x( v.x ), y( v.y ), z( v.z ) {}
};

// a = b + c
static inline void
vadd( vec3& a, const vec3& b, const vec3& c ) {
  a.x = b.x + c.x;
  a.y = b.y + c.y;
  a.z = b.z + c.z;
}
// a += b
static inline void
vadd( vec3& a, const vec3& b ) {
  a.x += b.x;
  a.y += b.y;
  a.z += b.z;
}
// a = b - c
static inline void
vsub( vec3& a, const vec3& b, const vec3& c ){
  a.x = b.x - c.x;
  a.y = b.y - c.y;
  a.z = b.z - c.z;
} 
// a -= b
static inline void
vsub( vec3& a, const vec3& b ) {
  a.x -= b.x;
  a.y -= b.y;
  a.z -= b.z;
}
// a = -b
static inline void
vneg( vec3& a, const vec3& b ) {
  a.x = - b.x;
  a.y = - b.y;
  a.z = - b.z;
}
// a = -a
static inline void
vneg( vec3& a ) {
  a.x = - a.x;
  a.y = - a.y;
  a.z = - a.z;
}

//  a = f * b
static inline void
vmul( vec3& a, const float& f, const vec3& b ) {
  a.x = f * b.x;
  a.y = f * b.y;
  a.z = f * b.z;
}
//  a *= f
static inline void
vmul( vec3& a, const float& f ) {
  a.x *= f;
  a.y *= f;
  a.z *= f;
}
//  a = b / f
static inline void
vdiv( vec3& a, const vec3& b, const float& f ) {
  float d = 1.0f / f;
  a.x = b.x * d;
  a.y = b.y * d;
  a.z = b.z * d;
}
//  a /= f
static inline void
vdiv( vec3& a, const float& f ) {
  float d = 1.0f / f;
  a.x *= d;
  a.y *= d;
  a.z *= d;
}

// a_i = b_i * c_i for each component
static inline void
vmul( vec3& a, const vec3& b, const vec3& c ) {
  a.x = b.x * c.x;
  a.y = b.y * c.y;
  a.z = b.z * c.z;
}
// a_i *= b_i for each component
static inline void
vmul( vec3& a, vec3& b ) {
  a.x *= b.x;
  a.y *= b.y;
  a.z *= b.z;
}

// a_i = b_i / c_i for each component
static inline void
vdiv( vec3& a, const vec3& b, const vec3& c ) {
  a.x = b.x / c.x;
  a.y = b.y / c.y;
  a.z = b.z / c.z;
}
// a_i /= b_i for each component
static inline void
vdiv( vec3& a, const vec3& b ) {
  a.x /= b.x;
  a.y /= b.y;
  a.z /= b.z;
}

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

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

// a = b + c * d
static inline void
vaddmul( vec3& a, const vec3& b, const vec3& c, const vec3& d ) {
  a.x = b.x + c.x * d.x;
  a.y = b.y + c.y * d.y;
  a.z = b.z + c.z * d.z;
}

// a += b * c
static inline void
vaddmul( vec3& a, const vec3& b, const vec3& c ) {
  a.x += b.x * c.x;
  a.y += b.y * c.y;
  a.z += b.z * c.z;
}

// a = normalize( b )
static inline void
vnormalize( vec3& a, const vec3& b ) {
  float l = 1.0f / sqrtf( sqr( b.x ) + sqr( b.y ) + sqr( b.z ) );
  a.x = b.x * l;
  a.y = b.y * l;
  a.z = b.z * l;
}
// a = normalize( a )
static inline void
vnormalize( vec3& a ) {
  float l = 1.0f / sqrtf( sqr( a.x ) + sqr( a.y ) + sqr( a.z ) );
  a.x *= l;
  a.y *= l;
  a.z *= l;
}
// ret = norm( a )
static inline float
vlength( const vec3& a ) {
  return sqrtf( sqr( a.x ) + sqr( a.y ) + sqr( a.z ) );
}

// ret = norm( a ) ^ 2
static inline float
vlength2( const vec3& a ) {
  return sqr( a.x ) + sqr( a.y ) + sqr( a.z );
}

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

// ret = a . b
static inline float
vdot( const vec3& a, const vec3& b ) {
  return a.x * b.x + a.y * b.y + a.z * b.z;
}
// a = b ^ c
static inline void
vcross( vec3& a, const vec3& b, const vec3& c ) {
  a.x = b.y * c.z - b.z * c.y;
  a.y = b.z * c.x - b.x * c.z;
  a.z = b.x * c.y - b.y * c.x;
}

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

// compute coordinate system from a vector
static inline void
coordinate_system(vec3& v1, vec3& v2, vec3& v3) {
  float inv_length;
  if(fabs(v1.x) > fabs(v1.y)) {
    inv_length = 1.0f / sqrtf((v1.x * v1.x) + (v1.z * v1.z));
    v2 = vec3(-v1.z * inv_length, 0.0f, v1.x * inv_length);
  }
  else {
    inv_length = 1.0f / sqrtf((v1.y * v1.y) + (v1.z * v1.z));
    v2 = vec3(0.0f, v1.z * inv_length, -v1.y * inv_length);
  }
  vcross(v3, v1, v2);
}

#endif // __vec3d_c_hpp__

---