Programa OpenGL para Animación simple (Revolución) en C

OpenGL es una API multiplataforma y multilenguaje para renderizar gráficos vectoriales 2D y 3D. Usando esto, podemos hacer mucho diseño y animaciones. A continuación se muestra la animación simple realizada con OpenGL .
Enfoque:
para hacer que una imagen se mueva, necesitamos comprender el procedimiento de trabajo de una función utilizada para mostrar, por ejemplo, glClear(GL_COLOR_BUFFER_BIT) . Su tarea es borrar la pantalla con el valor predeterminado después de un cierto tiempo (normalmente, después de 1/30 seg o 1/60 seg). Entonces, si ocurre algún cambio de coordenadas, parecerá que se está moviendo, ya que el ojo humano solo puede distinguir la imagen que está separada por 1/16 de segundo (persistencia de la visión).
Ahora, las coordenadas del círculo son X = r*cos(θ) y Y = r*sin(θ) o para la elipse X = rx*cos(θ) y Y = ry*cos(θ) donde rx y ry son radios en dirección X e Y y θ es el ángulo.
Si variamos θ de 0 a 2*pi (360 grados) con un aumento muy pequeño (digamos de 1 grado) y dibujamos un punto en esa coordenada, podemos hacer un círculo completo o una elipse. También podemos hacer un semicírculo o cualquier arco de círculo o elipse variando el valor inicial y final de θ (ángulo).
Estos conceptos se utilizan para dibujar la siguiente animación:

Se utilizan 7 partes horizontales de elipse y 3 elipses completas verticales, así como 1 círculo exterior y una elipse exterior para visualizar una órbita dibujada ajustando el θ y el radio.
Se dibuja una línea vertical para hacer la figura. Luego, para hacer que se mueva, se proporciona otro bucle donde el valor de j cambia con una cantidad muy pequeña para que el movimiento sea más suave.
Dado que teníamos que hacer que todos los puntos se movieran con el mismo tipo de movimiento para mantener la figura unida, entonces la ecuación de movimiento, es decir, glVertex2i(x/2 – 600*cos(j), y/2 – 100*sin(j )) se proporciona dentro de cada bucle for interno , de modo que se puede aplicar a todos los puntos por completo.

Para trabajar en el sistema operativo Ubuntu:

gcc filename.c -lGL -lGLU -lglut -lm 
where filename.c is the name of the file
with which this program is saved.

A continuación se muestra la implementación en C.

C

// C Program to illustrate
// OpenGL animation for revolution
 
#include<stdio.h>
#include<GL/glut.h>
#include<math.h>
 
// global declaration
int x, y;
float i, j;
 
// Initialization function
void myInit (void)
{
    // Reset background color with black (since all three argument is 0.0)
    glClearColor(0.0, 0.0, 0.0, 1.0);
     
    // Set picture color to green (in RGB model)
    // as only argument corresponding to G (Green) is 1.0 and rest are 0.0
    glColor3f(0.0, 1.0, 0.0);
     
    // Set width of point to one unit
    glPointSize(1.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
     
    // Set window size in X- and Y- direction
    gluOrtho2D(-780, 780, -420, 420);
}
 
// Function to display animation
void display (void)
{
    // Outer loop to make figure moving
    // loop variable j iterated up to 10000,
    // indicating that figure will be in motion for large amount of time
    // around 10000/6.29 = 1590 time it will revolve
    // j is incremented by small value to make motion smoother
    for (j = 0; j < 10000; j += 0.01)
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
         
        // Iterate i up to 2*pi, i.e., 360 degree
        // plot point with slight increment in angle,
        // so, it will look like a continuous figure
 
        // Loop is to draw outer circle
        for (i = 0;i < 6.29;i += 0.001)
        {
            x = 200 * cos(i);
            y = 200 * sin(i);
            glVertex2i(x, y);
             
            // For every loop, 2nd glVertex function is
            // to make smaller figure in motion
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        // 7 loops to draw parallel latitude
        for (i = 1.17; i < 1.97; i += 0.001)
        {
            x = 400 * cos(i);
            y = -150 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.07; i < 2.07; i += 0.001)
        {
            x = 400 * cos(i);
            y = -200 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.05; i < 2.09; i += 0.001)
        {
            x = 400 * cos(i);
            y = -250 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.06; i < 2.08; i += 0.001)
        {
            x = 400 * cos(i);
            y = -300 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.10; i < 2.04; i += 0.001)
        {
            x = 400 * cos(i);
            y = -350 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.16; i < 1.98; i += 0.001)
        {
            x = 400 * cos(i);
            y = -400 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 1.27; i < 1.87; i += 0.001)
        {
            x = 400 * cos(i);
            y = -450 + 300 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        // Loop is to draw vertical line
        for (i = 200; i >=- 200; i--)
        {
            glVertex2i(0, i);
            glVertex2i(-600 * cos(j), i / 2 - 100 * sin(j));
        }
         
        // 3 loops to draw vertical ellipse (similar to longitude)
        for (i = 0;i < 6.29; i += 0.001)
        {
            x = 70 * cos(i);
            y = 200 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 0; i < 6.29; i += 0.001)
        {
            x = 120 * cos(i);
            y = 200 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        for (i = 0; i < 6.29; i += 0.001)
        {
            x = 160 * cos(i);
            y = 200 * sin(i);
            glVertex2i(x, y);
            glVertex2i(x / 2 - 600 * cos(j), y / 2 - 100 * sin(j));
        }
         
        // Loop to make orbit of revolution
        for (i = 0; i < 6.29; i += 0.001)
        {
            x = 600 * cos(i);
            y = 100 * sin(i);
            glVertex2i(x, y);
        }
        glEnd();
        glFlush();
    }
}
 
// Driver Program
int main (int argc, char** argv)
{
    glutInit(&argc, argv);
     
    // Display mode which is of RGB (Red Green Blue) type
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
     
    // Declares window size
    glutInitWindowSize(1360, 768);
     
    // Declares window position which is (0, 0)
    // means lower left corner will indicate position (0, 0)
    glutInitWindowPosition(0, 0);
 
    // Name to window
    glutCreateWindow("Revolution");
 
    // Call to myInit()
    myInit();
    glutDisplayFunc(display);
    glutMainLoop();
}

Este artículo es una contribución de Aditya Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

C

Deja una respuesta Cancelar la respuesta