OpenGL入门学习

OpenGL作为当前主流的图形API之一，它在一些场合具有比DirectX更优越的特性。 1、与C语言紧密结合。 OpenGL命令最初就是用C语言函数来进行描述的，对于学习过C语言的人来讲，OpenGL是容易理解和学习的。如果你曾经接触过TC的graphics.h，你会发现，使用OpenGL作图甚至比TC更加简单。 2、强大的可移植性。 微软的Direct3D虽然也是十分优秀的图形API，但它只用于Windows系统（现在还要加上一个XBOX游戏机）。而OpenGL不仅用于 Windows，还可以用于Unix/Linux等其它系统，它甚至在大型计算机、各种专业计算机（如：医疗用显示设备）上都有应用。并且，OpenGL 的基本命令都做到了硬件无关，甚至是平台无关。 3、高性能的图形渲染。 OpenGL是一个工业标准，它的技术紧跟时代，现今各个显卡厂家无一不对OpenGL提供强力支持，激烈的竞争中使得OpenGL性能一直领先。 总之，OpenGL是一个很NB的图形软件接口。至于究竟有多NB，去看看DOOM3和QUAKE4等专业游戏就知道了。 OpenGL官方网站（英文） http://www.opengl.org 下面将对Windows下的OpenGL编程进行简单介绍。 学习OpenGL前的准备工作 第一步，选择一个编译环境 现在Windows系统的主流编译环境有Visual Studio，Broland C++ Builder，Dev-C++等，它们都是支持OpenGL的。但这里我们选择Visual Studio 2005作为学习OpenGL的环境。 第二步，安装GLUT工具包 GLUT不是OpenGL所必须的，但它会给我们的学习带来一定的方便，推荐安装。 Windows环境下的GLUT下载地址：（大小约为150k） http://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip 无法从以上地址下载的话请使用下面的连接: http://upload.programfan.com/upfile/200607311626279.zip Windows环境下安装GLUT的步骤： 1、将下载的压缩包解开，将得到5个文件 2、在“我的电脑”中搜索“gl.h”，并找到其所在文件夹（如果是VisualStudio2005，则应该是其安装目录下面的“VC\PlatformSDK\include\gl文件夹”）。把解压得到的glut.h放到这个文件夹。 3、把解压得到的glut.lib和glut32.lib放到静态函数库所在文件夹（如果是VisualStudio2005，则应该是其安装目录下面的“VC\lib”文件夹）。 4、把解压得到的glut.dll和glut32.dll放到操作系统目录下面的system32文件夹内。（典型的位置为：C:\Windows\System32） 第三步，建立一个OpenGL工程 这里以VisualStudio2005为例。 选择File->New->Project，然后选择Win32 Console Application，选择一个名字，然后按OK。 在谈出的对话框左边点Application Settings，找到Empty project并勾上，选择Finish。 然后向该工程添加一个代码文件，取名为“OpenGL.c”，注意用.c来作为文件结尾。 搞定了，就跟平时的工程没什么两样的。 第一个OpenGL程序 一个简单的OpenGL程序如下：（注意，如果需要编译并运行，需要正确安装GLUT，安装方法如上所述） #include <GL/glut.h> void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glRectf(-0.5f, -0.5f, 0.5f, 0.5f);     glFlush(); } int main(int argc, char *argv[]) {     glutInit(&argc, argv);     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);     glutInitWindowPosition(100, 100);     glutInitWindowSize(400, 400);     glutCreateWindow("第一个OpenGL程序");     glutDisplayFunc(&myDisplay);     glutMainLoop();     return 0; } 该程序的作用是在一个黑色的窗口中央画一个白色的矩形。下面对各行语句进行说明。 首先，需要包含头文件#include <GL/glut.h>，这是GLUT的头文件。 本来OpenGL程序一般还要包含<GL/gl.h>和<GL/glu.h>，但GLUT的头文件中已经自动将这两个文件包含了，不必再次包含。 然后看main函数。 int main(int argc, char *argv[])，这个是带命令行参数的main函数，各位应该见过吧？没见过的同志们请多翻翻书，等弄明白了再往下看。 注意main函数中的各语句，除了最后的return之外，其余全部以glut开头。这种以glut开头的函数都是GLUT工具包所提供的函数，下面对用到的几个函数进行介绍。 1、glutInit，对GLUT进行初始化，这个函数必须在其它的GLUT使用之前调用一次。其格式比较死板，一般照抄这句glutInit(&argc, argv)就可以了。 2、 glutInitDisplayMode，设置显示方式，其中GLUT_RGB表示使用RGB颜色，与之对应的还有GLUT_INDEX（表示使用索引颜色）。GLUT_SINGLE表示使用单缓冲，与之对应的还有GLUT_DOUBLE（使用双缓冲）。更多信息，请自己Google。当然以后的教程也会有一些讲解。 3、glutInitWindowPosition，这个简单，设置窗口在屏幕中的位置。 4、glutInitWindowSize，这个也简单，设置窗口的大小。 5、glutCreateWindow，根据前面设置的信息创建窗口。参数将被作为窗口的标题。注意：窗口被创建后，并不立即显示到屏幕上。需要调用glutMainLoop才能看到窗口。 6、glutDisplayFunc，设置一个函数，当需要进行画图时，这个函数就会被调用。（这个说法不够准确，但准确的说法可能初学者不太好理解，暂时这样说吧）。 7、glutMainLoop，进行一个消息循环。（这个可能初学者也不太明白，现在只需要知道这个函数可以显示窗口，并且等待窗口关闭后才会返回，这就足够了。） 在glutDisplayFunc函数中，我们设置了“当需要画图时，请调用myDisplay函数”。于是myDisplay函数就用来画图。观察myDisplay中的三个函数调用，发现它们都以gl开头。这种以gl开头的函数都是OpenGL的标准函数，下面对用到的函数进行介绍。 1、glClear，清除。GL_COLOR_BUFFER_BIT表示清除颜色，glClear函数还可以清除其它的东西，但这里不作介绍。 2、glRectf，画一个矩形。四个参数分别表示了位于对角线上的两个点的横、纵坐标。 3、glFlush，保证前面的OpenGL命令立即执行（而不是让它们在缓冲区中等待）。其作用跟fflush(stdout)类似。 openGL实用工具包(GLUT)介绍： OpenGL包含渲染函数，但被涉及成独立于任何窗口系统和操作系统。因此，OpenGL并没用用于打开窗口以及检测键盘或鼠标事件的函数。GLUT库被用来简化这些相关任务，此外还提供了一些用于创建复杂三位物体（如球体、圆环和茶壶等）的函数。     窗口管理函数    glutInit(int *argc, char **argv)，初始化GLUT并处理命令行参数，应在调用其他GLUT函数前调用glutInit()。    glutInitDisplayMode(unsigned int mode),指定使用RGBA模式还是颜色索引模式。还可以指定使用单缓存还是双缓存等。    glutInitWindowPosition(int x, int y),指定窗口左上角在屏幕上的位置。    glutInitWindowSize(int width, int size),指定窗口的大小，单位为象素。    int glutCreateWindow(char *string)，使用一个OpenGL场景创建一个窗口，该函数返回一个标识符，唯一的标识新建的窗口，注意，在调用glutMainLoop()之前，窗口不会被显示出来。     显示回调函数    glutDisplayFunc(void(*func)(void))是最重要的时间回调函数。每当GLUT认为需要重新显示窗口的内容时，都将执行函数glutDisplayFunc()函数注册的回调函数，因此，应将为重新绘制场景需要调用的函数都放到显示回调函数中。如果程序修改了窗口的内容，可能需要调用函数glutPostRedisplay(void)，它提醒函数glutMainLoop调用注册的显示回调函数。     运行程序    glutMainLoop(void)，显示创建的所有窗口，被渲染到这些窗口中的内容也将显示出来。程序开始事件处理，这册的显示回调函数被触发，进入该循环，便不会退出。     处理输入事件    glutReshapeFunc(void(*func)(int w, int h))，指定窗口大小发生改变时应采取的措施；    glutKeyboardFunc(void(*func)(unsigned char key, int x, int y))和glutMouseFunc(void(*func)(int button,int state,int x,int y))，指定当特定的键和鼠标按钮被按下或者松开时应调用的回调函数。    glutMotionFunc(void(*func)(int x, int y))，这册了当用户按下鼠标按钮并移动鼠标时应调用的回调函数。     管理后台处理    glutIdleFunc(void(*func)(void))指定一个在没有其他事件需要处理时（如事件循环空闲）执行的函数。     绘制三维物体    glutWireCube(GLdouble size)、glutSolidCube(GLdouble size)、glutWireSphere(GLdouble radius, GLint slices,GLint statcks)、glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)等

OpenGL入门学习（二）

本次课程所要讲的是绘制简单的几何图形，在实际绘制之前，让我们先熟悉一些概念。 一、点、直线和多边形 我们知道数学（具体的说，是几何学）中有点、直线和多边形的概念，但这些概念在计算机中会有所不同。 数学上的点，只有位置，没有大小。但在计算机中，无论计算精度如何提高，始终不能表示一个无穷小的点。另一方面，无论图形输出设备（例如，显示器）如何精确，始终不能输出一个无穷小的点。一般情况下，OpenGL中的点将被画成单个的像素（像素的概念，请自己搜索之~），虽然它可能足够小，但并不会是无穷小。同一像素上，OpenGL可以绘制许多坐标只有稍微不同的点，但该像素的具体颜色将取决于OpenGL的实现。当然，过度的注意细节就是钻牛角尖，我们大可不必花费过多的精力去研究“多个点如何画到同一像素上”。 同样的，数学上的直线没有宽度，但OpenGL的直线则是有宽度的。同时，OpenGL的直线必须是有限长度，而不是像数学概念那样是无限的。可以认为，OpenGL的“直线”概念与数学上的“线段”接近，它可以由两个端点来确定。 多边形是由多条线段首尾相连而形成的闭合区域。OpenGL规定，一个多边形必须是一个“凸多边形”（其定义为：多边形内任意两点所确定的线段都在多边形内，由此也可以推导出，凸多边形不能是空心的）。多边形可以由其边的端点（这里可称为顶点）来确定。（注意：如果使用的多边形不是凸多边形，则最后输出的效果是未定义的——OpenGL为了效率，放宽了检查，这可能导致显示错误。要避免这个错误，尽量使用三角形，因为三角形都是凸多边形） 可以想象，通过点、直线和多边形，就可以组合成各种几何图形。甚至于，你可以把一段弧看成是很多短的直线段相连，这些直线段足够短，以至于其长度小于一个像素的宽度。这样一来弧和圆也可以表示出来了。通过位于不同平面的相连的小多边形，我们还可以组成一个“曲面”。 二、在OpenGL中指定顶点 由以上的讨论可以知道，“点”是一切的基础。 如何指定一个点呢？OpenGL提供了一系列函数。它们都以glVertex开头，后面跟一个数字和1~2个字母。例如： glVertex2d glVertex2f glVertex3f glVertex3fv 等等。 数字表示参数的个数，2表示有两个参数，3表示三个，4表示四个（我知道有点罗嗦~）。 字母表示参数的类型，s表示16位整数（OpenGL中将这个类型定义为GLshort），                   i表示32位整数（OpenGL中将这个类型定义为GLint和GLsizei），                   f表示32位浮点数（OpenGL中将这个类型定义为GLfloat和GLclampf），                   d表示64位浮点数（OpenGL中将这个类型定义为GLdouble和GLclampd）。                   v表示传递的几个参数将使用指针的方式，见下面的例子。 这些函数除了参数的类型和个数不同以外，功能是相同的。例如，以下五个代码段的功能是等效的： （一）glVertex2i(1, 3); （二）glVertex2f(1.0f, 3.0f); （三）glVertex3f(1.0f, 3.0f, 0.0f); （四）glVertex4f(1.0f, 3.0f, 0.0f, 1.0f); （五）GLfloat VertexArr3[] = {1.0f, 3.0f, 0.0f};      glVertex3fv(VertexArr3); 以后我们将用glVertex*来表示这一系列函数。 注意：OpenGL的很多函数都是采用这样的形式，一个相同的前缀再加上参数说明标记，这一点会随着学习的深入而有更多的体会。 三、开始绘制 假设现在我已经指定了若干顶点，那么OpenGL是如何知道我想拿这些顶点来干什么呢？是一个一个的画出来，还是连成线？或者构成一个多边形？或者做其它什么事情？ 为了解决这一问题，OpenGL要求：指定顶点的命令必须包含在glBegin函数之后，glEnd函数之前（否则指定的顶点将被忽略）。并由glBegin来指明如何使用这些点。 例如我写： glBegin(GL_POINTS);     glVertex2f(0.0f, 0.0f);     glVertex2f(0.5f, 0.0f); glEnd(); 则这两个点将分别被画出来。如果将GL_POINTS替换成GL_LINES，则两个点将被认为是直线的两个端点，OpenGL将会画出一条直线。 我们还可以指定更多的顶点，然后画出更复杂的图形。 另一方面，glBegin支持的方式除了GL_POINTS和GL_LINES，还有GL_LINE_STRIP，GL_LINE_LOOP，GL_TRIANGLES，GL_TRIANGLE_STRIP，GL_TRIANGLE_FAN等，每种方式的大致效果见下图： 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 我并不准备在glBegin的各种方式上大作文章。大家可以自己尝试改变glBegin的方式和顶点的位置，生成一些有趣的图案。 程序代码： void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glBegin( /* 在这里填上你所希望的模式 */ );         /* 在这里使用glVertex*系列函数 */         /* 指定你所希望的顶点位置 */     glEnd();     glFlush(); } 把这段代码改成你喜欢的样子，然后用它替换第一课中的myDisplay函数，编译后即可运行。 两个例子 例一、画一个圆 /* 正四边形，正五边形，正六边形，……，直到正n边形，当n越大时，这个图形就越接近圆 当n大到一定程度后，人眼将无法把它跟真正的圆相区别 这时我们已经成功的画出了一个“圆” （注：画圆的方法很多，这里使用的是比较简单，但效率较低的一种） 试修改下面的const int n的值，观察当n=3,4,5,8,10,15,20,30,50等不同数值时输出的变化情况 将GL_POLYGON改为GL_LINE_LOOP、GL_POINTS等其它方式，观察输出的变化情况 */ #include <math.h> const int n = 20; const GLfloat R = 0.5f; const GLfloat Pi = 3.1415926536f; void myDisplay(void) {     int i;     glClear(GL_COLOR_BUFFER_BIT);     glBegin(GL_POLYGON);     for(i=0; i<n; ++i)         glVertex2f(R*cos(2*Pi/n*i), R*sin(2*Pi/n*i));     glEnd();     glFlush(); } 例二、画一个五角星 /* 设五角星的五个顶点分布位置关系如下：      A  E       B    D   C 首先，根据余弦定理列方程，计算五角星的中心到顶点的距离a （假设五角星对应正五边形的边长为.0） a = 1 / (2-2*cos(72*Pi/180)); 然后，根据正弦和余弦的定义，计算B的x坐标bx和y坐标by，以及C的y坐标 （假设五角星的中心在坐标原点） bx = a * cos(18 * Pi/180); by = a * sin(18 * Pi/180); cy = -a * cos(18 * Pi/180); 五个点的坐标就可以通过以上四个量和一些常数简单的表示出来 */ #include <math.h> const GLfloat Pi = 3.1415926536f; void myDisplay(void) {     GLfloat a = 1 / (2-2*cos(72*Pi/180));     GLfloat bx = a * cos(18 * Pi/180);     GLfloat by = a * sin(18 * Pi/180);     GLfloat cy = -a * cos(18 * Pi/180);     GLfloat         PointA[2] = { 0, a },         PointB[2] = { bx, by },         PointC[2] = { 0.5, cy },         PointD[2] = { -0.5, cy },         PointE[2] = { -bx, by };     glClear(GL_COLOR_BUFFER_BIT);     // 按照A->C->E->B->D->A的顺序，可以一笔将五角星画出     glBegin(GL_LINE_LOOP);         glVertex2fv(PointA);         glVertex2fv(PointC);         glVertex2fv(PointE);         glVertex2fv(PointB);         glVertex2fv(PointD);     glEnd();     glFlush(); } 例三、画出正弦函数的图形 /* 由于OpenGL默认坐标值只能从-1到1，（可以修改，但方法留到以后讲） 所以我们设置一个因子factor，把所有的坐标值等比例缩小， 这样就可以画出更多个正弦周期 试修改factor的值，观察变化情况 */ #include <math.h> const GLfloat factor = 0.1f; void myDisplay(void) {     GLfloat x;     glClear(GL_COLOR_BUFFER_BIT);     glBegin(GL_LINES);         glVertex2f(-1.0f, 0.0f);         glVertex2f(1.0f, 0.0f);        // 以上两个点可以画x轴         glVertex2f(0.0f, -1.0f);         glVertex2f(0.0f, 1.0f);        // 以上两个点可以画y轴     glEnd();     glBegin(GL_LINE_STRIP);     for(x=-1.0f/factor; x<1.0f/factor; x+=0.01f)     {         glVertex2f(x*factor, sin(x)*factor);     }     glEnd();     glFlush(); } 小结 本课讲述了点、直线和多边形的概念，以及如何使用OpenGL来描述点，并使用点来描述几何图形。 大家可以发挥自己的想象，画出各种几何图形，当然，也可以用GL_LINE_STRIP把很多位置相近的点连接起来，构成函数图象。如果有兴趣，也可以去找一些图象比较美观的函数，自己动手，用OpenGL把它画出来。

OpenGL入门学习（三）

在第二课中，我们学习了如何绘制几何图形，但大家如果多写几个程序，就会发现其实还是有些郁闷之处。例如：点太小，难以看清楚；直线也太细，不舒服；或者想画虚线，但不知道方法只能用许多短直线，甚至用点组合而成。 这些问题将在本课中被解决。 下面就点、直线、多边形分别讨论。 1、关于点 点的大小默认为1个像素，但也可以改变之。改变的命令为glPointSize，其函数原型如下： void glPointSize(GLfloat size); size必须大于0.0f，默认值为1.0f，单位为“像素”。 注意：对于具体的OpenGL实现，点的大小都有个限度的，如果设置的size超过最大值，则设置可能会有问题。 例子： void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glPointSize(5.0f);     glBegin(GL_POINTS);         glVertex2f(0.0f, 0.0f);         glVertex2f(0.5f, 0.5f);     glEnd();     glFlush(); } 2、关于直线 （1）直线可以指定宽度： void glLineWidth(GLfloat width); 其用法跟glPointSize类似。 （2）画虚线。 首先，使用glEnable(GL_LINE_STIPPLE);来启动虚线模式（使用glDisable(GL_LINE_STIPPLE)可以关闭之）。 然后，使用glLineStipple来设置虚线的样式。 void glLineStipple(GLint factor, GLushort pattern); pattern是由1和0组成的长度为16的序列，从最低位开始看，如果为1，则直线上接下来应该画的factor个点将被画为实的；如果为0，则直线上接下来应该画的factor个点将被画为虚的。 以下是一些例子： 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 示例代码： void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glEnable(GL_LINE_STIPPLE);     glLineStipple(2, 0x0F0F);     glLineWidth(10.0f);     glBegin(GL_LINES);         glVertex2f(0.0f, 0.0f);         glVertex2f(0.5f, 0.5f);     glEnd();     glFlush(); } 3、关于多边形 多边形的内容较多，我们将讲述以下四个方面。 （1）多边形的两面以及绘制方式。 虽然我们目前还没有真正的使用三维坐标来画图，但是建立一些三维的概念还是必要的。 从三维的角度来看，一个多边形具有两个面。每一个面都可以设置不同的绘制方式：填充、只绘制边缘轮廓线、只绘制顶点，其中“填充”是默认的方式。可以为两个面分别设置不同的方式。 glPolygonMode(GL_FRONT, GL_FILL);           // 设置正面为填充方式 glPolygonMode(GL_BACK, GL_LINE);            // 设置反面为边缘绘制方式 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // 设置两面均为顶点绘制方式 （2）反转 一般约定为“顶点以逆时针顺序出现在屏幕上的面”为“正面”，另一个面即成为“反面”。生活中常见的物体表面，通常都可以用这样的“正面”和“反面”，“合理的”被表现出来（请找一个比较透明的矿泉水瓶子，在正对你的一面沿逆时针画一个圆，并标明画的方向，然后将背面转为正面，画一个类似的圆，体会一下“正面”和“反面”。你会发现正对你的方向，瓶的外侧是正面，而背对你的方向，瓶的内侧才是正面。正对你的内侧和背对你的外侧则是反面。这样一来，同样属于“瓶的外侧”这个表面，但某些地方算是正面，某些地方却算是反面了）。 但也有一些表面比较特殊。例如“麦比乌斯带”（请自己Google一下），可以全部使用“正面”或全部使用“背面”来表示。 可以通过glFrontFace函数来交换“正面”和“反面”的概念。 glFrontFace(GL_CCW);  // 设置CCW方向为“正面”，CCW即CounterClockWise，逆时针 glFrontFace(GL_CW);   // 设置CW方向为“正面”，CW即ClockWise，顺时针 下面是一个示例程序，请用它替换第一课中的myDisplay函数，并将glFrontFace(GL_CCW)修改为glFrontFace(GL_CW)，并观察结果的变化。 void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glPolygonMode(GL_FRONT, GL_FILL); // 设置正面为填充模式     glPolygonMode(GL_BACK, GL_LINE);  // 设置反面为线形模式     glFrontFace(GL_CCW);              // 设置逆时针方向为正面     glBegin(GL_POLYGON);              // 按逆时针绘制一个正方形，在左下方         glVertex2f(-0.5f, -0.5f);         glVertex2f(0.0f, -0.5f);         glVertex2f(0.0f, 0.0f);         glVertex2f(-0.5f, 0.0f);     glEnd();     glBegin(GL_POLYGON);              // 按顺时针绘制一个正方形，在右上方         glVertex2f(0.0f, 0.0f);         glVertex2f(0.0f, 0.5f);         glVertex2f(0.5f, 0.5f);         glVertex2f(0.5f, 0.0f);     glEnd();     glFlush(); } （3）剔除多边形表面 在三维空间中，一个多边形虽然有两个面，但我们无法看见背面的那些多边形，而一些多边形虽然是正面的，但被其他多边形所遮挡。如果将无法看见的多边形和可见的多边形同等对待，无疑会降低我们处理图形的效率。在这种时候，可以将不必要的面剔除。 首先，使用glEnable(GL_CULL_FACE);来启动剔除功能（使用glDisable(GL_CULL_FACE)可以关闭之） 然后，使用glCullFace来进行剔除。 glCullFace的参数可以是GL_FRONT，GL_BACK或者GL_FRONT_AND_BACK，分别表示剔除正面、剔除反面、剔除正反两面的多边形。 注意：剔除功能只影响多边形，而对点和直线无影响。例如，使用glCullFace(GL_FRONT_AND_BACK)后，所有的多边形都将被剔除，所以看见的就只有点和直线。 （4）镂空多边形 直线可以被画成虚线，而多边形则可以进行镂空。 首先，使用glEnable(GL_POLYGON_STIPPLE);来启动镂空模式（使用glDisable(GL_POLYGON_STIPPLE)可以关闭之）。 然后，使用glPolygonStipple来设置镂空的样式。 void glPolygonStipple(const GLubyte *mask); 其中的参数mask指向一个长度为128字节的空间，它表示了一个32*32的矩形应该如何镂空。其中：第一个字节表示了最左下方的从左到右（也可以是从右到左，这个可以修改）8个像素是否镂空（1表示不镂空，显示该像素；0表示镂空，显示其后面的颜色），最后一个字节表示了最右上方的8个像素是否镂空。 但是，如果我们直接定义这个mask数组，像这样： static GLubyte Mask[128] = {     0x00, 0x00, 0x00, 0x00,   //  这是最下面的一行     0x00, 0x00, 0x00, 0x00,     0x03, 0x80, 0x01, 0xC0,   //  麻     0x06, 0xC0, 0x03, 0x60,   //  烦     0x04, 0x60, 0x06, 0x20,   //  的     0x04, 0x30, 0x0C, 0x20,   //  初     0x04, 0x18, 0x18, 0x20,   //  始     0x04, 0x0C, 0x30, 0x20,   //  化     0x04, 0x06, 0x60, 0x20,   //  ，     0x44, 0x03, 0xC0, 0x22,   //  不     0x44, 0x01, 0x80, 0x22,   //  建     0x44, 0x01, 0x80, 0x22,   //  议     0x44, 0x01, 0x80, 0x22,   //  使     0x44, 0x01, 0x80, 0x22,   //  用     0x44, 0x01, 0x80, 0x22,     0x44, 0x01, 0x80, 0x22,     0x66, 0x01, 0x80, 0x66,     0x33, 0x01, 0x80, 0xCC,     0x19, 0x81, 0x81, 0x98,     0x0C, 0xC1, 0x83, 0x30,     0x07, 0xE1, 0x87, 0xE0,     0x03, 0x3F, 0xFC, 0xC0,     0x03, 0x31, 0x8C, 0xC0,     0x03, 0x3F, 0xFC, 0xC0,     0x06, 0x64, 0x26, 0x60,     0x0C, 0xCC, 0x33, 0x30,     0x18, 0xCC, 0x33, 0x18,     0x10, 0xC4, 0x23, 0x08,     0x10, 0x63, 0xC6, 0x08,     0x10, 0x30, 0x0C, 0x08,     0x10, 0x18, 0x18, 0x08,     0x10, 0x00, 0x00, 0x08   // 这是最上面的一行 }; 这样一堆数据非常缺乏直观性，我们需要很费劲的去分析，才会发现它表示的竟然是一只苍蝇。 如果将这样的数据保存成图片，并用专门的工具进行编辑，显然会方便很多。下面介绍如何做到这一点。 首先，用Windows自带的画笔程序新建一副图片，取名为mask.bmp，注意保存时，应该选择“单色位图”。在“图象”->“属性”对话框中，设置图片的高度和宽度均为32。 用放大镜观察图片，并编辑之。黑色对应二进制零（镂空），白色对应二进制一（不镂空），编辑完毕后保存。 然后，就可以使用以下代码来获得这个Mask数组了。 static GLubyte Mask[128]; FILE *fp; fp = fopen("mask.bmp", "rb"); if( !fp )     exit(0); // 移动文件指针到这个位置，使得再读sizeof(Mask)个字节就会遇到文件结束 // 注意-(int)sizeof(Mask)虽然不是什么好的写法，但这里它确实是正确有效的 // 如果直接写-sizeof(Mask)的话，因为sizeof取得的是一个无符号数，取负号会有问题 if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )     exit(0); // 读取sizeof(Mask)个字节到Mask if( !fread(Mask, sizeof(Mask), 1, fp) )     exit(0); fclose(fp); 好的，现在请自己编辑一个图片作为mask，并用上述方法取得Mask数组，运行后观察效果。 说明：绘制虚线时可以设置factor因子，但多边形的镂空无法设置factor因子。请用鼠标改变窗口的大小，观察镂空效果的变化情况。 #include <stdio.h> #include <stdlib.h> void myDisplay(void) {     static GLubyte Mask[128];     FILE *fp;     fp = fopen("mask.bmp", "rb");     if( !fp )         exit(0);     if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )         exit(0);     if( !fread(Mask, sizeof(Mask), 1, fp) )         exit(0);     fclose(fp);     glClear(GL_COLOR_BUFFER_BIT);     glEnable(GL_POLYGON_STIPPLE);     glPolygonStipple(Mask);     glRectf(-0.5f, -0.5f, 0.0f, 0.0f);  // 在左下方绘制一个有镂空效果的正方形     glDisable(GL_POLYGON_STIPPLE);     glRectf(0.0f, 0.0f, 0.5f, 0.5f);    // 在右上方绘制一个无镂空效果的正方形     glFlush(); } 小结 本课学习了绘制几何图形的一些细节。 点可以设置大小。 直线可以设置宽度；可以将直线画成虚线。 多边形的两个面的绘制方法可以分别设置；在三维空间中，不可见的多边形可以被剔除；可以将填充多边形绘制成镂空的样式。 了解这些细节会使我们在一些图象绘制中更加得心应手。 另外，把一些数据写到程序之外的文件中，并用专门的工具编辑之，有时可以显得更方便。

OpenGL入门学习（四）

本次学习的是颜色的选择。终于要走出黑白的世界了~~ OpenGL支持两种颜色模式：一种是RGBA，一种是颜色索引模式。 无论哪种颜色模式，计算机都必须为每一个像素保存一些数据。不同的是，RGBA模式中，数据直接就代表了颜色；而颜色索引模式中，数据代表的是一个索引，要得到真正的颜色，还必须去查索引表。 1. RGBA颜色 RGBA模式中，每一个像素会保存以下数据：R值（红色分量）、G值（绿色分量）、B值（蓝色分量）和A值（alpha分量）。其中红、绿、蓝三种颜色相组合，就可以得到我们所需要的各种颜色，而alpha不直接影响颜色，它将留待以后介绍。 在RGBA模式下选择颜色是十分简单的事情，只需要一个函数就可以搞定。 glColor*系列函数可以用于设置颜色，其中三个参数的版本可以指定R、G、B的值，而A值采用默认；四个参数的版本可以分别指定R、G、B、A的值。例如： void glColor3f(GLfloat red, GLfloat green, GLfloat blue); void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); （还记得吗？3f表示有三个浮点参数~请看第二课中关于glVertex*函数的叙述。） 将浮点数作为参数，其中0.0表示不使用该种颜色，而1.0表示将该种颜色用到最多。例如： glColor3f(1.0f, 0.0f, 0.0f);   表示不使用绿、蓝色，而将红色使用最多，于是得到最纯净的红色。 glColor3f(0.0f, 1.0f, 1.0f);   表示使用绿、蓝色到最多，而不使用红色。混合的效果就是浅蓝色。 glColor3f(0.5f, 0.5f, 0.5f);   表示各种颜色使用一半，效果为灰色。 注意：浮点数可以精确到小数点后若干位，这并不表示计算机就可以显示如此多种颜色。实际上，计算机可以显示的颜色种数将由硬件决定。如果OpenGL找不到精确的颜色，会进行类似“四舍五入”的处理。 大家可以通过改变下面代码中glColor3f的参数值，绘制不同颜色的矩形。 void myDisplay(void) {     glClear(GL_COLOR_BUFFER_BIT);     glColor3f(0.0f, 1.0f, 1.0f);     glRectf(-0.5f, -0.5f, 0.5f, 0.5f);     glFlush(); } 注意：glColor系列函数，在参数类型不同时，表示“最大”颜色的值也不同。 采用f和d做后缀的函数，以1.0表示最大的使用。 采用b做后缀的函数，以127表示最大的使用。 采用ub做后缀的函数，以255表示最大的使用。 采用s做后缀的函数，以32767表示最大的使用。 采用us做后缀的函数，以65535表示最大的使用。 这些规则看似麻烦，但熟悉后实际使用中不会有什么障碍。 2、索引颜色（选看） 在索引颜色模式中，OpenGL需要一个颜色表。这个表就相当于画家的调色板：虽然可以调出很多种颜色，但同时存在于调色板上的颜色种数将不会超过调色板的格数。试将颜色表的每一项想象成调色板上的一个格子：它保存了一种颜色。 在使用索引颜色模式画图时，我说“我把第i种颜色设置为某某”，其实就相当于将调色板的第i格调为某某颜色。“我需要第k种颜色来画图”，那么就用画笔去蘸一下第k格调色板。 颜色表的大小是很有限的，一般在256~4096之间，且总是2的整数次幂。在使用索引颜色方式进行绘图时，总是先设置颜色表，然后选择颜色. 2.1、选择颜色 使用glIndex*系列函数可以在颜色表中选择颜色。其中最常用的可能是glIndexi，它的参数是一个整形。 void glIndexi(GLint c); 是的，这的确很简单。 2.2、设置颜色表 OpenGL 并直接没有提供设置颜色表的方法，因此设置颜色表需要使用操作系统的支持。我们所用的Windows和其他大多数图形操作系统都具有这个功能，但所使用的函数却不相同。正如我没有讲述如何自己写代码在Windows下建立一个窗口，这里我也不会讲述如何在Windows下设置颜色表。 GLUT工具包提供了设置颜色表的函数glutSetColor，但我测试始终有问题。现在为了让大家体验一下索引颜色，我向大家介绍另一个OpenGL工具包： aux。这个工具包是VisualStudio自带的，不必另外安装，但它已经过时，这里仅仅是体验一下，大家不必深入。 #include <windows.h> #include <GL/gl.h> #include <GL/glaux.h> #pragma comment (lib, "opengl32.lib") #pragma comment (lib, "glaux.lib") #include <math.h> const GLdouble Pi = 3.1415926536; void myDisplay(void) {     int i;     for(i=0; i<8; ++i)         auxSetOneColor(i, (float)(i&0x04), (float)(i&0x02), (float)(i&0x01));     glShadeModel(GL_FLAT);     glClear(GL_COLOR_BUFFER_BIT);     glBegin(GL_TRIANGLE_FAN);     glVertex2f(0.0f, 0.0f);     for(i=0; i<=8; ++i)     {         glIndexi(i);         glVertex2f(cos(i*Pi/4), sin(i*Pi/4));     }     glEnd();     glFlush(); } int main(void) {     auxInitDisplayMode(AUX_SINGLE|AUX_INDEX);     auxInitPosition(0, 0, 400, 400);     auxInitWindow("L");     myDisplay();     Sleep(10 * 1000);     return 0; } 其它部分大家都可以不管，只看myDisplay函数就可以了。首先，使用auxSetOneColor设置颜色表中的一格。循环八次就可以设置八格。 glShadeModel等下再讲，这里不提。 然后在循环中用glVertex设置顶点，同时用glIndexi改变顶点代表的颜色。 最终得到的效果是八个相同形状、不同颜色的三角形。 索引颜色虽然讲得多了点。索引颜色的主要优势是占用空间小（每个像素不必单独保存自己的颜色，只用很少的二进制位就可以代表其颜色在颜色表中的位置），花费系统资源少，图形运算速度快，但它编程稍稍显得不是那么方便，并且画面效果也会比RGB颜色差一些。“星际争霸”可能代表了256色的颜色表的画面效果，虽然它在一台很烂的PC上也可以运行很流畅，但以目前的眼光来看，其画面效果就显得不足了。 目前的PC机性能已经足够在各种场合下使用RGB颜色，因此PC程序开发中，使用索引颜色已经不是主流。当然，一些小型设备例如GBA、手机等，索引颜色还是有它的用武之地。 3、指定清除屏幕用的颜色 我们写：glClear(GL_COLOR_BUFFER_BIT);意思是把屏幕上的颜色清空。 但实际上什么才叫“空”呢？在宇宙中，黑色代表了“空”；在一张白纸上，白色代表了“空”；在信封上，信封的颜色才是“空”。 OpenGL用下面的函数来定义清楚屏幕后屏幕所拥有的颜色。 在RGB模式下，使用glClearColor来指定“空”的颜色，它需要四个参数，其参数的意义跟glColor4f相似。 在索引颜色模式下，使用glClearIndex来指定“空”的颜色所在的索引，它需要一个参数，其意义跟glIndexi相似。 void myDisplay(void) {     glClearColor(1.0f, 0.0f, 0.0f, 0.0f);     glClear(GL_COLOR_BUFFER_BIT);     glFlush(); } 呵，这个还真简单~ 4、指定着色模型 OpenGL允许为同一多边形的不同顶点指定不同的颜色。例如： #include <math.h> const GLdouble Pi = 3.1415926536; void myDisplay(void) {     int i;     // glShadeModel(GL_FLAT);     glClear(GL_COLOR_BUFFER_BIT);     glBegin(GL_TRIANGLE_FAN);     glColor3f(1.0f, 1.0f, 1.0f);     glVertex2f(0.0f, 0.0f);     for(i=0; i<=8; ++i)     {         glColor3f(i&0x04, i&0x02, i&0x01);         glVertex2f(cos(i*Pi/4), sin(i*Pi/4));     }     glEnd();     glFlush(); } 在默认情况下，OpenGL会计算两点顶点之间的其它点，并为它们填上“合适”的颜色，使相邻的点的颜色值都比较接近。如果使用的是RGB模式，看起来就具有渐变的效果。如果是使用颜色索引模式，则其相邻点的索引值是接近的，如果将颜色表中接近的项设置成接近的颜色，则看起来也是渐变的效果。但如果颜色表中接近的项颜色却差距很大，则看起来可能是很奇怪的效果。 使用glShadeModel函数可以关闭这种计算，如果顶点的颜色不同，则将顶点之间的其它点全部设置为与某一个点相同。（直线以后指定的点的颜色为准，而多边形将以任意顶点的颜色为准，由实现决定。）为了避免这个不确定性，尽量在多边形中使用同一种颜色。 glShadeModel的使用方法： glShadeModel(GL_SMOOTH);   // 平滑方式，这也是默认方式 glShadeModel(GL_FLAT);     // 单色方式 小结： 本课学习了如何设置颜色。其中RGB颜色方式是目前PC机上的常用方式。 可以设置glClear清除后屏幕所剩的颜色。 可以设置颜色填充方式：平滑方式或单色方式。

OpenGL入门学习（五）

今天要讲的是三维变换的内容，课程比较枯燥。主要是因为很多函数在单独使用时都不好描述其效果，我只好在最后举一个比较综合的例子。希望大家能一口气看到底了。只看一次可能不够，如果感觉到迷糊，不妨多看两遍。有疑问可以在下面跟帖提出。 我也使用了若干图形，希望可以帮助理解。 在前面绘制几何图形的时候，大家是否觉得我们绘图的范围太狭隘了呢？坐标只能从-1到1，还只能是X轴向右，Y轴向上，Z轴垂直屏幕。这些限制给我们的绘图带来了很多不便。 我们生活在一个三维的世界——如果要观察一个物体，我们可以： 1、从不同的位置去观察它。（视图变换） 2、移动或者旋转它，当然了，如果它只是计算机里面的物体，我们还可以放大或缩小它。（模型变换） 3、如果把物体画下来，我们可以选择：是否需要一种“近大远小”的透视效果。另外，我们可能只希望看到物体的一部分，而不是全部（剪裁）。（投影变换） 4、我们可能希望把整个看到的图形画下来，但它只占据纸张的一部分，而不是全部。（视口变换） 这些，都可以在OpenGL中实现。 OpenGL变换实际上是通过矩阵乘法来实现。无论是移动、旋转还是缩放大小，都是通过在当前矩阵的基础上乘以一个新的矩阵来达到目的。关于矩阵的知识，这里不详细介绍，有兴趣的朋友可以看看线性代数（大学生的话多半应该学过的）。 OpenGL可以在最底层直接操作矩阵，不过作为初学，这样做的意义并不大。这里就不做介绍了。 1、模型变换和视图变换 从“相对移动”的观点来看，改变观察点的位置与方向和改变物体本身的位置与方向具有等效性。在OpenGL中，实现这两种功能甚至使用的是同样的函数。 由于模型和视图的变换都通过矩阵运算来实现，在进行变换前，应先设置当前操作的矩阵为“模型视图矩阵”。设置的方法是以GL_MODELVIEW为参数调用glMatrixMode函数，像这样： glMatrixMode(GL_MODELVIEW); 通常，我们需要在进行变换前把当前矩阵设置为单位矩阵。这也只需要一行代码： glLoadIdentity(); 然后，就可以进行模型变换和视图变换了。进行模型和视图变换，主要涉及到三个函数： glTranslate*，把当前矩阵和一个表示移动物体的矩阵相乘。三个参数分别表示了在三个坐标上的位移值。 glRotate*，把当前矩阵和一个表示旋转物体的矩阵相乘。物体将绕着(0,0,0)到(x,y,z)的直线以逆时针旋转，参数angle表示旋转的角度。 glScale*，把当前矩阵和一个表示缩放物体的矩阵相乘。x,y,z分别表示在该方向上的缩放比例。 注意我都是说“与XX相乘”，而不是直接说“这个函数就是旋转”或者“这个函数就是移动”，这是有原因的，马上就会讲到。 假设当前矩阵为单位矩阵，然后先乘以一个表示旋转的矩阵R，再乘以一个表示移动的矩阵T，最后得到的矩阵再乘上每一个顶点的坐标矩阵v。所以，经过变换得到的顶点坐标就是((RT)v)。由于矩阵乘法的结合率，((RT)v) = (R(Tv))，换句话说，实际上是先进行移动，然后进行旋转。即：实际变换的顺序与代码中写的顺序是相反的。由于“先移动后旋转”和“先旋转后移动”得到的结果很可能不同，初学的时候需要特别注意这一点。 OpenGL之所以这样设计，是为了得到更高的效率。但在绘制复杂的三维图形时，如果每次都去考虑如何把变换倒过来，也是很痛苦的事情。这里介绍另一种思路，可以让代码看起来更自然（写出的代码其实完全一样，只是考虑问题时用的方法不同了）。 让我们想象，坐标并不是固定不变的。旋转的时候，坐标系统随着物体旋转。移动的时候，坐标系统随着物体移动。如此一来，就不需要考虑代码的顺序反转的问题了。 以上都是针对改变物体的位置和方向来介绍的。如果要改变观察点的位置，除了配合使用glRotate*和glTranslate*函数以外，还可以使用这个函数：gluLookAt。它的参数比较多，前三个参数表示了观察点的位置，中间三个参数表示了观察目标的位置，最后三个参数代表从(0,0,0)到 (x,y,z)的直线，它表示了观察者认为的“上”方向。 2、投影变换 投影变换就是定义一个可视空间，可视空间以外的物体不会被绘制到屏幕上。（注意，从现在起，坐标可以不再是-1.0到1.0了！） OpenGL支持两种类型的投影变换，即透视投影和正投影。投影也是使用矩阵来实现的。如果需要操作投影矩阵，需要以GL_PROJECTION为参数调用glMatrixMode函数。 glMatrixMode(GL_PROJECTION); 通常，我们需要在进行变换前把当前矩阵设置为单位矩阵。 glLoadIdentity(); 透视投影所产生的结果类似于照片，有近大远小的效果，比如在火车头内向前照一个铁轨的照片，两条铁轨似乎在远处相交了。 使用glFrustum函数可以将当前的可视空间设置为透视投影空间。其参数的意义如下图： 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 也可以使用更常用的gluPerspective函数。其参数的意义如下图： 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 正投影相当于在无限远处观察得到的结果，它只是一种理想状态。但对于计算机来说，使用正投影有可能获得更好的运行速度。 使用glOrtho函数可以将当前的可视空间设置为正投影空间。其参数的意义如下图： 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 如果绘制的图形空间本身就是二维的，可以使用gluOrtho2D。他的使用类似于glOrgho。 3、视口变换 当一切工作已经就绪，只需要把像素绘制到屏幕上了。这时候还剩最后一个问题：应该把像素绘制到窗口的哪个区域呢？通常情况下，默认是完整的填充整个窗口，但我们完全可以只填充一半。（即：把整个图象填充到一半的窗口内） 声明：该图片来自www.opengl.org，该图片是《OpenGL编程指南》一书的附图，由于该书的旧版（第一版，1994年）已经流传于网络，我希望没有触及到版权问题。 使用glViewport来定义视口。其中前两个参数定义了视口的左下脚（0,0表示最左下方），后两个参数分别是宽度和高度。 4、操作矩阵堆栈 介于是入门教程，先简单介绍一下堆栈。你可以把堆栈想象成一叠盘子。开始的时候一个盘子也没有，你可以一个一个往上放，也可以一个一个取下来。每次取下的，都是最后一次被放上去的盘子。通常，在计算机实现堆栈时，堆栈的容量是有限的，如果盘子过多，就会出错。当然，如果没有盘子了，再要求取一个盘子，也会出错。 我们在进行矩阵操作时，有可能需要先保存某个矩阵，过一段时间再恢复它。当我们需要保存时，调用glPushMatrix函数，它相当于把矩阵（相当于盘子）放到堆栈上。当需要恢复最近一次的保存时，调用glPopMatrix函数，它相当于把矩阵从堆栈上取下。OpenGL规定堆栈的容量至少可以容纳32个矩阵，某些OpenGL实现中，堆栈的容量实际上超过了32个。因此不必过于担心矩阵的容量问题。 通常，用这种先保存后恢复的措施，比先变换再逆变换要更方便，更快速。 注意：模型视图矩阵和投影矩阵都有相应的堆栈。使用glMatrixMode来指定当前操作的究竟是模型视图矩阵还是投影矩阵。 5、综合举例 好了，视图变换的入门知识差不多就讲完了。但我们不能就这样结束。因为本次课程的内容实在过于枯燥，如果分别举例，可能效果不佳。我只好综合的讲一个例子，算是给大家一个参考。至于实际的掌握，还要靠大家自己花功夫。闲话少说，现在进入正题。 我们要制作的是一个三维场景，包括了太阳、地球和月亮。假定一年有12个月，每个月30天。每年，地球绕着太阳转一圈。每个月，月亮围着地球转一圈。即一年有360天。现在给出日期的编号（0~359），要求绘制出太阳、地球、月亮的相对位置示意图。（这是为了编程方便才这样设计的。如果需要制作更现实的情况，那也只是一些数值处理而已，与OpenGL关系不大） 首先，让我们认定这三个天体都是球形，且他们的运动轨迹处于同一水平面，建立以下坐标系：太阳的中心为原点，天体轨迹所在的平面表示了X轴与Y轴决定的平面，且每年第一天，地球在X轴正方向上，月亮在地球的正X轴方向。 下一步是确立可视空间。注意：太阳的半径要比太阳到地球的距离短得多。如果我们直接使用天文观测得到的长度比例，则当整个窗口表示地球轨道大小时，太阳的大小将被忽略。因此，我们只能成倍的放大几个天体的半径，以适应我们观察的需要。（百度一下，得到太阳、地球、月亮的大致半径分别是：696000km，  6378km，1738km。地球到太阳的距离约为1.5亿km=150000000km，月亮到地球的距离约为380000km。） 让我们假想一些数据，将三个天体的半径分别“修改”为：69600000（放大100倍），15945000（放大2500倍），4345000（放大5000倍）。将地球到月亮的距离“修改”为38000000（放大100倍）。地球到太阳的距离保持不变。 为了让地球和月亮在离我们很近时，我们仍然不需要变换观察点和观察方向就可以观察它们，我们把观察点放在这个位置：(0, -200000000, 0)  ——因为地球轨道半径为150000000，咱们就凑个整，取-200000000就可以了。观察目标设置为原点（即太阳中心），选择Z轴正方向作为  “上”方。当然我们还可以把观察点往“上”方移动一些，得到(0, -200000000, 200000000)，这样可以得到45度角的俯视效果。 为了得到透视效果，我们使用gluPerspective来设置可视空间。假定可视角为60度（如果调试时发现该角度不合适，可修改之。我在最后选择的数值是75。），高宽比为1.0。最近可视距离为1.0，最远可视距离为200000000*2=400000000。即：gluPerspective  (60, 1, 1, 400000000); 现在我们来看看如何绘制这三个天体。 为了简单起见，我们把三个天体都想象成规则的球体。而我们所使用的glut实用工具中，正好就有一个绘制球体的现成函数：glutSolidSphere，这个函数在“原点”绘制出一个球体。由于坐标是可以通过glTranslate*和glRotate*两个函数进行随意变换的，所以我们就可以在任意位置绘制球体了。函数有三个参数：第一个参数表示球体的半径，后两个参数代表了“面”的数目，简单点说就是球体的精确程度，数值越大越精确，当然代价就是速度越缓慢。这里我们只是简单的设置后两个参数为20。 太阳在坐标原点，所以不需要经过任何变换，直接绘制就可以了。 地球则要复杂一点，需要变换坐标。由于今年已经经过的天数已知为day，则地球转过的角度为day/一年的天数*360度。前面已经假定每年都是360天，因此地球转过的角度恰好为day。所以可以通过下面的代码来解决： glRotatef(day, 0, 0, -1); /* 注意地球公转是“自西向东”的，因此是饶着Z轴负方向进行逆时针旋转 */ glTranslatef(地球轨道半径, 0, 0); glutSolidSphere(地球半径, 20, 20); 月亮是最复杂的。因为它不仅要绕地球转，还要随着地球绕太阳转。但如果我们选择地球作为参考，则月亮进行的运动就是一个简单的圆周运动了。如果我们先绘制地球，再绘制月亮，则只需要进行与地球类似的变换： glRotatef(月亮旋转的角度, 0, 0, -1); glTranslatef(月亮轨道半径, 0, 0); glutSolidSphere(月亮半径, 20, 20); 但这个“月亮旋转的角度”，并不能简单的理解为day/一个月的天数30*360度。因为我们在绘制地球时，这个坐标已经是旋转过的。现在的旋转是在以前的基础上进行旋转，因此还需要处理这个“差值”。我们可以写成：day/30*360 - day，即减去原来已经转过的角度。这只是一种简单的处理，当然也可以在绘制地球前用glPushMatrix保存矩阵，绘制地球后用glPopMatrix恢复矩阵。再设计一个跟地球位置无关的月亮位置公式，来绘制月亮。通常后一种方法比前一种要好，因为浮点的运算是不精确的，即是说我们计算地球本身的位置就是不精确的。拿这个不精确的数去计算月亮的位置，会导致 “不精确”的成分累积，过多的“不精确”会造成错误。我们这个小程序没有去考虑这个，但并不是说这个问题不重要。 还有一个需要注意的细节： OpenGL把三维坐标中的物体绘制到二维屏幕，绘制的顺序是按照代码的顺序来进行的。因此后绘制的物体会遮住先绘制的物体，即使后绘制的物体在先绘制的物体的“后面”也是如此。使用深度测试可以解决这一问题。使用的方法是：1、以GL_DEPTH_TEST为参数调用glEnable函数，启动深度测试。2、在必要时（通常是每次绘制画面开始时），清空深度缓冲，即：glClear(GL_DEPTH_BUFFER_BIT);其中，glClear (GL_COLOR_BUFFER_BIT)与glClear(GL_DEPTH_BUFFER_BIT)可以合并写为： glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 且后者的运行速度可能比前者快。 到此为止，我们终于可以得到整个“太阳，地球和月亮”系统的完整代码。 Code: -------------------------------------------------------------------------------- // 太阳、地球和月亮 // 假设每个月都是30天 // 一年12个月，共是360天 static int day = 200; // day的变化：从0到359 void myDisplay(void) {     glEnable(GL_DEPTH_TEST);     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     glMatrixMode(GL_PROJECTION);     glLoadIdentity();     gluPerspective(75, 1, 1, 400000000);     glMatrixMode(GL_MODELVIEW);     glLoadIdentity();     gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);     // 绘制红色的“太阳”     glColor3f(1.0f, 0.0f, 0.0f);     glutSolidSphere(69600000, 20, 20);     // 绘制蓝色的“地球”     glColor3f(0.0f, 0.0f, 1.0f);     glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f);     glTranslatef(150000000, 0.0f, 0.0f);     glutSolidSphere(15945000, 20, 20);     // 绘制黄色的“月亮”     glColor3f(1.0f, 1.0f, 0.0f);     glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f);     glTranslatef(38000000, 0.0f, 0.0f);     glutSolidSphere(4345000, 20, 20);     glFlush(); } -------------------------------------------------------------------------------- 试修改day的值，看看画面有何变化。 小结：本课开始，我们正式进入了三维的OpenGL世界。 OpenGL通过矩阵变换来把三维物体转变为二维图象，进而在屏幕上显示出来。为了指定当前操作的是何种矩阵，我们使用了函数glMatrixMode。 我们可以移动、旋转观察点或者移动、旋转物体，使用的函数是glTranslate*和glRotate*。 我们可以缩放物体，使用的函数是glScale*。 我们可以定义可视空间，这个空间可以是“正投影”的（使用glOrtho或gluOrtho2D），也可以是“透视投影”的（使用glFrustum或gluPerspective）。 我们可以定义绘制到窗口的范围，使用的函数是glViewport。 矩阵有自己的“堆栈”，方便进行保存和恢复。这在绘制复杂图形时很有帮助。使用的函数是glPushMatrix和glPopMatrix。 好了，艰苦的一课终于完毕。我知道，本课的内容十分枯燥，就连最后的例子也是。但我也没有更好的办法了，希望大家能坚持过去。不必担心，熟悉本课内容后，以后的一段时间内，都会是比较轻松愉快的了。

OpenGL入门学习（六）

今天要讲的是动画制作——可能是各位都很喜欢的。除了讲授知识外，我们还会让昨天那个“太阳、地球和月亮”天体图画动起来。缓和一下枯燥的气氛。 本次课程，我们将进入激动人心的计算机动画世界。 想必大家都知道电影和动画的工作原理吧？是的，快速的把看似连续的画面一幅幅的呈现在人们面前。一旦每秒钟呈现的画面超过24幅，人们就会错以为它是连续的。 我们通常观看的电视，每秒播放25或30幅画面。但对于计算机来说，它可以播放更多的画面，以达到更平滑的效果。如果速度过慢，画面不够平滑。如果速度过快，则人眼未必就能反应得过来。对于一个正常人来说，每秒60~120幅图画是比较合适的。具体的数值因人而异。 假设某动画一共有n幅画面，则它的工作步骤就是： 显示第1幅画面，然后等待一小段时间，直到下一个1/24秒 显示第2幅画面，然后等待一小段时间，直到下一个1/24秒 …… 显示第n幅画面，然后等待一小段时间，直到下一个1/24秒 结束 如果用C语言伪代码来描述这一过程，就是： for(i=0; i<n; ++i) {     DrawScene(i);     Wait(); } 1、双缓冲技术 在计算机上的动画与实际的动画有些不同：实际的动画都是先画好了，播放的时候直接拿出来显示就行。计算机动画则是画一张，就拿出来一张，再画下一张，再拿出来。如果所需要绘制的图形很简单，那么这样也没什么问题。但一旦图形比较复杂，绘制需要的时间较长，问题就会变得突出。 让我们把计算机想象成一个画图比较快的人，假如他直接在屏幕上画图，而图形比较复杂，则有可能在他只画了某幅图的一半的时候就被观众看到。而后面虽然他把画补全了，但观众的眼睛却又没有反应过来，还停留在原来那个残缺的画面上。也就是说，有时候观众看到完整的图象，有时却又只看到残缺的图象，这样就造成了屏幕的闪烁。 如何解决这一问题呢？我们设想有两块画板，画图的人在旁边画，画好以后把他手里的画板与挂在屏幕上的画板相交换。这样以来，观众就不会看到残缺的画了。这一技术被应用到计算机图形中，称为双缓冲技术。即：在存储器（很有可能是显存）中开辟两块区域，一块作为发送到显示器的数据，一块作为绘画的区域，在适当的时候交换它们。由于交换两块内存区域实际上只需要交换两个指针，这一方法效率非常高，所以被广泛的采用。 注意：虽然绝大多数平台都支持双缓冲技术，但这一技术并不是OpenGL标准中的内容。OpenGL为了保证更好的可移植性，允许在实现时不使用双缓冲技术。当然，我们常用的PC都是支持双缓冲技术的。 要启动双缓冲功能，最简单的办法就是使用GLUT工具包。我们以前在main函数里面写： glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE); 其中GLUT_SINGLE表示单缓冲，如果改成GLUT_DOUBLE就是双缓冲了。 当然还有需要更改的地方——每次绘制完成时，我们需要交换两个缓冲区，把绘制好的信息用于屏幕显示（否则无论怎么绘制，还是什么都看不到）。如果使用GLUT工具包，也可以很轻松的完成这一工作，只要在绘制完成时简单的调用glutSwapBuffers函数就可以了。 2、实现连续动画 似乎没有任何疑问，我们应该把绘制动画的代码写成下面这个样子： for(i=0; i<n; ++i) {     DrawScene(i);     glutSwapBuffers();     Wait(); } 但事实上，这样做不太符合窗口系统的程序设计思路。还记得我们的第一个OpenGL程序吗？我们在main函数里写：glutDisplayFunc(&myDisplay); 意思是对系统说：如果你需要绘制窗口了，请调用myDisplay这个函数。为什么我们不直接调用myDisplay，而要采用这种看似“舍近求远”的做法呢？原因在于——我们自己的程序无法掌握究竟什么时候该绘制窗口。因为一般的窗口系统——拿我们熟悉一点的来说——Windows和X窗口系统，都是支持同时显示多个窗口的。假如你的程序窗口碰巧被别的窗口遮住了，后来用户又把原来遮住的窗口移开，这时你的窗口需要重新绘制。很不幸的，你无法知道这一事件发生的具体时间。因此这一切只好委托操作系统来办了。 现在我们再看上面那个循环。既然DrawScene都可以交给操作系统来代办了，那让整个循环运行起来的工作是否也可以交给操作系统呢？答案是肯定的。我们先前的思路是：绘制，然后等待一段时间；再绘制，再等待一段时间。但如果去掉等待的时间，就变成了绘制，绘制，……，不停的绘制。——当然了，资源是公用的嘛，杀毒软件总要工作吧？我的下载不能停下来吧？我的mp3播放还不能给耽搁了。总不能因为我们的动画，让其他的工作都停下来。因此，我们需要在CPU空闲的时间绘制。 这里的“在CPU空闲的时间绘制”和我们在第一课讲的“在需要绘制的时候绘制”有些共通，都是“在XX时间做XX事”，GLUT工具包也提供了一个比较类似的函数：glutIdleFunc，表示在CPU空闲的时间调用某一函数。其实GLUT还提供了一些别的函数，例如“在键盘按下时做某事”等。 到现在，我们已经可以初步开始制作动画了。好的，就拿上次那个“太阳、地球和月亮”的程序开刀，让地球和月亮自己动起来。 Code: #include <GL/glut.h> // 太阳、地球和月亮 // 假设每个月都是30天 // 一年12个月，共是360天 static int day = 200; // day的变化：从0到359 void myDisplay(void) {     /****************************************************      这里的内容照搬上一课的，只因为使用了双缓冲，补上最后这句     *****************************************************/     glutSwapBuffers(); } void myIdle(void) {     /* 新的函数，在空闲时调用，作用是把日期往后移动一天并重新绘制，达到动画效果 */     ++day;     if( day >= 360 )         day = 0;     myDisplay(); } int main(int argc, char *argv[]) {     glutInit(&argc, argv);     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); // 修改了参数为GLUT_DOUBLE     glutInitWindowPosition(100, 100);     glutInitWindowSize(400, 400);     glutCreateWindow("太阳，地球和月亮");   // 改了窗口标题     glutDisplayFunc(&myDisplay);     glutIdleFunc(&myIdle);               // 新加入了这句     glutMainLoop();     return 0; } 3、关于垂直同步 代码是写好了，但相信大家还有疑问。某些朋友可能在运行时发现，虽然CPU几乎都用上了，但运动速度很快，根本看不清楚，另一些朋友在运行时发现CPU使用率很低，根本就没有把空闲时间完全利用起来。但对于上面那段代码来说，这些现象都是合理的。这里就牵涉到关于垂直同步的问题。 大家知道显示器的刷新率是比较有限的，一般为60~120Hz，也就是一秒钟刷新60~120次。但如果叫计算机绘制一个简单的画面，例如只有一个三角形，则一秒钟可以绘制成千上万次。因此，如果最大限度的利用计算机的处理能力，绘制很多幅画面，但显示器的刷新速度却跟不上，这不仅造成性能的浪费，还可能带来一些负面影响（例如，显示器只刷新到一半时，需要绘制的内容却变化了，由于显示器是逐行刷新的，于是显示器上半部分和下半部分实际上是来自两幅画面）。采用垂直同步技术可以解决这一问题。即，只有在显示器刷新时，才把绘制好的图象传输出去供显示。这样一来，计算机就不必去绘制大量的根本就用不到的图象了。如果显示器的刷新率为85Hz，则计算机一秒钟只需要绘制85幅图象就足够，如果场景足够简单，就会造成比较多的CPU空闲。 几乎所有的显卡都支持“垂直同步”这一功能。 垂直同步也有它的问题。如果刷新频率为60Hz，则在绘制比较简单的场景时，绘制一幅图画需要的时间很段，帧速可以恒定在60FPS（即60帧/秒）。如果场景变得复杂，绘制一幅图画的时间超过了1/60秒，则帧速将急剧下降。 如果绘制一幅图画的时间为1/50，则在第一个1/60秒时，显示器需要刷新了，但由于新的图画没有画好，所以只能显示原来的图画，等到下一个1/60秒时才显示新的图画。于是显示一幅图画实际上用了1/30秒，帧速为30FPS。（如果不采用垂直同步，则帧速应该是50FPS） 如果绘制一幅图画的时间更长，则下降的趋势就是阶梯状的：60FPS，30FPS，20FPS，……（60/1，60/2，60/3，……） 如果每一幅图画的复杂程度是不一致的，且绘制它们需要的时间都在1/60上下。则在1/60时间内画完时，帧速为60FPS，在1/60时间未完成时，帧速为30FPS，这就造成了帧速的跳动。这是很麻烦的事情，需要避免它——要么想办法简化每一画面的绘制时间，要么都延迟一小段时间，以作到统一。 回过头来看前面的问题。如果使用了大量的CPU而且速度很快无法看清，则打开垂直同步可以解决该问题。当然如果你认为垂直同步有这样那样的缺点，也可以关闭它。——至于如何打开和关闭，因操作系统而异了。具体步骤请自己搜索之。 当然，也有其它办法可以控制动画的帧速，或者尽量让动画的速度尽量和帧速无关。不过这里面很多内容都是与操作系统比较紧密的，况且它们跟OpenGL关系也不太大。这里就不做介绍了。 4、计算帧速 不知道大家玩过3D Mark这个软件没有，它可以运行各种场景，测出帧速，并且为你的系统给出评分。这里我也介绍一个计算帧速的方法。 根据定义，帧速就是一秒钟内播放的画面数目（FPS）。我们可以先测量绘制两幅画面之间时间t，然后求它的倒数即可。假如t=0.05s，则FPS的值就是1/0.05=20。 理论上是如此了，可是如何得到这个时间呢？通常C语言的time函数精确度一般只到一秒，肯定是不行了。clock函数也就到十毫秒左右，还是有点不够。因为FPS为60和FPS为100的时候，t的值都是十几毫秒。 你知道如何测量一张纸的厚度吗？一个粗略的办法就是：用很多张纸叠在一起测厚度，计算平均值就可以了。我们这里也可以这样办。测量绘制50幅画面（包括垂直同步等因素的等待时间）需要的时间t'，由t'=t*50很容易的得到FPS=1/t=50/t' 下面这段代码可以统计该函数自身的调用频率，（原理就像上面说的那样），程序并不复杂，并且这并不属于OpenGL的内容，所以我不打算详细讲述它。 Code: #include <time.h> double CalFrequency() {     static int count;     static double save;     static clock_t last, current;     double timegap;     ++count;     if( count <= 50 )         return save;     count = 0;     last = current;     current = clock();     timegap = (current-last)/(double)CLK_TCK;     save = 50.0/timegap;     return save; } 最后，要把计算的帧速显示出来，但我们并没有学习如何使用OpenGL把文字显示到屏幕上。——但不要忘了，在我们的图形窗口背后，还有一个命令行窗口~使用printf函数就可以轻易的输出文字了。 #include <stdio.h> double FPS = CalFrequency(); printf("FPS = %f\n", FPS); 最后的一步，也被我们解决了——虽然做法不太雅观，没关系，以后我们还会改善它的。 时间过得太久，每次给的程序都只是一小段，一些朋友难免会出问题。 现在，我给出一个比较完整的程序，供大家参考。 Code: #include <GL/glut.h> #include <stdio.h> #include <time.h> // 太阳、地球和月亮 // 假设每个月都是12天 // 一年12个月，共是360天 static int day = 200; // day的变化：从0到359 double CalFrequency() {     static int count;     static double save;     static clock_t last, current;     double timegap;     ++count;     if( count <= 50 )         return save;     count = 0;     last = current;     current = clock();     timegap = (current-last)/(double)CLK_TCK;     save = 50.0/timegap;     return save; } void myDisplay(void) {     double FPS = CalFrequency();     printf("FPS = %f\n", FPS);     glEnable(GL_DEPTH_TEST);     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     glMatrixMode(GL_PROJECTION);     glLoadIdentity();     gluPerspective(75, 1, 1, 400000000);     glMatrixMode(GL_MODELVIEW);     glLoadIdentity();     gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);     // 绘制红色的“太阳”     glColor3f(1.0f, 0.0f, 0.0f);     glutSolidSphere(69600000, 20, 20);     // 绘制蓝色的“地球”     glColor3f(0.0f, 0.0f, 1.0f);     glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f);     glTranslatef(150000000, 0.0f, 0.0f);     glutSolidSphere(15945000, 20, 20);     // 绘制黄色的“月亮”     glColor3f(1.0f, 1.0f, 0.0f);     glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f);     glTranslatef(38000000, 0.0f, 0.0f);     glutSolidSphere(4345000, 20, 20);     glFlush();     glutSwapBuffers(); } void myIdle(void) {     ++day;     if( day >= 360 )         day = 0;     myDisplay(); } int main(int argc, char *argv[]) {     glutInit(&argc, argv);     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);     glutInitWindowPosition(100, 100);     glutInitWindowSize(400, 400);     glutCreateWindow("太阳，地球和月亮");     glutDisplayFunc(&myDisplay);     glutIdleFunc(&myIdle);     glutMainLoop();     return 0; }