Contente

• Passos
• Parte 1 de 3: Instalação inicial
• Parte 2 de 3: A função display ()
• Parte 3 de 3: Interatividade do programa

OpenGL é uma ferramenta de programação 3D que permite criar imagens 3D complexas a partir de formas simples. Neste artigo, você aprenderá a desenhar com a ajuda dele um cubo simples que pode ser girado em três dimensões!

Passos

Parte 1 de 3: Instalação inicial

1. 1 Instale o OpenGL. Comece com um tutorial sobre como instalar o OpenGL em seu computador. Se você já tem OpenGL e um compilador C, pode pular esta etapa e passar para a próxima.
2. 2 Crie um documento. Crie um novo arquivo em seu editor de código favorito e salve-o como mycube.c
3. 3 Adicione #includes. Aqui estão as diretivas #include básicas de que você precisará. É importante lembrar que as diretivas para diferentes sistemas operacionais são diferentes e, portanto, você precisa escolher tudo para que o programa seja universal e possa ser executado em qualquer sistema.

   // Inclui #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else #include GL / glut.h> #endif

4. 4 Adicione protótipos funcionais e globais. A próxima etapa é declarar protótipos funcionais.

   // Protótipos funcionais void display (); void specialKeys (); // Variáveis ​​globais double rotate_y = 0; double rotate_x = 0;

5. 5 Defina a função main ().

   int main (int argc, char * argv []) // Inicializar GLUT e processar parâmetros personalizados glutInit (& argc, argv); // Solicitar uma janela com suporte para buffer duplo, Z-Buffering e True Color glutInitDisplayMode (GLUT_DOUBLE

Parte 2 de 3: A função display ()

1. 1 Compreenda a finalidade da função display (). Todo o trabalho de renderização do cubo recairá nas linhas frágeis desta função. A ideia geral é esta: você desenhará seis faces separadas do cubo e as colocará em suas respectivas posições.
   • Para cada face, você definirá quatro cantos e o OpenGL os conectará com linhas e os preencherá com a cor escolhida. Como fazer isso será explicado a seguir.
2. 2 Adicione a função glClear (). Em primeiro lugar, ao trabalhar com esta função, precisamos cor clara e z-buffer... Sem isso, o antigo ficará visível sob a nova imagem, e os objetos desenhados pelo programa serão posicionados incorretamente.

   void display () // Limpar a tela e o buffer Z glClear (GL_COLOR_BUFFER_BIT

   • Preste atenção nas duas últimas linhas. Estas são as funções glFlush (); e glutSwapBuffers ();, dando o efeito de buffer duplo, que foi descrito acima.

Parte 3 de 3: Interatividade do programa

1. 1 Adicione a função specialKeys (). Em princípio, tudo está quase pronto, mas o cubo é apenas desenhado e não girado. Para fazer isso, você precisa criar a função specialKeys (), que permitirá que você gire o cubo pressionando as teclas de seta!
   • É para esta função que as variáveis ​​globais rotate_x e rotate_y foram declaradas. Quando você pressiona as teclas de seta para a esquerda e para a direita, o valor rotate_y aumenta ou diminui em cinco graus. O valor de rotate_x mudará da mesma maneira, mas desta vez pressionando as teclas de seta para cima e para baixo.

   void specialKeys (int key, int x, int y) {// Seta para a direita - aumenta a rotação em 5 graus if (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Seta para a esquerda - diminui a rotação em 5 graus else if (key == GLUT_KEY_LEFT) rotate_y - = 5; else if (chave == GLUT_KEY_UP) rotate_x + = 5; else if (chave == GLUT_KEY_DOWN) rotate_x - = 5; // Solicitar atualização da tela glutPostRedisplay (); }

2. 2 Adicione glRotate (). A última coisa que faremos é adicionar uma linha que nos permitirá girar o objeto. Voltar para a função mostrar () e antes da descrição do lado FRONT, adicione:

   // Reinicializar transformações glLoadIdentity (); // Girar quando o usuário muda Os valores rotate_x e rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0,0, 1,0, 0,0); // Lado multicolor - FRONT ....

   • Observe que a sintaxe glRotatef ()que é semelhante à sintaxe de glColor3f () e glVertex3f (), mas sempre requer quatro parâmetros. O primeiro é o ângulo de rotação em graus. Os próximos três são os eixos ao longo dos quais ocorre a rotação, na ordem x, y, z. Por enquanto, precisamos girar o cubo ao longo de dois eixos, x e y.
   • Todas as transformações que definimos no programa requerem linhas semelhantes. Basicamente, representamos a rotação de um objeto ao longo do eixo x como uma alteração no valor de rotate_x e a rotação ao longo do eixo y como uma alteração no valor de rotate_y. No entanto, o OpenGL agrupará tudo em uma matriz de transformação. Cada vez que você chamar display, você criará uma matriz de transformação, e glLoadIdentity () permitirá que você comece com uma nova matriz a cada vez.
   • Outras funções de transformação que você pode ter usado são glTranslatef () e glScalef (). Eles são semelhantes a glRotatef (), exceto que requerem apenas três parâmetros: os valores x, y e z para redimensionar e dimensionar o objeto.
   • Para que tudo seja exibido corretamente quando todas as três transformações são aplicadas a um objeto, você precisa definir as transformações na ordem apropriada, a saber glTranslate, glRotate, glScale - e nunca de outra forma. OpenGL transforma o objeto lendo o programa de baixo para cima. Para entender melhor isso, imagine como o cubo 1x1x1 ficaria após todas as transformações se o OpenGL as aplicasse na ordem mostrada (de cima para baixo), e então pense em como o OpenGL processaria o cubo lendo as instruções de baixo para cima.
3. 3 Adicione os seguintes comandos para dimensionar o cubo duas vezes nas direções xey, para girar o cubo 180 graus no eixo y e para mover o cubo 0,1 no eixo x. Certifique-se de que todos os comandos relevantes, incluindo os comandos glRotate () fornecidos anteriormente, estão na ordem correta. Se você tem medo de errar, veja a versão final do programa no final do artigo.

   // Mais transformações glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0,0, 1,0, 0,0); glScalef (2.0, 2.0, 0.0);

4. 4 Compile e execute o código. Digamos que você esteja usando gcc como seu compilador, então digite os seguintes comandos em seu terminal:

   No Linux: gcc cube.c -o cube -lglut -lGL ./ mycube No Mac: gcc -o foo foo.c -framework GLUT -framework OpenGL ./ mycube No Windows: gcc -Wall -ofoo foo.c -lglut32cu - lglu32 -lopengl32 ./ mycube

5. 5 Verifique o código final. Aqui está o código final criado pelo autor do artigo, que não traduz os comentários.

   // // Arquivo: mycube.c // Autor: Matt Daisley // Criado: 25/04/2012 // Projeto: Código-fonte para Fazer um Cubo em OpenGL // Descrição: Cria uma janela OpenGL e desenha um cubo 3D / / Que o usuário pode girar usando as teclas de seta // // Controles: Seta para a esquerda - Girar para a esquerda // Seta para a direita - Girar para a direita // Seta para cima - Girar para cima // Seta para baixo - Girar para baixo // ------ -------------------------------------------------- - // Inclui // ------------------------------------------- - -------------- #include stdio.h> #include stdarg.h> #include math.h> #define GL_GLEXT_PROTOTYPES #ifdef __APPLE__ #include GLUT / glut.h> #else # include GL / glut.h> #endif // --------------------------------------- - ------------------ // Protótipos de função // ------------------------- - -------------------------------- void display (); void specialKeys (); // ------------------------------------------------ ---------- // Variáveis ​​globais // ---------------------------------- ------------------------ double rotate_y = 0; double rotate_x = 0; // ------------------------------------------------ ---------- // display () Função de retorno de chamada // ------------------------------- --------------------------- void display () // Limpar tela e Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // Função de retorno de chamada specialKeys () // --------------------------------------- - ------------------ void specialKeys (int key, int x, int y) {// Seta para a direita - aumenta a rotação em 5 graus if (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Seta para a esquerda - diminui a rotação em 5 graus else if (key == GLUT_KEY_LEFT) rotate_y - = 5; else if (key == GLUT_KEY_UP) rotate_x + = 5; else if (key == GLUT_KEY_DOWN) rotate_x - = 5; // Solicitar atualização de exibição glutPostRedisplay ();} // ----------------------------------- - ---------------------- // função main () // ------------------- - -------------------------------------- int main (int argc, char * argv [] ) GLUT_RGB