Contenido

• Pasos
• Parte 1 de 3: Instalación inicial
• Parte 2 de 3: La función display ()
• Parte 3 de 3: Interactividad del programa

OpenGL es una herramienta de programación 3D que le permite crear imágenes 3D complejas a partir de formas simples. En este artículo, aprenderá a dibujar con su ayuda un cubo simple que se puede rotar en tres dimensiones.

Pasos

Parte 1 de 3: Instalación inicial

1. 1 Instale OpenGL. Comience con un tutorial sobre cómo instalar OpenGL en su computadora. Si ya tiene OpenGL y un compilador de C, puede omitir este paso y pasar al siguiente.
2. 2 Crea un documento. Cree un nuevo archivo en su editor de código favorito y guárdelo como mycube.c
3. 3 Agregue #includes. Aquí están las directivas básicas #include que necesitará. Es importante recordar que las directivas para diferentes sistemas operativos son diferentes y, por lo tanto, debe elegir todo para que el programa sea universal y pueda ejecutarse en cualquier sistema.

   // Incluye #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 Agregue prototipos funcionales y globales. El siguiente paso es declarar prototipos funcionales.

   // Prototipos funcionales void display (); void specialKeys (); // Variables globales double rotate_y = 0; doble rotate_x = 0;

5. 5 Defina la función main ().

   int main (int argc, char * argv []) // Inicializar GLUT y procesar los parámetros personalizados glutInit (& argc, argv); // Solicite una ventana con soporte para búfer doble, búfer Z y glutInitDisplayMode de color verdadero (GLUT_DOUBLE

Parte 2 de 3: La función display ()

1. 1 Comprenda el propósito de la función display (). Todo el trabajo de renderizado del cubo recaerá sobre las frágiles líneas de esta función. La idea general es la siguiente: dibujarás seis caras separadas del cubo y las colocarás en sus respectivas posiciones.
   • Para cada cara, definirás cuatro esquinas, y OpenGL las conectará con líneas y las rellenará con el color que elijas. A continuación se explica cómo hacer esto.
2. 2 Agregue la función glClear (). En primer lugar, cuando trabajamos con esta función, necesitamos color claro y búfer z... Sin esto, el antiguo será visible debajo de la nueva imagen y los objetos dibujados por el programa se colocarán incorrectamente.

   void display () // Limpiar la pantalla y el búfer Z glClear (GL_COLOR_BUFFER_BIT

   • Preste atención a las dos últimas líneas. Estas son las funciones glFlush (); y glutSwapBuffers ();, dando el efecto de doble búfer, que se describió anteriormente.

Parte 3 de 3: Interactividad del programa

1. 1 Agregue la función specialKeys (). En principio, todo está casi listo, pero el cubo solo se dibuja y no se gira. Para hacer esto, necesita crear la función specialKeys (), lo que te permitirá rotar el cubo presionando las teclas de flecha.
   • Es para esta función que se declararon las variables globales rotate_x y rotate_y. Cuando presiona las teclas de flecha izquierda y derecha, el valor de rotate_y aumentará o disminuirá cinco grados. El valor de rotate_x cambiará de la misma manera, pero esta vez presionando las teclas de flecha hacia arriba y hacia abajo.

   void specialKeys (int key, int x, int y) {// Flecha derecha - aumenta la rotación en 5 grados if (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Flecha izquierda - Disminuir la rotación en 5 grados else if (key == GLUT_KEY_LEFT) rotate_y - = 5; de lo contrario, si (clave == GLUT_KEY_UP) rotate_x + = 5; si no (clave == GLUT_KEY_DOWN) rotate_x - = 5; // Solicitar actualización de pantalla glutPostRedisplay (); }

2. 2 Agregue glRotate (). Lo último que haremos es agregar una línea que nos permitirá rotar el objeto. Volver a la función mostrar () y antes de la descripción del lado DELANTERO agregue:

   // Restablecer transformaciones glLoadIdentity (); // Rotar cuando el usuario cambia Los valores rotate_x y rotate_y glRotatef (rotate_x, 1.0, 0.0, 0.0); glRotatef (rotate_y, 0.0, 1.0, 0.0); // Lado multicolor - DELANTERO ....

   • Tenga en cuenta que la sintaxis glRotatef ()que es similar a la sintaxis de glColor3f () y glVertex3f (), pero siempre requiere cuatro parámetros. El primero es el ángulo de rotación en grados. Los tres siguientes son los ejes a lo largo de los cuales tiene lugar la rotación, en el orden x, y, z. Por ahora, necesitamos rotar el cubo a lo largo de dos ejes, xey.
   • Todas las transformaciones que definimos en el programa requieren líneas similares. Básicamente, representamos la rotación de un objeto a lo largo del eje x como un cambio en el valor de rotate_x, y la rotación a lo largo del eje y como un cambio en el valor de rotate_y. Sin embargo, OpenGL agrupará todo en una matriz de transformación. Cada vez que llame a display, creará una matriz de transformación y glLoadIdentity () le permitirá comenzar con una nueva matriz cada vez.
   • Otras funciones de transformación que puede haber utilizado son glTranslatef () y glScalef (). Son similares a glRotatef (), excepto que solo requieren tres parámetros: los valores x, y, z para cambiar el tamaño y escalar el objeto.
   • Para que todo se muestre correctamente cuando las tres transformaciones se aplican a un objeto, debe establecer las transformaciones en el orden apropiado, es decir glTranslate, glRotate, glScale - y nunca de otro modo. OpenGL transforma el objeto leyendo el programa de abajo hacia arriba. Para comprender mejor esto, imagine cómo se vería el cubo de 1x1x1 después de todas las transformaciones si OpenGL las aplicara en el orden que se muestra (de arriba a abajo), y luego piense cómo OpenGL procesará el cubo leyendo las instrucciones de abajo hacia arriba.
3. 3 Agregue los siguientes comandos para escalar el cubo dos veces en las direcciones xey, para rotar el cubo 180 grados en el eje y y para mover el cubo 0.1 en el eje x. Asegúrese de que todos los comandos relevantes, incluidos los comandos glRotate () dados anteriormente, estén en el orden correcto. Si tiene miedo de cometer un error, consulte la versión final del programa al final del artículo.

   // Más transformaciones glTranslatef (0.1, 0.0, 0.0); glRotatef (180, 0.0, 1.0, 0.0); glScalef (2.0, 2.0, 0.0);

4. 4 Compila y ejecuta el código. Digamos que estás usando gcc como tu compilador, así que ingresa los siguientes comandos en tu terminal:

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

5. 5 Verifique el código final. Aquí está el código final creado por el autor del artículo, que no traduce los comentarios.

   // // Archivo: mycube.c // Autor: Matt Daisley // Creado: 25/4/2012 // Proyecto: Código fuente para Make a Cube en OpenGL // Descripción: Crea una ventana OpenGL y dibuja un cubo 3D / / Que el usuario puede rotar usando las teclas de flecha // // Controles: Flecha izquierda - Girar a la izquierda // Flecha derecha - Girar a la derecha // Flecha arriba - Girar hacia arriba // Flecha abajo - Girar hacia abajo // ------ -------------------------------------------------- - // Incluye // ------------------------------------------- - -------------- #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 // --------------------------------------- - ------------------ // Prototipos de funciones // ------------------------- - -------------------------------- visualización vacía (); void specialKeys (); // ------------------------------------------------ ---------- // Variables globales // ---------------------------------- ------------------------ doble rotate_y = 0; doble rotate_x = 0; // ------------------------------------------------ ---------- // display () Función de devolución de llamada // ------------------------------- --------------------------- void display () // Limpiar pantalla y Z-buffer glClear (GL_COLOR_BUFFER_BIT // ------ -------------------------------------------------- - // función de devolución de llamada specialKeys () // --------------------------------------- - ------------------ void specialKeys (int key, int x, int y) {// Flecha derecha - aumenta la rotación en 5 grados si (key == GLUT_KEY_RIGHT) rotate_y + = 5; // Flecha izquierda - disminuir la rotación en 5 grados 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 actualización de visualización glutPostRedisplay ();} // ----------------------------------- - ---------------------- // función main () // ------------------- - -------------------------------------- int main (int argc, char * argv [] ) GLUT_RGB