//------------------------------------------------------------------------------
// Calcule l'angle à un temps précis et sans dépassement d'un angle max (pour tentacule)
// vitesse   : vitesse de la rotation
// max       : angle maximal à ne pas dépasser
// angle_old : angle déjà affiché
// Retourne l'angle calculé
//------------------------------------------------------------------------------


float CalculAngle ( float vitesse, float max, float angle_old )
{
    float angle = vitesse * 25.0f;
    if ( max != 0 )
    {
        if ( angle < -max ) angle = -max;
        if ( angle > max )  angle = max;
    }
    return angle;
}


//------------------------------------------------------------------------------
// Dessine une tentacule
// angle : angle de départ de la rotation
// posx, posy : point de départ en x ou en y
//------------------------------------------------------------------------------


void Tentacule ( float angle )
{
    float val;

    glPushMatrix ( );

    // Branche inclinée
    glTranslatef ( 0.0f, 2.0f, 0.0f );      // On se recule de 25 unités pour voir le cube
    glColor3f ( 0.0f, 0.0f, 0.8f );         // On lui donne une couleur de 0 à 1 (RVB)
    val = 1.13f; // sqrt(0.8f*0.8f+0.8f*0.8f);
    glBegin(GL_QUADS);
        glVertex3f( -0.8f, -0.8f, 0.0f );
        glVertex3f(  0.8f, -0.8f, 0.0f );
        glVertex3f(  val * cos ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
        glVertex3f(  val * cos ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
    glEnd();

    glRotatef ( -CalculAngle ( vitesse, 45, angle ), 0, 0, 1 );   // On effectue une rotation sur l'axe z
    glTranslatef ( 0.0f, 1.8f, 0.0f );      // On se recule de 25 unités pour voir le cube
    glColor3f ( 0.0f, 0.0f, 0.6f );         // On lui donne une couleur de 0 à 1 (RVB)
    val = 0.8f; //sqrt(0.6f*0.6f+0.6f*0.6f);
    glBegin(GL_QUADS);
        glVertex3f( -0.8f, -0.8f, 0.0f );
        glVertex3f(  0.8f, -0.8f, 0.0f );
        glVertex3f(  val * cos ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
        glVertex3f(  val * cos ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
    glEnd();

    glRotatef ( -CalculAngle ( vitesse, 45, angle ), 0, 0, 1 );   // On effectue une rotation sur l'axe z
    glTranslatef ( 0.0f, 1.4f, 0.0f );      // On se recule de 25 unités pour voir le cube
    glColor3f ( 0.0f, 0.0f, 0.4f );         // On lui donne une couleur de 0 à 1 (RVB)
    val = 0.56f; //sqrt(0.4f*0.4f+0.4f*0.4f);
    glBegin(GL_QUADS);
        glVertex3f( -0.6f, -0.6f, 0.0f );
        glVertex3f(  0.6f, -0.6f, 0.0f );
        glVertex3f(  val * cos ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
        glVertex3f(  val * cos ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
    glEnd();

    glRotatef ( -CalculAngle ( vitesse, 45, angle ), 0, 0, 1 );   // On effectue une rotation sur l'axe z
    glTranslatef ( 0.0f, 1.0f, 0.0f );      // On se recule de 25 unités pour voir le cube
    glColor3f ( 0.0f, 0.0f, 0.2f );         // On lui donne une couleur de 0 à 1 (RVB)
    val = 0.28f; //sqrt(0.2f*0.2f+0.2f*0.2f);
    glBegin(GL_QUADS);
        glVertex3f( -0.4f, -0.4f, 0.0f );
        glVertex3f(  0.4f, -0.4f, 0.0f );
        glVertex3f(  val * cos ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
        glVertex3f(  val * cos ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
    glEnd();

    glRotatef ( -CalculAngle ( vitesse, 45, angle ), 0, 0, 1 );   // On effectue une rotation sur l'axe z
    glTranslatef ( 0.0f, 0.6f, 0.0f );      // On se recule de 25 unités pour voir le cube
    glColor3f ( 0.0f, 0.0f, 0.1f );         // On lui donne une couleur de 0 à 1 (RVB)
    val = 0.0f; //sqrt(0.0f*0.0f+0.0f*0.0f);
    glBegin(GL_QUADS);
        glVertex3f( -0.2f, -0.2f, 0.0f );
        glVertex3f(  0.2f, -0.2f, 0.0f );
        glVertex3f(  val * cos ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 - 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
        glVertex3f(  val * cos ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f),
                     val * sin ( ( 90 + 45 - CalculAngle ( vitesse, 45, angle ))*pi/180.0f), 0.0f );
    glEnd();


    glPopMatrix ( );
}


//------------------------------------------------------------------------------
// Début de la fonction de dégradé ( 0 : le fade continue / 1 : le fade est fini
//------------------------------------------------------------------------------


bool debFade ( float secondes, bool ouverture )
{
    static float tps_ecoule = 0.0f;
    float valFade;

    tps_ecoule += temps.ecart;
    valFade = (float) ( tps_ecoule ) / (float) ( secondes );
    if (!ouverture) valFade = 1 - valFade;
    
    if (tps_ecoule > secondes) { tps_ecoule = 0.0f; ouverture = 1-ouverture; }
    else glColor4f ( 1, valFade, 0.5+0.5*valFade, valFade ); // on applique le fade ( Rouge, Vert, Bleu, Alpha )

    return ouverture;
}


//------------------------------------------------------------------------------
// Attente de x secondes
//------------------------------------------------------------------------------


bool attenteFade ( float secondes )
{
    static float tps_ecoule = 0.0f;
    tps_ecoule += temps.ecart;
    glColor4f ( 1, 1, 1, 1 );
    if ( tps_ecoule > secondes ) { tps_ecoule = 0.0f ;return true; }
    else return false;
}


//------------------------------------------------------------------------------
// Fonction qui dessine une étoile
//------------------------------------------------------------------------------


void DrawEtoile ( float posx, float posy, float posz, float rayon1, float rayon2 )
{
    float x, y;
    int angle = 90;
    int i;

    glBegin ( GL_POLYGON );
        for ( i=0 ; i<10 ; i++ )
        {
            (i%2==0)?(x=rayon1):(x=rayon2);
            (i%2==0)?(y=rayon1):(y=rayon2);
            x *= cos ( ( angle + i * 36 ) * 3.141592 / 180.00 );
            y *= sin ( ( angle + i * 36 ) * 3.141592 / 180.00 );
            glVertex3f ( x + posx, y + posy, posz );
        }
    glEnd ( );
}


//------------------------------------------------------------------------------
// Fin de la fonction de dégradé
//------------------------------------------------------------------------------


void finFade ( )
{
    // on réinstalle les paramètres originaux (avant le fade)
    glDisable ( GL_BLEND );
    glEnable ( GL_DEPTH_TEST );
    glColor4f ( 1, 1, 1, 1 );
}


//------------------------------------------------------------------------------
// Intro ( true : l'intro continue / false : l'intro est finie )
//------------------------------------------------------------------------------


bool intro ( )
{
    static float theta = 0.0f;
    static bool ouv = true;
    static bool att = false;
    static bool ferm = false;
    
    glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity ( );
    
    // affiche l'environnement en 360°
    glPushMatrix ( );
        glTranslatef ( 0.0f, 0.0f, -20.0f );
        glRotatef ( -90, 1.0f, 0.0f, 0.0f );
        glRotatef ( theta*0.25f, 0.0f, 0.0f, 1.0f );
        glScaled ( 20, 20, 20 );
        AffichageASE ( sphere, TEX_360, TEX_ENV );
    glPopMatrix ( );

    glPushMatrix ( );
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    glTranslatef ( 0, 0, -10 );

    glEnable ( GL_BLEND );          // activation du blending
    glDisable ( GL_DEPTH_TEST );    // donc on retire le test de la distance

    glColor3d ( 0, 0, 0 );
    if ( ouv ) ouv = debFade ( 5.0f, ouv );
    if (( !ouv ) && ( !att )) att = attenteFade ( 3.5f );
    if (( !ferm ) && ( att )) ferm = debFade ( 2.0f, ferm );

    glDisable ( GL_COLOR );
    glEnable ( GL_TEXTURE_2D );
    glBindTexture ( GL_TEXTURE_2D, texture[TEX_ESTRELLA] );
    glBegin (GL_QUADS);
        glTexCoord2d ( 0, 0.33f ); glVertex3f ( -3.0f, -1.0f, 0 );
        glTexCoord2d ( 0, 0.66f ); glVertex3f ( -3.0f,  1.0f, 0 );
        glTexCoord2d ( 1, 0.66f ); glVertex3f (  3.0f,  1.0f, 0 );
        glTexCoord2d ( 1, 0.33f ); glVertex3f (  3.0f, -1.0f, 0 );
    glEnd ();
    
    glBindTexture ( GL_TEXTURE_2D, texture[TEX_OPENGL] );
    glBegin (GL_QUADS);
        glTexCoord2d ( 0.0f, 0.0f ); glVertex3f ( -5.0f, -3.0f, 0 );
        glTexCoord2d ( 0.0f, 1.0f ); glVertex3f ( -5.0f, -2.0f, 0 );
        glTexCoord2d ( 1.0f, 1.0f ); glVertex3f ( -3.0f, -2.0f, 0 );
        glTexCoord2d ( 1.0f, 0.0f ); glVertex3f ( -3.0f, -3.0f, 0 );
    glEnd ();
    
    glBindTexture ( GL_TEXTURE_2D, texture[TEX_DEVCPP] );
    glBegin (GL_QUADS);
        glTexCoord2d ( 0.0f, 0.0f ); glVertex3f ( -1.0f, -3.0f, 0 );
        glTexCoord2d ( 0.0f, 1.0f ); glVertex3f ( -1.0f, -2.5f, 0 );
        glTexCoord2d ( 1.0f, 1.0f ); glVertex3f (  1.0f, -2.5f, 0 );
        glTexCoord2d ( 1.0f, 0.0f ); glVertex3f (  1.0f, -3.0f, 0 );
    glEnd ();

    glBindTexture ( GL_TEXTURE_2D, texture[TEX_FMOD] );
    glBegin (GL_QUADS);
        glTexCoord2d ( 0.0f, 0.0f ); glVertex3f (  2.0f, -3.0f, 0 );
        glTexCoord2d ( 0.0f, 1.0f ); glVertex3f (  2.0f, -2.5f, 0 );
        glTexCoord2d ( 1.0f, 1.0f ); glVertex3f (  4.0f, -2.5f, 0 );
        glTexCoord2d ( 1.0f, 0.0f ); glVertex3f (  4.0f, -3.0f, 0 );
    glEnd ();

    glDisable ( GL_TEXTURE_2D );
    glEnable ( GL_COLOR );

    finFade ( );

    glPushMatrix ( );
    glTranslated ( 3*cos(theta/180.0f*pi), sin(theta/180.0f*pi), 0 );

    glRotatef ( theta , 1.0f, 1.0f, 0.0f);
    glColor3f ( 0.93f, 0.92f, 0.15f );
    DrawEtoile ( 0, 0, 0, 0.2, 0.6 );

    glPopMatrix ( );
    
    AfficheFlare ( 3*cos(theta/180.0f*pi), sin(theta/180.0f*pi), -0.1f );

    glPopMatrix ( );
    theta += temps.ecart*100.0f;

    if ( ferm ) { playMenu = true; return false; }
    else  return true;
}


//------------------------------------------------------------------------------
// Fin Du Fichier
//------------------------------------------------------------------------------