vec.h

Go to the documentation of this file.

 
#ifndef _VEC_H
#define _VEC_H
 
 
 
 
struct vec2;
struct vec3;
struct vec4;
struct Vector;
struct Point;
 
struct Point
{
    Point( ) : x(0), y(0), z(0) {}
    Point( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
 
    explicit Point( const vec3& v );   // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
    explicit Point( const vec4& v );   // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
    explicit Point( const Vector& v );   // l'implementation se trouve en fin de fichier, la structure vector n'est pas encore connue.
    
    float operator() ( const unsigned int i ) const; // l'implementation se trouve en fin de fichier
    float& operator() ( const unsigned int i ); // l'implementation se trouve en fin de fichier
    
    float x, y, z;
};
 
Point Origin( );
 
float distance( const Point& a, const Point& b );
float distance2( const Point& a, const Point& b );
 
Point center( const Point& a, const Point& b );
 
Point min( const Point& a, const Point& b );
Point max( const Point& a, const Point& b );
 
 
struct Vector
{
    Vector( ) : x(0), y(0), z(0) {}
    Vector( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
    explicit Vector( const Point& a, const Point& b ) : x(b.x - a.x), y(b.y - a.y), z(b.z - a.z) {}
 
    explicit Vector( const vec3& v );   // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
    explicit Vector( const vec4& v );   // l'implementation se trouve en fin de fichier, la structure vec3 n'est pas encore connue.
    explicit Vector( const Point& a );   // l'implementation se trouve en fin de fichier.
    
    float operator() ( const unsigned int i ) const; // l'implementation se trouve en fin de fichier
    float& operator() ( const unsigned int i ); // l'implementation se trouve en fin de fichier
    
    float x, y, z;
};
 
Vector normalize( const Vector& v );
Vector cross( const Vector& u, const Vector& v );
float dot( const Vector& u, const Vector& v );
float length( const Vector& v );
float length2( const Vector& v );
 
Vector operator- ( const Point& a, const Point& b );
 
Point operator+ ( const Point& a, const Point& b );
 
Point operator* ( const float k, const Point& a );
Point operator* ( const Point& a, const float k );
Point operator/ ( const Point& a, const float k );
 
Vector operator- ( const Vector& v );
 
Point operator+ ( const Point& a, const Vector& v );
Point operator+ ( const Vector& v, const Point& a );
Point operator- ( const Vector& v, const Point& a );
Point operator- ( const Point& a, const Vector& v );
Vector operator+ ( const Vector& u, const Vector& v );
Vector operator- ( const Vector& u, const Vector& v );
Vector operator+ ( const float k, const Vector& v );
Vector operator+ ( const Vector& v, const float k );
 
Vector operator* ( const float k, const Vector& v );
Vector operator* ( const Vector& v, const float k );
 
Vector operator* ( const Vector& a, const Vector& b );
Vector operator/ ( const Vector& v, const float k );
 
 
struct vec2
{
    vec2( ) : x(0), y(0) {}
    vec2( const float _x, const float _y ) : x(_x), y(_y) {}
    
    float operator() ( const unsigned int i ) const { return (&x)[i]; }
    float& operator() ( const unsigned int i ) { return (&x)[i]; }
 
    float x, y;
};
 
 
struct vec3
{
    vec3( ) : x(0), y(0), z(0) {}
    vec3( const float _x, const float _y, const float _z ) : x(_x), y(_y), z(_z) {}
    vec3( const vec2& a, const float _z ) : x(a.x), y(a.y), z(_z) {}
 
    vec3( const Point& a );    // l'implementation se trouve en fin de fichier.
    vec3( const Vector& v );    // l'implementation se trouve en fin de fichier.
 
    float operator() ( const unsigned int i ) const { return (&x)[i]; }
    float& operator() ( const unsigned int i ) { return (&x)[i]; }
    
    float x, y, z;
};
 
 
struct vec4
{
    vec4( ) : x(0), y(0), z(0), w(0) {}
    vec4( const float _x, const float _y, const float _z, const float _w ) : x(_x), y(_y), z(_z), w(_w) {}
    vec4( const vec2& v, const float _z= 0, const float _w= 0 ) : x(v.x), y(v.y), z(_z), w(_w) {}
    vec4( const vec3& v, const float _w= 0 ) : x(v.x), y(v.y), z(v.z), w(_w) {}
 
    vec4( const Point& a );    // l'implementation se trouve en fin de fichier.
    vec4( const Vector& v );    // l'implementation se trouve en fin de fichier.
    
    float operator() ( const unsigned int i ) const { return (&x)[i]; }
    float& operator() ( const unsigned int i ) { return (&x)[i]; }
 
    float x, y, z, w;
};
 
 
// implementation des constructeurs explicites.
inline Point::Point( const vec3& v ) : x(v.x), y(v.y), z(v.z) {}
inline Point::Point( const vec4& v ) : x(v.x), y(v.y), z(v.z) {}
inline Point::Point( const Vector& v ) : x(v.x), y(v.y), z(v.z) {}
 
inline Vector::Vector( const vec3& v ) : x(v.x), y(v.y), z(v.z) {}
inline Vector::Vector( const vec4& v ) : x(v.x), y(v.y), z(v.z) {}
inline Vector::Vector( const Point& a ) : x(a.x), y(a.y), z(a.z) {}
 
inline vec3::vec3( const Point& a ) : x(a.x), y(a.y), z(a.z) {}
inline vec3::vec3( const Vector& v ) : x(v.x), y(v.y), z(v.z) {}
 
inline vec4::vec4( const Point& a ) : x(a.x), y(a.y), z(a.z), w(1.f) {}
inline vec4::vec4( const Vector& v ) : x(v.x), y(v.y), z(v.z), w(0.f) {}
 
//
inline float Point::operator( ) ( const unsigned int i ) const { return (&x)[i]; }
inline float Vector::operator( ) ( const unsigned int i ) const { return (&x)[i]; }
 
inline float& Point::operator( ) ( const unsigned int i ) { return (&x)[i]; }
inline float& Vector::operator( ) ( const unsigned int i ) { return (&x)[i]; }
 
//
#include <iostream>
 
inline std::ostream& operator<<(std::ostream& o, const Point& p)
{
    o<<"p("<<p.x<<","<<p.y<<","<<p.z<<")";
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const Vector& v)
{
    o<<"v("<<v.x<<","<<v.y<<","<<v.z<<")";
    return o;
}
 
#endif