OpenGL入门学习

大家好，欢迎来到IT知识分享网。

环境搭建

$ sudo apt-get install build-essential

安装OpenGL Library

$ sudo apt-get install libgl1-mesa-dev

安装OpenGL Utilities

$ sudo apt-get install libglu1-mesa-dev

  OpenGL Utilities 是一组建构于 OpenGL Library 之上的工具组，提供许多很方便的函式，使 OpenGL 更强大且更容易使用。

  安装OpenGL Utility Toolkit

$ sudo apt-get install libglut-dev

Reading package lists... Done Building dependency tree Reading state information... Done E: Unable to locate package libglut-dev

将上述

$ sudo apt-get install libglut-dev

命令改成

$ sudo apt-get install freeglut3-dev

#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; }

编译

$ gcc -o test test.c -lGL -lGLU -lglut

  该程序的作用是在一个黑色的窗口中央画一个白色的矩形。下面对各行语句进行说明。

  首先，需要包含头文件#include <GL/glut.h>，这是GLUT的头文件。
  本来OpenGL程序一般还要包含<GL/gl.h>和<GL/glu.h>，但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入门学习[二]

  本次课程所要讲的是绘制简单的几何图形，在实际绘制之前，让我们先熟悉一些概念。

点、直线和多边形

  我们知道数学（具体的说，是几何学）中有点、直线和多边形的概念，但这些概念在计算机中会有所不同。数学上的点，只有位置，没有大小。但在计算机中，无论计算精度如何提高，始终不能表示一个无穷小的点。另一方面，无论图形输出设备（例如，显示器）如何精确，始终不能输出一个无穷小的点。一般情况下，OpenGL中的点将被画成单个的像素（像素的概念，请自己搜索之~），虽然它可能足够小，但并不会是无穷小。同一像素上，OpenGL可以绘制许多坐标只有稍微不同的点，但该像素的具体颜色将取决于OpenGL的实现。当然，过度的注意细节就是钻牛角尖，我们大可不必花费过多的精力去研究“多个点如何画到同一像素上”。同样的，数学上的直线没有宽度，但OpenGL的直线则是有宽度的。同时，OpenGL的直线必须是有限长度，而不是像数学概念那样是无限的。可以认为，OpenGL的“直线”概念与数学上的“线段”接近，它可以由两个端点来确定。多边形是由多条线段首尾相连而形成的闭合区域。OpenGL规定，一个多边形必须是一个“凸多边形”（其定义为：多边形内任意两点所确定的线段都在多边形内，由此也可以推导出，凸多边形不能是空心的）。多边形可以由其边的端点（这里可称为顶点）来确定。（注意：如果使用的多边形不是凸多边形，则最后输出的效果是未定义的——OpenGL为了效率，放宽了检查，这可能导致显示错误。要避免这个错误，尽量使用三角形，因为三角形都是凸多边形）

  可以想象，通过点、直线和多边形，就可以组合成各种几何图形。甚至于，你可以把一段弧看成是很多短的直线段相连，这些直线段足够短，以至于其长度小于一个像素的宽度。这样一来弧和圆也可以表示出来了。通过位于不同平面的相连的小多边形，我们还可以组成一个“曲面”。

在OpenGL中指定顶点

glVertex2d glVertex2f glVertex3f glVertex3fv

  这些函数除了参数的类型和个数不同以外，功能是相同的。例如，以下五个代码段的功能是等效的：

（一）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的很多函数都是采用这样的形式，一个相同的前缀再加上参数说明标记，这一点会随着学习的深入而有更多的体会。

开始绘制

glBegin(GL_POINTS); glVertex2f(0.0f, 0.0f); glVertex2f(0.5f, 0.0f); glEnd();

这里是对每种图形进行测试

  我并不准备在glBegin的各种方式上大作文章。大家可以自己尝试改变glBegin的方式和顶点的位置，生成一些有趣的图案。

void myDisplay(void) { glClear(GL_COLOR_BUFFER_BIT); glBegin( /* 在这里填上你所希望的模式 */ ); /* 在这里使用glVertex*系列函数 */ /* 指定你所希望的顶点位置 */ glEnd(); glFlush(); }

例一、画一个圆

#include <math.h> const int n = 20; const GLfloat R = 0.5f; const GLfloat Pi = 3.f; 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(); }

编译命令：

$ gcc -o test test.c -lGL -lGLU -lglut -lm

生成图形：

例二、画一个五角星

  首先，根据余弦定理列方程，计算五角星的中心到顶点的距离a （为什么这么计算我想了很久都无法想通，高中的数学喂狗了！！TODO）

a = 1 / (2-2*cos(72*Pi/180));

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.f; 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(); }

例三、画出正弦函数的图形

#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入门学习[三]

关于点

  点的大小默认为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(); }

关于直线

（1）直线可以指定宽度：

void glLineWidth(GLfloat width);

void glLineStipple(GLint factor, GLushort pattern);

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

关于这个这里介绍的还不是很详细，可以看博文：opengl 直线的线型(各种虚线)

关于多边形

glPolygonMode(GL_FRONT, GL_FILL); // 设置正面为填充方式 glPolygonMode(GL_BACK, GL_LINE); // 设置反面为边缘绘制方式 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // 设置两面均为顶点绘制方式

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

将glFrontFace(GL_CCW)修改为glFrontFace(GL_CW)之后运行结果：

  首先，使用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);

#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入门学习[四]

RGBA颜色

例如：

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系列函数，在参数类型不同时，表示“最大”颜色的值也不同。

索引颜色

选择颜色
  使用glIndex*系列函数可以在颜色表中选择颜色。其中最常用的可能是glIndexi，它的参数是一个整形。

void glIndexi(GLint c);

是的，这的确很简单。

设置颜色表
  OpenGL 并没有直接提供设置颜色表的方法，因此设置颜色表需要使用操作系统的支持。原文的例子是在windows下设置颜色表，这里略过。

指定清除屏幕用的颜色

void myDisplay(void) { glClearColor(1.0f, 0.0f, 0.0f, 0.0f); glClear(GL_COLOR_BUFFER_BIT); glFlush(); }

呵，这个还真简单~

指定着色模型

  OpenGL允许为同一多边形的不同顶点指定不同的颜色。例如：

#include <math.h> const GLdouble Pi = 3.; 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(); }

glShadeModel(GL_SMOOTH); // 平滑方式，这也是默认方式 glShadeModel(GL_FLAT); // 单色方式

OpenGL入门学习[五]

  在前面绘制几何图形的时候，大家是否觉得我们绘图的范围太狭隘了呢？坐标只能从-1到1，还只能是X轴向右，Y轴向上，Z轴垂直屏幕。这些限制给我们的绘图带来了很多不便。

  我们生活在一个三维的世界——如果要观察一个物体，我们可以：

这些，都可以在OpenGL中实现。

模型变换和视图变换

glMatrixMode(GL_MODELVIEW);

  通常，我们需要在进行变换前把当前矩阵设置为单位矩阵。这也只需要一行代码：

glLoadIdentity();

  然后，就可以进行 模型变换和视图变换了。进行模型和视图变换，主要涉及到三个函数：

  以上都是针对改变物体的位置和方向来介绍的。如果要改变观察点的位置，除了配合使用glRotate*和glTranslate*函数以外，还可以使用这个函数：gluLookAt。它的参数比较多，前三个参数表示了观察点的位置，中间三个参数表示了观察目标的位置，最后三个参数代表从(0,0,0)到 (x,y,z)的直线，它表示了观察者认为的“上”方向。

投影变换

glMatrixMode(GL_PROJECTION);

  通常，我们需要在进行变换前把当前矩阵设置为单位矩阵。

glLoadIdentity();

  正投影相当于在无限远处观察得到的结果，它只是一种理想状态。但对于计算机来说，使用正投影有可能获得更好的运行速度。使用glOrtho函数可以将当前的可视空间设置为正投影空间。

  如果绘制的图形空间本身就是二维的，可以使用gluOrtho2D。他的使用类似于glOrgho。

视口变换

操作矩阵堆栈

注意：模型视图矩阵和投影矩阵都有相应的堆栈。使用glMatrixMode来指定当前操作的究竟是模型视图矩阵还是投影矩阵。

综合举例

  好了，视图变换的入门知识差不多就讲完了。但我们不能就这样结束。因为本次课程的内容实在过于枯燥，如果分别举例，可能效果不佳。我只好综合的讲一个例子，算是给大家一个参考。至于实际的掌握，还要靠大家自己花功夫。闲话少说，现在进入正题。

  我们要制作的是一个三维场景，包括了太阳、地球和月亮。假定一年有12个月，每个月30天。每年，地球绕着太阳转一圈。每个月，月亮围着地球转一圈。即一年有360天。

  现在给出日期的编号（0~359），要求绘制出太阳、地球、月亮的相对位置示意图。（这是为了编程方便才这样设计的。如果需要制作更现实的情况，那也只是一些数值处理而已，与OpenGL关系不大）

  首先，让我们认定这三个天体都是球形，且他们的运动轨迹处于同一水平面，建立以下坐标系：太阳的中心为原点，天体轨迹所在的平面表示了X轴与Y轴决定的平面，且每年第一天，地球在X轴正方向上，月亮在地球的正X轴方向。

  下一步是确立可视空间。注意：太阳的半径要比太阳到地球的距离短得多。如果我们直接使用天文观测得到的长度比例，则当整个窗口表示地球轨道大小时，太阳的大小将被忽略。因此，我们只能成倍的放大几个天体的半径，以适应我们观察的需要。（百度一下，得到太阳、地球、月亮的大致半径分别是：km，6378km，1738km。地球到太阳的距离约为1.5亿km=km，月亮到地球的距离约为km。）

  让我们假想一些数据，将三个天体的半径分别“修改”为：（放大100倍），（放大2500倍），（放大2500倍）。将地球到月亮的距离“修改”为（放大100倍）。地球到太阳的距离保持不变。

  为了让地球和月亮在离我们很近时，我们仍然不需要变换观察点和观察方向就可以观察它们，我们把观察点放在这个位置：(0, -, 0) ——因为地球轨道半径为，咱们就凑个整，取-就可以了。观察目标设置为原点（即太阳中心），选择Z轴正方向作为 “上”方。当然我们还可以把观察点往“上”方移动一些，得到(0, -, )，这样可以得到45度角的俯视效果。

  为了得到透视效果，我们使用gluPerspective来设置可视空间。假定可视角为60度（如果调试时发现该角度不合适，可修改之。我在最后选择的数值是75。）高宽比为1.0。最近可视距离为1.0，最远可视距离为*2=。即：gluPerspective (60, 1, 1, );现在我们来看看如何绘制这三个天体。

  为了简单起见，我们把三个天体都想象成规则的球体。而我们所使用的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把三维坐标中的物体绘制到二维屏幕，绘制的顺序是按照代码的顺序来进行的。因此后绘制的物体会遮住先绘制的物体，即使后绘制的物体在先绘制的物体的“后面”也是如此。使用深度测试可以解决这一问题。使用的方法是：

  到此为止，我们终于可以得到整个“太阳，地球和月亮”系统的完整代码。

// 太阳、地球和月亮 // 假设每个月都是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, ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0, -, , 0, 0, 0, 0, 0, 1); // 绘制红色的“太阳” glColor3f(1.0f, 0.0f, 0.0f); glutSolidSphere(, 20, 20); // 绘制蓝色的“地球” glColor3f(0.0f, 0.0f, 1.0f); glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f); glTranslatef(, 0.0f, 0.0f); glutSolidSphere(, 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(, 0.0f, 0.0f); glutSolidSphere(, 20, 20); glFlush(); }

  好了，艰苦的一课终于完毕。我知道，本课的内容十分枯燥，就连最后的例子也是。但我也没有更好的办法了，希望大家能坚持过去。不必担心，熟悉本课内容后，以后的一段时间内，都会是比较轻松愉快的了。

OpenGL入门学习[六]

  今天要讲的是动画制作——可能是各位都很喜欢的。除了讲授知识外，我们还会让昨天那个“太阳、地球和月亮”天体图画动起来。缓和一下枯燥的气氛。

  本次课程，我们将进入激动人心的计算机动画世界。

  想必大家都知道电影和动画的工作原理吧？是的，快速的把看似连续的画面一幅幅的呈现在人们面前。一旦每秒钟呈现的画面超过24幅，人们就会错以为它是连续的。

  我们通常观看的电视，每秒播放25或30幅画面。但对于计算机来说，它可以播放更多的画面，以达到更平滑的效果。如果速度过慢，画面不够平滑。如果速度过快，则人眼未必就能反应得过来。对于一个正常人来说，每秒60~120幅图画是比较合适的。具体的数值因人而异。

  假设某动画一共有n幅画面，则它的工作步骤就是：

  如果用C语言伪代码来描述这一过程，就是：

for(i=0; i<n; ++i) { DrawScene(i); Wait(); }

双缓冲技术

  在计算机上的动画与实际的动画有些不同：实际的动画都是先画好了，播放的时候直接拿出来显示就行。计算机动画则是画一张，就拿出来一张，再画下一张，再拿出来。如果所需要绘制的图形很简单，那么这样也没什么问题。但一旦图形比较复杂，绘制需要的时间较长，问题就会变得突出。

  让我们把计算机想象成一个画图比较快的人，假如他直接在屏幕上画图，而图形比较复杂，则有可能在他只画了某幅图的一半的时候就被观众看到。而后面虽然他把画补全了，但观众的眼睛却又没有反应过来，还停留在原来那个残缺的画面上。也就是说，有时候观众看到完整的图象，有时却又只看到残缺的图象，这样就造成了屏幕的闪烁。

  如何解决这一问题呢？我们设想有两块画板，画图的人在旁边画，画好以后把他手里的画板与挂在屏幕上的画板相交换。这样以来，观众就不会看到残缺的画了。这一技术被应用到计算机图形中，称为双缓冲技术。即：在存储器（很有可能是显存）中开辟两块区域，一块作为发送到显示器的数据，一块作为绘画的区域，在适当的时候交换它们。由于交换两块内存区域实际上只需要交换两个指针，这一方法效率非常高，所以被广泛的采用。

注意：虽然绝大多数平台都支持双缓冲技术，但这一技术并不是OpenGL标准中的内容。OpenGL为了保证更好的可移植性，允许在实现时不使用双缓冲技术。当然，我们常用的PC都是支持双缓冲技术的。

  要启动双缓冲功能，最简单的办法就是使用GLUT工具包。我们以前在main函数里面写：

glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);

实现连续动画

  似乎没有任何疑问，我们应该把绘制动画的代码写成下面这个样子：

for(i=0; i<n; ++i) { DrawScene(i); glutSwapBuffers(); Wait(); }

  但事实上，这样做不太符合窗口系统的程序设计思路。还记得我们的第一个OpenGL程序吗？我们在main函数里写：

glutDisplayFunc(&myDisplay);

  这里的“在CPU空闲的时间绘制”和我们在第一课讲的“在需要绘制的时候绘制”有些共通，都是“在XX时间做XX事”，GLUT工具包也提供了一个比较类似的函数：glutIdleFunc，表示在CPU空闲的时间调用某一函数。其实GLUT还提供了一些别的函数，例如“在键盘按下时做某事”等。

  到现在，我们已经可以初步开始制作动画了。好的，就拿上次那个“太阳、地球和月亮”的程序开刀，让地球和月亮自己动起来。

#include <GL/glut.h> #include <stdio.h> #include <stdlib.h> #include <GL/glut.h> // 太阳、地球和月亮 // 假设每个月都是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, ); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0, -, , 0, 0, 0, 0, 0, 1); // 绘制红色的“太阳” glColor3f(1.0f, 0.0f, 0.0f); glutSolidSphere(, 20, 20); // 绘制蓝色的“地球” glColor3f(0.0f, 0.0f, 1.0f); glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f); glTranslatef(, 0.0f, 0.0f); glutSolidSphere(, 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(, 0.0f, 0.0f); glutSolidSphere(, 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); // 修改了参数为GLUT_DOUBLE glutInitWindowPosition(100, 100); glutInitWindowSize(400, 400); glutCreateWindow("太阳，地球和月亮"); // 改了窗口标题 glutDisplayFunc(&myDisplay); glutIdleFunc(&myIdle); // 新加入了这句 glutMainLoop(); return 0; }

因为这个是动态的结果截图无意义，这里就不上图了。

关于垂直同步

  代码是写好了，但相信大家还有疑问。某些朋友可能在运行时发现，虽然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关系也不太大。这里就不做介绍了。

计算帧速

#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);

OpenGL入门学习[七]

  今天要讲的是OpenGL光照的基本知识。虽然内容显得有点多，但条理还算比较清晰，理解起来应该没有困难。即使对于一些内容没有记住，问题也不大——光照部分是一个比较独立的内容，它的学习与其它方面的学习可以分开，不像视图变换那样，影响到许多方面。课程的最后给出了一个有关光照效果的动画演示程序，我想大家会喜欢的。

  从生理学的角度上讲，眼睛之所以看见各种物体，是因为光线直接或间接的从它们那里到达了眼睛。人类对于光线强弱的变化的反应，比对于颜色变化的反应来得灵敏。因此对于人类而言，光线很大程度上表现了物体的立体感。

  OpenGL对于光照效果提供了直接的支持，只需要调用某些函数，便可以实现简单的光照效果。但是在这之前，我们有必要了解一些基础知识。

建立光照模型

  在现实生活中，某些物体本身就会发光，例如太阳、电灯等，而其它物体虽然不会发光，但可以反射来自其它物体的光。这些光通过各种方式传播，最后进入我们的眼睛——于是一幅画面就在我们的眼中形成了。

法线向量

注意：使用glTranslate*函数或者glRotate*函数可以改变物体的外观，但法线向量并不会随之改变。然而，使用glScale*函数，对每一坐标轴进行不同程度的缩放，很有可能导致法线向量的不正确，虽然OpenGL提供了一些措施来修正这一问题，但由此也带来了各种开销。因此，在使用了法线向量的场合，应尽量避免使用glScale*函数。即使使用，也最好保证各坐标轴进行等比例缩放。

控制光源

  在OpenGL中，仅仅支持有限数量的光源。使用GL_LIGHT0表示第0号光源，GL_LIGHT1表示第1号光源，依次类推，OpenGL至少会支持8个光源，即GL_LIGHT0到GL_LIGHT7。使用glEnable函数可以开启它们。例如，glEnable(GL_LIGHT0);可以开启第0号光源。使用glDisable函数则可以关闭光源。一些OpenGL实现可能支持更多数量的光源，但总的来说，开启过多的光源将会导致程序运行速度的严重下降，玩过3D Mark的朋友可能多少也有些体会。一些场景中可能有成百上千的电灯，这时可能需要采取一些近似的手段来进行编程，否则以目前的计算机而言，是无法运行这样的程序的。
  每一个光源都可以设置其属性，这一动作是通过glLight*函数完成的。glLight*函数具有三个参数，第一个参数指明是设置哪一个光源的属性，第二个参数指明是设置该光源的哪一个属性，第三个参数则是指明把该属性值设置成多少。光源的属性众多，下面将分别介绍。

（1）GL_AMBIENT、GL_DIFFUSE、GL_SPECULAR属性。这三个属性表示了光源所发出的光的反射特性（以及颜色）。每个属性由四个值表示，分别代表了颜色的R, G, B, A值。GL_AMBIENT表示该光源所发出的光，经过非常多次的反射后，最终遗留在整个光照环境中的强度（颜色）。GL_DIFFUSE表示该光源所发出的光，照射到粗糙表面时经过漫反射，所得到的光的强度（颜色）。GL_SPECULAR表示该光源所发出的光，照射到光滑表面时经过镜面反射，所得到的光的强度（颜色）。

（2）GL_POSITION属性。表示光源所在的位置。由四个值（X, Y, Z, W）表示。如果第四个值W为零，则表示该光源位于无限远处，前三个值表示了它所在的方向。这种光源称为方向性光源，通常，太阳可以近似的被认为是方向性光源。如果第四个值W不为零，则X/W, Y/W, Z/W表示了光源的位置。这种光源称为位置性光源。对于位置性光源，设置其位置与设置多边形顶点的方式相似，各种矩阵变换函数例如：glTranslate*、glRotate*等在这里也同样有效。方向性光源在计算时比位置性光源快了不少，因此，在视觉效果允许的情况下，应该尽可能的使用方向性光源。

（3）GL_SPOT_DIRECTION、GL_SPOT_EXPONENT、GL_SPOT_CUTOFF属性。表示将光源作为聚光灯使用（这些属性只对位置性光源有效）。很多光源都是向四面八方发射光线，但有时候一些光源则是只向某个方向发射，比如手电筒，只向一个较小的角度发射光线。GL_SPOT_DIRECTION属性有三个值，表示一个向量，即光源发射的方向。GL_SPOT_EXPONENT属性只有一个值，表示聚光的程度，为零时表示光照范围内向各方向发射的光线强度相同，为正数时表示光照向中央集中，正对发射方向的位置受到更多光照，其它位置受到较少光照。数值越大，聚光效果就越明显。

（4）GL_CONSTANT_ATTENUATION、GL_LINEAR_ATTENUATION、GL_QUADRATIC_ATTENUATION属性。这三个属性表示了光源所发出的光线的直线传播特性（这些属性只对位置性光源有效）。现实生活中，光线的强度随着距离的增加而减弱，OpenGL把这个减弱的趋势抽象成函数：

衰减因子 = 1 / (k1 + k2 * d + k3 * k3 * d)

  其中d表示距离，光线的初始强度乘以衰减因子，就得到对应距离的光线强度。k1,k2,k3分别就是GL_CONSTANT_ATTENUATION, GL_LINEAR_ATTENUATION, GL_QUADRATIC_ATTENUATION。通过设置这三个常数，就可以控制光线在传播过程中的减弱趋势。属性还真是不少。当然了，如果是使用方向性光源，（3）（4）这两类属性就不会用到了，问题就变得简单明了。

控制材质

  材质与光源相似，也需要设置众多的属性。不同的是，光源是通过glLight*函数来设置的，而材质则是通过glMaterial*函数来设置的。

  glMaterial*函数有三个参数。第一个参数表示指定哪一面的属性。可以是GL_FRONT、GL_BACK或者GL_FRONT_AND_BACK。分别表示设置“正面”“背面”的材质，或者两面同时设置。（关于“正面”“背面”的内容需要参看前些课程的内容）第二、第三个参数与glLight*函数的第二、三个参数作用类似。下面分别说明glMaterial*函数可以指定的材质属性。

（1）GL_AMBIENT、GL_DIFFUSE、GL_SPECULAR属性。这三个属性与光源的三个对应属性类似，每一属性都由四个值组成。GL_AMBIENT表示各种光线照射到该材质上，经过很多次反射后最终遗留在环境中的光线强度（颜色）。GL_DIFFUSE表示光线照射到该材质上，经过漫反射后形成的光线强度（颜色）。GL_SPECULAR表示光线照射到该材质上，经过镜面反射后形成的光线强度（颜色）。通常，GL_AMBIENT和GL_DIFFUSE都取相同的值，可以达到比较真实的效果。使用GL_AMBIENT_AND_DIFFUSE可以同时设置GL_AMBIENT和GL_DIFFUSE属性。

（2）GL_SHININESS属性。该属性只有一个值，称为“镜面指数”，取值范围是0到128。该值越小，表示材质越粗糙，点光源发射的光线照射到上面，也可以产生较大的亮点。该值越大，表示材质越类似于镜面，光源照射到上面后，产生较小的亮点。

（3）GL_EMISSION属性。该属性由四个值组成，表示一种颜色。OpenGL认为该材质本身就微微的向外发射光线，以至于眼睛感觉到它有这样的颜色，但这光线又比较微弱，以至于不会影响到其它物体的颜色。

（4）GL_COLOR_INDEXES属性。该属性仅在颜色索引模式下使用，由于颜色索引模式下的光照比RGBA模式要复杂，并且使用范围较小，这里不做讨论。

选择光照模型

最后的准备

  到现在可以说是完事俱备了。不过，OpenGL默认是关闭光照处理的。要打开光照处理功能，使用下面的语句：

glEnable(GL_LIGHTING);

  要关闭光照处理功能，使用glDisable(GL_LIGHTING);即可。

示例程序

下面给出具体的代码：

#include <gl/glut.h> #define WIDTH 400 #define HEIGHT 400 static GLfloat angle = 0.0f; void myDisplay(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 创建透视效果视图 glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(90.0f, 1.0f, 1.0f, 20.0f); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0, 5.0, -10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); // 定义太阳光源，它是一种白色的光源 { GLfloat sun_light_position[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat sun_light_ambient[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat sun_light_diffuse[] = { 
  1.0f, 1.0f, 1.0f, 1.0f}; GLfloat sun_light_specular[] = { 
  1.0f, 1.0f, 1.0f, 1.0f}; glLightfv(GL_LIGHT0, GL_POSITION, sun_light_position); glLightfv(GL_LIGHT0, GL_AMBIENT, sun_light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, sun_light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, sun_light_specular); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glEnable(GL_DEPTH_TEST); } // 定义太阳的材质并绘制太阳 { GLfloat sun_mat_ambient[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat sun_mat_diffuse[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat sun_mat_specular[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat sun_mat_emission[] = { 
  0.5f, 0.0f, 0.0f, 1.0f}; GLfloat sun_mat_shininess = 0.0f; glMaterialfv(GL_FRONT, GL_AMBIENT, sun_mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, sun_mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, sun_mat_specular); glMaterialfv(GL_FRONT, GL_EMISSION, sun_mat_emission); glMaterialf (GL_FRONT, GL_SHININESS, sun_mat_shininess); glutSolidSphere(2.0, 40, 32); } // 定义地球的材质并绘制地球 { GLfloat earth_mat_ambient[] = { 
  0.0f, 0.0f, 0.5f, 1.0f}; GLfloat earth_mat_diffuse[] = { 
  0.0f, 0.0f, 0.5f, 1.0f}; GLfloat earth_mat_specular[] = { 
  0.0f, 0.0f, 1.0f, 1.0f}; GLfloat earth_mat_emission[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; GLfloat earth_mat_shininess = 30.0f; glMaterialfv(GL_FRONT, GL_AMBIENT, earth_mat_ambient); glMaterialfv(GL_FRONT, GL_DIFFUSE, earth_mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, earth_mat_specular); glMaterialfv(GL_FRONT, GL_EMISSION, earth_mat_emission); glMaterialf (GL_FRONT, GL_SHININESS, earth_mat_shininess); glRotatef(angle, 0.0f, -1.0f, 0.0f); glTranslatef(5.0f, 0.0f, 0.0f); glutSolidSphere(2.0, 40, 32); } glutSwapBuffers(); } void myIdle(void) { angle += 1.0f; if( angle >= 360.0f ) angle = 0.0f; myDisplay(); } int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(200, 200); glutInitWindowSize(WIDTH, HEIGHT); glutCreateWindow("OpenGL光照演示"); glutDisplayFunc(&myDisplay); glutIdleFunc(&myIdle); glutMainLoop(); return 0; }

  可以使用多个光源来实现各种逼真的效果，然而，光源数量的增加将造成程序运行速度的明显下降。

OpenGL入门学习[八]

  同时，考虑这样一段代码：

const int segments = 100; const GLfloat pi = 3.14f; int i; glLineWidth(10.0); glBegin(GL_LINE_LOOP); for(i=0; i<segments; ++i) { GLfloat tmp = 2 * pi * i / segments; glVertex2f(cos(tmp), sin(tmp)); } glEnd();

分配显示列表编号

创建显示列表

glNewList(list, GL_COMPILE); glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.0f, 0.0f); glEnd();

  注意：显示列表只能装入OpenGL函数，而不能装入其它内容。例如：

int i = 3; glNewList(list, GL_COMPILE); if( i > 20 ) glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.0f, 0.0f); glEnd();

  其中if这个判断就没有被装入到显示列表。以后即使修改i的值，使i>20的条件成立，则glColor3f这个函数也不会被执行。因为它根本就不存在于显示列表中。

  另外，并非所有的OpenGL函数都可以装入到显示列表中。例如，各种用于查询的函数，它们无法被装入到显示列表，因为它们都具有返回值，而glCallList和glCallLists函数都不知道如何处理这些返回值。在网络方式下，设置客户端状态的函数也无法被装入到显示列表，这是因为显示列表被保存到服务器端，各种设置客户端状态的函数在发送到服务器端以前就被执行了，而服务器端无法执行这些函数。分配、创建、删除显示列表的动作也无法被装入到另一个显示列表，但调用显示列表的动作则可以被装入到另一个显示列表。

调用显示列表

  使用glCallList函数可以调用一个显示列表。该函数有一个参数，表示要调用的显示列表的编号。例如，要调用编号为10的显示列表，直接使用glCallList(10);就可以了。
  使用glCallLists函数可以调用一系列的显示列表。该函数有三个参数，第一个参数表示了要调用多少个显示列表。第二个参数表示了这些显示列表的编号的储存格式，可以是GL_BYTE（每个编号用一个GLbyte表示），GL_UNSIGNED_BYTE（每个编号用一个GLubyte表示），GL_SHORT，GL_UNSIGNED_SHORT，GL_INT，GL_UNSIGNED_INT，GL_FLOAT。第三个参数表示了这些显示列表的编号所在的位置。在使用该函数前，需要用glListBase函数来设置一个偏移量。假设偏移量为k，且glCallLists中要求调用的显示列表编号依次为l1, l2, l3, …，则实际调用的显示列表为l1+k, l2+k, l3+k, …。
例如：

GLuint lists[] = {1, 3, 4, 8}; glListBase(10); glCallLists(4, GL_UNSIGNED_INT, lists);

  则实际上调用的是编号为11, 13, 14, 18的四个显示列表。

注：“调用显示列表”这个动作本身也可以被装在另一个显示列表中。

销毁显示列表

• 1 明显的减少OpenGL函数的调用次数。如果函数调用是通过网络进行的（Linux等操作系统支持这样的方式，即由应用程序在客户端发出OpenGL请求，由网络上的另一台服务器进行实际的绘图操作），将显示列表保存在服务器端，可以大大减少网络负担。
• 2 保存中间结果，避免一些不必要的计算。例如前面的样例程序中，cos、sin函数的计算结果被直接保存到显示列表中，以后使用时就不必重复计算。
• 3 便于优化。我们已经知道，使用glTranslate*、glRotate*、glScale*等函数时，实际上是执行矩阵乘法操作，由于这些函数经常被组合在一起使用，通常会出现矩阵的连乘。这时，如果把这些操作保存到显示列表中，则一些复杂的OpenGL版本会尝试先计算出连乘的一部分结果，从而提高程序的运行速度。在其它方面也可能存在类似的例子。

 A点：( 0.5, -sqrt(6)/12, -sqrt(3)/6) B点：( -0.5, -sqrt(6)/12, -sqrt(3)/6) C点：( 0, -sqrt(6)/12, sqrt(3)/3) D点：( 0, sqrt(6)/4, 0)

  程序代码中也做了相应的修改

  下面给出程序代码，大家可以从中体会一下显示列表的用法。

#include <GL/glut.h> #include <stdio.h> #include <stdlib.h> #include <GL/glut.h> #define WIDTH 400 #define HEIGHT 400 #include <math.h> #define ColoredVertex(c, v) do{ glColor3fv(c); glVertex3fv(v); }while(0) GLfloat angle = 0.0f; void myDisplay(void) { static int list = 0; if( list == 0 ) { // 如果显示列表不存在，则创建 /* GLfloat PointA[] = {-0.5, -5*sqrt(5)/48, sqrt(3)/6}, PointB[] = { 0.5, -5*sqrt(5)/48, sqrt(3)/6}, PointC[] = { 0, -5*sqrt(5)/48, -sqrt(3)/3}, PointD[] = { 0, 11*sqrt(6)/48, 0}; */ // 2007年4月27日修改 GLfloat PointA[] = { 0.5f, -sqrt(6.0f)/12, -sqrt(3.0f)/6}, PointB[] = {-0.5f, -sqrt(6.0f)/12, -sqrt(3.0f)/6}, PointC[] = { 0.0f, -sqrt(6.0f)/12, sqrt(3.0f)/3}, PointD[] = { 0.0f, sqrt(6.0f)/4, 0}; GLfloat ColorR[] = { 
  1, 0, 0}, ColorG[] = { 
  0, 1, 0}, ColorB[] = { 
  0, 0, 1}, ColorY[] = { 
  1, 1, 0}; list = glGenLists(1); glNewList(list, GL_COMPILE); glBegin(GL_TRIANGLES); // 平面ABC ColoredVertex(ColorR, PointA); ColoredVertex(ColorG, PointB); ColoredVertex(ColorB, PointC); // 平面ACD ColoredVertex(ColorR, PointA); ColoredVertex(ColorB, PointC); ColoredVertex(ColorY, PointD); // 平面CBD ColoredVertex(ColorB, PointC); ColoredVertex(ColorG, PointB); ColoredVertex(ColorY, PointD); // 平面BAD ColoredVertex(ColorG, PointB); ColoredVertex(ColorR, PointA); ColoredVertex(ColorY, PointD); glEnd(); glEndList(); glEnable(GL_DEPTH_TEST); } // 已经创建了显示列表，在每次绘制正四面体时将调用它 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPushMatrix(); glRotatef(angle, 1, 0.5, 0); glCallList(list); glPopMatrix(); glutSwapBuffers(); } void myIdle(void) { ++angle; if( angle >= 360.0f ) angle = 0.0f; myDisplay(); } int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowPosition(200, 200); glutInitWindowSize(WIDTH, HEIGHT); glutCreateWindow("OpenGL 窗口"); glutDisplayFunc(&myDisplay); glutIdleFunc(&myIdle); glutMainLoop(); return 0; }

void setNormal(GLfloat* Point1, GLfloat* Point2, GLfloat* Point3) { GLfloat normal[3]; int i; for(i=0; i<3; ++i) normal[i] = (Point1[i]+Point2[i]+Point3[i]) / 3; glNormal3fv(normal); }

  限于篇幅，这里就不给出完整的程序了。不过，大家可以自行尝试，看看使用光照后效果有何种改观。尤其是注意四面体各个表面交界的位置，在未使用光照前，几乎看不清轮廓，在使用光照后，可比较容易的区分各个平面，因此立体感得到加强。

  当然了，这样的效果还不够。如果在各表面的交界处设置很多细小的平面，进行平滑处理，则光照后的效果将更真实。但这已经远离本课的内容了。

OpenGL入门学习[九]

注意：只有在RGBA模式下，才可以使用混合功能，颜色索引模式下是无法使用混合功能的。

源因子和目标因子

(Rs*Sr+Rd*Dr, Gs*Sg+Gd*Dg, Bs*Sb+Bd*Db, As*Sa+Ad*Da)

  当然了，如果颜色的某一分量超过了1.0，则它会被自动截取为1.0，不需要考虑越界的问题。

  源因子和目标因子是可以通过glBlendFunc函数来进行设置的。glBlendFunc有两个参数，前者表示源因子，后者表示目标因子。这两个参数可以是多种值，下面介绍比较常用的几种。

  除此以外，还有GL_SRC_COLOR（把源颜色的四个分量分别作为因子的四个分量）、GL_ONE_MINUS_SRC_COLOR、GL_DST_COLOR、GL_ONE_MINUS_DST_COLOR等，前两个在OpenGL旧版本中只能用于设置目标因子，后两个在OpenGL旧版本中只能用于设置源因子。新版本的OpenGL则没有这个限制，并且支持新的GL_CONST_COLOR（设定一种常数颜色，将其四个分量分别作为因子的四个分量）、GL_ONE_MINUS_CONST_COLOR、GL_CONST_ALPHA、GL_ONE_MINUS_CONST_ALPHA。另外还有GL_SRC_ALPHA_SATURATE。新版本的OpenGL还允许颜色的alpha值和RGB值采用不同的混合因子。但这些都不是我们现在所需要了解的。毕竟这还是入门教材，不需要整得太复杂~

二维图形混合举例

  下面看一个简单的例子，实现将两种不同的颜色混合在一起。为了便于观察，我们绘制两个矩形：glRectf(-1, -1, 0.5, 0.5);glRectf(-0.5, -0.5, 1, 1);，这两个矩形有一个重叠的区域，便于我们观察混合的效果。
  先来看看使用glBlendFunc(GL_ONE, GL_ZERO);的它的结果与不使用混合时相同。

void myDisplay(void) { glClear(GL_COLOR_BUFFER_BIT); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ZERO); glColor4f(1, 0, 0, 0.5); glRectf(-1, -1, 0.5, 0.5); glColor4f(0, 1, 0, 0.5); glRectf(-0.5, -0.5, 1, 1); glutSwapBuffers(); }

  尝试把glBlendFunc的参数修改为

glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_ONE, GL_ONE);

第二种情况：

实现三维混合

  也许你迫不及待的想要绘制一个三维的带有半透明物体的场景了。但是现在恐怕还不行，还有一点是在进行三维场景的混合时必须注意的，那就是深度缓冲。

  深度缓冲是这样一段数据，它记录了每一个像素距离观察者有多近。在启用深度缓冲测试的情况下，如果将要绘制的像素比原来的像素更近，则像素将被绘制。否则，像素就会被忽略掉，不进行绘制。这在绘制不透明的物体时非常有用——不管是先绘制近的物体再绘制远的物体，还是先绘制远的物体再绘制近的物体，或者干脆以混乱的顺序进行绘制，最后的显示结果总是近的物体遮住远的物体。

  然而在你需要实现半透明效果时，发现一切都不是那么美好了。如果你绘制了一个近距离的半透明物体，则它在深度缓冲区内保留了一些信息，使得远处的物体将无法再被绘制出来。虽然半透明的物体仍然半透明，但透过它看到的却不是正确的内容了。

  要解决以上问题，需要在绘制半透明物体时将深度缓冲区设置为只读，这样一来，虽然半透明物体被绘制上去了，深度缓冲区还保持在原来的状态。如果再有一个物体出现在半透明物体之后，在不透明物体之前，则它也可以被绘制（因为此时深度缓冲区中记录的是那个不透明物体的深度）。以后再要绘制不透明物体时，只需要再将深度缓冲区设置为可读可写的形式即可。嗯？你问我怎么绘制一个一部分半透明一部分不透明的物体？这个好办，只需要把物体分为两个部分，一部分全是半透明的，一部分全是不透明的，分别绘制就可以了。
  即使使用了以上技巧，我们仍然不能随心所欲的按照混乱顺序来进行绘制。必须是先绘制不透明的物体，然后绘制透明的物体。否则，假设背景为蓝色，近处一块红色玻璃，中间一个绿色物体。如果先绘制红色半透明玻璃的话，它先和蓝色背景进行混合，则以后绘制中间的绿色物体时，想单独与红色玻璃混合已经不能实现了。

  总结起来，绘制顺序就是：首先绘制所有不透明的物体。如果两个物体都是不透明的，则谁先谁后都没有关系。然后，将深度缓冲区设置为只读。接下来，绘制所有半透明的物体。如果两个物体都是半透明的，则谁先谁后只需要根据自己的意愿（注意了，先绘制的将成为“目标颜色”，后绘制的将成为“源颜色”，所以绘制的顺序将会对结果造成一些影响）。最后，将深度缓冲区设置为可读可写形式。

  调用glDepthMask(GL_FALSE);可将深度缓冲区设置为只读形式。调用glDepthMask(GL_TRUE);可将深度缓冲区设置为可读可写形式。

  一些网上的教程，包括大名鼎鼎的NeHe教程，都在使用三维混合时直接将深度缓冲区禁用，即调用glDisable(GL_DEPTH_TEST);。这样做并不正确。如果先绘制一个不透明的物体，再在其背后绘制半透明物体，本来后面的半透明物体将不会被显示（被不透明的物体遮住了），但如果禁用深度缓冲，则它仍然将会显示，并进行混合。NeHe提到某些显卡在使用glDepthMask函数时可能存在一些问题，但可能是由于我的阅历有限，并没有发现这样的情况。

  那么，实际的演示一下吧。我们来绘制一些半透明和不透明的球体。假设有三个球体，一个红色不透明的，一个绿色半透明的，一个蓝色半透明的。红色最远，绿色在中间，蓝色最近。根据前面所讲述的内容，红色不透明球体必须首先绘制，而绿色和蓝色则可以随意修改顺序。这里为了演示不注意设置深度缓冲的危害，我们故意先绘制最近的蓝色球体，再绘制绿色球体。

  为了让这些球体有一点立体感，我们使用光照。在(1, 1, -1)处设置一个白色的光源。代码如下：

void setLight(void) { static const GLfloat light_position[] = { 
  1.0f, 1.0f, -1.0f, 1.0f}; static const GLfloat light_ambient[] = { 
  0.2f, 0.2f, 0.2f, 1.0f}; static const GLfloat light_diffuse[] = { 
  1.0f, 1.0f, 1.0f, 1.0f}; static const GLfloat light_specular[] = { 
  1.0f, 1.0f, 1.0f, 1.0f}; glLightfv(GL_LIGHT0, GL_POSITION, light_position); glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular); glEnable(GL_LIGHT0); glEnable(GL_LIGHTING); glEnable(GL_DEPTH_TEST); }

  每一个球体颜色不同。所以它们的材质也都不同。这里用一个函数来设置材质。

void setMatirial(const GLfloat mat_diffuse[4], GLfloat mat_shininess) { static const GLfloat mat_specular[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; static const GLfloat mat_emission[] = { 
  0.0f, 0.0f, 0.0f, 1.0f}; glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_diffuse); glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular); glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission); glMaterialf (GL_FRONT, GL_SHININESS, mat_shininess); }

  有了这两个函数，我们就可以根据前面的知识写出整个程序代码了。这里只给出了绘制的部分，其它部分大家可以自行完成。

void myDisplay(void) { // 定义一些材质颜色 const static GLfloat red_color[] = { 
  1.0f, 0.0f, 0.0f, 1.0f}; const static GLfloat green_color[] = { 
  0.0f, 1.0f, 0.0f, 0.3333f}; const static GLfloat blue_color[] = { 
  0.0f, 0.0f, 1.0f, 0.5f}; // 清除屏幕 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // 启动混合并设置混合因子 glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // 设置光源 setLight(); // 以(0, 0, 0.5)为中心，绘制一个半径为.3的不透明红色球体（离观察者最远） setMatirial(red_color, 30.0); glPushMatrix(); glTranslatef(0.0f, 0.0f, 0.5f); glutSolidSphere(0.3, 30, 30); glPopMatrix(); // 下面将绘制半透明物体了，因此将深度缓冲设置为只读 glDepthMask(GL_FALSE); // 以(0.2, 0, -0.5)为中心，绘制一个半径为.2的半透明蓝色球体（离观察者最近） setMatirial(blue_color, 30.0); glPushMatrix(); glTranslatef(0.2f, 0.0f, -0.5f); glutSolidSphere(0.2, 30, 30); glPopMatrix(); // 以(0.1, 0, 0)为中心，绘制一个半径为.15的半透明绿色球体（在前两个球体之间） setMatirial(green_color, 30.0); glPushMatrix(); glTranslatef(0.1, 0, 0); glutSolidSphere(0.15, 30, 30); glPopMatrix(); // 完成半透明物体的绘制，将深度缓冲区恢复为可读可写的形式 glDepthMask(GL_TRUE); glutSwapBuffers(); }

  大家也可以将上面两处glDepthMask删去，结果会看到最近的蓝色球虽然是半透明的，但它的背后直接就是红色球了，中间的绿色球没有被正确绘制。（我经过测试发现不是这样的，和原来的显示一样，是不是因为版本改变了？？）

/*/
转来的东西，原文是在windows上开发，这里在linux下稍作修改就能跑起来。