├── OpenGL_Lab
    ├── 10_跳跃的立体小球
    │   └── 10_BallJump.c
    ├── 11_动态旋转的立体时钟
    │   └── 11_clock.c
    ├── 12_三次Besizer曲线
    │   └── 12_BesierCurve.c
    ├── 13_三次Bezier曲面线框模型
    │   └── 13_BesizerSurfaceWireframe.c
    ├── 14_三次Bezier曲面并添加光照效果
    │   └── 14_BesizerSurface.c
    ├── 15_NURBS曲面并添加光照效果
    │   └── 15_NuresSurface.c
    ├── 1_二维网络棋盘
    │   └── 1_chessboard.c
    ├── 2_绘制三维对象_框架
    │   └── 2_3Dbasicframe.c
    ├── 3_绘制平滑着色的三角形
    │   └── 3_DrawTriangle.c
    ├── 4_相交区域的混合着色
    │   └── 4_MixColor.c
    ├── 5_3D茶壶
    │   └── 5_3DTeapot.c
    ├── 6_太阳系
    │   └── 6_SolarSystem.c
    ├── 7_绘制正方形
    │   └── 7_DrawCube.c
    ├── 8_立方体表面纹理贴图
    │   └── 8_CubeTexture.c
    ├── 9_粒子的随机运动
    │   └── 9_ParticlesRandomMotion.c
    └── README.md
├── README.md
└── test.c


/OpenGL_Lab/10_跳跃的立体小球/10_BallJump.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <GL/glut.h>
  3 | #include <cmath>
  4 | #include <stdlib.h>
  5 | #include <GL/glut.h>
  6 | #include <math.h>
  7 | 
  8 | //色彩全局常量
  9 | GLfloat WHITE[] = { 1, 1, 1 };    //白色
 10 | GLfloat RED[] = { 1, 0, 0 };    //红色
 11 | GLfloat GREEN[] = { 0, 1, 0 };    //绿色
 12 | GLfloat MAGENTA[] = { 1, 0, 1 };  //洋红
 13 | 
 14 | //摄像机类：水平移动半径为10，按上下键则垂直移动
 15 | class Camera {
 16 | public:  
 17 |     double theta;      //确定x和z的位置
 18 |     double y;          //y位置
 19 |     double dTheta;     //角度增量
 20 |     double dy;         //上下y增量
 21 | public:
 22 |     //类构造函数—默认初始化用法
 23 |     Camera() : theta(0), y(3), dTheta(0.04), dy(0.2) {}
 24 |     //类方法
 25 |     double getX() { return 10 * cos(theta); }
 26 |     double getY() { return y; }
 27 |     double getZ() { return 10 * sin(theta); }
 28 |     void moveRight() { theta += dTheta; }
 29 |     void moveLeft() { theta -= dTheta; }
 30 |     void moveUp() { y += dy; }
 31 |     void moveDown() { if (y > dy) y -= dy; }
 32 | };
 33 | 
 34 | //球类定义
 35 | //半径、颜色、最大高度
 36 | //x和z固定
 37 | //用lame bouncing algorithm
 38 | //每帧上下移动0.05单位
 39 | class Ball {
 40 |     //类的属性
 41 |     double radius;
 42 |     GLfloat* color;
 43 |     double maximumHeight;
 44 |     double x;
 45 |     double y;
 46 |     double z;
 47 |     int direction;   //方向
 48 | public:
 49 |     //构造函数
 50 |     Ball(double r, GLfloat* c, double h, double x, double z) :
 51 |         radius(r), color(c), maximumHeight(h), direction(-1),
 52 |         y(h), x(x), z(z) {
 53 |     }
 54 | 
 55 |     //更新和绘制方法
 56 |     void update() {
 57 |         //正反运动
 58 |         y += direction * 0.05;
 59 |         if (y > maximumHeight) {
 60 |             y = maximumHeight;
 61 |             direction = -1;
 62 |         }
 63 |         else if (y < radius) {
 64 |             y = radius;
 65 |             direction = 1;
 66 |         }
 67 |         glPushMatrix();
 68 |         //单独设置每个球的材质参数
 69 |         glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, color);
 70 |         glTranslated(x, y, z);
 71 |         //创建球
 72 |         glutSolidSphere(radius, 30, 30);
 73 |         glPopMatrix();
 74 |     }
 75 | };
 76 | 
 77 | //棋盘格：沿x和z平面分布
 78 | //点光源位置设置为(4, 3, 7).
 79 | class Checkerboard {
 80 |     int displayListId;
 81 |     int width;
 82 |     int depth;
 83 | public:
 84 |     //构造函数
 85 |     Checkerboard(int width, int depth) : width(width), depth(depth) {}
 86 | 
 87 |     //中心X
 88 |     double centerx() { return width / 2; }
 89 | 
 90 |     //中心Y
 91 |     double centerz() { return depth / 2; }
 92 | 
 93 |     //创建方法
 94 |     void create() {
 95 |         displayListId = glGenLists(1);     //每个显示列表对应1个编号——关联起来
 96 |         //新建操作表
 97 |         glNewList(displayListId, GL_COMPILE);   //把下述命令装入显示列表但不显示
 98 |         //光源位置参数
 99 |         GLfloat lightPosition[] = { 4, 3, 7, 1 };
100 |         //设置光源位置
101 |         glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
102 |         //开始绘制四边形
103 |         glBegin(GL_QUADS);
104 |         //法向量方向
105 |         glNormal3d(0, 1, 0);
106 |         for (int x = 0; x < width - 1; x++) {
107 |             for (int z = 0; z < depth - 1; z++) {
108 |                 //设置每个格子的材质属性
109 |                 glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE,
110 |                     (x + z) % 2 == 0 ? RED : WHITE);
111 |                 //四边形的4个点坐标
112 |                 glVertex3d(x, 0, z);
113 |                 glVertex3d(x + 1, 0, z);
114 |                 glVertex3d(x + 1, 0, z + 1);
115 |                 glVertex3d(x, 0, z + 1);
116 |             }
117 |         }
118 |         glEnd();
119 |         glEndList();
120 |     }
121 |     //按列表编号绘制棋盘格
122 |     void draw() {
123 |     glCallList(displayListId);
124 |     }
125 | };
126 | 
127 | //全局变量：棋盘格、相机和3个球的数组
128 | Checkerboard checkerboard(8, 8);
129 | Camera camera;
130 | //创建3个小球的数组
131 | Ball balls[] = {
132 |     Ball(1, GREEN, 7, 6, 1),
133 |     Ball(1.5, MAGENTA, 6, 3, 4),
134 |     Ball(0.4, WHITE, 5, 1, 7)
135 | };
136 | 
137 | //自定义初始化方法
138 | void init() {
139 |     //允许深度测试
140 |     glEnable(GL_DEPTH_TEST);
141 |     //设置散射和镜像反射为白光
142 |     glLightfv(GL_LIGHT0, GL_DIFFUSE, WHITE);
143 |     glLightfv(GL_LIGHT0, GL_SPECULAR, WHITE);
144 |     //设置前表面的高光镜像反射为白光
145 |     glMaterialfv(GL_FRONT, GL_SPECULAR, WHITE);
146 |     //设置前表面散射光反光系数
147 |     glMaterialf(GL_FRONT, GL_SHININESS, 30);
148 |     //允许灯光
149 |     glEnable(GL_LIGHTING);
150 |     //打开0#灯
151 |     glEnable(GL_LIGHT0);
152 |     //创建棋盘格
153 |     checkerboard.create();
154 | }
155 | 
156 | //自定义绘制函数
157 | //通过类绘制各对象，display函数代码得以简化
158 | void display() {
159 |     //清除前一帧绘图结果
160 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
161 |     //装入单位阵
162 |     glLoadIdentity();
163 |     //设置视角——摄像机参数
164 |     gluLookAt(camera.getX(), camera.getY(), camera.getZ(),    //摄像机位置
165 |         checkerboard.centerx(), 0.0, checkerboard.centerz(),   //焦点坐标
166 |         0.0, 1.0, 0.0);   //摄像机机顶方向矢量
167 |     //绘制棋盘
168 |     checkerboard.draw();
169 |     //绘制小球
170 |     for (int i = 0; i < sizeof balls / sizeof(Ball); i++) {
171 |         //更新位置并绘图
172 |         balls[i].update();
173 |     }
174 |     //glFlush();
175 |     glutSwapBuffers();
176 | }
177 | 
178 | //窗口调整大小时调用的函数
179 | void reshape(GLint w, GLint h) {
180 |     glViewport(0, 0, w, h);
181 |     glMatrixMode(GL_PROJECTION);
182 |     glLoadIdentity();
183 |     gluPerspective(40.0, GLfloat(w) / GLfloat(h), 1.0, 150.0);
184 |     glMatrixMode(GL_MODELVIEW);
185 | }
186 | 
187 | //自定义计时器函数
188 | void timer(int v) {
189 |     //当计时器唤醒时所调用的函数
190 |     glutPostRedisplay();
191 |     //设置下一次计时器的参数
192 |     glutTimerFunc(1000 / 60, timer/*函数名*/, v);
193 | }
194 | 
195 | //键盘处理函数
196 | void onKey(int key, int, int) {
197 |     //按键：上下左右
198 |     switch (key) {
199 |     case GLUT_KEY_LEFT: camera.moveLeft(); break;
200 |     case GLUT_KEY_RIGHT: camera.moveRight(); break;
201 |     case GLUT_KEY_UP: camera.moveUp(); break;
202 |     case GLUT_KEY_DOWN: camera.moveDown(); break;
203 |     }
204 |     glutPostRedisplay();
205 | }
206 | 
207 | int main(int argc, char** argv) {
208 |     glutInit(&argc, argv);
209 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
210 |     glutInitWindowPosition(80, 80);
211 |     glutInitWindowSize(800, 600);
212 |     glutCreateWindow("跳跃的球");
213 |     glutDisplayFunc(display);   //设置显示函数
214 |     glutReshapeFunc(reshape);   //设置窗口调整大小的函数
215 |     glutSpecialFunc(onKey);   //设置按键处理函数
216 |     glutTimerFunc(100, timer, 0);  //设置计时器函数--每100ms被调用1次
217 |     init();//自定义初始化函数
218 |     glutMainLoop();//进入opengl主循环
219 |     
220 |     return 0;
221 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/11_动态旋转的立体时钟/11_clock.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include<Windows.h>
  3 | #include<GL\glut.h>
  4 | #include<GL\GLAUX.H>
  5 | #include<stdio.h>
  6 | #include<stdlib.h>
  7 | #include<math.h>
  8 | #include<time.h>
  9 | 
 10 | #pragma comment(lib, "glut32.lib")
 11 | #pragma comment(lib, "glaux.lib")
 12 | 
 13 | GLfloat  xrot = 0;   // X 旋转量
 14 | GLfloat  yrot = 0;   // Y 旋转量
 15 | GLfloat  zrot = 0;   // Z 旋转量
 16 | GLuint  texture[1];  // 存储一个纹理---数组
 17 | 
 18 | const GLfloat Pi = 3.1415926536;
 19 | const GLfloat R = 0.8f;
 20 | const int n = 200;
 21 | static GLfloat angle = 2 * Pi;
 22 | 
 23 | //载入位图图象到内存
 24 | AUX_RGBImageRec *LoadBMP(CHAR *Filename)
 25 | {
 26 |     FILE *File = NULL;         // 文件句柄
 27 |     if (!Filename)          // 确保文件名已提供
 28 |     {
 29 |         return NULL;         // 如果没提供，返回 NULL
 30 |     }
 31 |     File = fopen(Filename, "r");       // 尝试打开文件
 32 |     if (File)           // 判断文件是否存在
 33 |     {
 34 |         fclose(File);         // 关闭句柄
 35 |         return auxDIBImageLoadA(Filename);    // 载入位图并返回指针
 36 |     }
 37 |     return NULL;          // 如果载入失败，返回 NULL
 38 | }
 39 | 
 40 | //载入位图并转换成纹理
 41 | //参数：纹理指针、bmp文件名、用户指定的纹理编号
 42 | int LoadGLTextures(GLuint *texture, char *bmp_file_name, int texture_id)
 43 | {
 44 |     int Status = FALSE;         // 状态指示器
 45 |     // 创建纹理的存储空间
 46 |     AUX_RGBImageRec *TextureImage[1];
 47 |     memset(TextureImage, 0, sizeof(void *) * 1);   // 将指针设为 NULL
 48 |     // 载入位图，检查有无错误，如果位图没找到则退出
 49 |     if (TextureImage[0] = LoadBMP(bmp_file_name))
 50 |     {
 51 |         Status = TRUE;         // 将 Status 设为 TRUE
 52 |         //生成(generate)纹理
 53 |         glGenTextures(texture_id, texture); //&texture[0]);     
 54 |         //绑定2D纹理对象
 55 |         glBindTexture(GL_TEXTURE_2D, *texture); //texture[0]);
 56 |         //关联图像数据与纹理对象
 57 |         glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
 58 |         //图形绘制时所使用的滤波器参数
 59 |         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 线形滤波
 60 |         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 线形滤波
 61 |     }
 62 | 
 63 |     //释放图像的内存，因为已经生成纹理了，没用了
 64 |     if (TextureImage[0])        // 纹理是否存在
 65 |     {
 66 |         if (TextureImage[0]->data)      // 纹理图像是否存在
 67 |         {
 68 |             free(TextureImage[0]->data);    // 释放纹理图像占用的内存
 69 |         }
 70 |         free(TextureImage[0]);       // 释放图像结构
 71 |     }
 72 |     else
 73 |         printf("纹理不存在");
 74 |     return Status;          // 返回 Status
 75 | }
 76 | 
 77 | void DrawCube(void)         // 从这里开始进行所有的绘制
 78 | {
 79 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 清除屏幕和深度缓存
 80 |     glLoadIdentity();         // 重置当前的模型观察矩阵
 81 |     glTranslatef(0.0f, 0.0f, -5.0f);         // 移入屏幕 5 个单位
 82 |     glRotatef(xrot, 1.0f, 0.0f, 0.0f);         // 绕X轴旋转
 83 |     glRotatef(yrot, 0.0f, 1.0f, 0.0f);         // 绕Y轴旋转
 84 |     glRotatef(zrot, 0.0f, 0.0f, 1.0f);         // 绕Z轴旋转
 85 |     glColor4f(1.0, 1.0, 1.0, 1.0);
 86 |     glBindTexture(GL_TEXTURE_2D, texture[0]);      // 选择纹理
 87 |     glBegin(GL_QUADS);
 88 |     // 前面
 89 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
 90 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
 91 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的右上
 92 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的左上
 93 |     // 后面
 94 |     glEnd();
 95 |     glColor4f(1.0, 1.0, 0.0, 1.0);
 96 |     glBindTexture(GL_TEXTURE_2D, texture[1]);
 97 |     glBegin(GL_QUADS);
 98 | 
 99 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的右下
100 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
101 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
102 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的左下
103 |     // 顶面
104 |     glEnd();
105 |     glColor4f(1.0, 1.0, 0.0, 1.0);
106 |     glBegin(GL_QUADS);
107 | 
108 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
109 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的左下
110 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的右下
111 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
112 |     // 底面
113 |     glEnd();
114 |     glColor4f(1.0, 1.0, 0.0, 1.0);
115 |     glBegin(GL_QUADS);
116 | 
117 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的右上
118 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的左上
119 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
120 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
121 |     // 右面
122 |     glEnd();
123 |     glColor4f(1.0, 1.0, 0.0, 1.0);
124 |     glBegin(GL_QUADS);
125 | 
126 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的右下
127 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
128 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的左上
129 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
130 |     // 左面
131 |     glEnd();
132 |     glColor4f(1.0, 1.0, 0.0, 1.0);
133 |     glBegin(GL_QUADS);
134 | 
135 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的左下
136 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
137 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的右上
138 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
139 |     glEnd();
140 | 
141 |     glFlush(); //glutSwapBuffers();
142 | }
143 | 
144 | float Mysecond(struct tm *ptr)
145 | {
146 |     return((Pi / 2) - (((float)ptr->tm_sec) / 60) * 2 * Pi);
147 | }
148 | 
149 | float Mymin(struct tm *ptr)
150 | {
151 |     return((Pi / 2) - ((ptr->tm_min + (Mysecond(ptr) / 60)) / 60) * 2 * Pi);
152 | }
153 | 
154 | float Myhour(struct tm *ptr)
155 | {
156 |     if (0 < ptr->tm_hour&&ptr->tm_hour < 12)
157 |     {
158 |         return((Pi / 2) - ((float)ptr->tm_hour + Mymin(ptr) / 60.0) / 12.0 * 2 * Pi);
159 |     }
160 |     else{
161 |         return((Pi / 2) - ((ptr->tm_hour - 12.0 + Mymin(ptr) / 60.0) / 12) * 2 * Pi);
162 |     }
163 | }
164 | 
165 | void myDisplay(void)
166 | {
167 |     struct tm *ptr;  //获取系统时间
168 |     time_t it;
169 |     it = time(NULL);
170 |     ptr = localtime(&it);
171 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  //清除颜色
172 |     glLoadIdentity();
173 |     glTranslatef(0.0f, 0.0f, -5.0f);
174 | 
175 |     DrawCube();//钟盘
176 |     glEnable(GL_POINT_SMOOTH);
177 |     glEnable(GL_LINE_SMOOTH);
178 |     glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
179 |     glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
180 |     glEnable(GL_BLEND);
181 |     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
182 |     glPushMatrix();
183 |     glTranslatef(0, -0.0, 1.0);
184 |     glColor4f(1.0, 0.0, 0.0, 0.5);  //洋红色
185 |     glBegin(GL_POLYGON);
186 |     for (int i = 0; i < n; i++){
187 |         glVertex2f(R*cos(2 * Pi / n*i), R*sin(2 * Pi / n*i));
188 |     }
189 |     glEnd();
190 | 
191 |     //刻度
192 |     glColor4f(1.0, 1.0, 1.0, 0.5);  //白色
193 |     glBegin(GL_POINTS);
194 |     glPointSize(5.0f);
195 |     for (int j = 0; j < 12; j++)
196 |     {
197 |         glVertex2f(0.75*cos(2 * Pi / 12 * j), 0.75*sin(2 * Pi / 12 * j));
198 |     }
199 |     glEnd();
200 | 
201 |     //表盘上的中心点
202 |     glPointSize(5.0f);
203 |     glColor4f(0.0, 0.0, 0.0, 0.2);
204 |     glBegin(GL_POINTS);
205 |     glVertex2f(0.0, 0.0);
206 |     glEnd();
207 | 
208 |     //时针
209 |     glLineWidth(5.0f);  //设置线的宽度
210 |     glColor4f(1.0, 0.0, 1.0, 0.5);  //洋红色
211 |     glBegin(GL_LINES);  //画线函数
212 |     glRotatef((angle / 3600.0), 0.0, 0.0, 1.0);
213 |     glVertex2f(0.0, 0.0);
214 |     glVertex2f(cos(Myhour(ptr))*R*0.55, sin(Myhour(ptr))*R*0.55);
215 |     glEnd();
216 | 
217 |     //分针
218 |     glLineWidth(5.0f);
219 |     glColor4f(0.0, 1.0, 0.0, 0.5);  //绿色
220 |     glBegin(GL_LINES);
221 |     glRotatef((angle / 60.0), 0.0, 0.0, 1.0);
222 |     glVertex2f(0.0, 0.0);
223 |     glVertex2f(cos(Mymin(ptr))*R*0.65, sin(Mymin(ptr))*R*0.65);
224 |     glEnd();
225 | 
226 |     //秒针
227 |     glLineWidth(3.0f);
228 |     glColor4f(0.0, 0.0, 1.0, 0.5);  //蓝色
229 |     glBegin(GL_LINES);
230 |     glRotatef(angle, 0.0, 0.0, 1.0);
231 |     glVertex2f(0.0, 0.0);
232 |     glVertex2f(cos(Mysecond(ptr))*R*0.85, sin(Mysecond(ptr))*R*0.85);
233 |     glEnd();
234 |     glPopMatrix();
235 |     glutSwapBuffers();//    glFlush();  //保证前面的OpenGL命令立即执行，而不是让它们在缓冲区中等待
236 | }
237 | 
238 | void init(void)
239 | {
240 |     glClearColor(1.0, 1.0, 1.0, 1.0);  //清理颜色，为白色，（也可认为是背景颜色）
241 |     glCullFace(GL_BACK);
242 |     //背面裁剪(背面不可见)
243 |     glEnable(GL_CULL_FACE);
244 |     //启用裁剪
245 |     glEnable(GL_TEXTURE_2D);
246 |     LoadGLTextures(&texture[0], "clock3.bmp", 1);            //载入纹理贴图
247 |     LoadGLTextures(&texture[1], "clock3.bmp", 2);
248 | }
249 | 
250 | //当窗口大小改变时，会调用这个函数
251 | void reshape(GLsizei w, GLsizei h)
252 | {
253 |     //这里小说明一下：矩阵模式是不同的，他们各自有一个矩阵。投影相关
254 |     //只能用投影矩阵。
255 |     glViewport(0, 0, w, h);        //设置视口
256 |     glMatrixMode(GL_PROJECTION);    //设置矩阵模式为投影变换矩阵，
257 |     glLoadIdentity();                //变为单位矩阵
258 |     gluPerspective(60, (GLfloat)w / h, 0, 1000);    //设置投影矩阵
259 |     glMatrixMode(GL_MODELVIEW);        //设置矩阵模式为视图矩阵(模型)
260 |     glLoadIdentity();                //变为单位矩阵
261 | }
262 | 
263 | //键盘输入事件函数
264 | void keyboard(unsigned char key, int x, int y)
265 | {
266 |     switch (key)
267 |     {
268 |     case 'x':    //当按下键盘上d时，以沿X轴旋转为主
269 |         xrot += 6.0f;   //设置旋转增量
270 |         glutPostRedisplay();   //重绘函数
271 |         break;
272 |     case 'y':
273 |         yrot += 6.0f;
274 |         glutPostRedisplay();
275 |         break;
276 |     case 'z':
277 |         zrot += 6.0f;
278 |         glutPostRedisplay();
279 |         break;
280 |     default:
281 |         break;
282 |     }
283 | }
284 | 
285 | void myIdle(void)
286 | {
287 |     angle -= ((2 * Pi) / 60);
288 |     Sleep(1000);
289 |     if (angle < 0.0f){
290 |         angle = 2 * Pi;
291 |     }
292 |     myDisplay();
293 | }
294 | 
295 | int main(int argc, char *argv[])
296 | {
297 |     glutInit(&argc, argv);  //对GLUT进行初始化
298 |     //    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);  //设置显示方式
299 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//设置双缓存
300 |     //GLUT_RGB表示使用RGB颜色，GLUT_SINGLE表示使用单缓冲
301 |     glutInitWindowPosition(200, 200);  //设置窗口在屏幕中的位置
302 |     glutInitWindowSize(500, 500);  //设置窗口的大小
303 |     glutCreateWindow("OpenGL时钟");  //设置窗口的标题
304 |     init();  //初始化资源,这里一定要在创建窗口以后，不然会无效。
305 |     LoadGLTextures(&texture[0], "clock3.bmp", 1);
306 |     LoadGLTextures(&texture[1], "clock3.bmp", 2);
307 |     glutDisplayFunc(&myDisplay);  //调用画图函数
308 |     glutIdleFunc(&myIdle);
309 |     glutReshapeFunc(reshape);                //绘制图形时的回调
310 |     glutKeyboardFunc(keyboard);
311 |     glutMainLoop();  //进行一个消息循环。显示窗口，并等待窗口关闭后才会返回
312 | 
313 |     return 0;
314 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/12_三次Besizer曲线/12_BesierCurve.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | #include <GL/glut.h>
  5 | 
  6 | //4个控制点的3D坐标——z坐标全为0
  7 | GLfloat ctrlpoints[4][3] = {
  8 |     { -4, -4, 0 }, { -2, 4, 0 }, { 2, -4, 0 }, { 4, 4, 0 }
  9 | };
 10 | 
 11 | void init(void)
 12 | {
 13 |     //背景色
 14 |     glClearColor(0.0, 0.0, 0.0, 1.0);
 15 |     //将控制点坐标映射为曲线坐标
 16 |     //参数1：GL_MAP1_VERTEX_3，3维点坐标
 17 |     //参数2和3：控制参数t或u的取值范围[0, 1]
 18 |     //参数4：曲线内插值点间的步长3————3维坐标
 19 |     //参数5：曲线间的补偿为顶点数4个————总步长为12
 20 |     //参数6：控制点二维数组首元素地址
 21 |     //注意: 若是在这里设置了相关参数，后续对ctrlpoints内容更改曲线不变
 22 |     glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
 23 |     //打开开关——允许3维坐标控制点到参数点转换开关
 24 |     glEnable(GL_MAP1_VERTEX_3);
 25 |     glShadeModel(GL_FLAT);
 26 | 
 27 |     //代码开关2：去掉本注释，可启用反走样
 28 |     /*
 29 |     glEnable(GL_BLEND);
 30 |     glEnable(GL_LINE_SMOOTH);  //允许直线反走样
 31 |     glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);  // Antialias the lines
 32 |     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 33 |     */
 34 | }
 35 | 
 36 | void display(void)
 37 | {
 38 |     int i;
 39 |     glClear(GL_COLOR_BUFFER_BIT);
 40 |     glColor3f(1.0, 1.0, 1.0);
 41 | 
 42 |     //代码开关1：去掉本注释，查看动态的曲线绘图效果：动态更新控制点坐标
 43 |     /*
 44 |     for(int t = 0; t < 4; t++) {
 45 |     for(int j = 0; j < 3; j++)
 46 |     ctrlpoints[t][j] = (rand() % 1024 / 1024.0 - 0.5) * 10;
 47 |     }
 48 |     //动态映射
 49 |     glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
 50 |     */
 51 |     glLoadIdentity();
 52 |     glColor3f(1.0, 0.0, 0.0);
 53 |     //绘制连续线段
 54 |     glBegin(GL_LINE_STRIP);
 55 |     //参数t或u取值为i/30，共计31个点
 56 |     for (i = 0; i <= 30; i++)
 57 |         glEvalCoord1f((GLfloat)i / 30.0);   //根据4个控制点坐标的参数化插值
 58 |     glEnd();
 59 |     /* 显示控制点 */
 60 |     glPointSize(5.0);
 61 |     glBegin(GL_POINTS);
 62 |     for (i = 0; i < 4; i++)
 63 |         glVertex3fv(&ctrlpoints[i][0]);
 64 |     glEnd();
 65 | 
 66 |     glTranslatef(-0.1f, 0.1f, 0.0f);
 67 |     glColor3f(0.0, 1.0, 0.0);
 68 |     //glLineWidth(2.0);
 69 |     //绘制连续线段——线段数越多，曲线越光滑
 70 |     glBegin(GL_LINE_STRIP);
 71 |     //设置参数t或u取值为i/60，共计61个点
 72 |     //实验：若让t从-2变化到+2，可看到什么效果
 73 |     for (i = 0; i <= 60; i++)
 74 |         glEvalCoord1f((GLfloat)i / 60.0);  //根据4个控制点坐标的参数化插值
 75 |     glEnd();
 76 | 
 77 |     glTranslatef(-0.1f, 0.1f, 0.0f);
 78 |     glColor3f(1.0, 1.0, 1.0);
 79 |     //绘制连续线段
 80 |     glBegin(GL_LINE_STRIP);
 81 |     //设置参数t或u取值为i/60，共计61个点
 82 |     //实验：若让t从-2变化到+2，可看到什么效果
 83 |     for (i = 0; i <= 100; i++)
 84 |         glEvalCoord1f((GLfloat)i / 100.0);
 85 |     glEnd();
 86 | 
 87 |     glutSwapBuffers();
 88 | }
 89 | 
 90 | //3D空间中绘制2D效果，采用正交投影
 91 | void reshape(GLsizei w, GLsizei h)
 92 | {
 93 |     glViewport(0, 0, w, h);
 94 | 
 95 |     glMatrixMode(GL_PROJECTION);
 96 |     glLoadIdentity();
 97 |     if (w <= h)
 98 |         glOrtho(-5.0, 5.0, -5.0*(GLfloat)h / (GLfloat)w, 5.0*(GLfloat)h / (GLfloat)w, -5.0, 5.0);
 99 |     else
100 |         glOrtho(-5.0*(GLfloat)w / (GLfloat)h, 5.0*(GLfloat)w / (GLfloat)h, -5.0, 5.0, -5.0, 5.0);
101 | 
102 |     glMatrixMode(GL_MODELVIEW);
103 |     glLoadIdentity();
104 | }
105 | 
106 | void keyboard(unsigned char key, int x, int y)
107 | {
108 |     switch (key)
109 |     {
110 |     case 'x':
111 |     case 'X':
112 |     case 27:   //ESC键
113 |         exit(0);
114 |         break;
115 |     default:
116 |         break;
117 |     }
118 | }
119 | 
120 | int main(int argc, char** argv)
121 | {
122 |     srand((unsigned int)time(0));
123 |     glutInit(&argc, argv);
124 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//使用双缓存模式和深度缓存
125 |     glutInitWindowSize(800, 800);
126 |     glutInitWindowPosition(0, 0);
127 |     glutCreateWindow("2D Bezier曲线");
128 |     init();
129 |     glutDisplayFunc(display);
130 |     glutReshapeFunc(reshape);
131 |     glutKeyboardFunc(keyboard);
132 |     glutIdleFunc(display);//设置空闲时调用的函数
133 |     glutMainLoop();
134 |     return 0;
135 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/13_三次Bezier曲面线框模型/13_BesizerSurfaceWireframe.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | #include <GL/glut.h>
  5 | 
  6 | /* 控制点的坐标 */
  7 | GLfloat ctrlpoints[4][4][3] = {
  8 |     { { -1.5, -1.5, 2.0 },
  9 |     { -0.5, -1.5, 2.0 },
 10 |     { 0.5, -1.5, -1.0 },
 11 |     { 1.5, -1.5, 2.0 }
 12 |     },
 13 | 
 14 |     { { -1.5, -0.5, 1.0 },
 15 |     { -0.5, 1.5, 2.0 },
 16 |     { 0.5, 0.5, 1.0 },
 17 |     { 1.5, -0.5, -1.0 } },
 18 | 
 19 |     { { -1.5, 0.5, 2.0 },
 20 |     { -0.5, 0.5, 1.0 },
 21 |     { 0.5, 0.5, 3.0 },
 22 |     { 1.5, -1.5, 1.5 } },
 23 | 
 24 |     { { -1.5, 1.5, -2.0 },
 25 |     { -0.5, 1.5, -2.0 },
 26 |     { 0.5, 0.5, 1.0 },
 27 |     { 1.5, 1.5, -1.0 } } };
 28 | 
 29 | void init(void)
 30 | {
 31 |     //背景色
 32 |     glClearColor(0.0, 0.0, 0.0, 1.0);
 33 |     //将控制点坐标映射为曲面坐标
 34 |     //参数1：GL_MAP1_VERTEX_3，3维点坐标
 35 |     //参数2和3：控制参数u的取值范围[0, 1]
 36 |     //参数4：x方向元素间的步长为3个GLfloat
 37 |     //参数5：x方向曲线间的步长为4个控制点——曲线由4个控制点确定
 38 |     //参数6-7：控制参数v的取值范围[0, 1]
 39 |     //参数8：y方向元素间的步长为12个GLfloat元素
 40 |     //参数9：y方向每条曲线的控制点数量为4
 41 |     //注意: 若是在这里设置了相关参数，后续对ctrlpoints内容更改曲线不变
 42 |     glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &ctrlpoints[0][0][0]);
 43 |     //允许二维映射
 44 |     glEnable(GL_MAP2_VERTEX_3);
 45 |     //二维映射：x、y方向U和V的参数[0, 1]，且中间插值数量为各20个
 46 |     glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
 47 |     //允许深度测试
 48 |     glEnable(GL_DEPTH_TEST);
 49 | 
 50 |     //代码开关2：启用反走样
 51 |     glEnable(GL_BLEND);
 52 |     glEnable(GL_LINE_SMOOTH);
 53 |     glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST);  // Antialias the lines
 54 |     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 55 | }
 56 | 
 57 | void display(void)
 58 | {
 59 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 60 |     glColor3f(0.0, 1.0, 0.0);
 61 |     glPushMatrix();
 62 |     //代码开关1：去掉注释查看效果；更改旋转角度参数，查看效果
 63 |     //glRotatef(0.1, 1.0, 1.0, 1.0);
 64 |     int i, j;
 65 |     //生成2D网格坐标，以从控制点参数插值确定网格点所对应的点集所对应的坐标
 66 |     for (j = 0; j <= 8; j++)     {
 67 |         glBegin(GL_LINE_STRIP);
 68 |         for (i = 0; i <= 30; i++)
 69 |             glEvalCoord2f((GLfloat)i / 30.0, (GLfloat)j / 8.0);  //固定y坐标时x方向的网格坐标
 70 |         glEnd();
 71 | 
 72 |         glBegin(GL_LINE_STRIP);
 73 |         for (i = 0; i <= 30; i++)
 74 |             glEvalCoord2f((GLfloat)j / 8.0, (GLfloat)i / 30.0);  //固定x坐标时y方向的网格坐标     
 75 |         glEnd();
 76 |     }
 77 | 
 78 |     //查看网格所确定的插值点(u, v)的位置
 79 |     glColor3f(1, 0, 0);
 80 |     glBegin(GL_POINTS);
 81 |     for (j = 0; j <= 8; j++)     {
 82 |         for (i = 0; i <= 30; i++)
 83 |             glVertex3f((GLfloat)i / 30.0, (GLfloat)j / 8.0, 0);
 84 |         for (i = 0; i <= 30; i++)
 85 |             glVertex3f((GLfloat)j / 8.0, (GLfloat)i / 30.0, 0);
 86 |     }
 87 |     glEnd();
 88 |     glPopMatrix();
 89 |     glutSwapBuffers();
 90 | }
 91 | 
 92 | void reshape(GLsizei w, GLsizei h)
 93 | {
 94 |     glViewport(0, 0, w, h);
 95 |     glMatrixMode(GL_PROJECTION);
 96 |     glLoadIdentity();
 97 |     if (w <= h)
 98 |         glOrtho(-5.0, 5.0, -5.0*(GLfloat)h / (GLfloat)w, 5.0*(GLfloat)h / (GLfloat)w, -5.0, 5.0);
 99 |     else
100 |         glOrtho(-5.0*(GLfloat)w / (GLfloat)h, 5.0*(GLfloat)w / (GLfloat)h, -5.0, 5.0, -5.0, 5.0);
101 |     glMatrixMode(GL_MODELVIEW);
102 |     glLoadIdentity();
103 | }
104 | 
105 | void keyboard(unsigned char key, int x, int y)
106 | {
107 |     switch (key)
108 |     {
109 |     case 'x':
110 |     case 'X':
111 |     case 27:   //ESC键
112 |         exit(0);
113 |         break;
114 |     default:
115 |         break;
116 |     }
117 | }
118 | 
119 | int main(int argc, char** argv)
120 | {
121 |     srand((unsigned int)time(0));
122 |     glutInit(&argc, argv);
123 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//使用双缓存模式和深度缓存
124 |     glutInitWindowSize(800, 800);
125 |     glutInitWindowPosition(0, 0);
126 |     glutCreateWindow("Bezier曲面线框模型");
127 |     init();
128 |     glutDisplayFunc(display);
129 |     glutReshapeFunc(reshape);
130 |     glutKeyboardFunc(keyboard);
131 |     glutIdleFunc(display);//设置空闲时调用的函数
132 |     glutMainLoop();
133 |     return 0;
134 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/14_三次Bezier曲面并添加光照效果/14_BesizerSurface.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | #include <GL/glut.h>
  5 | /* 控制点的坐标 */
  6 | GLfloat ctrlpoints[4][4][3] = {
  7 |     { { -1.5, -1.5, 2.0 },
  8 |     { -0.5, -1.5, 2.0 },
  9 |     { 0.5, -1.5, -1.0 },
 10 |     { 1.5, -1.5, 2.0 } },
 11 | 
 12 |     { { -1.5, -0.5, 1.0 },
 13 |     { -0.5, 1.5, 2.0 },
 14 |     { 0.5, 0.5, 1.0 },
 15 |     { 1.5, -0.5, -1.0 } },
 16 | 
 17 |     { { -1.5, 0.5, 2.0 },
 18 |     { -0.5, 0.5, 1.0 },
 19 |     { 0.5, 0.5, 3.0 },
 20 |     { 1.5, -1.5, 1.5 } },
 21 | 
 22 |     { { -1.5, 1.5, -2.0 },
 23 |     { -0.5, 1.5, -2.0 },
 24 |     { 0.5, 0.5, 1.0 },
 25 |     { 1.5, 1.5, -1.0 } } };
 26 | 
 27 | void init(void)
 28 | {
 29 |     //背景色
 30 |     glClearColor(0.0, 0.0, 0.0, 1.0);
 31 |     //将控制点坐标映射为曲面坐标
 32 |     //参数1：GL_MAP1_VERTEX_3，3维点坐标
 33 |     //参数2和3：控制参数u的取值范围[0, 1]
 34 |     //参数4：x方向元素间的步长为3个GLfloat
 35 |     //参数5：x方向曲线间的步长为4个控制点——曲线由4个控制点确定
 36 |     //参数6-7：控制参数v的取值范围[0, 1]
 37 |     //参数8：y方向元素间的步长为12个GLfloat元素
 38 |     //参数9：y方向每条曲线的控制点数量为4
 39 |     //note: 若是在这里设置了相关参数，后续对ctrlpoints内容更改曲线不变
 40 |     glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &ctrlpoints[0][0][0]);
 41 |     //允许二维映射
 42 |     glEnable(GL_MAP2_VERTEX_3);
 43 |     //二维映射：x、y方向U和V的参数[0, 1]，且中间插值数量为各20个
 44 |     glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
 45 |     //允许深度测试
 46 |     glDepthFunc(GL_LESS);
 47 |     glEnable(GL_DEPTH_TEST);
 48 |     //代码开关4：取消下面两行代码，查看曲面显示效果差异
 49 |     //打开自动法矢量开关
 50 |     //glEnable(GL_AUTO_NORMAL);
 51 |     //允许正则化法矢量
 52 |     //glEnable(GL_NORMALIZE);
 53 | 
 54 |     //代码开关3：设置材质与光源
 55 |     GLfloat ambient[] = { 0.4, 0.6, 0.2, 1.0 };
 56 |     GLfloat position[] = { 0.0, 1.0, 3.0, 1.0 };
 57 |     GLfloat mat_diffuse[] = { 0.2, 0.4, 0.8, 1.0 };
 58 |     GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
 59 |     GLfloat mat_shininess[] = { 80.0 };
 60 |     glEnable(GL_LIGHTING);
 61 |     glEnable(GL_LIGHT0);
 62 |     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
 63 |     glLightfv(GL_LIGHT0, GL_POSITION, position);
 64 |     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
 65 |     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
 66 |     glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
 67 | }
 68 | 
 69 | void display(void)
 70 | {
 71 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 72 |     glColor3f(0.0, 1.0, 0.0);
 73 |     //如果不希望旋转，则启用push和pop矩阵命令，并注释掉glRotatef行
 74 |     //glPushMatrix();
 75 |     //代码开关1：去掉注释查看效果；更改旋转角度参数，查看效果
 76 |     glRotatef(1.0, 1.0, 1.0, 1.0);
 77 |     glEvalMesh2(GL_FILL, 0, 20, 0, 20);
 78 |     //glPopMatrix();
 79 |     glutSwapBuffers();
 80 | }
 81 | 
 82 | void reshape(GLsizei w, GLsizei h)
 83 | {
 84 |     glViewport(0, 0, w, h);
 85 |     glMatrixMode(GL_PROJECTION);
 86 |     glLoadIdentity();
 87 |     if (w <= h)
 88 |         glOrtho(-5.0, 5.0, -5.0*(GLfloat)h / (GLfloat)w, 5.0*(GLfloat)h / (GLfloat)w, -5.0, 5.0);
 89 |     else
 90 |         glOrtho(-5.0*(GLfloat)w / (GLfloat)h, 5.0*(GLfloat)w / (GLfloat)h, -5.0, 5.0, -5.0, 5.0);
 91 |     glMatrixMode(GL_MODELVIEW);
 92 |     glLoadIdentity();
 93 | }
 94 | 
 95 | void keyboard(unsigned char key, int x, int y)
 96 | {
 97 |     switch (key)
 98 |     {
 99 |     case 'x':
100 |     case 'X':
101 |     case 27:   //ESC键
102 |         exit(0);
103 |         break;
104 |     default:
105 |         break;
106 |     }
107 | }
108 | 
109 | int main(int argc, char** argv)
110 | {
111 |     srand((unsigned int)time(0));
112 |     glutInit(&argc, argv);
113 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//使用双缓存模式和深度缓存
114 |     glutInitWindowSize(800, 800);
115 |     glutInitWindowPosition(0, 0);
116 |     glutCreateWindow("Bezier曲面");
117 |     init();
118 |     glutDisplayFunc(display);
119 |     glutReshapeFunc(reshape);
120 |     glutKeyboardFunc(keyboard);
121 |     glutIdleFunc(display);//设置空闲时调用的函数
122 |     glutMainLoop();
123 |     return 0;
124 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/15_NURBS曲面并添加光照效果/15_NuresSurface.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <stdlib.h>
  3 | #include <time.h>
  4 | #include <GL/glut.h>
  5 | 
  6 | /* 控制点的坐标 */
  7 | GLfloat ctrlpoints[4][4][3] = {
  8 |     { { -1.5, -1.5, 2.0 },
  9 |     { -0.5, -1.5, 2.0 },
 10 |     { 0.5, -1.5, -1.0 },
 11 |     { 1.5, -1.5, 2.0 } },
 12 | 
 13 |     { { -1.5, -0.5, 1.0 },
 14 |     { -0.5, 1.5, 2.0 },
 15 |     { 0.5, 0.5, 1.0 },
 16 |     { 1.5, -0.5, -1.0 } },
 17 | 
 18 |     { { -1.5, 0.5, 2.0 },
 19 |     { -0.5, 0.5, 1.0 },
 20 |     { 0.5, 0.5, 3.0 },
 21 |     { 1.5, -1.5, 1.5 } },
 22 | 
 23 |     { { -1.5, 1.5, -2.0 },
 24 |     { -0.5, 1.5, -2.0 },
 25 |     { 0.5, 0.5, 1.0 },
 26 |     { 1.5, 1.5, -1.0 } } };
 27 | 
 28 | GLUnurbsObj *theNurb; // 指向一个NURBS曲面对象的指针
 29 | 
 30 | void init(void)
 31 | {
 32 |     //背景色
 33 |     glClearColor(0.0, 0.0, 0.0, 1.0);
 34 |     //代码开关3：设置材质与光源
 35 |     GLfloat ambient[] = { 0.4, 0.6, 0.2, 1.0 };
 36 |     GLfloat position[] = { 1.0, 1.0, 3.0, 1.0 };
 37 |     GLfloat mat_diffuse[] = { 0.8, 0.6, 0.3, 1.0 };
 38 |     GLfloat mat_specular[] = { 0.8, 0.6, 0.3, 1.0 };
 39 |     GLfloat mat_shininess[] = { 45.0 };
 40 | 
 41 |     glEnable(GL_LIGHTING);
 42 |     glEnable(GL_LIGHT0);
 43 |     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
 44 |     glLightfv(GL_LIGHT0, GL_POSITION, position);
 45 |     glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
 46 |     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
 47 |     glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
 48 | 
 49 |     //允许深度测试
 50 |     glDepthFunc(GL_LESS);
 51 |     glEnable(GL_DEPTH_TEST);
 52 |     //代码开关4：取消下面两行代码，查看曲面显示效果差异
 53 |     //打开自动法矢量开关
 54 |     glEnable(GL_AUTO_NORMAL);
 55 |     //允许正则化法矢量
 56 |     glEnable(GL_NORMALIZE);
 57 |     theNurb = gluNewNurbsRenderer(); // 创建一个NURBS曲面对象  
 58 |     //修改NURBS曲面对象的属性——glu库函数
 59 |     ////采样sampling容错torerance
 60 |     gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 5.0);
 61 |     gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
 62 | }
 63 | 
 64 | void display(void)
 65 | {
 66 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 67 |     glColor3f(0.0, 1.0, 0.0);
 68 |     //各控制点影响力参数设置
 69 |     GLfloat knots[8] = { 0.0, 0.0, 0.0, 0.0,
 70 |         1.0, 1.0, 1.0, 1.0 }; // NURBS曲面的控制向量      
 71 |     glRotatef(1.0, 0.7, -0.6, 1.0); // 旋转变换  
 72 |     gluBeginSurface(theNurb); // 开始曲面绘制 
 73 |     //网络查询：参数GL_MAP2_VERTEX_3的作用？
 74 |     //将
 75 |     gluNurbsSurface(theNurb, 8, knots, 8, knots, 4 * 3, 3, &ctrlpoints[0][0][0], 4, 4, GL_MAP2_VERTEX_3); // 定义曲面的数学模型，确定其形状  
 76 |     gluEndSurface(theNurb); // 结束曲面绘制  
 77 |     glutSwapBuffers();
 78 | }
 79 | 
 80 | void reshape(GLsizei w, GLsizei h)
 81 | {
 82 |     glViewport(0, 0, w, h);
 83 |     glMatrixMode(GL_PROJECTION);
 84 |     glLoadIdentity();
 85 |     if (w <= h)
 86 |         glOrtho(-5.0, 5.0, -5.0*(GLfloat)h / (GLfloat)w, 5.0*(GLfloat)h / (GLfloat)w, -5.0, 5.0);
 87 |     else
 88 |         glOrtho(-5.0*(GLfloat)w / (GLfloat)h, 5.0*(GLfloat)w / (GLfloat)h, -5.0, 5.0, -5.0, 5.0);
 89 |     glMatrixMode(GL_MODELVIEW);
 90 |     glLoadIdentity();
 91 | }
 92 | 
 93 | void keyboard(unsigned char key, int x, int y)
 94 | {
 95 |     switch (key)
 96 |     {
 97 |     case 'x':
 98 |     case 'X':
 99 |     case 27:   //ESC键
100 |         exit(0);
101 |         break;
102 |     default:
103 |         break;
104 |     }
105 | }
106 | 
107 | int main(int argc, char** argv)
108 | {
109 |     srand((unsigned int)time(0));
110 |     glutInit(&argc, argv);
111 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//使用双缓存模式和深度缓存
112 |     glutInitWindowSize(800, 800);
113 |     glutInitWindowPosition(0, 0);
114 |     glutCreateWindow("Bezier曲面");
115 | 
116 |     init();
117 | 
118 |     glutDisplayFunc(display);
119 |     glutReshapeFunc(reshape);
120 |     glutKeyboardFunc(keyboard);
121 |     glutIdleFunc(display);//设置空闲时调用的函数
122 | 
123 |     glutMainLoop();
124 |     return 0;
125 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/1_二维网络棋盘/1_chessboard.c:
--------------------------------------------------------------------------------
 1 | // opengltest1.cpp : Defines the entry point for the console application.
 2 | //
 3 | 
 4 | #include "stdafx.h"
 5 | #include <GL/glut.h>
 6 | const GLfloat d = 0.04;
 7 | //主函数每次显示调用的用户自定义显示函数
 8 | void myDisplay(void)
 9 | {
10 |     //清除色彩位缓冲区
11 |     glClear(GL_COLOR_BUFFER_BIT);
12 |     for (int i = -25; i < 25; i++)
13 |     {
14 |         for (int j = -25; j < 25; j++)
15 |         {
16 |             if (j%2==0)
17 |             {
18 |                 if (i%2==0)
19 |                 {
20 |                     //glRectf 按浮点坐标与矩形宽度和高度参数绘制矩形
21 |                     glRectf(j*d , d *i, (j + 1)*d , d *(i + 1));
22 |                 }
23 |             }
24 |             else
25 |             {
26 |                 if ((i+200)%2==1)
27 |                 {
28 |                     glRectf(j*d , d *i, (j + 1)*d , d *(i + 1));
29 |                 }
30 |             }
31 |         }
32 |     }
33 |     //按上述命令绘制图形，glFlush命令只适用于单缓冲模式
34 |     glFlush();
35 | }
36 | 
37 | int main(int argc, char *argv[])
38 | {
39 |     //初始化opengl工具箱函数库
40 |     glutInit(&argc,argv);
41 |     //设置RGB色彩模式与单缓冲绘图模式
42 |     glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
43 |     //设置图像显示窗口的左上角位置(0,0)
44 |     glutInitWindowPosition(0,0);
45 |     //设置窗口大小(600,600)
46 |     glutInitWindowSize(600,600);
47 |     //设置窗口标题
48 |     glutCreateWindow("Open GL 程序 Step 1");
49 |     //设置主程序循环显示过程中所调用的显示函数
50 |     //&myDisplay，表示取得函数名所对应的地址（函数地址）
51 |     glutDisplayFunc(&myDisplay);
52 |     //程序主循环
53 |     glutMainLoop();
54 |     return 0;
55 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/2_绘制三维对象_框架/2_3Dbasicframe.c:
--------------------------------------------------------------------------------
  1 | // opengltest2.cpp : Defines the entry point for the console application.
  2 | //
  3 | 
  4 | #include "stdafx.h"
  5 | #include <GL/glut.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <math.h>
  9 | #define PI 3.1415926
 10 | //金字塔初始旋转角度
 11 | GLfloat rtri = 0;
 12 | //用户自定义三维空间的齐次坐标矩阵(4X4)——用于输出查看变化矩阵的变化
 13 | typedef float Mat44[16];
 14 | //自定义初始化opengl 环境
 15 | void init(void)
 16 | {
 17 |     //设置背景色——用于填充背景
 18 |     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
 19 |     //设置多边形填充模式为smooth 方式
 20 |     glShadeModel(GL_SMOOTH);
 21 |     //打开深度测试开关——用于检测物体间的z 深度差异
 22 |     glEnable(GL_DEPTH_TEST);
 23 |     //线的抗锯齿开关
 24 |     glEnable(GL_LINE_SMOOTH);
 25 |     //启用抗锯齿效果
 26 |     glHint(GL_LINE_SMOOTH,GL_NICEST);
 27 |     //指定混合函数
 28 |     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 29 |     //启用色彩混合状态
 30 |     glEnable(GL_BLEND);
 31 | }
 32 | //输出4X4 矩阵的结果
 33 | void outputmat(const Mat44 &mat) {
 34 |     for(int i = 0; i < 4; i++) {
 35 |         for(int j = 0; j < 4; j++)
 36 |             printf("%.3f ", mat[i * 4 + j]);
 37 |         printf("\n");
 38 |     }
 39 | }
 40 | 
 41 | //自定义绘制圆函数
 42 | void glCircle()
 43 | {
 44 |     double n=50;//分段数
 45 |     float R=1.0;//半径
 46 |     int i;
 47 |     //将绘图前的模型变换矩阵压入堆栈
 48 |     glPushMatrix();
 49 |     //设置颜色RGB 与透明度值(0.5)
 50 |     glColor4f(0.0,0.2,0.8, 0.5);
 51 |     //发出准备绘图命令
 52 |     glBegin(GL_TRIANGLE_FAN);
 53 |     glVertex2f(0.0,0.0);
 54 |     for(i=0; i<=n; i++)
 55 |         glVertex2f(R*cos(2*PI/n*i), R*sin(2*PI/n*i));
 56 |     //发出结束绘图命令
 57 |     glEnd();
 58 |     //绘图后，恢复绘图前的模型变换矩阵
 59 |     //这样，对当前图形的变换对后面图形绘制不影响
 60 |     glPopMatrix();
 61 | }
 62 | 
 63 | //opengl 用户自定义绘图函数
 64 | void display(void)
 65 | {
 66 |     //清除颜色缓存和深度缓存
 67 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 68 |     //装入单位转换矩阵[1 0 0 0; 0 1 0 0; 0 0 1 0; 0 0 0 1]
 69 |     glLoadIdentity();
 70 |     //平移变换命令——之后绘制的所有对象将沿Z 轴向屏幕内移动5 个单位
 71 |     glTranslatef(0.0f,0.0f,-5.0f);
 72 |     //旋转变换命令——后绘制的所有对象将沿Y 轴正向旋转rtri 个角度单位
 73 |     glRotatef(rtri,0.0f,1.0f,0.0f);
 74 |     //以下绘制的对象沿X 轴转动10 度
 75 |     //glRotatef(10, 1, 0, 0);
 76 |     //查看当前的4X4 矩阵变量
 77 |     Mat44 mat;
 78 |     //取得模型-视图变换矩阵
 79 |     glGetFloatv(GL_MODELVIEW_MATRIX, mat);
 80 |     //在DOS 控制台查看上述变换后的总变换矩阵结果
 81 |     outputmat(mat);
 82 |     //设置点元大小为5 个像素
 83 |     glPointSize(5);
 84 |     //发出命令：开始绘制点
 85 |     glBegin(GL_POINTS);
 86 |     glColor3f(1, 0, 0);//点的颜色为红色
 87 |     glVertex3f(0.7, 0.5, 0.4);//顶点（vertex）位置：(0.7, 0.5, 0.4)
 88 |     glColor3f(1, 0, 0);
 89 |     glVertex3f(0.7, 0.5, -0.4);
 90 |     glEnd();//结束绘制点
 91 |     //绘制坐标轴--X，Y，Z
 92 |     glBegin(GL_LINES);
 93 |     glColor3f(1, 0, 0);
 94 |     glVertex3f(0, 0, 0);
 95 |     glVertex3f(3, 0, 0);
 96 |     glColor3f(0, 1, 0);
 97 |     glVertex3f(0,0,0);
 98 |     glVertex3f(0,3,0);
 99 |     glColor3f(0, 0, 1);
100 |     glVertex3f(0, 0, 0);
101 |     glVertex3f(0, 0, 3);
102 |     glEnd();
103 |     //绘制2 个三角形
104 |     glBegin(GL_TRIANGLES);
105 |     glColor4f(0, 0, 1, 0.5);
106 |     glVertex2f(-0.7, 0);
107 |     glVertex2f(0.5, 0);
108 |     glVertex2f(0, 0.5);
109 |     glColor4f(0, 1, 1, 0.5);
110 |     glVertex3f(-0.5, -0.2, 0);
111 |     glVertex3f(0.8, -0.2, 0.3);
112 |     glVertex3f(0, 0.2, -0.5);
113 |     glEnd();
114 |     //绘制实心的圆环——在原有变换基础上，又增加了新的变换；
115 |     //为了不影响后续对象的变换，采用压栈的方式，保存当前变换矩阵
116 |     glPushMatrix();
117 |     {
118 |         glTranslatef(0.0f, 0.0f, -3.0f);//用于实心圆环的变换
119 |         glColor4f(1.0f, 0.0f, 0.0f, 0.5);
120 |         glutSolidTorus(0.3, 0.7, 30.0f, 30.0f);//绘制实心圆环
121 |     }
122 |     glPopMatrix(); //从堆栈中恢复已压栈的变换矩阵
123 |     //绘制实心球
124 |     glPushMatrix();
125 |     {
126 |         glTranslatef(1.0f, 1.0f, 3.0f);//增加了变换
127 |         glColor4f(0.0f, 1.0f, 0.0f, 0.5);
128 |         glTranslatef(0.5, 0, 0);
129 |         glutSolidSphere(0.4f, 30.0f, 30.0f);//绘制球体
130 |         glTranslatef(0, 0, -50);
131 |         glutSolidSphere(0.4f, 30.0f, 30.0f);//绘制球体
132 |     }
133 |     glPopMatrix();
134 |     //glScalef( 2.0, 2.0, 0.0 ); //比例变换
135 |     //开始绘制直线段
136 |     glBegin(GL_LINES);
137 |     glColor3f(1, 0, 0);
138 |     glVertex3f(0, 0, 0);
139 |     glVertex3f(1, 0, 0);
140 |     glColor3f(0, 1, 0);
141 |     glVertex3f(0, 0, 0);
142 |     glVertex3f(0, 1, 0);
143 |     glColor3f(0, 0, 1);
144 |     glVertex3f(0, 0, 0);
145 |     glVertex3f(0, 0, 1);
146 |     glEnd();
147 |     //平移变换
148 |     glTranslatef(-2, 0, 0);
149 |     glCircle();
150 |     //平移变换
151 |     glTranslatef(2, 0, 0);
152 |     //绘制立方体线框
153 |     glColor4f(1, 1, 1, 0.5);
154 |     glRotatef(30, 1, 0, 0);
155 |     glutWireCube(1);
156 |     rtri += 0.3;//全局的旋转变量加0.3 度      
157 |     //用缓冲区所绘制的对象替换窗口内容——适合于双缓冲技术
158 |     glutSwapBuffers();//交换双缓存
159 | }
160 | 
161 | //用户自定义窗口调整大小事件的处理函数
162 | //在这个函数中要求设置视口、投影、透视变换的相关参数
163 | void reshape (int w, int h)
164 | {
165 |     //设置视口参数为整个窗口范围内
166 |     glViewport(0, 0, (GLsizei) w, (GLsizei) h);
167 |     //设置投影参数:投影矩阵初始为单位阵
168 |     glMatrixMode (GL_PROJECTION);
169 |     glLoadIdentity();
170 |     //设置透视参数: 眼睛或摄像机的视角参数为60 度，视景体的宽度和高度比，视距（焦距）
171 |     //(near)和视径(far)参数
172 |     //near = 1, far = 100, Z 轴负向顺着视线方向指向屏幕内
173 |     //X 轴正向向右，Y 轴正向向上，坐标原点在屏幕中心处
174 |     gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 100.0);
175 |     //设置摄像机的位置及姿态参数:
176 |     //摄像机位置(cX, cY, cZ)
177 |     //视点所观察中心位置Ow(oX, oY, oZ)
178 |     //摄像机位姿参数——摄像机顶部矢量
179 |     gluLookAt(0, 0, 5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
180 |     //设置矩阵模式为模型-视图变换模式，以便于后面的自定义显示函数继续本模式
181 |     glMatrixMode(GL_MODELVIEW);
182 |     glLoadIdentity();
183 | }
184 | 
185 | //用户自定义键盘事件处理函数
186 | void keyboard(unsigned char key, int x, int y)
187 | {
188 |     switch (key)
189 |     {
190 |         case 'x':
191 |         case 27: //ESC 键盘
192 |         exit(0);
193 |         break;
194 |         default:
195 |         break;
196 |     }
197 | }
198 | 
199 | int main(int argc, char** argv)
200 | {
201 |     //用命令行参数初始化OpenGL
202 |     glutInit(&argc, argv);
203 |     //使用RGB 色彩、双缓存和深度模式
204 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
205 |     //初始化绘图窗口大小参数
206 |     glutInitWindowSize(1024, 768);
207 |     //窗口左上角坐标参数
208 |     glutInitWindowPosition(0, 0);
209 |     //创建窗口
210 |     glutCreateWindow("OpenGL HelloWorld");
211 |     //用户自定义初始化绘图环境函数
212 |     init();
213 |     //用户指定的绘图函数，display 名可变
214 |     glutDisplayFunc(display);
215 |     //窗口调整大小事件的处理函数
216 |     glutReshapeFunc(reshape);
217 |     //窗口键盘处理事件的处理函数
218 |     glutKeyboardFunc(keyboard);
219 |     //设置窗口空闲时调用的函数
220 |     glutIdleFunc(display);
221 |     //进入glut 函数库的主循环
222 |     glutMainLoop();
223 |     return 0;
224 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/3_绘制平滑着色的三角形/3_DrawTriangle.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | //三角形的绘制程序
  3 | #include <GL/glut.h>
  4 | 
  5 | //旋转参数
  6 | static GLfloat xRot=0.0f;
  7 | static GLfloat yRot=0.0f;
  8 | 
  9 | //确定多边形绕法的方向
 10 | bool bWinding = true;
 11 | 
 12 | //初始化窗口
 13 | void init()
 14 | {
 15 |     //设置窗口背景颜色为黑色
 16 |     glClearColor(0.0f,0.0f,0.0f,1.0f);
 17 | }
 18 | 
 19 | //显示函数：绘制几何体的命令
 20 | void display()
 21 | {
 22 |     //清除背景
 23 |     glClear(GL_COLOR_BUFFER_BIT);
 24 | 
 25 |     glPushMatrix();  //把当前变换矩阵压入堆栈
 26 | 
 27 |     glRotatef(xRot,1.0f,0.0f,0.0f);//使整个场景绕着x轴旋转
 28 |     glRotatef(yRot,0.0f,1.0f,0.0f);//使整个场景绕着y轴旋转
 29 | 
 30 |     //设置点的大小和线宽
 31 |     glPointSize(5);
 32 |     glLineWidth(5);
 33 | 
 34 |     //设置多边形绕法的方向是顺时针还是逆时针
 35 |     if (bWinding)
 36 |     {
 37 |         glFrontFace(GL_CW);   //CW---clock wise顺时针
 38 |     }
 39 |     else
 40 |     {
 41 |         glFrontFace(GL_CCW);  //CCW---
 42 |     }
 43 | 
 44 |     //绘制三角形
 45 |     glBegin(GL_TRIANGLES);
 46 |         glColor3f(0.8f,1.0f,0.0f);
 47 |         glVertex3f(0,30,30);
 48 | 
 49 |         glColor3f(1.0f,0.0f,0.0f);
 50 |         glVertex3f(-40,-40,40);
 51 | 
 52 |         glColor3f(0.0f,0.0f,1.0f);
 53 |         glVertex3f(40,-40,0);
 54 | 
 55 |         glColor3f(0.0f,0.0f,1.0f);
 56 |         glVertex3f(60,-20,0);
 57 | 
 58 |         glColor3f(0.0f,0.7f,1.0f);
 59 |         glVertex3f(30,-60,0);
 60 |     glEnd();
 61 | 
 62 |     glBegin(GL_LINES);
 63 |         glVertex3f(-100.3, 10.2, 10.5);
 64 |         glVertex3f(60, -10.2, -11);
 65 |     glEnd();
 66 | 
 67 |     glPopMatrix();  //还原
 68 | 
 69 |     glutSwapBuffers();//刷新命令缓冲区
 70 | }
 71 | 
 72 | void reshape(int w,int h)
 73 | {
 74 |     if (h == 0)
 75 |     {
 76 |         h = 1;
 77 |     }
 78 |     glViewport(0,0,w,h);
 79 |     
 80 |     glMatrixMode(GL_PROJECTION);  //矩阵模式：投影视图
 81 |     glLoadIdentity();
 82 |     if (w <= h)
 83 | {
 84 |     //正交参数设置：x=[-100, 100], y=[-100.0*h/w, 100.0*h/w], z=[-100,100]
 85 |         glOrtho(-100.0f,100.0f,-100.0f*h/w,100.0f*h/w,-100.0f,100.0f);
 86 |     }
 87 |     else
 88 |     {
 89 |         glOrtho(-100.0f*w/h,100.0f*w/h,-100.0f,100.0f,-100.0f,100.0f);
 90 |     }
 91 | 
 92 |     glMatrixMode(GL_MODELVIEW);  //矩阵模式：模型视图
 93 |     glLoadIdentity();
 94 | }
 95 | 
 96 | //由键盘控制旋转
 97 | void SpecialKeys(int key,int x,int y)
 98 | {
 99 |     if (key == GLUT_KEY_UP) 
100 |         xRot -=5.0f;
101 |     if (key == GLUT_KEY_DOWN) 
102 |         xRot +=5.0f;
103 |     if (key == GLUT_KEY_LEFT) 
104 |         yRot -=5.0f;
105 |     if (key == GLUT_KEY_RIGHT) 
106 |         yRot +=5.0f;
107 |     
108 |     if (xRot > 356.0f) 
109 |         xRot = 0.0f; 
110 |     if (xRot < -1.0f) 
111 |         xRot = 355.0f; 
112 |     if (yRot > 356.0f) 
113 |         yRot = 0.0f; 
114 |     if (yRot < -1.0f) 
115 |         yRot = 355.0f;
116 |     glutPostRedisplay();//刷新窗口
117 | }
118 | 
119 | //菜单处理
120 | void ProcessMenu(int value)
121 | {
122 |     switch(value)
123 |     {
124 |     case 1:
125 |         {
126 |             //修改多边形正面为填充模式
127 |             glPolygonMode(GL_FRONT,GL_FILL);
128 |             break;
129 |         }
130 |     case 2:
131 |         {
132 |             //修改多边形正面为线模式
133 |             glPolygonMode(GL_FRONT,GL_LINE);
134 |             break;
135 |         }
136 |     case 3:
137 |         {
138 |             //修改多边形正面为点填充模式
139 |             glPolygonMode(GL_FRONT,GL_POINT);
140 |             break;
141 |         }
142 |     case 4:
143 |         {
144 |             //修改多边形背面为填充模式
145 |             glPolygonMode(GL_BACK,GL_FILL);
146 |             break;
147 |         }
148 |     case 5:
149 |         {
150 |             //修改多边形背面为线模式
151 |             glPolygonMode(GL_BACK,GL_LINE);
152 |             break;
153 |         }
154 |     case 6:
155 |         {
156 |             //修改多边形背面为点填充模式
157 |             glPolygonMode(GL_BACK,GL_POINT);
158 |             break;
159 |         }
160 |     case 7:
161 |         {
162 |             //设置多边形的阴影模式为平面明暗模式
163 |             glShadeModel(GL_FLAT);
164 |             break;
165 |         }
166 |     case 8:
167 |         {
168 |             //设置多边形的阴影模式为光滑明暗模式
169 |             glShadeModel(GL_SMOOTH);
170 |             break;
171 |         }
172 |     case 9:
173 |         {
174 |             bWinding = !bWinding;
175 |             break;
176 |         } 
177 |     default:
178 |         break;
179 |     }
180 |     //提交修改并强制重新绘图
181 |     glutPostRedisplay();
182 | }
183 | 
184 | void main()
185 | {    
186 |     init();    
187 |     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);  //双缓冲
188 |     glutCreateWindow("多边形演示");
189 | 
190 |     glutDisplayFunc(display);
191 |     glutReshapeFunc(reshape);
192 |     glutSpecialFunc(SpecialKeys);//设置特殊键响应回调函数
193 | 
194 |     //菜单的句柄
195 |     int nModeMenu;
196 |     int nMainMenu;
197 |     int nColorMenu;
198 | 
199 |     //创建一个子菜单并定于菜单回调函数
200 |     nModeMenu = glutCreateMenu(ProcessMenu);
201 |     //添加菜单项，1表示选择菜单条目时传递的参数值
202 |     glutAddMenuEntry("正面多边形填充模式",1);
203 |     glutAddMenuEntry("正面线框模式",2);
204 |     glutAddMenuEntry("正面点模式",3);
205 |     glutAddMenuEntry("反面多边形填充模式",4);
206 |     glutAddMenuEntry("反面线框模式",5);
207 |     glutAddMenuEntry("反面点模式",6);
208 |     
209 |     //添加一个子菜单
210 |     nColorMenu = glutCreateMenu(ProcessMenu);
211 |     glutAddMenuEntry("平面明暗模式",7);
212 |     glutAddMenuEntry("光滑明暗模式",8);
213 | 
214 |     //创建主菜单
215 |     nMainMenu = glutCreateMenu(ProcessMenu);
216 |     glutAddSubMenu("多边形模式",nModeMenu);
217 |     glutAddSubMenu("颜色模式",nColorMenu);
218 |     glutAddMenuEntry("改变绕法",9);
219 |  
220 |     //将创建的菜单与右键关联，即把菜单设置为右键弹出式菜单
221 |     glutAttachMenu(GLUT_RIGHT_BUTTON);
222 |     
223 |     glutMainLoop();
224 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/4_相交区域的混合着色/4_MixColor.c:
--------------------------------------------------------------------------------
 1 | #include <GL/glut.h>
 2 | #include <stdlib.h>
 3 | 
 4 | static int leftFirst = GL_TRUE;
 5 | 
 6 | /*  Initialize alpha blending function.
 7 |  */
 8 | static void init(void)
 9 | {
10 |    glEnable (GL_BLEND);
11 |    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
12 |    //glBlendFunc(GL_ONE, GL_ONE);
13 |    glShadeModel (GL_FLAT);
14 |    glClearColor (0.0, 0.0, 0.0, 0.0);
15 | }
16 | 
17 | static void drawLeftTriangle(void)
18 | {
19 |    /* draw yellow triangle on LHS of screen */
20 | 
21 |    glBegin (GL_TRIANGLES);
22 |       glColor4f(1.0, 0.0, 0.0, 0.55);
23 |       glVertex3f(0.1, 0.9, 0.0); 
24 |       glVertex3f(0.1, 0.1, 0.0); 
25 |       glVertex3f(0.7, 0.5, 0.0); 
26 |    glEnd();
27 | }
28 | 
29 | static void drawRightTriangle(void)
30 | {
31 |    /* draw cyan triangle on RHS of screen */
32 | 
33 |    glBegin (GL_TRIANGLES);
34 |       glColor4f(0.0, 1.0, 0.0, 0.55);
35 |       glVertex3f(0.9, 0.9, 0.0); 
36 |       glVertex3f(0.3, 0.5, 0.0); 
37 |       glVertex3f(0.9, 0.1, 0.0); 
38 |    glEnd();
39 | }
40 | 
41 | void display(void)
42 | {
43 |    glClear(GL_COLOR_BUFFER_BIT);
44 | 
45 |    if (leftFirst) {
46 |       drawLeftTriangle();
47 |       drawRightTriangle();
48 |    }
49 |    else {
50 |       drawRightTriangle();
51 |       drawLeftTriangle();
52 |    }
53 | 
54 |    glFlush();
55 | }
56 | 
57 | void reshape(int w, int h)
58 | {
59 |    glViewport(0, 0, (GLsizei) w, (GLsizei) h);
60 | 
61 |    glMatrixMode(GL_PROJECTION);
62 |    glLoadIdentity();
63 | //2D正交投影参数
64 |    if (w <= h) 
65 |       gluOrtho2D (0.0, 1.0, 0.0, 1.0*(GLfloat)h/(GLfloat)w);
66 |    else 
67 |       gluOrtho2D (0.0, 1.0*(GLfloat)w/(GLfloat)h, 0.0, 1.0);
68 | }
69 | 
70 | void keyboard(unsigned char key, int x, int y)
71 | {
72 |    switch (key) {
73 |       case 't':
74 |       case 'T':
75 |          leftFirst = !leftFirst;
76 |          glutPostRedisplay();    
77 |          break;
78 |       case 27:  /*  Escape key  */
79 |          exit(0);
80 |          break;
81 |       default:
82 |          break;
83 |    }
84 | }
85 | 
86 | int main(int argc, char** argv)
87 | {
88 |    glutInit(&argc, argv);
89 |    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
90 |    glutInitWindowSize (200, 200);
91 |    glutCreateWindow (argv[0]);
92 |    init();
93 |    glutReshapeFunc (reshape);
94 |    glutKeyboardFunc (keyboard);
95 |    glutDisplayFunc (display);
96 |    glutMainLoop();
97 |    return 0;
98 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/5_3D茶壶/5_3DTeapot.c:
--------------------------------------------------------------------------------
 1 | //绘制茶壶
 2 | #include "stdafx.h"
 3 | #include <GL/glut.h>
 4 | #include <stdlib.h>
 5 | 
 6 | //自定义初始化opengl函数
 7 | void init(void)
 8 | {
 9 |     //材质反光性设置
10 |     GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };  //镜面反射参数
11 |     GLfloat mat_shininess[] = { 50.0 };               //高光指数
12 |     GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
13 |     GLfloat white_light[] = { 1.0, 1.0, 1.0, 1.0 };   //灯位置(1,1,1), 最后1-开关
14 |     GLfloat Light_Model_Ambient[] = { 0.2, 0.2, 0.2, 1.0 }; //环境光参数
15 | 
16 |     glClearColor(0.0, 0.0, 0.0, 0.0);  //背景色
17 |     glShadeModel(GL_SMOOTH);           //多变性填充模式
18 | 
19 |     //材质属性
20 |     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
21 |     glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
22 | 
23 |     //灯光设置
24 |     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
25 |     glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);   //散射光属性
26 |     glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);  //镜面反射光
27 |     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, Light_Model_Ambient);  //环境光参数
28 | 
29 |     glEnable(GL_LIGHTING);   //开关:使用光
30 |     glEnable(GL_LIGHT0);     //打开0#灯
31 |     glEnable(GL_DEPTH_TEST); //打开深度测试
32 | }
33 | 
34 | void display(void)
35 | {
36 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
37 |     glutSolidTeapot(0.5);
38 | 
39 |     /*
40 |     glBegin(GL_QUADS);
41 |     glVertex3f(0, 0, 10);
42 |     glVertex3f(0, 0, 10);
43 |     glVertex3f(20, 5, 10);
44 |     glVertex3f(30, 40, -10);
45 |     glEnd();
46 |     */
47 | 
48 |     glFlush();   //glSwapBuffers();
49 | }
50 | 
51 | void reshape(int w, int h)
52 | {
53 |     glViewport(0, 0, (GLsizei)w, (GLsizei)h);
54 | 
55 |     //设置投影参数
56 |     glMatrixMode(GL_PROJECTION);
57 |     glLoadIdentity();
58 |     //正交投影
59 |     if (w <= h)
60 |         glOrtho(-1.5, 1.5, -1.5*(GLfloat)h / (GLfloat)w, 1.5*(GLfloat)h / (GLfloat)w, -10.0, 10.0);
61 |     else
62 |         glOrtho(-1.5*(GLfloat)w / (GLfloat)h, 1.5*(GLfloat)w / (GLfloat)h, -1.5, 1.5, -10.0, 10.0);
63 | 
64 |     //设置模型参数--几何体参数
65 |     glMatrixMode(GL_MODELVIEW);
66 |     glLoadIdentity();
67 | }
68 | 
69 | int main(int argc, char** argv)
70 | {
71 |     glutInit(&argc, argv);
72 |     glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
73 |     glutInitWindowSize(500, 500);
74 |     glutInitWindowPosition(100, 100);
75 |     glutCreateWindow("茶壶");
76 | 
77 |     init();
78 | 
79 |     glutDisplayFunc(display);
80 |     glutReshapeFunc(reshape);
81 | 
82 |     glutMainLoop();
83 |     return 0;
84 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/6_太阳系/6_SolarSystem.c:
--------------------------------------------------------------------------------
 1 | //绘制太阳系
 2 | #include "stdafx.h"
 3 | #include <GL/glut.h>
 4 | #include <stdlib.h>
 5 | 
 6 | static int year = 0, day = 0, moon = 0;
 7 | 
 8 | void init(void)
 9 | {
10 |     glClearColor(0.0, 0.0, 0.0, 0.0);
11 |     glShadeModel(GL_SMOOTH);
12 | }
13 | 
14 | void display(void)
15 | {
16 |     glClear(GL_COLOR_BUFFER_BIT);
17 |     glColor3f(1.0, 1.0, 1.0);
18 |     glPushMatrix();
19 |     glColor3f(1.0, 0.0, 0.0);
20 |     glutSolidSphere(1.0, 20, 16); /* draw sun */
21 | 
22 |     glRotatef((GLfloat)year, 0.0, 1.0, 0.0);
23 |     glTranslatef(2.0, 0.0, 0.0);
24 |     glRotatef((GLfloat)day, 0.0, 1.0, 0.0);
25 |     glColor3f(0.0, 0.0, 1.0);
26 |     glutSolidSphere(0.3, 10, 8); /* draw earth */
27 | 
28 |     glTranslatef(1.0, 0.0, 0.0);
29 |     glRotatef((GLfloat)moon, 0.0, 1.0, 0.0);
30 |     glColor3f(1.0, 1.0, 1.0);
31 |     glutSolidSphere(0.2, 10, 8); /* draw moon */
32 |     glPopMatrix();
33 |     glutSwapBuffers();
34 | }
35 | 
36 | void reshape(int w, int h)
37 | {
38 |     glViewport(0, 0, (GLsizei)w, (GLsizei)h);
39 |     glMatrixMode(GL_PROJECTION);
40 |     glLoadIdentity();
41 |     gluPerspective(60.0, (GLfloat)w / (GLfloat)h, 1.0, 20.0);
42 |     glMatrixMode(GL_MODELVIEW);
43 |     glLoadIdentity();
44 |     gluLookAt(0.0, 5.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
45 | }
46 | 
47 | void keyboard(unsigned char key, int x, int y)
48 | {
49 |     switch (key) {
50 |     case 'd':
51 |         day = (day + 10) % 360;
52 |         moon = (moon + 5) % 360;
53 |         glutPostRedisplay();
54 |         break;
55 |     case 'D':
56 |         day = (day - 10) % 360;
57 |         glutPostRedisplay();
58 |         break;
59 |     case 'y':
60 |         year = (year + 5) % 360;
61 |         day = (day + 10) % 360;
62 |         moon = (moon + 5) % 360;
63 |         glutPostRedisplay();
64 |         break;
65 |     case 'Y':
66 |         year = (year - 5) % 360;
67 |         glutPostRedisplay();
68 |         break;
69 |     case 'm':
70 |         moon = (moon + 5) % 360;
71 |         glutPostRedisplay();
72 |         break;
73 |     case 27:
74 |         exit(0);
75 |         break;
76 |     default:
77 |         break;
78 |     }
79 | }
80 | 
81 | int main(int argc, char** argv)
82 | {
83 |     glutInit(&argc, argv);
84 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
85 |     glutInitWindowSize(800, 600);
86 |     glutInitWindowPosition(100, 100);
87 |     glutCreateWindow(argv[0]);
88 |     init();
89 |     glutDisplayFunc(display);
90 |     glutReshapeFunc(reshape);
91 |     glutKeyboardFunc(keyboard);
92 |     glutMainLoop();
93 |     return 0;
94 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/7_绘制正方形/7_DrawCube.c:
--------------------------------------------------------------------------------
 1 | #include <GL/glut.h>
 2 | void display()  //定义了所要绘制的图形实体
 3 | {
 4 |     glClear(GL_COLOR_BUFFER_BIT);
 5 |     glBegin(GL_POLYGON);
 6 |         glVertex2f(-0.5, -0.5);
 7 |         glVertex2f(-0.5, 0.5);
 8 |         glVertex2f(0.5, 0.5);
 9 |         glVertex2f(0.5, -0.5);
10 |     glEnd();
11 |     glFlush();
12 | }
13 | 
14 | int main(int argc, char ** argv)  //OpenGL的初始化
15 | {
16 |     glutInit(&argc, argv);
17 |     glutCreateWindow("simple");
18 |     glutDisplayFunc(display);
19 |     glutMainLoop();
20 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/8_立方体表面纹理贴图/8_CubeTexture.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <GL/glut.h>  //引用相关包
  3 | #include <windows.h>
  4 | #include <GL/glaux.h>
  5 | #include <stdio.h>
  6 | #include <stdlib.h>
  7 | 
  8 | //注意下面的编译指令——告诉编译器要连接的静态库
  9 | #pragma comment(lib, "glut32.lib")
 10 | #pragma comment(lib, "glaux.lib")
 11 | 
 12 | GLfloat  xrot = 0;   // X 旋转量
 13 | GLfloat  yrot = 0;   // Y 旋转量
 14 | GLfloat  zrot = 0;   // Z 旋转量
 15 | GLuint  texture[1];  // 存储一个纹理---数组
 16 | 
 17 | //载入位图图象到内存——固定用法
 18 | AUX_RGBImageRec *LoadBMP(CHAR *Filename)
 19 | {
 20 |     FILE *File = NULL;         // 文件句柄
 21 |     if (!Filename)          // 确保文件名已提供
 22 |     {
 23 |         return NULL;         // 如果没提供，返回 NULL
 24 |     }
 25 |     File = fopen(Filename, "r");       // 尝试打开文件
 26 |     if (File)           // 判断文件存在与否 
 27 |     {
 28 |         fclose(File);         // 关闭句柄
 29 |         return auxDIBImageLoadA(Filename);    // 载入位图并返回指针
 30 |     }
 31 |     return NULL;          // 如果载入失败，返回 NULL
 32 | }
 33 | 
 34 | //载入位图(调用上面的代码)并转换成纹理——固定用法
 35 | //参数：纹理指针、bmp文件名、用户指定的纹理编号
 36 | int LoadGLTextures(GLuint *texture, char *bmp_file_name, int texture_id)
 37 | {
 38 |     int Status = FALSE;         // 状态指示器
 39 |     // 创建纹理的存储空间
 40 |     AUX_RGBImageRec *TextureImage[1];
 41 |     memset(TextureImage, 0, sizeof(void *) * 1);   // 将指针设为 NULL
 42 |     // 载入位图，检查有无错误，如果位图没找到则退出
 43 |     if (TextureImage[0] = LoadBMP(bmp_file_name))
 44 |     {
 45 |         Status = TRUE;         // 将 Status 设为 TRUE
 46 |         //生成(generate)纹理
 47 |         glGenTextures(texture_id, texture); //&texture[0]);     
 48 |         //绑定2D纹理对象
 49 |         glBindTexture(GL_TEXTURE_2D, *texture); //texture[0]);
 50 |         //关联图像数据与纹理对象
 51 |         glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
 52 |         //图形绘制时所使用的滤波器参数
 53 |         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // 线形滤波
 54 |         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // 线形滤波
 55 |     }
 56 | 
 57 |     //释放图像的内存，因为已经生成纹理了，没用了
 58 |     if (TextureImage[0])        // 纹理是否存在
 59 |     {
 60 |         if (TextureImage[0]->data)      // 纹理图像是否存在
 61 |         {
 62 |             free(TextureImage[0]->data);    // 释放纹理图像占用的内存
 63 |         }
 64 |         free(TextureImage[0]);       // 释放图像结构
 65 |     }
 66 |     else
 67 |         printf("纹理不存在");
 68 |     return Status;          // 返回 Status
 69 | }
 70 | 
 71 | void DrawCube(void)         // 从这里开始进行所有的绘制
 72 | {
 73 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 清除屏幕和深度缓存
 74 | 
 75 |     glLoadIdentity();         // 重置当前的模型观察矩阵
 76 | 
 77 |     glTranslatef(0.0f, 0.0f, -5.0f);         // 移入屏幕 5 个单位
 78 |     glRotatef(xrot, 1.0f, 0.0f, 0.0f);         // 绕X轴旋转
 79 |     glRotatef(yrot, 0.0f, 1.0f, 0.0f);         // 绕Y轴旋转
 80 |     glRotatef(zrot, 0.0f, 0.0f, 1.0f);         // 绕Z轴旋转
 81 | 
 82 |     glBindTexture(GL_TEXTURE_2D, texture[0]);      // 选择纹理
 83 |     glBegin(GL_QUADS);
 84 |     // 前面
 85 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
 86 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
 87 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的右上
 88 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的左上
 89 |     // 后面
 90 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的右下
 91 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
 92 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
 93 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的左下
 94 |     // 顶面
 95 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
 96 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的左下
 97 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的右下
 98 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
 99 |     // 底面
100 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的右上
101 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的左上
102 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
103 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
104 |     // 右面
105 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, -1.0f, -1.0f); // 纹理和四边形的右下
106 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, 1.0f, -1.0f); // 纹理和四边形的右上
107 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(1.0f, 1.0f, 1.0f); // 纹理和四边形的左上
108 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(1.0f, -1.0f, 1.0f); // 纹理和四边形的左下
109 |     // 左面
110 |     glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f); // 纹理和四边形的左下
111 |     glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // 纹理和四边形的右下
112 |     glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // 纹理和四边形的右上
113 |     glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f); // 纹理和四边形的左上
114 |     glEnd();
115 | 
116 |     glFlush(); //glutSwapBuffers();
117 | 
118 |     xrot += 0.3f;              // X 轴旋转
119 |     yrot += 0.2f;              // Y 轴旋转
120 |     zrot += 0.4f;              // Z 轴旋转
121 | }
122 | 
123 | void display(void)
124 | {
125 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // 清楚颜色数据和深度数据（清屏）
126 |     glLoadIdentity();                                    // 重置视图
127 |     glTranslatef(0.0f, 0.0f, -5.0f);
128 |     DrawCube();
129 |     glutSwapBuffers();            //交换缓冲区。显示图形
130 | }
131 | 
132 | //初始化
133 | void init(void)
134 | {
135 |     glClearColor(1.0, 1.0, 1.0, 0.0);            //清理颜色，为黑色，（也可认为是背景颜色）
136 |     glCullFace(GL_BACK);                        //背面裁剪(背面不可见)
137 |     glEnable(GL_CULL_FACE);                        //启用裁剪
138 |     glEnable(GL_TEXTURE_2D);
139 |     LoadGLTextures(&texture[0], "mf.bmp", 1);            //载入纹理贴图
140 |     //LoadGLTextures(&texture[1], "mf1.bmp", 2);            //载入纹理贴图
141 | }
142 | 
143 | //当窗口大小改变时，会调用这个函数
144 | void reshape(GLsizei w, GLsizei h)
145 | {
146 |     //这里小说明一下：矩阵模式是不同的，他们各自有一个矩阵。投影相关
147 |     //只能用投影矩阵。(只是目前情况下哦，等我学多了可能就知道为什么了。)
148 |     glViewport(0, 0, w, h);        //设置视口
149 |     glMatrixMode(GL_PROJECTION);    //设置矩阵模式为投影变换矩阵，
150 |     glLoadIdentity();                //变为单位矩阵
151 |     gluPerspective(60, (GLfloat)w / h, 0, 1000);    //设置投影矩阵
152 | 
153 |     glMatrixMode(GL_MODELVIEW);        //设置矩阵模式为视图矩阵(模型)
154 |     glLoadIdentity();                //变为单位矩阵
155 | }
156 | 
157 | //键盘输入事件函数
158 | void keyboard(unsigned char key, int x, int y)
159 | {
160 |     switch (key)
161 |     {
162 |     case 'x':    //当按下键盘上d时，以沿X轴旋转为主
163 |         xrot += 1.0f;   //设置旋转增量
164 |         glutPostRedisplay();   //重绘函数
165 |         break;
166 |     case 'y':
167 |         yrot += 1.0f;
168 |         glutPostRedisplay();
169 |         break;
170 |     case 'z':
171 |         zrot += 1.0f;
172 |         glutPostRedisplay();
173 |         break;
174 |     default:
175 |         break;
176 |     }
177 | }
178 | 
179 | int main(int argc, char *argv[])
180 | {
181 |     glutInit(&argc, argv);  //固定格式
182 |     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);    //注意这里
183 |     glutInitWindowSize(600, 600);    //显示框的大小
184 |     glutInitWindowPosition(100, 100); //确定显示框左上角的位置
185 |     glutCreateWindow("OpenGL纹理贴图");
186 |     init();  //初始化资源,这里一定要在创建窗口以后，不然会无效。
187 |     LoadGLTextures(&texture[0], "mf.bmp", 1);
188 |     glutDisplayFunc(display);
189 |     glutReshapeFunc(reshape);                //绘制图形时的回调
190 |     glutKeyboardFunc(keyboard);
191 |     glutMainLoop();
192 |     return 0;
193 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/9_粒子的随机运动/9_ParticlesRandomMotion.c:
--------------------------------------------------------------------------------
  1 | #include "stdafx.h"
  2 | #include <GL/glut.h>
  3 | #include <stdlib.h>   //srand和rand
  4 | #include <time.h>   //time(int)
  5 | 
  6 | const int N = 2000;
  7 | float particles[N][3];
  8 | float rtri = 0;
  9 | 
 10 | // 初始化材质属性、光源、光照模型、深度缓冲区
 11 | void init(void)
 12 | {
 13 |     //材质反光性设置
 14 |     GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };  //镜面反射参数
 15 |     GLfloat mat_shininess[] = { 50.0 };               //高光指数
 16 |     GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
 17 |     GLfloat white_light[] = { 1.0, 1.0, 1.0, 1.0 };   //灯位置(1,1,1), 最后1-开关
 18 |     GLfloat Light_Model_Ambient[] = { 1.0, 0.2, 0.5, 0.1 }; //环境光参数
 19 | 
 20 |     glClearColor(0.0, 0.0, 0.0, 0.0);  //背景色
 21 |     glShadeModel(GL_SMOOTH);           //多变性填充模式
 22 | 
 23 |     //材质属性
 24 |     glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
 25 |     glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
 26 | 
 27 |     //灯光设置
 28 |     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
 29 |     glLightfv(GL_LIGHT0, GL_DIFFUSE, white_light);   //散射光属性
 30 |     glLightfv(GL_LIGHT0, GL_SPECULAR, white_light);  //镜面反射光
 31 |     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, Light_Model_Ambient);  //环境光参数
 32 | 
 33 |     glEnable(GL_LIGHTING);   //开关:使用光
 34 |     glEnable(GL_LIGHT0);     //打开0#灯
 35 |     glEnable(GL_DEPTH_TEST); //打开深度测试
 36 | }
 37 | 
 38 | void display(void)
 39 | {
 40 |     //通过循环更新每个粒子的位置
 41 |     for (int i = 0; i < N; i++) {
 42 |         for (int j = 0; j < 3; j++) {
 43 |             particles[i][j] += (rand() % 800 / 800.0 - 0.5) / 100;
 44 |         }
 45 |     }
 46 | 
 47 |     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);            //清除颜色缓存和深度缓存
 48 | 
 49 |     glLoadIdentity();   //装入单位转换矩阵
 50 | 
 51 |     //平移
 52 |     glTranslatef(0.0f, 0.0f, -4.0f);//总体旋转
 53 |     glRotatef(rtri, 0.1, 1.0, 0.1);
 54 |     //每个粒子的位置变动
 55 |     for (int i = 0; i < N; i++) {
 56 |         glPushMatrix();
 57 |         //平移到第i个粒子位置
 58 |         glTranslatef(particles[i][0], particles[i][1], particles[i][2]);
 59 |         glutSolidSphere(0.02, 20, 16);
 60 |         glPopMatrix();
 61 |     }
 62 | 
 63 |     rtri += 0.5f;//加一个角度
 64 |     glutSwapBuffers();//交换双缓存
 65 | }
 66 | 
 67 | void reshape(int width, int height)
 68 | {
 69 |     glViewport(0, 0, width, height);
 70 | 
 71 |     //投影模式
 72 |     glMatrixMode(GL_PROJECTION);
 73 |     glLoadIdentity();
 74 |     //设置斜投影矩阵参数
 75 |     gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 600.0f);
 76 | 
 77 |     //模型-视图矩阵模式
 78 |     glMatrixMode(GL_MODELVIEW);
 79 |     glLoadIdentity();
 80 | }
 81 | 
 82 | void keyboard(unsigned char key, int x, int y)
 83 | {
 84 |     switch (key)
 85 |     {
 86 |     case 'x':
 87 |     case 'X':
 88 |     case 27:   //ESC键
 89 |         exit(0);
 90 |         break;
 91 |     default:
 92 |         break;
 93 |     }
 94 | }
 95 | 
 96 | int main(int argc, char** argv)
 97 | {
 98 |     //seed初始化随机数函数
 99 |     srand((unsigned int)time(0));    //random seeds
100 |     for (int i = 0; i < N; i++) {
101 |         for (int j = 0; j < 3; j++) {
102 |             particles[i][j] = (rand() % 800 / 800.0 - 0.5) * 2;
103 |         }
104 |     }
105 |     glutInit(&argc, argv);
106 |     glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);//使用双缓存模式和深度缓存
107 |     glutInitWindowSize(800, 800);
108 |     glutInitWindowPosition(0, 0);
109 |     glutCreateWindow("粒子群");
110 |     init();
111 |     glutDisplayFunc(display);
112 |     glutReshapeFunc(reshape);
113 |     glutKeyboardFunc(keyboard);
114 |     glutIdleFunc(display);//设置空闲时调用的函数
115 |     glutMainLoop();
116 |     return 0;
117 | }


--------------------------------------------------------------------------------
/OpenGL_Lab/README.md:
--------------------------------------------------------------------------------
1 | ## OpenGL实验  
2 | 此实验是我在上大三计算机图形学课程时所做的有关OpenGL的实验。  
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## 学习OpenGL  
2 | 记录我学习OpenGL做的实验，收获和踩过的坑。  
3 | - OpenGL_Lab：大三计算机图形学课程实验。  
4 | 


--------------------------------------------------------------------------------
/test.c:
--------------------------------------------------------------------------------
 1 | #include <GL/glut.h>
 2 | void init(void)
 3 | {
 4 | glClearColor(0.0, 0.0, 0.0, 0.0);
 5 | glMatrixMode(GL_PROJECTION);
 6 | glOrtho(-5, 5, -5, 5, 5, 15);
 7 | glMatrixMode(GL_MODELVIEW);
 8 | gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0);
 9 | return;
10 | }
11 |  
12 | void display(void)
13 | {
14 | glClear(GL_COLOR_BUFFER_BIT);
15 | glColor3f(1.0, 0, 0);
16 | glutWireTeapot(3);
17 | glFlush();
18 | return;
19 | }
20 |  
21 | int main(int argc, char *argv[])
22 | {
23 | glutInit(&argc, argv);
24 | glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
25 | glutInitWindowPosition(0, 0);
26 | glutInitWindowSize(300, 300);
27 | glutCreateWindow("OpenGL 3D View");
28 | init();
29 | glutDisplayFunc(display);
30 | glutMainLoop();
31 | return 0;
32 | }
33 | 


--------------------------------------------------------------------------------