OpenGL练习(一)：二维图形和鼠标键盘事件

Rainyboy

作为工程师的基本技能，无论是机械设计图还是规律变化图，画图本身不是什么难事。然而OpenGL作为使用得最广泛的底层绘图库类之一，是值得学习的。本帖包含了四个例子，是近来在重新学习这一图形工具时的习作，分别是：
1，一个单摆的演示动画；
         


2，一个旋转的正方形（可以通过键盘控制转动方向）；
        


3，一个可以画圆、矩形和直线的小绘图工具（可以通过键盘控制绘图类型，有最简单的绘图预览）；
        


4，一个弹性球在窗口内四处碰撞的演示动画。
      


=========================================================


主程序的代码和预编译头文件的内容在这里给出，后续四个楼层分别给出这四个练习的具体代码。



===程序的入口点：OpenGLTest.cpp====

1. #include "stdafx.h"
   
2. #include "Simple_Pendulum.h"
   
3. #include "Rotat_Block.h"
   
4. #include "SimplePaint.h"
   
5. #include "ElasticBall.h"
   
6. 
   
7. 
   
8. int _tmain(int argc, _TCHAR* argv[])
   
9. {
   
10.         system("cls");
    
11.         cout<<"OpenGL练习 StageA: 二维图形和鼠标事件"<<endl;
    
12.         cout<<"1,单摆"<<endl;
    
13.         cout<<"2,旋转正方形"<<endl;
    
14.         cout<<"3,简单鼠标绘图器"<<endl;
    
15.         cout<<"4,弹性碰撞球"<<endl;
    
16.         cout<<"输入选项：";
    
17.         int c;
    
18.         cin>>c;
    
19.         switch(c)
    
20.         {
    
21.         case 1:
    
22.                 Simple_Pendulum(argc,argv);
    
23.                 break;
    
24.         case 2:
    
25.                 Rotat_Block(argc,argv);
    
26.                 break;
    
27.         case 3:
    
28.                 Simple_Paint(argc,argv);
    
29.                 break;
    
30.         case 4:
    
31.                 Elastic_Ball(argc,argv);
    
32.                 break;
    
33.         }
    
34.         return 0;
    
35. }

复制代码

===预编译头文件 stdafx.h =====

1. #pragma once
   
2. 
   
3. #include "targetver.h"
   
4. 
   
5. #include <stdio.h>
   
6. #include <tchar.h>
   
7. 
   
8. 
   
9. 
   
10. // TODO: 在此处引用程序需要的其他头文件
    
11. #include <windows.h>
    
12. #include <gl/GL.h>
    
13. #include <gl/GLU.h>
    
14. #include <gl/glut.h>
    
15. #include <math.h>
    
16. #include <stdlib.h>
    
17. #include <iostream>
    
18. #include <vector>
    
19. using namespace std;

复制代码

Rainyboy

====单摆演示动画，头文件：Simple_Pendulum.h=======

1. #include "stdafx.h"
   
2. class struct_SP_Global
   
3. {
   
4. public:
   
5.         struct_SP_Global()
   
6.         {
   
7.                 theta = 0;
   
8.                 theta_inc =1.0;
   
9.                 amplitude = 10.0;
   
10.                 DEG_TO_RAD = 0.017453;
    
11.         }
    
12. public:
    
13.         GLsizei ww;
    
14.         GLsizei hh;
    
15.         GLfloat theta;
    
16.         GLfloat theta_inc;
    
17.         GLfloat amplitude;
    
18.         GLfloat DEG_TO_RAD;
    
19. };
    
20. void SP_userReshape(GLsizei w,GLsizei h);
    
21. void SP_display();
    
22. void SP_init();
    
23. void SP_myidle();
    
24. int Simple_Pendulum(int argc, _TCHAR* argv[]);

复制代码

====单摆演示动画，代码文件：Simple_Pendulum.cpp======

1. #include "stdafx.h"
   
2. #include "Simple_Pendulum.h"
   
3. 
   
4. struct_SP_Global SP_Global;
   
5. void SP_userReshape(GLsizei w,GLsizei h)
   
6. {
   
7.         glMatrixMode(GL_PROJECTION);
   
8.         glLoadIdentity();
   
9.         gluOrtho2D(-(GLdouble)w/2,(GLdouble)w/2,-(GLdouble)h/2,(GLdouble)h/2);
   
10.         glMatrixMode(GL_MODELVIEW);
    
11.         glViewport(0,0,w,h);
    
12.         SP_Global.ww=w;
    
13.         SP_Global.hh=h;
    
14. }
    
15. void SP_display()
    
16. {
    
17.         glClear(GL_COLOR_BUFFER_BIT);
    
18.         GLfloat startLoc[2] = {0,SP_Global.hh/2};
    
19.         GLfloat Length = SP_Global.hh*9/10;
    
20.         GLfloat Angle = SP_Global.amplitude*SP_Global.DEG_TO_RAD*sin(2*SP_Global.DEG_TO_RAD*SP_Global.theta);
    
21.         GLfloat endLoc[2] = {startLoc[0]+Length*sin(Angle),startLoc[1]-Length*cos(Angle)};
    
22.         GLfloat EdgeLoc[2] ={0.0,0.0};
    
23.         //画摆线
    
24.         glBegin(GL_LINES);
    
25.         {
    
26.                 glColor3f(1.0,1.0,1.0);
    
27.                 glVertex2fv(startLoc);
    
28.                 glVertex2fv(endLoc);
    
29.         }
    
30.         glEnd();
    
31.         //画圆：以多边形边界逼近
    
32.         glBegin(GL_LINE_LOOP);
    
33.         {
    
34.                 glColor3f(1.0,1.0,1.0);
    
35.                 for(int i=0;i<20;++i)
    
36.                 {
    
37.                         GLfloat da = 360/20;
    
38.                         EdgeLoc[0] = endLoc[0] + 20*cos(i*SP_Global.DEG_TO_RAD*da);
    
39.                         EdgeLoc[1] = endLoc[1] + 20*sin(i*SP_Global.DEG_TO_RAD*da);
    
40.                         glVertex2fv(EdgeLoc);;
    
41.                 }
    
42.         }
    
43.         glEnd();
    
44.         //抗锯齿
    
45.         glLineWidth(2);
    
46.         glEnable(GL_LINE_SMOOTH|GL_POINT_SMOOTH);
    
47.         glutSwapBuffers();
    
48. }
    
49. 
    
50. void SP_init()
    
51. {
    
52.         glClearColor(0.0,0.0,0.0,0.0);
    
53. 
    
54.         glColor3f(1.0,1.0,1.0);
    
55. 
    
56.         glMatrixMode(GL_PROJECTION);
    
57.         glLoadIdentity();
    
58.         gluOrtho2D(-1.0,1.0,-1.0,1.0);
    
59. }
    
60. void SP_myidle()
    
61. {
    
62.         SP_Global.theta += SP_Global.theta_inc;
    
63.         if(SP_Global.theta > 360.0)
    
64.         {
    
65.                 SP_Global.theta -=360.0;
    
66.         }
    
67.         glutPostRedisplay();
    
68. }
    
69. int Simple_Pendulum(int argc, _TCHAR* argv[])
    
70. {
    
71.         glutInit(& argc,argv);
    
72.         glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    
73.         glutInitWindowSize(150,400);
    
74.         glutInitWindowPosition(0,0);
    
75.         glutCreateWindow("Simple Pendulum");
    
76.         //设置回调函数
    
77.         glutDisplayFunc(SP_display);
    
78.         glutReshapeFunc(SP_userReshape);
    
79.         glutIdleFunc(SP_myidle);
    
80.         //进入主消息循环
    
81.         SP_init();
    
82.         glutMainLoop();
    
83.         return 0;
    
84. }

复制代码

Rainyboy

====旋转正方形：头文件  Rotat_Block.h============

1. #include "stdafx.h"
   
2. 
   
3. class struct_RB_Global
   
4. {
   
5. public:
   
6.         struct_RB_Global()
   
7.         {
   
8.                 theta=0.0;
   
9.                 DEG_TO_RAD=0.017453;
   
10.                 theta_inc =2.0;
    
11.         }
    
12. public:
    
13.         GLsizei ww,hh;
    
14.         GLfloat theta;
    
15.         GLfloat DEG_TO_RAD;
    
16.         GLfloat theta_inc;
    
17. };
    
18. 
    
19. void RB_userReshape(GLsizei w,GLsizei h);
    
20. void RB_display();
    
21. void RB_init();
    
22. void RB_myidle();
    
23. void RB_mykey(unsigned char key,int x,int y);
    
24. int Rotat_Block(int argc, _TCHAR* argv[]);

复制代码

====旋转正方形：代码文件  Rotat_Block.cpp============

1. #include "stdafx.h"
   
2. #include "Rotat_Block.h"
   
3. 
   
4. 
   
5. struct_RB_Global RB_Global;
   
6. void RB_userReshape(GLsizei w,GLsizei h)
   
7. {
   
8.         glMatrixMode(GL_PROJECTION);
   
9.         glLoadIdentity();
   
10.         gluOrtho2D(-(GLdouble)w/2,(GLdouble)w/2,-(GLdouble)h/2,(GLdouble)h/2);
    
11.         glMatrixMode(GL_MODELVIEW);
    
12.         glViewport(0,0,w,h);
    
13.         RB_Global.ww=w;
    
14.         RB_Global.hh=h;
    
15. }
    
16. void RB_display()
    
17. {
    
18.         glClear(GL_COLOR_BUFFER_BIT);
    
19.         GLsizei lw = RB_Global.ww>RB_Global.hh?RB_Global.hh:RB_Global.ww;
    
20.         lw = lw/2;
    
21.         GLfloat ALPHA = RB_Global.DEG_TO_RAD*RB_Global.theta;
    
22.         glBegin(GL_POLYGON);
    
23.         {
    
24.                 glColor3f(0.0,1.0,0.0);
    
25.                 glVertex2f(lw * sin(ALPHA),lw * cos(ALPHA));
    
26.                 glColor3f(1.0,0.0,0.0);
    
27.                 glVertex2f(-lw * cos(ALPHA),lw * sin(ALPHA));
    
28.                 glColor3f(0.0,0.0,1.0);
    
29.                 glVertex2f(-lw * sin(ALPHA),-lw * cos(ALPHA));
    
30.                 glColor3f(0.0,1.0,0.0);
    
31.                 glVertex2f(lw * cos(ALPHA),-lw * sin(ALPHA));
    
32.         }
    
33.         glEnd();
    
34.        
    
35.         glutSwapBuffers();
    
36. }
    
37. 
    
38. void RB_init()
    
39. {
    
40.         glClearColor(0.0,0.0,0.0,0.0);
    
41. 
    
42.         glColor3f(1.0,1.0,1.0);
    
43. 
    
44.         glMatrixMode(GL_PROJECTION);
    
45.         glLoadIdentity();
    
46.         gluOrtho2D(-1.0,1.0,-1.0,1.0);
    
47. }
    
48. void RB_myidle()
    
49. {
    
50.         RB_Global.theta += RB_Global.theta_inc;
    
51.         if(RB_Global.theta > 360.0)
    
52.         {
    
53.                 RB_Global.theta -=360.0;
    
54.         }
    
55.         glutPostRedisplay();
    
56. }
    
57. void RB_mykey(unsigned char key,int x,int y)
    
58. {
    
59.         printf("%d  ,  %d\n",x,y);
    
60.         if (key=='R'||key=='r')
    
61.         {
    
62.                 RB_Global.theta_inc *= -1;
    
63.         }
    
64.         else if(key=='S'||key=='s')
    
65.         {
    
66.                 glutIdleFunc(NULL);
    
67.         }
    
68.         else if(key=='G'||key=='g')
    
69.         {
    
70.                 glutIdleFunc(RB_myidle);
    
71.         }
    
72.         glutPostRedisplay();
    
73. }
    
74. 
    
75. int Rotat_Block(int argc, _TCHAR* argv[])
    
76. {
    
77.         glutInit(& argc,argv);
    
78.         glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    
79.         glutInitWindowSize(500,500);
    
80.         glutInitWindowPosition(0,0);
    
81.         glutCreateWindow("Rotat Block");
    
82.         //设置回调函数
    
83.         glutDisplayFunc(RB_display);
    
84.         glutReshapeFunc(RB_userReshape);
    
85.         glutIdleFunc(RB_myidle);
    
86.         glutKeyboardFunc(RB_mykey);
    
87.         //进入主消息循环
    
88.         RB_init();
    
89.         //
    
90.         cout<<"R :反转选装方向"<<endl;
    
91.         cout<<"S :停止旋转"<<endl;
    
92.         cout<<"G :重新开始旋转"<<endl;
    
93.         //
    
94.         glutMainLoop();
    
95.         return 0;
    
96. }

复制代码

Rainyboy

====简单绘图器，头文件  SimplePaint.h===============

1. #include "stdafx.h"
   
2. 
   
3. #define PT_FIRST_CLICK 0
   
4. #define PT_SENCOND_CLICK 1
   
5. #define PT_NEVER_CLICK 2
   
6. #define ST_LINE 10
   
7. #define ST_BLOCK 11
   
8. #define ST_CIRCLE 12
   
9. 
   
10. struct PicItem
    
11. {
    
12.         GLint x_1,x_2,y_1,y_2;
    
13.         int PaintTag;
    
14.         int StyleTag;
    
15. };
    
16. 
    
17. typedef vector<PicItem> PicItem_vec;
    
18. 
    
19. class struct_SPAINT_Global
    
20. {
    
21. public:
    
22.         struct_SPAINT_Global()
    
23.         {
    
24.                 PaintTag = PT_NEVER_CLICK;
    
25.                 StyleTag = ST_CIRCLE;
    
26.                 DEG_TO_RAD = 0.017453;
    
27.         }
    
28. public:
    
29.         GLfloat DEG_TO_RAD;
    
30.         GLsizei ww,hh;
    
31.         GLint x_1,x_2,y_1,y_2;
    
32.         int PaintTag;
    
33.         int StyleTag;
    
34.         PicItem_vec PicItemHist;
    
35. };
    
36. 
    
37. 
    
38. 
    
39. 
    
40. void PlotItem(int x_1,int y_1,int x_2,int y_2,int PaintTag,int StyleTag);
    
41. void SPAINT_userReshape(GLsizei w,GLsizei h);
    
42. void SPAINT_display();
    
43. void SPAINT_init();
    
44. void SPAINT_mykey(unsigned char key,int x,int y);
    
45. void SPAINT_mymouse(int button, int state, int x,int y);
    
46. int Simple_Paint(int argc, _TCHAR* argv[]);
    
47. void SPAINT_myPasstiveMotion(int x,int y);

复制代码

====简单绘图器，代码文件  SimplePaint.cpp==============

1. #include "stdafx.h"
   
2. #include "SimplePaint.h"
   
3. 
   
4. struct_SPAINT_Global SPAINT_Global;
   
5. void SPAINT_userReshape(GLsizei w,GLsizei h)
   
6. {
   
7.         glMatrixMode(GL_PROJECTION);
   
8.         glLoadIdentity();
   
9.         gluOrtho2D(-(GLdouble)w/2,(GLdouble)w/2,-(GLdouble)h/2,(GLdouble)h/2);
   
10.         glMatrixMode(GL_MODELVIEW);
    
11.         glViewport(0,0,w,h);
    
12.         SPAINT_Global.ww=w;
    
13.         SPAINT_Global.hh=h;
    
14. }
    
15. void SPAINT_display()
    
16. {
    
17.         glClear(GL_COLOR_BUFFER_BIT);
    
18.         glColor3f(0.0,0.0,0.0);
    
19.         //绘制已有的图形
    
20.         for(int i=0;i<SPAINT_Global.PicItemHist.size();++i)
    
21.         {
    
22.                 PlotItem(
    
23.                         SPAINT_Global.PicItemHist[i].x_1,
    
24.                         SPAINT_Global.PicItemHist[i].y_1,
    
25.                         SPAINT_Global.PicItemHist[i].x_2,
    
26.                         SPAINT_Global.PicItemHist[i].y_2,
    
27.                         SPAINT_Global.PicItemHist[i].PaintTag,
    
28.                         SPAINT_Global.PicItemHist[i].StyleTag
    
29.                         );
    
30.         }
    
31.         glColor3f(1.0,0.0,0.0);
    
32.         //绘制试探的图形
    
33.         PlotItem(
    
34.         SPAINT_Global.x_1,
    
35.         SPAINT_Global.y_1,
    
36.         SPAINT_Global.x_2,
    
37.         SPAINT_Global.y_2,
    
38.         PT_SENCOND_CLICK,
    
39.         SPAINT_Global.StyleTag
    
40.         );
    
41.         //抗锯齿
    
42.         glLineWidth(1.5);
    
43.         glPolygonMode(GL_FRONT,GL_LINE);
    
44.         glPolygonMode(GL_BACK,GL_LINE);
    
45.         glEnable(GL_LINE_SMOOTH|GL_POINT_SMOOTH);
    
46.         glutSwapBuffers();
    
47. }
    
48. 
    
49. void PlotItem(int x_1,int y_1,int x_2,int y_2,int PaintTag,int StyleTag)
    
50. {
    
51.         GLfloat da;
    
52.         GLfloat R =(x_1 - x_2)*(x_1 - x_2) + (y_1 - y_2)*(y_1 - y_2);
    
53.         R = pow((float)R,(float)0.5)/2;
    
54.         switch(PaintTag)
    
55.         {
    
56.         case PT_FIRST_CLICK:
    
57.         case PT_NEVER_CLICK:
    
58.                 return;
    
59.         case PT_SENCOND_CLICK:
    
60.                 switch(StyleTag)
    
61.                 {
    
62.                 case ST_BLOCK:
    
63.                         glBegin(GL_POLYGON);
    
64.                         {
    
65.                                 glVertex2i(x_1,y_1);
    
66.                                 glVertex2i(x_1,y_2);
    
67.                                 glVertex2i(x_2,y_2);
    
68.                                 glVertex2i(x_2,y_1);
    
69.                         }
    
70.                         glEnd();
    
71.                         break;
    
72.                 case ST_LINE:
    
73.                         glBegin(GL_LINES);
    
74.                         {
    
75.                                 glVertex2i(x_1,y_1);
    
76.                                 glVertex2i(x_2,y_2);
    
77.                         }
    
78.                         glEnd();
    
79.                         break;
    
80.                 case ST_CIRCLE:
    
81.                         glBegin(GL_LINE_LOOP);
    
82.                         {
    
83.                                 for(int i=0;i<40;++i)
    
84.                                 {
    
85.                                         da= 360/40;
    
86.                                         glVertex2f((x_1+x_2)/2 + R*cos(i*SPAINT_Global.DEG_TO_RAD*da),
    
87.                                                 (y_1+y_2)/2 + R*sin(i*SPAINT_Global.DEG_TO_RAD*da));
    
88.                                 }
    
89.                         }
    
90.                         glEnd();
    
91.                         break;
    
92.                 }
    
93.         }
    
94. }
    
95. 
    
96. void SPAINT_init()
    
97. {
    
98.         glClearColor(1.0,1.0,1.0,1.0);
    
99. 
    
100.         glColor3f(1.0,1.0,1.0);
     
101. 
     
102.         glMatrixMode(GL_PROJECTION);
     
103.         glLoadIdentity();
     
104.         gluOrtho2D(-1.0,1.0,-1.0,1.0);
     
105. }
     
106. void SPAINT_mykey(unsigned char key,int x,int y)
     
107. {
     
108.         if (key=='L'||key=='l')
     
109.                 SPAINT_Global.StyleTag = ST_LINE;
     
110.         else if(key=='B'||key=='b')
     
111.                 SPAINT_Global.StyleTag = ST_BLOCK;
     
112.         else if(key=='C'||key=='c')
     
113.                 SPAINT_Global.StyleTag = ST_CIRCLE;
     
114. }
     
115. void SPAINT_mymouse(int button, int state, int x,int y)
     
116. {
     
117.         if(state == GLUT_DOWN && button == GLUT_LEFT_BUTTON)
     
118.         {
     
119.                 if(SPAINT_Global.PaintTag == PT_FIRST_CLICK || SPAINT_Global.PaintTag == PT_NEVER_CLICK)
     
120.                 {
     
121.                         SPAINT_Global.x_2 = x - SPAINT_Global.ww/2;
     
122.                         SPAINT_Global.y_2 = SPAINT_Global.hh/2 - y;
     
123.                         SPAINT_Global.PaintTag = PT_SENCOND_CLICK;
     
124.                 }
     
125.                 else if(SPAINT_Global.PaintTag == PT_SENCOND_CLICK)
     
126.                 {
     
127.                         SPAINT_Global.x_1 = x - SPAINT_Global.ww/2;
     
128.                         SPAINT_Global.y_1 = SPAINT_Global.hh/2 - y;
     
129.                         PicItem tPI;
     
130.                         tPI.x_1 = SPAINT_Global.x_1;
     
131.                         tPI.x_2 = SPAINT_Global.x_2;
     
132.                         tPI.y_1 = SPAINT_Global.y_1;
     
133.                         tPI.y_2 = SPAINT_Global.y_2;
     
134.                         tPI.PaintTag = SPAINT_Global.PaintTag;
     
135.                         tPI.StyleTag = SPAINT_Global.StyleTag;
     
136.                         SPAINT_Global.PicItemHist.push_back(tPI);
     
137.                         SPAINT_Global.PaintTag = PT_FIRST_CLICK;
     
138.                 }
     
139.         }
     
140. 
     
141.         glutPostRedisplay();
     
142. }
     
143. void SPAINT_myPasstiveMotion(int x,int y)
     
144. {
     
145.         if(SPAINT_Global.PaintTag == PT_FIRST_CLICK || SPAINT_Global.PaintTag == PT_NEVER_CLICK)
     
146.                 return;
     
147.         SPAINT_Global.x_1 = x - SPAINT_Global.ww/2;
     
148.         SPAINT_Global.y_1 = SPAINT_Global.hh/2 - y;
     
149.         glutPostRedisplay();
     
150. }
     
151. int Simple_Paint(int argc, _TCHAR* argv[])
     
152. {
     
153.         glutInit(& argc,argv);
     
154.         glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
     
155.         glutInitWindowSize(500,500);
     
156.         glutInitWindowPosition(0,0);
     
157.         glutCreateWindow("Simple");
     
158.         //设置回调函数
     
159.         glutDisplayFunc(SPAINT_display);
     
160.         glutReshapeFunc(SPAINT_userReshape);
     
161.         glutKeyboardFunc(SPAINT_mykey);
     
162.         glutMouseFunc(SPAINT_mymouse);
     
163.         glutPassiveMotionFunc(SPAINT_myPasstiveMotion);
     
164.         //
     
165.         cout<<"C : 画圆环"<<endl;
     
166.         cout<<"L : 画直线"<<endl;
     
167.         cout<<"B : 画矩形"<<endl;
     
168.         //
     
169.         //进入主消息循环
     
170.         SPAINT_init();
     
171.         glutMainLoop();
     
172.         return 0;
     
173. }

复制代码

Rainyboy

=====弹性小球演示动画，头文件   ElasticBall.h================

1. #include "stdafx.h"
   
2. class struct_EB_Global
   
3. {
   
4. public:
   
5.         struct_EB_Global()
   
6.         {
   
7.                 R = 40.0;
   
8.                 DEG_TO_RAD = 0.017453;
   
9.                 CenterLoc[0] = 0;
   
10.                 CenterLoc[1] = 0;
    
11.                 Velocity[0]=1.4;
    
12.                 Velocity[1]=2.7;
    
13.                 Step = 1.0;
    
14.         }
    
15. public:
    
16.         GLsizei ww;
    
17.         GLsizei hh;
    
18.         GLfloat R;
    
19.         GLfloat DEG_TO_RAD;
    
20.         GLint CenterLoc[2];
    
21.         GLfloat Velocity[2];
    
22.         GLfloat Step;
    
23. };
    
24. 
    
25. void EB_userReshape(GLsizei w,GLsizei h);
    
26. void EB_display();
    
27. void EB_init();
    
28. void EB_myidle();
    
29. int Elastic_Ball(int argc, _TCHAR* argv[]);

复制代码

=====弹性小球演示动画，代码文件   ElasticBall.cpp===============

1. #include "stdafx.h"
   
2. #include "ElasticBall.h"
   
3. struct_EB_Global EB_Global;
   
4. void EB_userReshape(GLsizei w,GLsizei h)
   
5. {
   
6.         glMatrixMode(GL_PROJECTION);
   
7.         glLoadIdentity();
   
8.         gluOrtho2D(-(GLdouble)w/2,(GLdouble)w/2,-(GLdouble)h/2,(GLdouble)h/2);
   
9.         glMatrixMode(GL_MODELVIEW);
   
10.         glViewport(0,0,w,h);
    
11.         EB_Global.ww=w;
    
12.         EB_Global.hh=h;
    
13. }
    
14. void EB_display()
    
15. {
    
16.         glClear(GL_COLOR_BUFFER_BIT);
    
17.         //画圆：以多边形边界逼近
    
18.         GLfloat EdgeLoc[2];
    
19.         glBegin(GL_LINE_LOOP);
    
20.         {
    
21.                 glColor3f(1.0,1.0,1.0);
    
22.                 for(int i=0;i<20;++i)
    
23.                 {
    
24.                         GLfloat da = 360/20;
    
25.                         EdgeLoc[0] = EB_Global.CenterLoc[0] + EB_Global.R*cos(i*EB_Global.DEG_TO_RAD*da);
    
26.                         EdgeLoc[1] = EB_Global.CenterLoc[1] + EB_Global.R*sin(i*EB_Global.DEG_TO_RAD*da);
    
27.                         glVertex2fv(EdgeLoc);
    
28.                 }
    
29.         }
    
30.         glEnd();
    
31.         //抗锯齿
    
32.         glLineWidth(2);
    
33.         glEnable(GL_LINE_SMOOTH|GL_POINT_SMOOTH);
    
34.         glutSwapBuffers();
    
35. }
    
36. 
    
37. void EB_init()
    
38. {
    
39.         glClearColor(0.0,0.0,0.0,0.0);
    
40. 
    
41.         glColor3f(1.0,1.0,1.0);
    
42. 
    
43.         glMatrixMode(GL_PROJECTION);
    
44.         glLoadIdentity();
    
45.         gluOrtho2D(-1.0,1.0,-1.0,1.0);
    
46. }
    
47. void EB_myidle()
    
48. {
    
49.         EB_Global.CenterLoc[0]+=EB_Global.Velocity[0]*EB_Global.Step;
    
50.         if(abs(EB_Global.CenterLoc[0]) + EB_Global.R >EB_Global.hh/2)
    
51.         {
    
52.                 EB_Global.Velocity[0] *= -1;
    
53.         }
    
54.         EB_Global.CenterLoc[1]+=EB_Global.Velocity[1]*EB_Global.Step;
    
55.         if(abs(EB_Global.CenterLoc[1]) + EB_Global.R >EB_Global.ww/2)
    
56.         {
    
57.                 EB_Global.Velocity[1] *= -1;
    
58.         }
    
59.         glutPostRedisplay();
    
60. }
    
61. int Elastic_Ball(int argc, _TCHAR* argv[])
    
62. {
    
63.         glutInit(& argc,argv);
    
64.         glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    
65.         glutInitWindowSize(500,500);
    
66.         glutInitWindowPosition(0,0);
    
67.         glutCreateWindow("Simple Pendulum");
    
68.         //设置回调函数
    
69.         glutDisplayFunc(EB_display);
    
70.         glutReshapeFunc(EB_userReshape);
    
71.         glutIdleFunc(EB_myidle);
    
72.         //进入主消息循环
    
73.         EB_init();
    
74.         glutMainLoop();
    
75.         return 0;
    
76. }

复制代码

meiyongyuandeze

院长，猛男！程序运行了下，感觉不错，多谢分享哈！

Rainyboy

回复 6 # meiyongyuandeze 的帖子

哪里，过奖了……远未触及OpenGL的精髓……路还长啊，呵呵

hityrj

恩……我想问下……我编写OpenGL代码时，主函数如果是 _tmain(int argc, _TCHAR* argv[])
会报错，只可以在int main(int argc, char **argv) 或int main(int argc, char *argv[])……这是什么原因呢

Rainyboy

回复 8 # hityrj 的帖子

哦，可能是由于UNICODE兼容方面的问题吧，你看看这个
http://baike.baidu.com/view/3478231.htm

impulse

采用Java 3d来做也不错，用它做个输电塔振型动画。

Rainyboy

回复 10 # impulse 的帖子

嗯嗯，做动画的方式还是很多的，达到目的就行

dafo2006

学习了！

wizardyjh

学习了~~~~~~~~~~