SdlSandbox/sdl1/rotationTest/Vecteur.cpp

#include "Vecteur.h"

Vec::Vec() : m_x(0.0), m_y(0.0), m_z(0.0)
{

}
Vec::Vec(float x, float y, float z) : m_x(x), m_y(y), m_z(z)
{

}
Vec::Vec(const Vec &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
{

}
Vec::~Vec()
{

}
float Vec::getX() const
{
    return m_x;
}

float Vec::getY() const
{
    return m_y;
}

float Vec::getZ() const
{
    return m_z;
}


// Setters

void Vec::setVecteur(float x, float y, float z)
{
    m_x = x;
    m_y = y;
    m_z = z;
}

void Vec::setX(float x)
{
    m_x = x;
}

void Vec::setY(float y)
{
    m_y = y;
}

void Vec::setZ(float z)
{
    m_z = z;
}
void Vec::normaliser()
{
    // La fonction sqrt() permet de trouver la racine carré d'un nombre

    float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));


    // Normalisation du vecteur

    if(longueur != 0.0)
    {
        m_x /= longueur;
        m_y /= longueur;
        m_z /= longueur;
    }
}
Vec& Vec::operator=(const Vec &vecteur)
{
    // Copie des valeurs

    m_x = vecteur.m_x;
    m_y = vecteur.m_y;
    m_z = vecteur.m_z;


    // Retour de l'objet

    return *this;
}
Vec Vec::operator+(const Vec &vecteur)
{
    // Création d'un objet résultat

    Vec resultat;


    // Addition des coordonnées

    resultat.m_x = m_x + vecteur.m_x;
    resultat.m_y = m_y + vecteur.m_y;
    resultat.m_z = m_z + vecteur.m_z;


    // Retour de résultat

    return resultat;
}
Vec Vec::operator-(const Vec &vecteur)
{
    // Création d'un objet résultat

    Vec resultat;


    // Soustraction des coordonnées

    resultat.m_x = m_x - vecteur.m_x;
    resultat.m_y = m_y - vecteur.m_y;
    resultat.m_z = m_z - vecteur.m_z;


    // Retour de résultat

    return resultat;
}
Vec Vec::operator*(float multiplicateur)
{
    // Création d'un objet résultat

    Vec resultat;


    // Multiplication des coordonnées

    resultat.m_x = m_x * multiplicateur;
    resultat.m_y = m_y * multiplicateur;
    resultat.m_z = m_z * multiplicateur;


    // Retour du résultat

    return resultat;
}
Vec Vec::operator/(float diviseur)
{
    // Création d'un objet résultat

    Vec resultat;


    // Multiplication des coordonnées

    resultat.m_x = m_x / diviseur;
    resultat.m_y = m_y / diviseur;
    resultat.m_z = m_z / diviseur;


    // Retour du résultat

    return resultat;
}
Vec Vec::operator*(const Vec &vecteur)
{
    // Création d'un objet résultat

    Vec resultat;


    // Produit Vectoriel

    resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
    resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
    resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);


    // Retour de l'objet

    return resultat;
}
void Vec::operator*=(const Vec &vecteur)
{
    *this = *this * vecteur;
}
void Vec::operator-=(const Vec &vecteur)
{
    *this = *this - vecteur;
}
void Vec::operator+=(const Vec &vecteur)
{
    *this = *this + vecteur;
}
void Vec::operator*=(float multiplicateur)
{
    *this = *this * multiplicateur;
}
void Vec::operator/=(float multiplicateur)
{
    *this = *this * multiplicateur;
}
float Vec::scalair(const Vec &vecteur)
{
    Vec v1(*this), v2(vecteur);
    v1.normaliser();
    v2.normaliser();
    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
}
bool Vec::operator==(const Vec &vecteur)
{
    if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
        return true;
    else
        return false;
}
bool Vec::operator!=(const Vec &vecteur)
{
    if(*this == vecteur)
        return false;
    else
        return true;
}
double Vec::norme()
{
    return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
}
void Vec::rotateR(float angle)
{
    float tmp = m_x;
    m_x = cos(angle)*m_x-sin(angle)*m_y;
    m_y = sin(angle)*tmp+cos(angle)*m_y;
}
void Vec::rotateD(float angle)
{
    float _angle = angle*M_PI/180;
    float tmp = m_x;
    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
}