HyperGunner/Structures/Vecteur.cpp

#include "Vecteur.h"

///Constructeurs
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()
{}

///Fonctions
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.0f)
    {
        m_x /= longueur;
        m_y /= longueur;
        m_z /= longueur;
    }
}

float Vec::scalair(const Vec &vecteur) const
{
    Vec v1(*this), v2(vecteur);
    v1.normaliser();
    v2.normaliser();
    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
}

double Vec::norme() const
{
    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.0;
    float tmp = m_x;
    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
}

///Getters
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;
}

///Opérateurs
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;
}

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;
}