#include "bouffee.h"
#include <math.h>
#include "vector.h"

Bouffee::Bouffee(double _posx, double _posy, double _posz, double _vie)
{
    pos[0]=_posx + .005*pow(-1.0, rand()%1);
    pos[1]=_posy + .005*pow(-1.0, rand()%1);
    pos[2]=_posz + .005*pow(-1.0, rand()%1);

    for (int i=0; i<3; i++){

        if(i!=1)
        vitesse[i]=( rand()%10)/1000.0 * pow(-1.0, rand()%2);
        else vitesse[i]=( rand()%10)/100.0 ;
    }
    vie= _vie *15.5;
    vieMax= vie;
}
void Bouffee::anime(double& temps)
{
    //double n_x=pos[0], n_y=pos[1], n_z=pos[2]; // possition courante
    vie -= temps;
    //double px=0.,py=0.,pz=0.;
    for (int i=0; i<3; i++)
        pos[i] +=  vitesse[i] * temps;

}

/*********************************************
 *
 *
 *
 *
 * ******************************************/
void Bouffee::setPos(double val, int numPos){
    pos[numPos]=val;

}
void Bouffee::setVitesse(double val, int numPos){
    pos[numPos]=val;

}
double Bouffee::getPos(int numPos){
    return pos[numPos];
}
double Bouffee::getVitesse(int numPos){
    return vitesse[numPos];
}
double Bouffee::getVie(){
    return vie;
}

/*********************************************
 *
 *
 *
 *
 * ******************************************/
void Bouffee::affiche(){
     glEnable(GL_TEXTURE_2D);
    // Comme on ne veut pas que ce quadrilatère soit affecté
    // par la lumière, on désactive l’éclairage juste avant
    // de l’afficher, et on le réactivera juste après. Vous
    // n’aurez donc pas besoin de spécifier la normale du
    // quadrilatère
    glDisable(GL_LIGHTING);
    // On veut pouvoir voir les deux côtés du quadrilatère
    glDisable(GL_CULL_FACE);
    // On active le blending pour que la couleur de la texture
    // se mélange à la couleur du reste de la scène dans des
    // proportions données par la valeur alpha de chaque texel
    // de la texture
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);

    // On récupère le positionnement de la camera
    float matrice [16];
    glGetFloatv( GL_MODELVIEW_MATRIX, matrice );

    Vector Haut, Droite;
    double taille=(vieMax-vie)/vieMax;

    Droite.x = matrice[0] * ( 2* taille );
    Droite.y = matrice[4] * ( 2* taille );
    Droite.z = matrice[8] * ( 2* taille );

    Haut.x = matrice[1] * ( 2* taille);
    Haut.y = matrice[5] * ( 2* taille );
    Haut.z = matrice[9] * ( 2* taille );
    Vector A, B, C, D;

    // On calcule la position des 4 sommets du quadrilatère
    A.x = pos[0] + Haut.x - Droite.x;
    A.y = pos[1] + Haut.y - Droite.y;
    A.z = pos[2] + Haut.z - Droite.z;

    B.x = pos[0] + Haut.x + Droite.x;
    B.y = pos[1] + Haut.y + Droite.y;
    B.z = pos[2] + Haut.z + Droite.z;

    C.x = pos[0] - Haut.x + Droite.x;
    C.y = pos[1] - Haut.y + Droite.y;
    C.z = pos[2] - Haut.z + Droite.z;

    D.x = pos[0] - Haut.x - Droite.x;
    D.y = pos[1] - Haut.y - Droite.y;
    D.z = pos[2] - Haut.z - Droite.z;

    //
    //
    //
    //    Affichage du quadrilatère texturé avec la texture RGBA
    // Draw a 2D face with texture
    // Affichage du billboard
    glBegin(GL_QUADS);
        glColor4d(1.,1.,1.,1. - taille);
        glTexCoord2f(0.0, 0.0);     glVertex3f(D.x,D.y,D.z);
        glTexCoord2f(0.0, 1.);      glVertex3f(C.x,C.y,C.z);
        glTexCoord2f(1.0, 1.0);     glVertex3f(B.x,B.y,B.z);
        glTexCoord2f(1.0, 0.0 );    glVertex3f(A.x,A.y,A.z);
    glEnd();


    // On désactive le blending
    glDisable(GL_BLEND);
    // On reactive l’utilisation de la lumière
    glEnable(GL_LIGHTING);
    // Pour ne voir qu’un seul côté des polygones
    // (affichage plus rapide)
    glEnable(GL_CULL_FACE);
    glDisable(GL_TEXTURE_2D);
}