A seção anterior ensinou como colorir triângulos e quadriláteros. Esta lição ensinará como girar esses objetos coloridos em torno de seus eixos coordenados.
Na verdade, basta adicionar algumas linhas ao código da seção anterior. Vamos reescrever toda a rotina novamente. É conveniente para você saber o que foi adicionado e o que foi modificado.
Adicione duas variáveis para controlar a rotação desses dois objetos. Estas duas variáveis são adicionadas após as outras variáveis no início do programa (bool fullscreen=TRUE; duas linhas abaixo). São variáveis do tipo ponto flutuante que nos permitem girar objetos com muita precisão. Os números de ponto flutuante contêm casas decimais, o que significa que não precisamos usar ângulos de 1, 2, 3... Você descobrirá que os números de ponto flutuante são a base da programação OpenGL. A nova variável chamada rtri é usada para girar o triângulo e rquad é usada para girar o quadrilátero.
Var
…
rtri : GLfloat; // Ângulo para triângulo (novo)
rquad : GLfloat; // Ângulo para quadrilátero (novo)
…
Em seguida, modifique glDraw() da seguinte forma:
Procedimento glDraw();
Começar
glClear(GL_COLOR_BUFFER_BIT Ou GL_DEPTH_BUFFER_BIT); // Limpa a tela e o buffer de profundidade;
glLoadIdentity(); //Redefinir a matriz de observação do modelo atual
//A próxima linha de código é nova. glRotatef(Angle,Xvector,Yvector,Zvector) é responsável por girar o objeto em torno de um determinado eixo.
//Este comando tem muitos usos. Ângulo geralmente é uma variável que representa o ângulo através do qual o objeto é girado.
//Os três parâmetros Xvector, Yvector e Zvector determinam em conjunto o sentido do eixo de rotação.
//Por exemplo, o vetor descrito por (1,0,0) passa por 1 unidade do eixo de coordenadas X e é direcionado para a direita.
//O vetor descrito por (-1,0,0) passa por 1 unidade do eixo de coordenadas X, mas na direção esquerda.
//D. Michael Traub: Fornece a explicação acima de Xvector, Yvector e Zvector.
//Para entender melhor a rotação de X, Y e Z, deixe-me dar alguns exemplos...
//Eixo X - Você está usando uma serra de mesa. O eixo no centro da lâmina é colocado da esquerda para a direita (assim como o eixo X no OpenGL).
//Os dentes afiados da serra giram descontroladamente em torno do eixo X, aparentemente girando para cima ou para baixo.
//Depende da direção em que a lâmina da serra começa a girar. Esta é a mesma situação de quando giramos algo em torno do eixo X no OpenGL.
//(Nota do tradutor: Se você colocar seu rosto voltado para o monitor neste momento, você definitivamente será serrado ^-^.)
//Eixo Y - Digamos que você esteja no centro de um enorme tornado, com o centro do tornado apontando do solo para o céu (assim como o eixo Y no OpenGL).
//Lixo e detritos giram descontroladamente em torno do eixo Y, da esquerda para a direita ou da direita para a esquerda.
//Esta é a mesma situação de quando giramos algo em torno do eixo Y no OpenGL.
//Eixo Z - Você está olhando para um ventilador de frente. O centro do ventilador está apontado diretamente para você (como o eixo Z no OpenGL).
//As pás do ventilador giram descontroladamente no sentido horário ou anti-horário em torno do eixo Z. Esta é a mesma situação de quando giramos algo em torno do eixo Z no OpenGL.
glTranslatef(-1.5, 0.0, -6.0); // Move para a esquerda 1,5 unidades e para a tela 6.0);
//Na linha de código a seguir, se rtri for igual a 7, giramos o triângulo 7 da esquerda para a direita em torno do eixo Y.
//Você também pode alterar o valor do parâmetro para girar o triângulo em torno dos eixos X e Y simultaneamente.
glRotatef(rtri, 0.0, 1.0, 0.0); // Gira o triângulo em torno do eixo Y (novo)
//Não há alterações no código abaixo. Um triângulo gradiente colorido é desenhado no lado esquerdo da tela e girado da esquerda para a direita em torno do eixo Y.
glBegin(GL_TRIANGLES); // Desenha triângulos
glColor3f(1.0, 0.0, 0.0); //Define a cor atual para vermelho
glVertex3f(0.0, 1.0, 0.0); // vértice superior
glColor3f(0.0, 1.0, 0.0); //Define a cor atual para verde
glVertex3f(-1.0, -1.0, 0.0); // canto inferior esquerdo
glColor3f(0.0, 0.0, 1.0); //Define a cor atual para azul
glVertex3f(1.0, -1.0, 0.0); // Inferior direito
glEnd(); // Fim do desenho do triângulo
//Você notará no código abaixo que adicionamos outra chamada glLoadIdentity().
//O objetivo é redefinir a matriz de observação do modelo.
//Se não redefinirmos e chamarmos glTranslate diretamente, ocorrerão resultados inesperados.
//Como o eixo de coordenadas foi girado, provavelmente não está na direção desejada.
//Então, o que originalmente queríamos mover o objeto para a esquerda e para a direita pode se tornar para cima e para baixo, dependendo de quanto você gira o eixo de coordenadas.
//Tente comentar glLoadIdentity() e veja quais resultados aparecerão.
//Após redefinir a matriz de observação do modelo, os eixos X, Y e Z são todos redefinidos e chamamos glTranslate.
//Você notará que desta vez movemos apenas 1,5 unidades para a direita em vez de 3,0 unidades como na última lição.
//Porque quando zeramos a cena, o foco voltou para o centro da cena (em 0,0).
//Desta forma você só precisa mover 1,5 unidades para a direita.
//Quando passarmos para a nova posição, gire o quad em torno do eixo X. O quadrado irá girar para cima e para baixo.
glLoadIdentity(); //Redefinir matriz de observação do modelo
glTranslatef(1.5, 0.0, -6.0); // Mova 1,5 unidades para a direita e vá para a tela 6.0;
glRotatef(rquad, 1.0, 0.0, 0.0); // Gira o quadrilátero em torno do eixo X (novo)
glBegin(GL_QUADS); // Desenha um quadrado
glColor3f(0.6, 0.2, 2.0); //Define a cor atual para roxo
glVertex3f(-1.0, 1.0, 0.0); // Canto superior esquerdo
glVertex3f(1.0, 1.0, 0.0); // Canto superior direito
glVertex3f(1.0, -1.0, 0.0); // canto inferior esquerdo
glVertex3f(-1.0, -1.0, 0.0); // Inferior direito
glEnd(); // Fim do desenho do quadrado
//As próximas duas linhas são novas.
//Se rtri e rquad forem imaginados como contêineres,
//Então no início do programa criamos containers (rtri e rquad).
//Quando o contêiner é criado, ele está vazio.
//A primeira linha do código abaixo adiciona 0,2 ao contêiner.
//Portanto, toda vez que executarmos o código anterior, o valor no contêiner rtri será aumentado em 0,2 aqui.
//A linha a seguir reduz o valor no contêiner rquad em 0,15.
//Da mesma forma, toda vez que executarmos o código anterior, o valor no contêiner rquad cairá 0,15 aqui.
//A queda eventualmente fará com que o objeto gire na direção oposta à direção de crescimento.
rtri := rtri + 0.2; // Aumenta a variável de rotação do triângulo (novo)
rquad := rquad - 0.15; // Reduz a variável de rotação do quadrilátero (novo)
Fim;