C语言中简单动画（Revolution）的OpenGL程序-yiteyi-C++库

OpenGL 是一种用于渲染2D和3D矢量图形的跨语言、跨平台API。使用这个，我们可以制作很多设计和动画。下面是使用 OpenGL . 方法： 为了使图片移动，我们需要了解用于显示的函数的工作过程，即 glClear（GLU颜色缓冲位） 它的任务是在一定时间后（通常在1/30秒或1/60秒后）用默认值清除屏幕。所以，如果坐标发生任何变化，那么它似乎在移动，因为人眼只能分辨出相隔1/16秒的图像（视觉的持久性）。现在，圆的坐标是X=r*cos（θ）和Y=r*sin（θ），或者对于椭圆X=rx*cos（θ）和Y=ry*cos（θ），其中rx和ry是X和Y方向的半径，并且 θ 这就是角度。如果我们改变 θ 从0到2*pi（360度），以非常小的增量（比如说1度）在该坐标上画点，我们可以画出一个完整的圆或椭圆。我们也可以通过改变起始值和结束值来制作半圆或圆或椭圆的任何圆弧 θ （角度）。这些概念用于绘制以下动画：

null

7个水平椭圆部分和3个垂直完整椭圆以及1个外圆和1个外椭圆用于可视化通过调整 θ 还有半径。
绘制一条垂直线使图形移动，然后给出另一个循环，其中j值的变化非常小，以使运动更平滑。
因为，我们必须使所有的点以相同的运动方式移动，以保持图形在一起，所以运动方程，也就是， glVertex2i（x/2-600*cos（j），y/2-100*sin（j）） 每个内在的循环，以便它可以应用于所有点。

在Ubuntu操作系统上工作：

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

推荐：请尝试你的方法 {IDE} 首先，在进入解决方案之前。

下面是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();                       
                         }                       

本文由阿迪蒂亚·库马尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END