An old game I made in 2010 when I was learning OpenGL at college, just intending to save it here.

OpenGL Racing Game

#include <c:/dev-cpp/include/gl/glut.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#define VALOR_PI 3.14159265;
 
// estrutura que descreve um ponto (x,y)
typedef struct ponto {
        GLfloat x, y;
}p;
p tr;
 
typedef struct quad {
        ponto p1, p2, p3, p4;
}q;
q carro, vf, vt, tr1, tr2, tr3, tr4, tr5, tr6, tr7, tr8, tr9, tr10;
q aq1, aq2, aq3, aq4, tp;
 
typedef struct curva{
        ponto v;
        int tipo; //1, 2, 3, 4 indicando cantos, sentido anti-horário
}f;
f cr1, cr2, cr3, cr4, cr5, cr6, cr7, cr8, cr9, cr10;
 
typedef struct bbox{
     quad q;
     int tipo; //0 = pista antiga / 1 = pista / 2 = chegada / 3 = arquibancada
     bool c; //colisão
}bb;
bb bb1, bb2, bb3, bb4, bb5, bb6, bb7, bb8, bb9, bb10, bb11, bb12, bb13, bb14, bb15, bb16, bb17, bb18, bb19, bb20, bb_chegada;
bb ba1, ba2, ba3, ba4;
 
float zoom = 1, velocidade = 0 , angulo = 90, valor_pi = 3.14159265, escala = 0.5, tempo_voltas[10], volta_mais_rapida, volta_recorde, vel_maxima = 10;
//DEBUGS: 0 = off / 1 = velocidade / 2 = colisão / 3 = volta completa
//ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
int giro = 200, debug = 0, max_debug = 3, voltas = 0, total_voltas = 3, estado = 0, vm = 0, vd = 0, az = 0, cor_selecionada = 0, logo1 = 0, logo2 = 0, logo3 = 0, cont_semaforo = 0;
bool esq, dir, cima, baixo, voltacompleta, tranca_teclas, baixo_aux, cima_aux;
 
quad getBox(curva c){
     q ret;
     ret.p1 = c.v;
     switch(c.tipo){
        case 1:
            ret.p2.x = c.v.x + 100; ret.p2.y = c.v.y;
            ret.p3.x = c.v.x + 100; ret.p3.y = c.v.y + 100;
            ret.p4.x = c.v.x; ret.p4.y = c.v.y + 100;
        break;
        case 2:
            ret.p2.x = c.v.x - 100; ret.p2.y = c.v.y;
            ret.p3.x = c.v.x - 100; ret.p3.y = c.v.y + 100;
            ret.p4.x = c.v.x; ret.p4.y = c.v.y + 100;
        break;
        case 3:
            ret.p2.x = c.v.x - 100; ret.p2.y = c.v.y;
            ret.p3.x = c.v.x - 100; ret.p3.y = c.v.y - 100;
            ret.p4.x = c.v.x; ret.p4.y = c.v.y - 100;
        break;
        case 4:
            ret.p2.x = c.v.x + 100; ret.p2.y = c.v.y;
            ret.p3.x = c.v.x + 100; ret.p3.y = c.v.y - 100;
            ret.p4.x = c.v.x; ret.p4.y = c.v.y - 100;
        break;
     }
     return ret;
}
 
void desenha_carro(void){
    //****** CARRO *********
    //lataria
    carro.p1.x = -40*escala; carro.p1.y = -20*escala;
    carro.p2.x = 40*escala; carro.p2.y = -20*escala;
    carro.p3.x = 40*escala; carro.p3.y = 20*escala;
    carro.p4.x = -40*escala; carro.p4.y = 20*escala;
    //vidro traseiro
    vt.p1.x = -20*escala; vt.p1.y = -15*escala;
    vt.p2.x = -10*escala; vt.p2.y = -10*escala;
    vt.p3.x = -10*escala; vt.p3.y = 10*escala;
    vt.p4.x = -20*escala; vt.p4.y = 15*escala;
    //vidro frontal
    vf.p1.x = 10*escala; vf.p1.y = 16*escala;
    vf.p2.x = 15*escala; vf.p2.y = 16*escala;
    vf.p3.x = 15*escala; vf.p3.y = -16*escala;
    vf.p4.x = 10*escala; vf.p4.y = -16*escala;
}
 
// Inicializa cor de fundo da janela e o valor inicial dos pontos
void Inicio(void) {
    glEnable(GL_LINE_SMOOTH);
 
    glClearColor(0.35, 0.9, 0.25, 0);
 
    //****** INÍCIO ********
    tr.x = 220; tr.y = 520;
 
    desenha_carro();
 
    //****** PISTA ********
 
    //reta 1
    tr1.p1.x = 110; tr1.p1.y = 490;    tr1.p2.x = 690; tr1.p2.y = 490;
    tr1.p3.x = 690; tr1.p3.y = 590;    tr1.p4.x = 110; tr1.p4.y = 590;
 
    //curva 1
    cr1.v.x = 690; cr1.v.y = 490; cr1.tipo = 1;
 
    //reta 2
    tr2.p1.x = 690; tr2.p1.y = 490;    tr2.p2.x = 790; tr2.p2.y = 490;
    tr2.p3.x = 790; tr2.p3.y = 450;    tr2.p4.x = 690; tr2.p4.y = 450;
 
    //curva 2
    cr2.v.x = 690; cr2.v.y = 450; cr2.tipo = 4;
 
    //reta 3
    tr3.p1.x = 690; tr3.p1.y = 450;    tr3.p2.x = 690; tr3.p2.y = 350;
    tr3.p3.x = 550; tr3.p3.y = 350;    tr3.p4.x = 550; tr3.p4.y = 450;
 
    //curva 3
    cr3.v.x = 550; cr3.v.y = 350; cr3.tipo = 2;
 
    //reta 4
    tr4.p1.x = 450; tr4.p1.y = 350;    tr4.p2.x = 550; tr4.p2.y = 350;
    tr4.p3.x = 550; tr4.p3.y = 320;    tr4.p4.x = 450; tr4.p4.y = 320;
 
    //curva 4
    cr4.v.x = 550; cr4.v.y = 320; cr4.tipo = 3;
 
    //reta 5
    tr5.p1.x = 690; tr5.p1.y = 320;    tr5.p2.x = 690; tr5.p2.y = 220;
    tr5.p3.x = 550; tr5.p3.y = 220;    tr5.p4.x = 550; tr5.p4.y = 320;
 
    //curva 5
    cr5.v.x = 690; cr5.v.y = 220; cr5.tipo = 1;
 
    //reta 6
    tr6.p1.x = 690; tr6.p1.y = 220;    tr6.p2.x = 790; tr6.p2.y = 220;
    tr6.p3.x = 790; tr6.p3.y = 110;    tr6.p4.x = 690; tr6.p4.y = 110;
 
    //curva 6
    cr6.v.x = 690; cr6.v.y = 110; cr6.tipo = 4;
 
    //reta 7
    tr7.p1.x = 690; tr7.p1.y = 110;    tr7.p2.x = 690; tr7.p2.y = 10;
    tr7.p3.x = 300; tr7.p3.y = 10;    tr7.p4.x = 300; tr7.p4.y = 110;
 
    //curva 7
    cr7.v.x = 300; cr7.v.y = 110; cr7.tipo = 3;
 
    //reta 8
    tr8.p1.x = 300; tr8.p1.y = 220;    tr8.p2.x = 200; tr8.p2.y = 220;
    tr8.p3.x = 200; tr8.p3.y = 110;    tr8.p4.x = 300; tr8.p4.y = 110;
 
    //curva 8
    cr8.v.x = 200; cr8.v.y = 220; cr8.tipo = 1;
 
    //reta 9
    tr9.p1.x = 200; tr9.p1.y = 220;    tr9.p2.x = 200; tr9.p2.y = 320;
    tr9.p3.x = 110; tr9.p3.y = 320;    tr9.p4.x = 110; tr9.p4.y = 220;
 
    //curva 9
    cr9.v.x = 110; cr9.v.y = 320; cr9.tipo = 3;
 
    //reta 10
    tr10.p1.x = 110; tr10.p1.y = 320;    tr10.p2.x = 10; tr10.p2.y = 320;
    tr10.p3.x = 10; tr10.p3.y = 490;    tr10.p4.x = 110; tr10.p4.y = 490;
 
    //curva 10
    cr10.v.x = 110; cr10.v.y = 490; cr10.tipo = 2;
 
    //****** Arquibancadas ********
    aq1.p1.x = -50; aq1.p1.y = -50; aq1.p2.x = -50; aq1.p2.y = -100;
    aq1.p3.x = 850; aq1.p3.y = -100; aq1.p4.x = 850; aq1.p4.y = -50;
 
    aq2.p1.x = -50; aq2.p1.y = 700; aq2.p2.x = -50; aq2.p2.y = 650;
    aq2.p3.x = 850; aq2.p3.y = 650; aq2.p4.x = 850; aq2.p4.y = 700;
 
    aq3.p1.x = -50; aq3.p1.y = -50; aq3.p2.x = -50; aq3.p2.y = 650;
    aq3.p3.x = -100; aq3.p3.y = 650; aq3.p4.x = -100; aq3.p4.y = -50;
 
    aq4.p1.x = 850; aq4.p1.y = -50; aq4.p2.x = 850; aq4.p2.y = 650;
    aq4.p3.x = 900; aq4.p3.y = 650; aq4.p4.x = 900; aq4.p4.y = -50;
 
    //****** Bounding Boxes *********
    bb1.q = tr1; bb2.q = tr2; bb3.q = tr3; bb4.q = tr4; bb5.q = tr5; bb6.q = tr6; bb7.q = tr7; bb8.q = tr8; bb9.q = tr9; bb10.q = tr10;
    ba1.q = aq1; ba2.q = aq2; ba3.q = aq3; ba4.q = aq4;
    ba1.tipo = 3; ba2.tipo = 3; ba3.tipo = 3; ba4.tipo = 3;
    bb11.q = getBox(cr1); bb12.q = getBox(cr2); bb13.q = getBox(cr3); bb14.q = getBox(cr4); bb15.q = getBox(cr5);
    bb16.q = getBox(cr6); bb17.q = getBox(cr7); bb18.q = getBox(cr8); bb19.q = getBox(cr9); bb20.q = getBox(cr10);
    bb_chegada.q.p1.x = 255; bb_chegada.q.p1.y = 490;
    bb_chegada.q.p2.x = 275; bb_chegada.q.p2.y = 490;
    bb_chegada.q.p3.x = 275; bb_chegada.q.p3.y = 590;
    bb_chegada.q.p4.x = 255; bb_chegada.q.p4.y = 590;
    bb_chegada.tipo = 2;
 
    //tela preta
    tp.p1.x = -400; tp.p1.y = -300;
    tp.p2.x = 400; tp.p2.y = -300;
    tp.p3.x = 400; tp.p3.y = 300;
    tp.p4.x = -400; tp.p4.y = 300;
}
 
void Rotacao(float ang, quad &qu){
     float auxx, auxy;
 
     auxx =  qu.p1.x*cos(ang) - qu.p1.y*sin(ang);
     auxy =  qu.p1.x*sin(ang) + qu.p1.y*cos(ang);
 
     qu.p1.x = auxx;
     qu.p1.y = auxy;
 
     auxx =  qu.p2.x*cos(ang) - qu.p2.y*sin(ang);
     auxy =  qu.p2.x*sin(ang) + qu.p2.y*cos(ang);
 
     qu.p2.x = auxx;
     qu.p2.y = auxy;
 
     auxx =  qu.p3.x*cos(ang) - qu.p3.y*sin(ang);
     auxy =  qu.p3.x*sin(ang) + qu.p3.y*cos(ang);
 
     qu.p3.x = auxx;
     qu.p3.y = auxy;
 
     auxx =  qu.p4.x*cos(ang) - qu.p4.y*sin(ang);
     auxy =  qu.p4.x*sin(ang) + qu.p4.y*cos(ang);
 
     qu.p4.x = auxx;
     qu.p4.y = auxy;
}
 
void CalculaRotacao(char op){
     //http://www.convertworld.com/pt/angulo/
     //15° = 0.2618 rad
     //30° = 0.5236 rad
     float ang = 0;
 
     if(op == 'A'){
         ang += 0.2618;
         angulo += 15;
      }
     else if(op == 'H'){
          ang -= 0.2618;
          angulo -= 15;
     }
 
     Rotacao(ang, carro);
     Rotacao(ang, vf);
     Rotacao(ang, vt);
}
 
void reseta_boxes(void){
   bb1.c = 0; bb2.c = 0; bb3.c = 0; bb4.c = 0; bb5.c = 0;
   bb6.c = 0; bb7.c = 0; bb8.c = 0; bb9.c = 0; bb10.c = 0;
   bb11.c = 0; bb12.c = 0; bb13.c = 0; bb14.c = 0; bb15.c = 0;
   bb16.c = 0; bb17.c = 0; bb18.c = 0; bb19.c = 0; bb20.c = 0;
}
 
void reinicia_jogo(void){
     //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
     tr.x = 220; tr.y = 520;
     voltas = 0;
     for(int i=0;i<10;i++) tempo_voltas[i] = 0;
     volta_mais_rapida = 0;
     voltacompleta = 0;
     reseta_boxes();
     velocidade = 0;
     angulo = 90;
     desenha_carro();
     cont_semaforo = estado==5?5:15;
     estado = 2;
}
 
void muda_cor(void){
     cor_selecionada++;
     if(cor_selecionada>3) cor_selecionada = 0;
     switch(cor_selecionada){
        case 0: vm = 0; vd = 0; az = 0; break;
        case 1: vm = 250; vd = 20; az = 20; break;
        case 2: vm = 0; vd = 0; az = 150; break;
        case 3: vm = 255; vd = 255; az = 255; break;
     }
}
 
void TeclasNormais(unsigned char tecla, int x, int y){
     //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
     if(estado == 3){
         if((tecla == 'Z' || tecla == 'z') && zoom < 3){zoom += 0.1;}
         if((tecla == 'X' || tecla == 'x') && zoom > 0.4){zoom -= 0.1;}
         if(tecla == 'C' || tecla == 'c'){muda_cor();}
     }
 
     if(tecla == 'I' || tecla == 'i'){if(estado==1 || estado == 5) reinicia_jogo();}
     //if(tecla == 'R' || tecla == 'r'){if(estado>1){reinicia_jogo();}
 
     if(tecla == 'B' || tecla == 'b'){
         debug = debug==max_debug?0:debug + 1;
         printf("DEBUG MODE: %i\n", debug);
     }
 
     if(tecla == 'P' || tecla == 'p'){
         if(estado==3) estado = 4;
         else if(estado==4) estado = 3;
     }
 
     if(tecla == 'V' || tecla == 'v'){
         //velocidade = 300;
         //vel_maxima = 300;
         //escala = 2;
         tempo_voltas[voltas] +=10;
         voltacompleta = 1;
     }
 
     //redesenha cena aplicando as mudanças
     glutPostRedisplay();
}
 
void TeclasEspeciais(int tecla, int x, int y){
     //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
     if(!tranca_teclas){
         if(tecla == GLUT_KEY_UP){
            cima = 1;
            baixo_aux = 0;
         }
         if(tecla == GLUT_KEY_DOWN){
             baixo = 1;
             cima_aux = 0;
         }
         if(estado == 3){
             if(tecla == GLUT_KEY_LEFT) esq = 1;
             if(tecla == GLUT_KEY_RIGHT) dir = 1;
         }
     }
}
 
void TeclasEspeciaisUp(int tecla, int x, int y){
     if(tecla == GLUT_KEY_UP){cima = 0; cima_aux = 0;}
     if(tecla == GLUT_KEY_DOWN){baixo = 0; baixo_aux = 0;}
     if(tecla == GLUT_KEY_LEFT) esq = 0;
     if(tecla == GLUT_KEY_RIGHT) dir = 0;
}
 
void SoltaTeclas(int timer){
    tranca_teclas = 1;
    cima = 0; baixo = 0;
    timer--;
    if(timer > 0) glutTimerFunc(100, SoltaTeclas, timer);
    else{tranca_teclas = 0;}
}
 
void FuncaoMove(int valor){
    //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
    if(estado==3 || estado==5){
        if(estado == 3){
            if(cima) velocidade += 0.5;
            if(baixo) velocidade -= 0.3;
        }
 
        velocidade = velocidade * 0.98;
        if(estado == 5){
             velocidade = velocidade * 0.95;
             if(velocidade<1) velocidade = 0;
        }
 
        if(velocidade > vel_maxima) velocidade = vel_maxima;
        if(velocidade < -vel_maxima/2) velocidade = -vel_maxima/2;
 
        if(debug == 1) printf("%f || X: %f - Y: %f\n", velocidade, tr.x, tr.y);
 
        tr.x += sin((angulo * valor_pi)/180) * velocidade;
        tr.y += cos((angulo * valor_pi)/180) * -velocidade;
 
        if(velocidade > 7 || velocidade <-7) giro = 50;
        if(velocidade < 7 && velocidade >-7) giro = 100;
        if(velocidade < 5 && velocidade >-5) giro = 200;
        if(velocidade < 3 && velocidade >-3) giro = 500;
 
        glutPostRedisplay();
    }
    glutTimerFunc(30, FuncaoMove, 1);
}
 
void FuncaoGira(int valor){
    if(dir && (velocidade > 2||velocidade < -2)) CalculaRotacao('H');
    if(esq && (velocidade > 2||velocidade < -2)) CalculaRotacao('A');
 
    glutPostRedisplay();
    glutTimerFunc(giro, FuncaoGira, 1);
}
 
//desenha quadriláteros
void quads(quad q){
    glBegin(GL_QUADS);
        glVertex2f(q.p1.x, q.p1.y);
        glVertex2f(q.p2.x, q.p2.y);
        glVertex2f(q.p3.x, q.p3.y);
        glVertex2f(q.p4.x, q.p4.y);
    glEnd();
}
 
//quadrados sem preenchimento
void quad_borda(quad q){
     glBegin(GL_LINE_LOOP);
        glVertex2f(q.p1.x, q.p1.y);
        glVertex2f(q.p2.x, q.p2.y);
        glVertex2f(q.p3.x, q.p3.y);
        glVertex2f(q.p4.x, q.p4.y);
    glEnd();
}
 
//desenha as bounding boxes
void box(bbox b) {
    glLineWidth(4.0f);
 
    if(b.c) glColor4ub(0, 255, 0, 150);
    else glColor4ub(255, 0, 0, 150);
    if(b.tipo == 2) glColor4ub(0, 0, 255, 150);
    else if(b.tipo == 3) glColor4ub(255, 255, 0, 150);
    quad_borda(b.q);
    //glutPostRedisplay();
}
 
//desenha a chegada
void desenha_chegada() {
    glPointSize(15/zoom);
    float px = 260, py = 495; //490 a 590
    bool preto = 0;
    glBegin(GL_POINTS);
        for(int i=0;i<20;i++){
            if(preto){glColor3ub(255, 255, 255); preto = 0;}
            else{glColor3ub(0, 0, 0); preto = 1;}
            glVertex2f(px, py);
            if(i==9){py-=90;px+=10; preto=1;}
            else py += 10;
        }
    glEnd();
}
 
void bitmap_output(GLfloat x, GLfloat y, char *string, void *font){
  int len, i;
  glRasterPos2f(x, y);
  len = (int) strlen(string);
  for (i = 0; i < len; i++) glutBitmapCharacter(font, string[i]);
}
 
void stroke_output(GLfloat x, GLfloat y, float esc, float larg, bool mono, char *format, ...){
  va_list args;
  char buffer[200], *p;
 
  va_start(args, format);
  vsprintf(buffer, format, args);
  va_end(args);
  glPushMatrix();
  glTranslatef(x, y, 0);
  glScalef(esc*zoom,esc*zoom,0);
  glLineWidth(larg);
  for(p = buffer; *p; p++) glutStrokeCharacter(mono?GLUT_STROKE_MONO_ROMAN:GLUT_STROKE_ROMAN, *p);
  glPopMatrix();
}
 
void escreve_velocidade(void){
     char vel[20];
     sprintf(vel,"Velocidade: %3.0fkm/h", velocidade*10);
     stroke_output(tr.x - 255*zoom, tr.y - 190*zoom, 0.08, 1.8, 1, vel);
}
 
void escreve_voltas(void){
     char vt[20];
     sprintf(vt,"Voltas: %d/%d", voltas<total_voltas?voltas+1:voltas, total_voltas);
     stroke_output(tr.x - 255*zoom, tr.y + 180*zoom, 0.1, 1.8, 1, vt);
}
 
void escreve_tempo(void){
     char vt[20];
     sprintf(vt,"Tempo: %3.1fs", tempo_voltas[voltas]);
     stroke_output(tr.x - 40*zoom, tr.y + 182*zoom, 0.08, 1.8, 1, vt);
}
 
void escreve_melhor_volta(void){
     char vt[20];
     sprintf(vt,"Melhor: %3.1fs", volta_mais_rapida);
     stroke_output(tr.x + 155*zoom, tr.y + 182*zoom, 0.08, 1.8, 1, vt);
}
 
void escreve_recorde(void){
     char vt[20];
     sprintf(vt,"Recorde: %3.1fs", volta_recorde);
     stroke_output(tr.x + 145*zoom, tr.y -190*zoom, 0.08, 1.8, 1, vt);
}
 
void escreve_pause(void){
     glColor3ub(255,255,255);
     stroke_output(tr.x-40*zoom, tr.y, 0.1, 1.8, 1, "Pausado");
}
 
void escreve_fim_jogo(void){
     char vt[30];
     bool vtr = 0;
     glColor3ub(255,255,255);
     stroke_output(tr.x-80*zoom, tr.y+100*zoom, 0.2, 1.8, 0, "Fim de jogo");
     stroke_output(tr.x-80*zoom, tr.y+70*zoom, 0.08, 1.8, 1, "Voltas:");
     for(int i=0;i<total_voltas;i++){
        if(tempo_voltas[i] == volta_mais_rapida && !vtr){glColor3ub(255,0,0); vtr=1;}
        else glColor3ub(255,255,255);
        sprintf(vt,"Volta %i: %3.1fs", i+1, tempo_voltas[i]);
        stroke_output(tr.x-80*zoom, tr.y+(40-14*i)*zoom, 0.08, 1.8, 1, vt);
     }
     if(volta_mais_rapida == volta_recorde){
       glColor3ub(0,255,0);
       stroke_output(tr.x-80*zoom, tr.y+(40-14*total_voltas-20)*zoom, 0.08, 1.8, 1, "Novo Recorde! :)");
     }
}
 
void escreve_tela(void){
   glColor3ub(255,255,255);
   escreve_velocidade();
   escreve_voltas();
   //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
   if(estado > 1 && estado < 5) escreve_tempo();
   if(volta_recorde) escreve_recorde();
   escreve_melhor_volta();
}
 
void tela_preta(int opac){
     glPushMatrix();
     glTranslatef(tr.x, tr.y, 0);
     glScalef(zoom,zoom,20);
     glColor4ub(0, 0, 0, opac);
     quads(tp);
     glPopMatrix();
}
 
void tela_ini(int i){
    int c1 = 100;
    int c2 = 230;
 
    int vtr[16][2] = {{1,2},{1,3},{0,3},{0,10},{2,10},{2,3},{4,3},{4,10},{6,10},{6,3},{5,3},{5,2},{4,2},{4,1},{2,1},{2,2}};
    int quar[18][2] = {{1,0},{1,5},{0,5},{0,7},{4,7},{4,9},{6,9},{6,7},{7,7},{7,6},{6,6},{6,2},{4,2},{4,6},{2,6},{2,5},{3,5},{3,0}};
    int dois[30][2] = {{1,0},{5,0},{5,1},{6,1},{6,4},{5,4},{5,5},{4,5},{4,6},{3,6},{3,7},{2,7},{2,8},{6,8},{6,9},{0,9},{0,7},{1,7},{1,6},{2,6},{2,5},{3,5},{3,4},{4,4},{4,1},{2,1},{2,3},{0,3},{0,1},{1,1}};
    int esc = 20;
 
    //glPushMatrix();
    glPushMatrix();
    glColor3ub(logo1, logo1, logo1);
    glTranslatef(tr.x - 11*esc, tr.y-100, 0);
    glBegin(GL_LINE_LOOP);
    for(int j=0;j<16;j++) glVertex2f(vtr[j][0]*esc,vtr[j][1]*esc);
    glEnd();
    glPopMatrix();
 
    glPushMatrix();
    glColor3ub(logo2, logo2, logo2);
    glTranslatef(tr.x-4*esc, tr.y-100, 0);
    glBegin(GL_LINE_LOOP);
    for(int j=0;j<18;j++) glVertex2f(quar[j][0]*esc,(10-quar[j][1])*esc);
    glEnd();
    glPopMatrix();
 
    glPushMatrix();
    glColor3ub(logo3, logo3, logo3);
    glTranslatef(tr.x + 4*esc, tr.y-100, 0);
    glBegin(GL_LINE_LOOP);
    for(int j=0;j<30;j++) glVertex2f(dois[j][0]*esc,(10-dois[j][1])*esc);
    glEnd();
    glPopMatrix();
 
    //glPopMatrix();
 
    stroke_output(tr.x-50*zoom, tr.y-125*zoom, 0.08, 1.8, 0, "v42.com.br");
 
    if(i==-1){
        if(logo1 < c1) logo1+=15;
        if(logo2 < c2){logo2+=15;logo3+=15;}
        else if(i==-1) glutTimerFunc(30, tela_ini, 2);
        printf("Tela 1 \n");
    }else{
        glColor3ub(255, 255, 255);
        if(i>1 && estado == 0)glutTimerFunc(500, tela_ini, i-1);
        else estado = 1;
        printf("Segurando \n");
    }
}
 
void semaforo(int i){
     if(cont_semaforo>0 && estado == 2){
        cont_semaforo--; glutTimerFunc(3000, semaforo, cont_semaforo);
        printf("Semaforo: %d \n",cont_semaforo);
     }
     else {
          estado = 3;
     }
     printf("Estado %d ",estado);
}
 
//desenha chegada da tela inicial
void menu(void){
    float px = tr.x-200, py = tr.y - 200;
    bool preto = 0;
    quad qdr;
    int esc = 5;
 
    qdr.p1.x = -5; qdr.p1.y = -5; qdr.p2.x = 5; qdr.p2.y = -5;
    qdr.p3.x = 5; qdr.p3.y = 5; qdr.p4.x = -5; qdr.p4.y = 5;
 
    for(int i=0;i<20;i++){
        if(preto){glColor3ub(255, 255, 255); preto = 0;}
        else{glColor3ub(0, 0, 0); preto = 1;}
 
        glPushMatrix();
        glTranslatef(px, py, 0);
        glScalef(esc,esc,0);
        glRotatef(-3.6, 0, 0, 1);
        quads(qdr);
        glPopMatrix();
 
        if(i==9){py-=90.55*esc;px-=0.05*esc; preto=1;}
        else {px += 1*esc; py += 10*esc;}
    }
 
    glColor3ub(255, 255, 255);
    stroke_output(tr.x-50*zoom, tr.y+100*zoom, 0.4, 3, 0, "Carro.exe");
    stroke_output(tr.x-50*zoom, tr.y+50*zoom, 0.08, 1.8, 1, "Pressione i para Iniciar");
    stroke_output(tr.x-50*zoom, tr.y-20*zoom, 0.08, 1.8, 1, "Comandos");
    stroke_output(tr.x-50*zoom, tr.y-45*zoom, 0.08, 1.8, 1, "Setas: Mover Carro");
    stroke_output(tr.x-50*zoom, tr.y-65*zoom, 0.08, 1.8, 1, "C: Mudar Cor");
    //stroke_output(tr.x-50*zoom, tr.y-85*zoom, 0.08, 1.8, 1, "P: Pausar o jogo");
    stroke_output(tr.x-50*zoom, tr.y-85*zoom, 0.08, 1.8, 1, "R: Reiniciar o jogo");
    stroke_output(tr.x-50*zoom, tr.y-105*zoom, 0.08, 1.8, 1, "B: Debugs");
}
 
//desenha as telas de apresentação e game over
void desenha_telas(void){
     //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
     switch(estado){
         case 0:
              tela_preta(255);
              tela_ini(-1);
              break;
         case 1:
              tela_preta(255);
              menu();
              break;
         case 2:
              semaforo(0);
              break;
         case 4:
              tela_preta(130);
              escreve_pause();
              break;
         case 5:
              tela_preta(200);
              escreve_fim_jogo();
              break;
     }
}
 
//desenha o carro
void desenhaCarro(void){
    glColor3ub(vm, vd, az);
    glBegin(GL_QUADS);
        glVertex2f(carro.p1.x + tr.x, carro.p1.y + tr.y);
        glVertex2f(carro.p2.x + tr.x, carro.p2.y + tr.y);
        glVertex2f(carro.p3.x + tr.x, carro.p3.y + tr.y);
        glVertex2f(carro.p4.x + tr.x, carro.p4.y + tr.y);
    glEnd();
    if(cor_selecionada == 1){
        glLineWidth(1.8/zoom);
        glColor3ub(120, 20, 20);
        glBegin(GL_LINE_LOOP);
            glVertex2f(carro.p1.x + tr.x, carro.p1.y + tr.y);
            glVertex2f(carro.p2.x + tr.x, carro.p2.y + tr.y);
            glVertex2f(carro.p3.x + tr.x, carro.p3.y + tr.y);
            glVertex2f(carro.p4.x + tr.x, carro.p4.y + tr.y);
        glEnd();
    }
    glColor3ub(180, 180, 250);
    if(cor_selecionada>0)glColor3ub(70, 70, 40);
    glBegin(GL_QUADS);
        glVertex2f(vt.p1.x + tr.x, vt.p1.y + tr.y);
        glVertex2f(vt.p2.x + tr.x, vt.p2.y + tr.y);
        glVertex2f(vt.p3.x + tr.x, vt.p3.y + tr.y);
        glVertex2f(vt.p4.x + tr.x, vt.p4.y + tr.y);
    glEnd();
    glBegin(GL_QUADS);
        glVertex2f(vf.p1.x + tr.x, vf.p1.y + tr.y);
        glVertex2f(vf.p2.x + tr.x, vf.p2.y + tr.y);
        glVertex2f(vf.p3.x + tr.x, vf.p3.y + tr.y);
        glVertex2f(vf.p4.x + tr.x, vf.p4.y + tr.y);
    glEnd();
    if(cor_selecionada == 1){
        glLineWidth(0.8/zoom);
        glColor3ub(120, 20, 20);
        glBegin(GL_LINE_LOOP);
            glVertex2f(vt.p1.x + tr.x, vt.p1.y + tr.y);
            glVertex2f(vt.p2.x + tr.x, vt.p2.y + tr.y);
            glVertex2f(vt.p3.x + tr.x, vt.p3.y + tr.y);
            glVertex2f(vt.p4.x + tr.x, vt.p4.y + tr.y);
        glEnd();
        glBegin(GL_LINE_LOOP);
            glVertex2f(vf.p1.x + tr.x, vf.p1.y + tr.y);
            glVertex2f(vf.p2.x + tr.x, vf.p2.y + tr.y);
            glVertex2f(vf.p3.x + tr.x, vf.p3.y + tr.y);
            glVertex2f(vf.p4.x + tr.x, vf.p4.y + tr.y);
        glEnd();
    }
 
}
 
void testes(void){
     GLint mv[4];
     glGetIntegerv( GL_VIEWPORT, mv );
     printf("%i, %i, %i, %i\n", mv[0], mv[1], mv[2], mv[3]);
 
     for(float ang=0;ang<=90;ang+=30){
         printf("ANG: %f - sin: %f - cos: %f\n", ang, sin(ang), cos(ang));
     }
     printf("ANGULO: %f \n", angulo);
}
 
//desenha bounding boxes
void desenhaCaixas(void){
     if(debug == 2){
        box(bb1); box(bb2); box(bb3); box(bb4); box(bb5);
        box(bb6); box(bb7); box(bb8); box(bb9); box(bb10);
        box(bb11); box(bb12); box(bb13); box(bb14); box(bb15);
        box(bb16); box(bb17); box(bb18); box(bb19); box(bb20);
        box(bb_chegada);
        box(ba1); box(ba2); box(ba3); box(ba4);
     }
}
 
//testa se completou a volta
bool volta_completa(void){
     if(bb1.c && bb2.c && bb3.c && bb4.c && bb5.c && bb6.c &&
        bb7.c && bb8.c && bb9.c && bb10.c && bb11.c && bb12.c &&
        bb13.c && bb14.c && bb15.c && bb16.c && bb17.c && bb18.c &&
        bb19.c && bb20.c){
           reseta_boxes();
           voltacompleta = 1;
           return true;
    }
    return false;
}
 
void FuncaoVoltas(int i){
  float tempo_total;
  //ESTADOS: 0 - tela inicial / 1 = menu  / 2 - semáforo / 3 - jogando / 4 - pausado / 5 - game over
  if(estado == 3){
     if(voltas<total_voltas){
         if(voltacompleta){
             if(!volta_mais_rapida || tempo_voltas[voltas]<volta_mais_rapida) volta_mais_rapida = tempo_voltas[voltas];
             if(debug == 3) printf("*** VOLTA %i COMPLETA! ***\n Tempo: %5.2fs\n", voltas+1, tempo_voltas[voltas]);
             if(!volta_recorde || volta_mais_rapida<volta_recorde) volta_recorde = volta_mais_rapida;
             voltacompleta = 0;
             voltas++;
         }
         if(voltas<total_voltas)tempo_voltas[voltas] += 0.1;
     }else{
        estado = 5;
        for(int i=0;i<total_voltas;i++) tempo_total += tempo_voltas[i];
        if(debug == 3) printf("*** GAME OVER ***\n Tempo total: %5.2fs\nMelhor volta: %5.2fs\nVolta Recorde: %5.2fs", tempo_total, volta_mais_rapida, volta_recorde);
     }
  }
     glutTimerFunc(100, FuncaoVoltas, 1);
}
 
//colisão de um ponto com um quadrilátero
bool colidiu_pquad(ponto p, quad b){
     GLfloat xi, xf, yi, yf;
 
     if(b.p1.x != b.p2.x){
       if(b.p1.x < b.p2.x){xi = b.p1.x; xf = b.p2.x;}
       else{xi = b.p2.x; xf = b.p1.x;}
     }else{
        if(b.p1.x < b.p3.x){xi = b.p1.x; xf = b.p3.x;}
        else{xi = b.p3.x; xf = b.p1.x;}
     }
 
     if(b.p1.y != b.p2.y){
        if(b.p1.y < b.p2.y){yi = b.p1.y; yf = b.p2.y;}
        else{yi = b.p2.y; yf = b.p1.y;}
     }else{
        if(b.p1.y < b.p3.y){yi = b.p1.y; yf = b.p3.y;}
        else{yi = b.p3.y; yf = b.p1.y;}
     }
 
     if(p.x + tr.x>=xi && p.x + tr.x<=xf && p.y + tr.y>=yi && p.y + tr.y<= yf){
        if(debug == 2) printf("%f,%f / X: %f a %f / Y: %f a %f\n", p.x + tr.x, p.y + tr.y, xi, xf, yi, yf);
        return true;
     }
     return false;
}
 
//colisão entre um quadrilátero e uma box
bool colidiu(quad q, bbox &b){
     if(b.tipo!=2 && b.c) return true;
     if(colidiu_pquad(q.p1, b.q)) b.c = 1;
     if(!b.c && colidiu_pquad(q.p2, b.q)) b.c = 1;
     if(!b.c && colidiu_pquad(q.p3, b.q)) b.c = 1;
     if(!b.c && colidiu_pquad(q.p4, b.q)) b.c = 1;
     if(b.c && b.tipo==2){
        b.c = 0;
        volta_completa();
     }
     if(b.c && b.tipo == 3){
        b.c = 0;
        if(!tranca_teclas){
           velocidade = -velocidade;
           SoltaTeclas(3);
        }
     }
}
 
void testa_colisao(int i){
    //colisão retas
         colidiu(carro, bb1); colidiu(carro, bb2); colidiu(carro, bb3);
         colidiu(carro, bb4); colidiu(carro, bb5); colidiu(carro, bb6);
         colidiu(carro, bb7); colidiu(carro, bb8); colidiu(carro, bb9);
         colidiu(carro, bb10);
     //colisão curvas
         colidiu(carro, bb11); colidiu(carro, bb12); colidiu(carro, bb13);
         colidiu(carro, bb14); colidiu(carro, bb15); colidiu(carro, bb16);
         colidiu(carro, bb17); colidiu(carro, bb18); colidiu(carro, bb19);
         colidiu(carro, bb20);
     //colisão chegada
        colidiu(carro, bb_chegada);
    //colisão arquibancada
        colidiu(carro, ba1); colidiu(carro, ba2);
        colidiu(carro, ba3); colidiu(carro, ba4);
 
     glutTimerFunc(70, testa_colisao, 1);
}
 
//desenha curvas
void curvas(curva c){
 
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(c.v.x, c.v.y);
 
    switch(c.tipo){
        case 1:
            glVertex2f(c.v.x + 100, c.v.y);
            glVertex2f(c.v.x + 90, c.v.y + 40);
            glVertex2f(c.v.x + 70, c.v.y + 70);
            glVertex2f(c.v.x + 40, c.v.y + 90);
            glVertex2f(c.v.x, c.v.y + 100);
        break;
        case 2:
            glVertex2f(c.v.x - 100, c.v.y);
            glVertex2f(c.v.x - 90, c.v.y + 40);
            glVertex2f(c.v.x - 70, c.v.y + 70);
            glVertex2f(c.v.x - 40, c.v.y + 90);
            glVertex2f(c.v.x, c.v.y + 100);
        break;
        case 3:
            glVertex2f(c.v.x - 100, c.v.y);
            glVertex2f(c.v.x - 90, c.v.y - 40);
            glVertex2f(c.v.x - 70, c.v.y - 70);
            glVertex2f(c.v.x - 40, c.v.y - 90);
            glVertex2f(c.v.x, c.v.y - 100);
        break;
        case 4:
            glVertex2f(c.v.x + 100, c.v.y);
            glVertex2f(c.v.x + 90, c.v.y - 40);
            glVertex2f(c.v.x + 70, c.v.y - 70);
            glVertex2f(c.v.x + 40, c.v.y - 90);
            glVertex2f(c.v.x, c.v.y - 100);
        break;
    }
     glEnd();
}
 
// Desenha cena
void DesenhaCena(void) {
    GLint mv[4];
    glGetIntegerv( GL_VIEWPORT, mv );
     // Limpa a janela com a cor especificada como cor de fundo
    glClear(GL_COLOR_BUFFER_BIT);
 
    //transparência
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    //glViewport(mv[0}, mv[1}, mv[2}, mv[3}); //viewport: Xmin, Ymin, Xmax, Ymax
 
    glMatrixMode(GL_PROJECTION);   // indica que a matriz a seguir deve ser carregada
    glLoadIdentity();               // na matriz de transformacao de visualizacao
    gluOrtho2D(-266*zoom + tr.x, 266*zoom + tr.x, -200*zoom + tr.y, 200*zoom + tr.y);
    glMatrixMode(GL_MODELVIEW);     // recoloca a OpenGL em estado de transformacoes de modelagem
    glLoadIdentity();
 
    //pista
    glColor3ub(50, 50, 50);
    quads(tr1); quads(tr2); quads(tr3); quads(tr4); quads(tr5); quads(tr6); quads(tr7); quads(tr8); quads(tr9); quads(tr10);
    curvas(cr1); curvas(cr2); curvas(cr3); curvas(cr4); curvas(cr5); curvas(cr6); curvas(cr7); curvas(cr8); curvas(cr9); curvas(cr10);
 
    //arquibancadas
    glColor3ub(0, 0, 0);
    quads(aq1); quads(aq2); quads(aq3); quads(aq4);
 
    //chegada
    desenha_chegada();
 
    //carro
    desenhaCarro();
 
    //desenha bounding boxes
    desenhaCaixas();
 
    //textos
    escreve_tela();
 
    //telas
    desenha_telas();
 
    glutSwapBuffers(); //Alterna buffers
}
 
// Parte principal - ponto de início de execução
// Cria janela
// Inicializa aspectos relacionados a janela e a geracao da imagem
// Especifica a função callback de desenho
main()
    {
    // Indica que devem ser usados dois buffers para armazenamento da imagem e
    //representacao de cores RGB
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
 
    // Cria uma janela com o titulo especificado
    glutInitWindowSize(800,600);
    glutCreateWindow("Carros");
    Inicio();
    //testes();
 
    //mapeamento de teclas
    glutKeyboardFunc(TeclasNormais);
 
    //mapeamento teclas especiais
    glutSpecialFunc(TeclasEspeciais);
 
    //mapeamento teclas especiais up
    glutSpecialUpFunc(TeclasEspeciaisUp);
 
    // Especifica a função de desenho
    glutDisplayFunc(DesenhaCena);
 
    //função pra animar a cena
    glutTimerFunc(30, FuncaoMove, 1);
    glutTimerFunc(50, FuncaoGira, 1);
    glutTimerFunc(75, testa_colisao, 1);
    glutTimerFunc(100, FuncaoVoltas, 1);
 
    // Dispara a "maquina de estados" de OpenGL
    glutMainLoop();
}