Como fazer um cubo em opengl

4 partes:

OpenGL é uma ferramenta de programação muito versátil em três dimensões utilizadas para desenhar cenas 3D complexas usando rotinas simples. Este artigo irá ensiná-lo a desenhar um cubo que você pode girar para ver em três dimensões!

Para este projeto você vai precisar de um editor de código e algum conhecimento da linguagem de programação C.

// Inclui#include #include #include #define GL_GLEXT_PROTOTYPES#ifdef __APPLE__#include #else#include #endif

4) protótipos de funções e variáveis ​​globais

• O próximo passo será a declarar alguns protótipos de função.
  
  

  // Função protótiposvazio display()-vazio specialKeys()-// variáveis ​​globaisduplo rotate_y=0-duplo rotate_x=0-

• Eles serão explicados em detalhe cada uma dessas funções e variáveis ​​globais como eles vão depois de implementá-las ao abrigo deste tutorial. Por enquanto, o importante é declarada.

5) Definir a função main ()

• int principal(int argc, carbonizar* argv)// Inicializa parâmetros do usuário GLUT e processoglutInit(&argc,argv)-// Janela Request com buffer duplo cor real e Z-buffer com glutInitDisplayMode(GLUT_DOUBLE 

vazio display()GL_DEPTH_BUFFER_BIT)-

2) Funções glBegin () e glEnd ()

• OpenGL define objetos como combinações de diferentes polígonos. Com o comando glBegin (), Você pode desenhar qualquer forma, como se você tivesse um lápis. Para levantar o lápis e desenhar uma nova forma, você precisará usar o comando glEnd (). Para este tutorial você vai usar GL_POLYGON para desenhar cada lado do cubo, no entanto, você pode usar outros parâmetros como GL_LINE, GL_QUAD ou GL_TRIANGLE para criar outras formas.
  
  
• Vamos começar com a parte da frente do cubo. Em seguida, adicionar cor a todos os 6 lados.
  
  

  // Lado da frente: Lado multicolor glBegin(GL_POLYGON)-// Vértices serão incluídos no passo seguinte.glEnd()-

3) glVertex3f Function ()

• Quando você decidiu começar um polígono, você deve definir os vértices. A função glVertex tem várias maneiras de fazer isso, dependendo do que você quer fazer com o objeto.
  
  
• A primeira vai definir quantos vão trabalhar dimensões. Os "3" acima em glVertex3f indica que você vai trabalhar em três dimensões, mas será possível trabalhar com 2 ou 4 dimensões. A letra "f" significa que eles vão ser números reais, números de ponto flutuante, mas você também pode trabalhar com short, números inteiros ou duplas.
  
  
• Tenha em mente que estes pontos são definidos no contra no sentido horário. Agora é irrelevante, mas é importante quando se trabalha com luz, texturas e remoção seletiva de rostos. Isso é extremamente importante, por isso, se usado para definir os pontos de encontro dos ponteiros do relógio agora.
  
  
• Adicione os vértices entre as linhas glBegin () e glEnd ().
  
  

  // Lado da frente: Lado multicolorglBegin(GL_POLYGON)-glVertex3f( -0,5, -0,5, -0,5)-// P1glVertex3f( -0,5, 0,5, -0,5)-// P2glVertex3f( 0,5, 0,5, -0,5)-// P3glVertex3f( 0,5, -0,5, -0,5)-// P4glEnd()-

4) Função glColor3f ()

• glColor Ele funciona de uma forma semelhante ao glVertex. Você pode definir os pontos tão curto, inteiro, duplo ou flutuante. Cada cor tem um valor entre 0 e 1. Todos fazem o ponto preto 0 e 1 fazem toda a ponto branco. O "3" na glColor3f () refere-se à cor RGB sistema sem canal alfa. O nível alfa define a transparência da cor. Para alterar esse nível, então você tem que usar glColor4f (), o último parâmetro terá um valor de 0 (opaco) a 1 (transparente).
  
  
• Quando você chamar glColor3f (), cada vértice desenhado a partir desse ponto será essa cor. Portanto, se você quer que os quatro vértices são o vermelho, você só tem que definir a cor de uma vez antes glVertex3f () comandos e todos os vértices são dessa cor.
  
  
• A parte frontal definido abaixo mostra como definir uma nova cor para cada vértice. Quando o fizer, você verá uma propriedade interessante de cores OpenGL. Porque cada vértice do polígono tem sua própria cor, misturar cores OpenGL automaticamente! O próximo passo irá mostrar-lhe como atribuir quatro vértices com a mesma cor.
  
  
  
  

  // Lado da frente: Lado multicolorglBegin(GL_POLYGON)-glColor3f( 1.0, 0.0, 0.0 )- glVertex3f( 0,5, -0,5, -0,5 )-// P1 é vermelhoglColor3f( 0.0, 1.0, 0.0 )- glVertex3f( 0,5, 0,5, -0,5 )-// P2 é verdeglColor3f( 0.0, 0.0, 1.0 )- glVertex3f( -0,5, 0,5, -0,5 )-// P3 é azulglColor3f( 1.0, 0.0, 1.0 )- glVertex3f( -0,5, -0,5, -0,5 )-// P4 é roxoglEnd()-

5) em outro lugar

• Nós encorajamos você se propõe a encontrar os outros vértices para os outros 5 lados do cubo, mas para simplificar as coisas já resolvidas e incluídos no o display () End Function a seguir:
  
  

  // VERSO: lado brancoglBegin(GL_POLYGON)-glColor3f(1.0, 1.0, 1.0 )-glVertex3f( 0,5, -0,5, 0,5 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glVertex3f( -0,5, -0,5, 0,5 )-glEnd()-// LADO DIREITO: Lado roxoglBegin(GL_POLYGON)-glColor3f( 1.0, 0.0, 1.0 )-glVertex3f( 0,5, -0,5, -0,5 )-glVertex3f( 0,5, 0,5, -0,5 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( 0,5, -0,5, 0,5 )-glEnd()-// LADO ESQUERDO: lado verdeglBegin(GL_POLYGON)-glColor3f(0.0, 1.0, 0.0 )-glVertex3f( -0,5, -0,5, 0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glVertex3f( -0,5, 0,5, -0,5 )-glVertex3f( -0,5, -0,5, -0,5 )-glEnd()-// TOP SIDE: Lateral AzulglBegin(GL_POLYGON)-glColor3f(0.0, 0.0, 1.0 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( 0,5, 0,5, -0,5 )-glVertex3f( -0,5, 0,5, -0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glEnd()-// Lado inferior: lado vermelhoglBegin(GL_POLYGON)-glColor3f(1.0, 0.0, 0.0 )-glVertex3f( 0,5, -0,5, -0,5 )-glVertex3f( 0,5, -0,5, 0,5 )-glVertex3f( -0,5, -0,5, 0,5 )-glVertex3f( -0,5, -0,5, -0,5 )-glEnd()-glFlush()-glutSwapBuffers()-

• Você também deve incluir duas últimas linhas de código para esta função: glFlush () - e glutSwapBuffers () -, que irá dar o efeito de double-buffer.

vazio specialKeys( int chave, int X, int e ) {// A seta para a direita aumenta o seu volume de negócios de 5 grausse (chave == GLUT_KEY_RIGHT)rotate_y += 5-// A seta para a esquerda: diminuição de rotação 5 grausmais se (chave == GLUT_KEY_LEFT)rotate_y -= 5-mais se (chave == GLUT_KEY_UP)rotate_x += 5-mais se (chave == GLUT_KEY_DOWN)rotate_x -= 5-// Pedido para atualizar a telaglutPostRedisplay()-}

2) glRotate ()

• A última instrução irá adicionar as linhas para girar o objeto. função retorna display () e antes lado da frente, adicione as linhas a seguir:
  
  

  // Repor as mudançasglLoadIdentity()-// Rodar quando o usuário altera os valores de "rotate_x" e "rotate_y".glRotatef( rotate_x, 1.0, 0.0, 0.0 )-glRotatef( rotate_y, 0.0, 1.0, 0.0 )-// Lado da frente: Lado multicolor....

• Note-se que a sintaxe glRotatef () É semelhante ao glColor3f () e glVertex3f () mas sempre requer 4 parâmetros. O primeiro parâmetro é o grau de rotação que será aplicado e os outros três parâmetros são os rotacionais eixos X, Y e Z. Por agora só precisa girar em torno de X e Y.
  
  
• Todas as transformações que você digita no programa precisam semelhante a esta linha. Conceitualmente, ele é considerado como para girar o objeto no eixo X pelo valor definido pelo "rotate_x" e, em seguida, se transforma no eixo Y por "rotate_y". No entanto, OpenGL combina todas essas declarações em uma transformação de matriz. Cada vez que você chamar a função "display", você vai construir uma matriz de transformação e glLoadIdentity () irá assegurar que você comece com uma nova matriz em cada passagem.
  
  
• As outras funções de transformação que poderiam ser aplicados são glTranslatef () e glScalef (). Estas funções são semelhantes aos glRotatef (), excepto que apenas exigem três parâmetros, as quantidades de X, Y, Z para mover ou desenhar o objecto a escala.
  
  
• Para conseguir o efeito desejado quando você aplica as três transformações a um objeto, é necessário que as arandelas na ordem correta. sempre escrevê-los em ordem: glTranslate, glRotate, em seguida, glScale. O que será essencialmente OpenGL irá aplicar as transformações de baixo para cima. Para assimilar, imagine a aparência de um simples cubo 1x1x1 com transformações OpenGL se o top-down aplicado e se eu fiz de baixo para cima.
  
  
• Adicione os seguintes comandos para desenhar para dimensionar o cubo 2 na eixos X e Y, o cubo gira 180 graus no eixo Y, em seguida, mover o cubo no eixo X 0,1 Tal como acontece com os comandos glRotate () , certifique-se de colocá-los na ordem correta descrita acima (se não tiver certeza, você vai vê-lo feito no código final localizado no final deste tutorial).
  
  

  // Outros transformaçõesglTranslatef( 0,1, 0.0, 0.0 )-glRotatef( 180, 0.0, 1.0, 0.0 )-glScalef( 2.0, 2.0, 0.0 )-

compilação

• O último passo para completar o seu primeiro projeto com OpenGL vai compilar e executar o código. Supondo que você tem à sua disposição um compilador gcc, execute os seguintes comandos em um terminal para compilar e testar o programa.
  
  

  Linux:gcc cube.c -ou cubo -lglut -LGL./ micuboEn Mac:gcc -ou bla.c -quadro GLUT -quadro OpenGL./ micuboEn do Windows:gcc -parede -ofoo foo.c -lglut32cu -lglu32 -lopengl32./ micubo

//// Arquivo: micubo.c// Autor: Matthew Diaz// Criado: 2012/04/25// Projeto: código-fonte para fazer um cubo em OpenGL// Descrição: criar uma janela OpenGL e desenhar um cubo 3D// O usuário pode rodar com as setas // // Controles: Seta esquerda: rotação à esquerda// Seta para a direita: Girar para a direita // Seta para cima: girar para cima // Seta para baixo: gire para baixo // ------------------------------------------------ ----------// Livrarias// ------------------------------------------------ ----------#include #include #include #define GL_GLEXT_PROTOTYPES#ifdef __APPLE__#include #else#include #endif// ------------------------------------------------ ----------// Função protótipos// ------------------------------------------------ ----------vazio display()-vazio specialKeys()-// ------------------------------------------------ ----------// variáveis ​​globais// ------------------------------------------------ ----------duplo rotate_y=0-duplo rotate_x=0-// ------------------------------------------------ ----------// Função de retorno de chamada "display ()"// ------------------------------------------------ ----------vazio display()GL_DEPTH_BUFFER_BIT)-// Repor transformaçõesglLoadIdentity()-// Outros transformações// GlTranslatef (0.1, 0.0, 0.0) - // Não incluído// GlRotatef (180, 0.0, 1.0, 0.0) - // Não incluído// Rodar quando o usuário muda "rotate_x" e "rotate_y"glRotatef( rotate_x, 1.0, 0.0, 0.0 )-glRotatef( rotate_y, 0.0, 1.0, 0.0 )-// Outros transformações// GlScalef (2.0, 2.0, 0.0) - // Não incluído// Lado da frente: Lado multicolorglBegin(GL_POLYGON)-glColor3f( 1.0, 0.0, 0.0 )- glVertex3f( 0,5, -0,5, -0,5 )-// P1 é vermelhoglColor3f( 0.0, 1.0, 0.0 )- glVertex3f( 0,5, 0,5, -0,5 )-// P2 é verdeglColor3f( 0.0, 0.0, 1.0 )- glVertex3f( -0,5, 0,5, -0,5 )-// P3 é azulglColor3f( 1.0, 0.0, 1.0 )- glVertex3f( -0,5, -0,5, -0,5 )-// P4 é roxoglEnd()-// VERSO: lado brancoglBegin(GL_POLYGON)-glColor3f(1.0, 1.0, 1.0 )-glVertex3f( 0,5, -0,5, 0,5 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glVertex3f( -0,5, -0,5, 0,5 )-glEnd()-// LADO DIREITO: Lado roxoglBegin(GL_POLYGON)-glColor3f( 1.0, 0.0, 1.0 )-glVertex3f( 0,5, -0,5, -0,5 )-glVertex3f( 0,5, 0,5, -0,5 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( 0,5, -0,5, 0,5 )-glEnd()-// LADO ESQUERDO: lado verdeglBegin(GL_POLYGON)-glColor3f(0.0, 1.0, 0.0 )-glVertex3f( -0,5, -0,5, 0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glVertex3f( -0,5, 0,5, -0,5 )-glVertex3f( -0,5, -0,5, -0,5 )-glEnd()-// TOP SIDE: Lateral AzulglBegin(GL_POLYGON)-glColor3f(0.0, 0.0, 1.0 )-glVertex3f( 0,5, 0,5, 0,5 )-glVertex3f( 0,5, 0,5, -0,5 )-glVertex3f( -0,5, 0,5, -0,5 )-glVertex3f( -0,5, 0,5, 0,5 )-glEnd()-// Lado inferior: lado vermelhoglBegin(GL_POLYGON)-glColor3f(1.0, 0.0, 0.0 )-glVertex3f( 0,5, -0,5, -0,5 )-glVertex3f( 0,5, -0,5, 0,5 )-glVertex3f( -0,5, -0,5, 0,5 )-glVertex3f( -0,5, -0,5, -0,5 )-glEnd()-glFlush()-glutSwapBuffers()-// ------------------------------------------------ ----------// função de retorno "specialKeys ()" // ------------------------------------------------ ----------vazio specialKeys( int chave, int X, int e ) {// Seta para a direita: aumento de 5 graus de rotaçãose (chave == GLUT_KEY_RIGHT)rotate_y += 5-// Seta para a esquerda: rotação de diminuição de 5 grausmais se (chave == GLUT_KEY_LEFT)rotate_y -= 5-mais se (chave == GLUT_KEY_UP)rotate_x += 5-mais se (chave == GLUT_KEY_DOWN)rotate_x -= 5-// Update Ordem de exibiçãoglutPostRedisplay()-}// ------------------------------------------------ ----------// Função "main ()"// ------------------------------------------------ ----------int principal(int argc, carbonizar* argv) GLUT_DEPTH)-// Cria janelaglutCreateWindow("incrível cubo")-// Ativar profundidade teste Z-bufferglEnable(GL_DEPTH_TEST)-// funções de retorno de chamadaglutDisplayFunc(display)-glutSpecialFunc(specialKeys)-// Eventos Pass Control GLUTglutMainLoop()-// Retorna o sistema operacionalretorno 0-