OpenGL图形编程入门
OpenGL3D
1.1OpenGL
我们生活在一个充满三维物体的三维世界中，为了使计算机能精确地再现这些物体，我们必须能在三
维空间描绘这些物体。我们又生活在一个充满信息的世界中，能否尽快地理解并运用这些信息将直接影响
事业的成败，所以我们需要用一种最直接的形式来
表
关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf
示这些信息。
最近几年计算机图形学的发展使得三维表现技术得以形成，这些三维表现技术使我们能够再现三维世
界中的物体，能够用三维形体来表示复杂的信息，这种技术就是可视化（Visualization） 技术。可视化技术使人能够在三维图形世界中直接对具有形体的信息进行操作，和计算机直接交流。这种技术已经把人
和机器的力量以一种直觉而自然的方式加以统 一，这种革命性的变化无疑将极大地提高人们的工作效率。
可视化技术赋予人们一种仿真的、三维的并且具有实时交互的能力，这样人们可以在三维图形世界中用以 前不可想象的手段来获取信息或发挥自己创造性的思维。机械工程师可以从二维平面图中得以解放直接进
入三维世界，从而很快得到自己
设计
领导形象设计圆作业设计ao工艺污水处理厂设计附属工程施工组织设计清扫机器人结构设计
的三维机械零件模型。 医生可以从病人的三维扫描图象分析病人的病
灶。军事指挥员可以面对用三维图形技术生成的战场地形，指挥具有真实感的三维飞机、军舰、坦克向目
标开进并分析 战斗
方案
气瓶 现场处置方案 .pdf气瓶 现场处置方案 .doc见习基地管理方案.doc关于群访事件的化解方案建筑工地扬尘治理专项方案下载
的效果。
更令人惊奇的是目前正在发展的虚拟现实技术，它能使人们进入一个三维的、多媒体的虚拟世界，人
们可以游历远古时代的城堡,也 可以遨游浩翰的太空。所有这些都依赖于计算机图形学、计算机可视化技
术的发展。人们对计算机可视化技术的研究已经历了一个很长的历程，而且形成了许多可视 化工具，其中SGI公司推出的GL三维图形库表现突出，易于使用而且功能强大。利用GL开发出来的三维应用软件颇受许多专业技术人员的喜爱，这些三维应用 软件已涉及建筑、产品设计、医学、地球科学、流体力学等领
域。随着计算机技术的继续发展，GL已经进一步发展成为OpenGL，OpenGL已被认为是高 性能图形和交互式视景处理的
标准
excel标准偏差excel标准偏差函数exl标准差函数国标检验抽样标准表免费下载红头文件格式标准下载
，目前包括ATT公司UNIX软件实验室、IBM公司、DEC公司、SUN公司、HP公司、Microsoft公司和 SGI公司在内的几家在计算机市场占领导地位的大公司都采用了OpenGL图形标准。
值得一提的是，由于Microsoft公司在 Windows NT中提供OpenGL图形标准，OpenGL将在微机中广泛应用，尤其是OpenGL三维图形加速卡和微机图形工作站的推出，人们可以在微机上实现三维 图形应用，如CAD设计、仿真模拟、三维游戏等，从而更有机会、更方便地使用OpenGL及其应用软件来建立自己的三维图形世界。
1.2OpenGL
OpenGL实际上是一种图形与硬件的接口。它包括了120个图形函数，开发者可以用这些函数来建
立三维模型和进行三维实时交互。与其他图形程序设计接 口不同，OpenGL提供了十分清晰明了的图形函数，因此初学的程序设计员也能利用OpenGL的图形处理能力和1670万种色彩的调色板很快地设计出三 维图形以及三维交互软件。
OpenGL强有力的图形函数不要求开发者把三维物体模型的数据写成固定的数据格式，这样开发者不
但可以直接使用自己的数据，而且可以利用其他不同格式的数据源。这种灵活性极大地节省了开发者的时
间，提高了软件开发效益。
长期以来，从事三维图形开发的技术人员都不得不在自己的程序中编写矩阵变换、外部设备访问等函
数，这样为调制这些与自己的软件开发目标关系并不十分密切的函数费脑筋，而OpenGL正是提供一种直观的编程环境，它提供的一系列函数大大地简化了三维图形程序。例如：
, OpenGL提供一系列的三维图形单元供开发者调用。
, OpenGL提供一系列的图形变换函数。
, OpenGL提供一系列的外部设备访问函数，使开发者可以方便地访问鼠标、键盘、空间球、数据
手套等这种直观的三维图形开发环境体现了OpenGL的技术优势，这也是许多三维图形开发者热
衷于OpenGL的缘由所在。
1.3OpenGL
OpenGL成为目前三维图形开发标准在计算机发展初期，人们就开始从事计算机图形的开发。直到
计算机硬软件和计算机图形学高度发达的九十年代，人们发 现复杂的数据以视觉的形式表现时是最易理解
的，因而三维图形得以迅猛发展，于是各种三维图形工具软件包相继推出，如PHIGS、PEX、 RenderMan等。这些三维图形工具软件包有些侧重于使用方便，有些侧重于渲染效果或与应用软件的连接，但没有一
种三维工具软件包在交互式三维图形建 模能力、外部设备管理以及编程方便程度上能够OpenGL相比拟。
OpenGL经过对GL的进一步发展，实现二维和三维的高级图形技术，在性 能上表现得异常优越，它包括建模、变换、光线处理、色彩处理、动画以及更先进的能力，如纹理影射、物体运动模糊等。OpenGL的这些能力为实现逼真的三 维渲染效果、建立交互的三维景观提供了优秀的软件工具。OpenGL在硬件、窗口、操作系统方面是相互独立的。
许多计算机公司已经把 OpenGL集成到各种窗口和操作系统中，其中操作系统包括UNIX、Windows NT、DOS等，窗口系统有X窗口、Windows等。为了实现一个完整功能的图形处理系统，设计一个与
OpenGL相关的系统结构为：其最底层是图形硬 件，第二层为操作系统，第三层为窗口系统，第四层为
OpenGL，第五层为应用软件。OpenGL是网络透明的，在客户 — 服务器（Client-Server）体系结构中，OpenGL允许本地和远程绘图。所以在网络系统中，OpenGL在X窗口、Windows或其它窗口系统下都可以以一个独立的图形窗口出现。
OpenGL作为一个性能优越的图形应用程序设计界面（API） 而适合于广泛的计算环境，从个人计算
机到工作站和超级计算机，OpenGL都能实现高性能的三维图形功能。由于许多在计算机界具有领导地位
的计算机公司纷 纷采用OpenGL作为三维图形应用程序设计界面，OpenGL应用程序具有广泛的移植性。因此，OpenGL已成为目前的三维图形开发标准，是从事三维 图形开发工作的技术人员所必须掌握的开
发工具。
OpenGL
2.1OpenGL
OpenGL是一个与硬件图形发生器的软件接口，它包括了100多个图形操作函数，开发者可以利用
这些函数来构造景物模型、进行三维图形交互软件的开 发。正如上一章所述，OpenGL是一个高性能的图形开发软件包。OpenGL支持网络，在网络系统中用户可以在不同的图形终端上运行程序显示图形。 OpenGL作为一个与硬件独立的图形接口，它不提供与硬件密切相关的设备操作函数，同时，它也不提供
描述类似于飞机、汽车、分子形状等复杂形体的图形操 作函数。用户必须从点、线、面等最基本的图形单
元开始构造自己的三维模型。当然，象OpenInventor那样更高一级的基于OpenGL的三维图形建 模开发软件包将提供方便的工具。因此OpenGL的图形操作函数十分基本、灵活。例如OpenGL中的模型绘制过程就多种多样，内容十分丰 富，OpenGL提供了以下的对三维物体的绘制方式：
, （wireframe）
这种方式仅绘制三维物体的网格轮廓线。
, （depth_cued）
用网格线方式绘图，增加模拟人眼看物体一样，远处的物体比近处的物体要暗些。
, （antialiased）
用网格线方式绘图，绘图时采用反走样技术以减少图形线条的参差不齐。
, （flat_shade）
对模型的隐藏面进行消隐，对模型的平面单元按光照程度进行着色但不进行光滑处理。
, （smooth_shade）
对模型进行消隐按光照渲染着色的过程中再进行光滑处理，这种方式更接近于现实。
, （shadows、textures）
在模型表面贴上纹理甚至于加上光照阴影，使得三维景观象照片一样。
, （motion-blured）
模拟物体运动时人眼观察所感觉的动感现象。
, （atmosphere-effects）
在三维景观中加入如雾等大气环境效果，使人身临其境。
, （depth-of-effects）
类似于照相机镜头效果，模型在聚焦点处清晰，反之则模糊。
这些三维物体绘图和特殊效果处理方式，说明OpenGL已经能够模拟比较复杂的三维物体或自然景
观，这就是我们所面对的OpenGL。
2.2OpenGL
整个OpenGL的基本工作
流程
快递问题件怎么处理流程河南自建厂房流程下载关于规范招聘需求审批流程制作流程表下载邮件下载流程设计
如下图：
其中几何顶点数据包括模型的顶点集、线集、多边形集，这些数据经过流程图的上部，包括运算器、
逐个顶点操作等；图像数据包括象素集、影像集、位图集等，图像象素数据的处理方式与几何顶点数据的
处理方式是不同的，但它们都经过光栅化、逐个片元（Fragment）处理直至把最后的光栅数据写入帧缓冲器。在OpenGL中的所有数据包括几何顶点数据和象素数据都可以被存储在显示列表中或者立即可以得
到处理。OpenGL中，显示列表技术是一项重要的技术。
OpenGL要求把所有的几何图形单元都用顶点来描述，这样运算器和逐个顶点计算操作都可以针对每
个顶点进行计算和操作，然后进行光栅化形成图形碎片；对于象素数据，象素操作结果被存储在纹理组装
用的内存中，再象几何顶点操作一样光栅化形成图形片元。
整个流程操作的最后，图形片元都要进行一系列的逐个片元操作，这样最后的象素值BZ送入帧缓冲器实现图形的显示。
2.3OpenGL
在上一节中说明了OpenGL的基本工作流程，根据这个流程可以归纳出在OpenGL中进行主要的图形操作直至在计算机屏幕上渲染绘制出三维图形景观的基本步骤：
1）根据基本图形单元建立景物模型，并且对所建立的模型进行数学描述（OpenGL中把：点、线、多边形、图像和位图都作为基本图形单元）。
2）把景物模型放在三维空间中的合适的位置，并且设置视点（viewpoint）以观察所感兴趣的景观。
3）计算模型中所有物体的色彩，其中的色彩根据应用要求来确定，同时确定光照条件、纹理粘贴方式
等。
4）把景物模型的数学描述及其色彩信息转换至计算机屏幕上的象素，这个过程也就是光栅化
（rasterization）。
在这些步骤的执行过程中，OpenGL可能执行其他的一些操作，例如自动消隐处理等。另外，景物光
栅化之后被送入帧缓冲器之前还可以根据需要对象素数据进行操作。
WindowsNTOpenGL
3.1Windows NTOpenGL
如前面的章节所述，Windows NT下的OpenGL同样包含100多个库函数，这些函数都按一定的格
式来命名，即每个函数都以gl开头。Windows NT下的OpenGL除了具有基本的OpenGL函数外，还支持其他四类函数：
OpenGL实用库 43个函数，每个函数以glu开头。 OpenGL辅助库 31个函数，每个函数以aux开头。 Windows专用库函数（WGL） 6个函数，每个函数以wgl开头。 Win32 API函数 5个函数，函数前面没有专用前缀。
在OpenGL中有115个核心函数，这些函数是最基本的，它们可以在任何OpenGL的工作平台上应用。这些函数用于建立各种各样的形体， 产生光照效果，进行反走样以及进行纹理映射，进行投影变换等
等。由于这些核心函数有许多种形式并能够接受不同类型的参数，实际上这些函数可以派生出300 多个函数。
OpenGL的实用函数是比OpenGL核心函数更高一层的函数，这些函数是通过调用核心函数来起作
用的。这些函数提供了十分简单 的用法，从而减轻了开发者的编程负担。OpenGL的实用函数包括纹理映射、坐标变换、多边形分化、绘制一些如椭球、圆柱、茶壶等简单多边形实体（本指南 将详细讲述这些函数的具体用法）等。这部分函数象核心函数一样在任何OpenGL平台都可以应用。
OpenGL的辅助库是一些特殊的函数，这 些函数本来是用于初学者做简单的练习之用，因此这些函
数不能在所有的OpenGL平台上使用，在Windows NT环境下可以使用这些函数。这些函数使用简单，
它们可以用于窗口管理、输入输出处理以及绘制一些简单的三维形体。为了使OpenGL的应用程序具有良好 的移植性，在使用OpenGL辅助库的时候应谨慎。
6个WGL函数是用于连接OpenGL与Windows NT的，这些函数用于在Windows NT环境下的OpenGL窗口能够进行渲染着色，在窗口内绘制位图字体以及把文本放在窗口的某一位置等。这些函数把
Windows与OpenGL揉合在一 起。最后的5个Win32函数用于处理象素存储格式和双缓冲区，显然这
些函数仅仅能够用于Win32系统而不能用于其它OpenGL平台。
3.2OpenGL
OpenGL能够对整个三维模型进行渲染着色，从而绘制出与客观世界十分类似的三维景象。另外
OpenGL还可以进行三维交互、动作模拟等。具体的功能主要有以下这些内容。
,
OpenGL能够绘制点、线和多边形。应用这些基本的形体，我们可以构造出几乎所有的三维模型。
OpenGL通常用模型的多边形的顶点来描述三维模型。如何通过多边形及其顶点来描述三维模型，
在指南的在后续章节会有详细的介绍。
,
在 建立了三维景物模型后，就需要用OpenGL描述如何观察所建立的三维模型。观察三维模型
是通过一系列的坐标变换进行的。模型的坐标变换在使观察者能够在 视点位置观察与视点相适应
的三维模型景观。在整个三维模型的观察过程中，投影变换的类型决定观察三维模型的观察方式，
不同的投影变换得到的三维模型的景象 也是不同的。最后的视窗变换则对模型的景象进行裁剪缩
放，即决定整个三维模型在屏幕上的图象。
,
OpenGL 应用了一些专门的函数来指定三维模型的颜色。程序员可以选择二个颜色模式，即
RGBA模式和颜色表模式。在RGBA模式中，颜色直接由RGB值来指定；在 颜色表模式中，颜
色值则由颜色表中的一个颜色索引值来指定。程序员还可以选择平面着色和光滑着色二种着色方
式对整个三维景观进行着色。
,
用OpenGL绘制的三维模型必须加上光照才能更加与客观物体相似。OpenGL提供了管理四种
光（辐射光、环境光、镜面光和漫反射光）的方法，另外还可以指定模型表面的反射特性。
,
OpenGL提供了一系列的增强三维景观的图象效果的函数，这些函数通过反走样、混合和雾化来
增强图象的效果。反走样用于改善图象中线段图形的锯齿而更平滑，混合用于处理模型的半透明
效果，雾使得影像从视点到远处逐渐褪色，更接近于真实。
,
OpenGL还提供了专门对位图和图象进行操作的函数。
,
三维景物因缺少景物的具体细节而显得不够真实，为了更加逼真地表现三维景物，OpenGL提供
了纹理映射的功能。OpenGL提供的一系列纹理映射函数使得开发者可以十分方便地把真实图象
贴到景物的多边形上，从而可以在视窗内绘制逼真的三维景观。
,
为了获得平滑的动画效果，需要先在内存中生成下一幅图象，然后把已经生成的图象从内存拷贝
到屏幕上，这就是OpenGL的双缓存技术（double buffer）。OpenGL提供了双缓存技术的一
系列函数。
,
目前有许多图形应用需要人机交互，OpenGL提供了方便的三维图形人机交互接口，用户可以选
择修改三维景观中的物体。
3.3Windows NTOpenGL
OpenGL的作用机制是客户（client）/服务器（sever） 机制，即客户（用OpenGL绘制景物的应用程序）向服务器（即OpenGL内核）发布OpenGL命令，服务器则解释这些命令。大多数情况下，客
户和服 务器在同一机器上运行。正是OpenGL的这种客户/服务器机制，OpenGL可以十分方便地在网络环境下使用。因此Windows NT下的OpenGL是网络透明的。正象Windows的图形设备接口（GDI）把图形函数库封装在一个动态链接库（Windows NT下的GDI32.DLL）内一样，OpenGL图形库也被封装在一个动态链接库内（OPENGL32.DLL）。受客户应用程序调用的OpenGL函数都先在OPENGL32.DLL中处理，然后传给服务器WINSRV.DLL。OpenGL的命令再次得到处理并且直接传给Win32的设备驱动接口（Device Drive Interface,DDI），这样就把经过处理的图形命令送给视频显示驱动程序。下图简要
说明这个过程：
3-1 OpenGLWindows NT
在三维图形加速卡的GLINT图形加速芯片的加速支持下，二个附加的驱动程序被加入这个过程中。一
个OpenGL可安装客户驱动程序（Installable Client Driver,ICD）被加在客户这一边，一个硬件指定
DDI（Hardware-specific DDI）被加在服务器这边，这个驱动程序与Wind32 DDI是同一级别的。
3-2 OpenGL
OpenGL
用OpenGL编写的程序结构类似于用其他语言编写的程序。实际上，OpenGL是一个丰富的三维图形函数库，编写OpenGL程序并非难事，只需在基本C语言中调用这些函数，用法同Turbo C、Microsoft C等类似，但也有许多不同之处。
本指南所有的程序都是在Windows NT的Microsoft Visual C++集成环境下编译连接的，其中有部分头文件和函数是为这个环境所用的，例如判别操作系统的头文件“glos.h”。此外，为便于各类读者同时快速入 门，在短时间内掌握OpenGL编程的基本方法和技巧，指南中例子尽量采用标准ANSI C调用
OpenGL函数来编写，而且所有例程都只采用OpenGL附带的辅助库中的窗口系统。此外，这样也便于
程序在各平台间移植，尤其往工作站UNIX 操作系统移植时，也只需改动头文件等很少很少的部分。下面
列出一个简单的OpenGL程序：
4-1 OpenGL（Simple.c）
#include
#include
#include "glos.h"
void main(void)
{
auxInitDisplayMode(AUX_SINGLE|AUX_RGBA);
auxInitPosition(0,0,500,500);
auxInitWindow("simple");
glClearColor(0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,0.0,0.0);
glRectf(-0.5,-0.5,0.5,0.5);
glFlush();
_sleep(1000);
}
这个程序运行结果是在屏幕窗口内画一个红色的方块。
下面具体分析整个程序结构：首先，在程序最开始处是OpenGL头文件：、。前一 个是gl库的头文件，后一个是辅助库的头文件。此外，在以后的几章中还将说明
OpenGL的另外两个头文件，一个是实用 库的头文件，另一个是X窗口扩充库的头文件（这个常用在工作站上）。接下来是主函数main()的定义：一般的程序结构 是先定义一个窗口：
auxInitDisplayMode(AUX_SINGLE|AUX_RGBA);
auxInitPosition(0,0,500,500);
auxInitWindow("simple");
auxInitDisplayMode(AUX_SINGLE|AUX_RGBA)设置窗口显示模式为RGBA方式，即彩色方式，并且图形缓存为单缓存（SINGLE BUFFER）。 auxInitPosition(0, 0, 500, 500)定义窗口的初始位置，前两个参数(0, 0)为窗口的左上角点的屏幕坐标，后两个参数(500,500)为窗口的宽度和高度。auxInitWindow("simple")是窗口初始化，字符 参数是窗口名称。
然后是窗口内清屏：
glClearColor(0.0,0.0,0.0,0.0); glClear(GL_COLOR_BUFFER_BIT);
第一句将窗口清为黑色，第二句将颜色缓冲区清为glClearColor(0.0, 0.0, 0.0, 0.0)命令所设置的颜色，即同窗口背景颜色一致。
再接着是在窗口内画一个物体：
glColor3f(1.0,0.0,0.0);
glRectf(-0.5,-0.5,0.5,0.5);
很明显，第一句设置物体颜色，函数中前三个参数分别为R、G、B值，最后一个参数是Alpha值，范围都从0至1；第二句绘制一个二维矩形。：OpenGL是针对三维图形而言，因此用作OpenGL编程绘制物体必须意识到任何一个物体都是三维的，具有空间性，而显示于屏幕上的物体都是三维物体在
二维平面上的投影。
从表面上看，上述程序代码很简单，实际上已经用到了缺省的投影形式（正射投影）。再看glFlush()
函数，表示强制绘图完成。最后一句_sleep(1000)，参数单位为毫秒，整句意思是保持现有状况一秒钟，
然后结束程序运行。这个函数是VC++的库函数。
总而言之，OpenGL程序基本结构为定义窗口、清理窗口、绘制物体、结束运行。
OpenGL
OpenGL的数据类型定义可以与其它语言一致，但建议在ANSI C下最好使用以下定义的
数据类型，例如GLint、GLfloat等。具体类型见表5-1。
前缀 数据类型 相应C语言类型 OpenGL类型 ==================================================
==============
b 8-bit integer signed char GLbyte
s 16-bit integer short GLshort
i 32-bit integer long GLint,GLsizei f 32-bit floating-point float GLfloat,GLclampf d 64-bit floating-point double GLdouble,GLclampd ub 8-bit unsigned integer unsigned char GLubyte,GLboolean us 16-bit unsigned integer unsigned short GLushort ui 32-bit unsigned integer unsigned long GLuint,GLenum,GLbitfield
5-1
OpenGL的库函数命名方式很有规律，了解这种规律后阅读和编写程序都比较容易方便。
首先，每个库函数有前缀gl、glu、glx或aux，表示此函数分属于基本库、实用库、X窗口扩充库或辅助库，其后的函数名头字母大写，后缀是参数类型的简写，取i、f，参见表5-1。例：
glVertex2i(2,4);
glVertex3f(2.0,4.0,5.0);
：有的函数参数类型后缀前带有数字2、3、4。2代表二维，3代表三维，4代表alpha值（以后介绍）。
有些OpenGL函数最后带一个字母v，表示函数参数可用一个指针指向一个向量（或数组）
来替代一系列单个参数值。下面两种格式都表示设置当前颜色为红色，二者等价。
glColor3f(1.0,0.0,0.0);
float color_array[]={1.0,0.0,0.0};
glColor3fv(color_array);
除了以上基本命名方式外，还有一种带“*”星号的表示方法，例如glColor*()，它表示可以用函数的各种方式来设置当前颜色。同理，glVertex*v()表示用一个指针指向所有类型的向量
来定义一系列顶点坐标值。
最后，OpenGL也定义GLvoid类型，如果用C语言编写，可以用它替代void类型。
OpenGL
OpenGL是一个开放的系统，它是独立于任何窗口系统或操作系统的。尽管它包含了许多图形函数，
但它却没有窗口函数，也没有从键盘和鼠标读取事件的函 数，所以要初学者写出一个完整的图形程序是相
当困难的。另外，OpenGL图形函数中只提供基本的几何原形：点、线、多边形，因此要创建基本的三维
几何体 如球、锥体等，也很不容易。而OpenGL辅助库就是为解决这些基本问题专门设计的，它提供了
一些基本的窗口管理函数和三维图形绘制函数，能帮助初学者尽 快进入OpenGL世界，掌握关键的三维图形技术，体会其中奇妙的乐趣。但是，对于复杂的应用，这些函数远远不够，只能作为参考。
6.1
这一节内容可以作为手册查阅，初学者不必深究。
辅助库函数大致分为六类：
6.1.1
相关函数有三个，它们在第一章已提到，这里将详细介绍：
void auxInitWindow(GLbyte *titleString)
打开一个由auxInitDisplayMode()和auxInitPosition()指定的窗口。函数参数是窗口标题，窗口
背景缺省颜色是RGBA下的黑色或颜色表（color_index）下的0号调色板的颜色。按下Escape键可以完成关掉窗口、结束程序、全部清屏三项功能。
void auxInitDisplayMode(GLbitfield mask)
设置窗口显示模式。基本模式有RGBA或颜色表、单或双缓存，也可指定其他附加模式：深度、模板
或累积缓存（depth,stencil,and/or accumulation buffer）。参数mask是一组位标志的联合（取或），AUX_RGBA或AUX_INDEX、AUX_SINGLE或AUX_DOUBLE，以及其它有效标志AUX_DEPTH、AUX_STENCIL或AUX_ACCUM。
void auxInitPosition(GLint x,GLint y,GLsizei width,GLsizei height)
设置窗口位置及大小。参数（x, y）为窗口的左上角点的屏幕坐标，参数（width, height）为窗口的宽度和高度，单位为象素，缺省值为（0, 0, 100, 100）。
6.1.2
当窗口创建后，且在进入主函数循环之前，应当登记以下列出的回调函数（callback function）：
void auxReshapeFunc(void(*function)(GLsizei,GLsizei))
定义窗口改变时形状重定函数。参数function是一个函数指针，这个函数带有两个参数，即窗口改
变后的新宽度和新高度。通常，function是 glViewport()，显示裁减后的新尺寸，重定义投影矩阵，以
便使投影后图像的比例与视点匹配，避免比例失调。若不调用 auxReshapeFunc()，缺省重定物体形状的函数功能是调用一个二维的正射投影矩阵。运用辅助库，窗口将在每个事件改变后自动重新绘制。
void auxKeyFunction(GLint key,void(*function)(void))
定义键盘响应函数。参数function就是当按下key键时所调用的函数指针，辅助库为参数key定义了几个常量：AUX_0至AUX_9、 AUX_A至AUX_Z、AUX_a至AUX_z、AUX_LEFT、AUX_RIGHT、AUX_UP、AUX_DOWN（方向键）、 AUX_ESCAPE、AUX_SPACE或AUX_RETURN。
void auxMouseFunc(GLint button,Glint mode,void(*function)(AUX_EVENTREC *))
定义鼠标响应函数。参数function就是当鼠标以mode方式作用于button时所调用的函数。参数button有 AUX_LEFTBUTTON、AUX_MIDDLEBUTTON或AUX_RIGHTBUTTON（以右手为标准）。参数mode代表鼠标触击状态，击 中时为AUX_MOUSEDOWN，释放时为AUX_MOUSEUP。参数function必须带一个参数，它是指向结构AUX_EVENNTREC的指 针。当函数auxMouseFunc()被调用时将为这个结构分配相应的内存。通常用法类似如下：
void function(AUX_EVENTREC *event)
{
GLint x,y;
x=event->data[AUX_MOUSEX];
y=event->data[AUX_MOUSEY];
...
}
6.1.3
因为OpenGL本身没有窗口系统，所以依赖于窗口系统的颜色映射就没法装入颜色查找表。如果采用
颜色表模式，就要用到辅助库提供的用RGB值定义的单个颜色索引函数：
void auxSetOneColor(GLint index,GLfloat red,GLfloat green,GLfloat blue)
设置自定义颜色的索引。参数index即索引号，参数red、green、blue分别为红、绿、蓝值，范围在（0～1）内。
6.1.4
每组三维物体包括两种形式：网状体（wire）和实心体（solid）。网状体没有平面法向，而实心体有，
能进行光影计算，有光照时采用实心体模型。下面这些函数的 参数都是定义物体大小的，可以改变。
以上物体均以各自中心为原点绘制，所有坐标都已单位化，可以缩放。
6.1.5
void auxIdleFunc(void *func)
定义空闲状态执行函数。参数func是一个指针，指向所要执行的函数功能。当它为零时，func执行
无效。
6.1.6
void auxMainLoop(void(*displayFunc)(void))
定义场景绘制循环函数。displayFunc指针指向场景绘制函数。当窗口需要更新或场景发生改变时，
程序便调用它所指的函数，重新绘制场景。
6.2
下面举一个辅助库的应用例子，testaux.c：
6-1 testaux.c
#include "glos.h"
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w,GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
void CALLBACK myReshape(GLsizei w,GLsizei h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-1.5,1.5,-1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w,-10.0,10.0);
else
glOrtho(-1.5*(GLfloat)h/(GLfloat)w,
1.5*(GLfloat)h/(GLfloat)w,-1.5,1.5,-10.0,10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void CALLBACK display(void)
{
glColor3f(1.0,1.0,0.0);
auxWireSphere(1.0);
glFlush();
}
void main(void)
{
auxInitDisplayMode(AUX_SINGLE|AUX_RGBA);
auxInitPosition(0,0,500,500);
auxInitWindow("AUX_SAMPLE");
myinit();
auxReshapeFunc(myReshape);
auxMainLoop(display);
}
6-1
以上程序运行结果是在屏幕窗口内绘制一个黄色的网状球体，这个程序充分体现了辅助库的基本应用
方法。
首先，在主函数中用辅助库函 数定义一个窗口auxInitWindow()，然后初始化颜色myinit()，这些在第一章中已说明。接下来是两个十分重要的函数 auxReshapeFunc()和auxMainLoop()，参数都是一个函数指针，指向的都是回调函数（回调函数定义用CALLBACK说明）。
前者是窗口形状重定函数，参数指针指向函数myReshape()，它的两个参数就是窗口的新宽度和新
高度。然后用glViewport(0, 0, w, h)重定视口，并且在新视口内重新定义投影矩阵，
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-1.5,1.5,-1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w,-10.0,10.0);
else
glOrtho(-1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w,-1.5,1.5,-10.0,10.0);
即先用glMatrixMode()说明当前矩阵操作与投影有关GL_PROJECTION，再用glLoadIdentity()将矩阵清为单位矩 阵，避免受其它矩阵操作的干扰；然后调用glOrtho()对物体进行正射投影，并且用判断语句给出了两种情况，使投影后图像的比例与视点匹配，避免比例 失调。
再下来调用glMatrixMode()将矩阵操作改为对观察物体有关的方式GL_MODELVIEW，同样用 glLoadIdentity()清矩阵。后者是主函数循环函数，参数指针指向函数display()，即绘制物体。当窗口需要更新或物体发生改变时，程 序便调用它重新绘制。以上例子是辅助库的最基本应用，复杂的应用将在
后续的章节中详细介绍。
OpenGL
OpenGL基本库提供了大量绘制各种类型图元的方法，辅助库也提供了不少描述复杂三维图形的函
数。这一章主要介绍基本图元，如点、线、多边形，有了这些图元，就可以建立比较复杂的模型了。
7.1
OpenGL是三维图形的函数库，它所定义的点、线、多边形等图元与一般的定义不太一样，存在一
定的差别。对编程者来说，能否理解二者之间的差别十分重 要。一种差别源于基于计算机计算的限制。
OpenGL中所有浮点计算精度有限，故点、线 、多边形的坐标值存在一定的误差。另一种差别源于位图
显示的限制。以这种方式显示图形，最小的显示图元是一个象素，尽管每个象素宽度很小，但它们仍然比
数 学上所定义的点或线宽要大得多。当用OpenGL 进行计算时，虽然是用一系列浮点值定义点串，但每
个点仍然是用单个象素显示，只是近似拟合。
OpenGL图元是抽象的几何概念，不是真实世界中的物体，因此须用相关的数学模型来描述。
7.1.1 （Homogeneous Coordinate）
在空间直角坐标系中，任意一点可用一个三维坐标矩阵[x y z]表示。如果将该点用一个四维坐标的矩
阵[Hx Hy Hz H]表示时，则称为齐次坐标表示方法。在齐次坐标中，最后一维坐标H称为比例因子。
在OpenGL中，二维坐标点全看作三维坐标点，所有的点都用齐次坐标来描述，统一作为三维齐次点
来处理。每个齐次点用一个向量(x, y, z, w)表示，其中四个元素全不为零。齐次点具有下列几个性质：
1）如果实数a非零，则(x, y, x, w)和(ax, ay, az, aw)表示同一个点，类似于x/y = (ax)/( ay)。
2）三维空间点(x, y, z)的齐次点坐标为(x, y, z, 1.0)，二维平面点(x,y)的齐次坐标为(x, y, 0.0, 1.0)。
3）当w不为零时，齐次点坐标(x, y, z, w)即三维空间点坐标(x/w, y/w, z/w)；当w为零时，齐次点(x, y, z, 0.0)表示此点位于某方向的无穷远处。
：OpenGL中指定w大于或等于0.0。
7.1.2 (Point)
用浮点值表示的点称为顶点（Vertex）。 所有顶点在OpenGL内部计算时都作为三维点处理，用二
维坐标(x, y)定义的点在OpenGL中默认z值为0。所有顶点坐标用齐次坐标(x, y, z, w) 表示，如果w不为0.0，这些齐次坐标表示的顶点即为三维空间点(x/w, y/w, z/w)。编程者可以自己指定w值，但很少这样做。一般来说，w缺省为1.0。
7.1.3 (Line)
在OpenGL中，线代表线段（Line Segment），不是数学意义上的那种沿轴两个方向无限延伸的线。
这里的线由一系列顶点顺次连结而成，有闭合和不闭合两种。见图7-1所示。
7-1
7.1.4 (Polygon)
OpenGL中定义的多边形是由一系列线段依次连结而成的封闭区域。这些线段不能交叉，区域内不能
有空洞，多边形必须在凸多边形，否则不能被OpenGL函数接受。合法和非法多边形图示见图7-2。
7-2
OpenGL多边形可以是平面多边形，即所有顶点在一个平面上，也可以是空间多边形。更复杂的多边
形将在提高篇中介绍。
7.2
7.2.1
在OpenGL中，所有几何物体最终都由有一定顺序的顶点集来描述。
函数glVertex{234}{sifd}[v](TYPE coords)可以用二维、三维或齐次坐标定义顶点。举例如下：
glVertex2s(2,3);
glVertex3d(0.0,1.0,3.1414926535);
glVertex4f(2.4,1.0,-2.2,2.0);
GLfloat pp[3]={5.0,2.0,10.2};
glVertex3fv(pp);
第一例子表示一个空间顶点(2, 3, 0)，第二个例子表示用双精度浮点数定义一个顶点，第三个例子表
示用齐次坐标定义一个顶点，其真实坐标为(1.2, 0.5, -1.1)，最后一个例子表示用一个指针（或数组）定义顶点。
7.2.2
在实际应用中，通常用一组相关的顶点序列以一定的方式组织起来定义某个几何图元，而不采用单独
定义多个顶点来构造几何图元。在OpenGL中，所有被定 义的顶点必须放在glBegain()和glEnd()两个
函数之间才能正确表达一个几何图元或物体，否则，glVertex*()不完成任何操作。如：
glBegin(GL_POLYGON);
glVertex2f(0.0,0.0);
glVertex2f(0.0,3.0);
glVertex2f(3.0,3.0);
glVertex2f(4.0,1.5);
glVertex2f(3.0,0.0);
glEnd();
以上这段程序定义了一个多边形，如果将glBegin()中的参数GL_POLYGON改为GL_POINTS，则图形变为一组顶点（5个），见图7-3所示。
7-3
点函数glBegin(GLenum mode)标志描述一个几何图元的顶点列表的开始，其参数mode表示几何图元的描述类型。所有类型及说明见表7-1所示，相应的图示见图7-4。
7-1
7-4
函数glEnd()标志顶点列表的结束。
从图7-4中可看出，可以采用许多方法构造几何图元，这些方法仅仅依赖于所给的顶点数据。
在glBegin()和glEnd()之间最重要的信息就是由函数glVertex*()定义的顶点，必要时也可为每个
顶点指定颜色、法向、纹理坐标或其他，即调用相关的函数，见表7-2所示，具体用法以后会逐步介绍。
7-2 glBegin()glEnd()
看如下几句：
glBegin(GL_POINTS);
glColor3f(1.0,0.0,0.0); /* red color */
glVertex(...);
glColor3f(0.0,1.0,0.0); /* green color */
glColor3f(0.0,0.0,1.0); /* blue color */
glVertex(...);
glVertex(...);
glEnd();
颜色等的设置只对当前点或后续点有效。上一例中第一个点是红色，第二个点和第三个点都是蓝色。
其中设置绿色时，之后没有顶点操作，而是设置蓝色，故只有当前蓝色对紧跟其后的两个顶点有效。
为了更好地理解构造几何图元函数的用法，下面举一个简单的例子：
7-3 （drawgeom.c）
#include "glos.h"
#include
#include
void myinit(void);
void DrawMyObjects(void);
void CALLBACK myReshape(GLsizei w,GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);
glShadeModel(GL_FLAT);
}
void CALLBACK myReshape(GLsizei w,GLsizei h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-20.0,20.0,-20.0*(GLfloat)h/(GLfloat)w, 20.0*(GLfloat)h/(GLfloat)w,-50.0,50.0);
else
glOrtho(-20.0*(GLfloat)h/(GLfloat)w, 20.0*(GLfloat)h/(GLfloat)w,-20.0,20.0,-50.0,50.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void CALLBACK display(void)
{
glColor3f(1.0,1.0,0.0);
DrawMyObjects();
glFlush();
}
void DrawMyObjects(void)
{
/* draw some points */
glBegin(GL_POINTS);
glColor3f(1.0,0.0,0.0);
glVertex2f(-10.0,11.0);
glColor3f(1.0,1.0,0.0);
glVertex2f(-9.0,10.0);
glColor3f(0.0,1.0,1.0);
glVertex2f(-8.0,12.0);
glEnd();
/* draw some line_segments */
glBegin(GL_LINES);
glColor3f(1.0,1.0,0.0);
glVertex2f(-11.0,8.0);
glVertex2f(-7.0,7.0);
glColor3f(1.0,0.0,1.0);
glVertex2f(-11.0,9.0);
glVertex2f(-8.0,6.0);
glEnd();
/* draw one opened_line */
glBegin(GL_LINE_STRIP);
glColor3f(0.0,1.0,0.0);
glVertex2f(-3.0,9.0);
glVertex2f(2.0,6.0);
glVertex2f(3.0,8.0);
glVertex2f(-2.5,6.5);
glEnd();
/* draw one closed_line */
glBegin(GL_LINE_LOOP);
glColor3f(0.0,1.0,1.0);
glVertex2f(7.0,7.0);
glVertex2f(8.0,8.0);
glVertex2f(9.0,6.5);
glVertex2f(10.3,7.5);
glVertex2f(11.5,6.0);
glVertex2f(7.5,6.0);
glEnd();
/* draw one filled_polygon */
glBegin(GL_POLYGON);
glColor3f(0.5,0.3,0.7);
glVertex2f(-7.0,2.0);
glVertex2f(-8.0,3.0);
glVertex2f(-10.3,0.5);
glVertex2f(-7.5,-2.0);
glVertex2f(-6.0,-1.0);
glEnd();
/* draw some filled_quandrangles */
glBegin(GL_QUADS);
glColor3f(0.7,0.5,0.2);
glVertex2f(0.0,2.0);
glVertex2f(-1.0,3.0);
glVertex2f(-3.3,0.5);
glVertex2f(-0.5,-1.0);
glColor3f(0.5,0.7,0.2);
glVertex2f(3.0,2.0);
glVertex2f(2.0,3.0);
glVertex2f(0.0,0.5);
glVertex2f(2.5,-1.0);
glEnd();
/* draw some filled_strip_quandrangles */
glBegin(GL_QUAD_STRIP);
glVertex2f(6.0,-2.0);
glVertex2f(5.5,1.0);
glVertex2f(8.0,-1.0);
glColor3f(0.8,0.0,0.0);
glVertex2f(9.0,2.0);
glVertex2f(11.0,-2.0);
glColor3f(0.0,0.0,0.8);
glVertex2f(11.0,2.0);
glVertex2f(13.0,-1.0);
glColor3f(0.0,0.8,0.0);
glVertex2f(14.0,1.0);
glEnd();
/* draw some filled_triangles */
glBegin(GL_TRIANGLES);
glColor3f(0.2,0.5,0.7);
glVertex2f(-10.0,-5.0);
glVertex2f(-12.3,-7.5);
glVertex2f(-8.5,-6.0);
glColor3f(0.2,0.7,0.5);
glVertex2f(-8.0,-7.0);
glVertex2f(-7.0,-4.5);
glVertex2f(-5.5,-9.0);
glEnd();
/* draw some filled_strip_triangles */
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(-1.0,-8.0);
glVertex2f(-2.5,-5.0);
glColor3f(0.8,0.8,0.0);
glVertex2f(1.0,-7.0);
glColor3f(0.0,0.8,0.8);
glVertex2f(2.0,-4.0);
glColor3f(0.8,0.0,0.8);
glVertex2f(4.0,-6.0);
glEnd();
/* draw some filled_fan_triangles */
glBegin(GL_TRIANGLE_FAN);
glVertex2f(8.0,-6.0);
glVertex2f(10.0,-3.0);
glColor3f(0.8,0.2,0.5);
glVertex2f(12.5,-4.5);
glColor3f(0.2,0.5,0.8);
glVertex2f(13.0,-7.5);
glColor3f(0.8,0.5,0.2);
glVertex2f(10.5,-9.0);
glEnd();
}
void main(void)
{
auxInitDisplayMode(AUX_SINGLE|AUX_RGBA);
auxInitPosition(0,0,500,500);
auxInitWindow("Geometric Primitive Types");
myinit();
auxReshapeFunc(myReshape);
auxMainLoop(display);
}
以上程序运行结果就是图7-4所示的内容，这个例子很好地说明了几何图元的类型及颜色等函数的
用法。希望读者自己仔细分析每个物体的绘制方法，体会其中 的关键之处，达到举一反三的效果。当然，
还可利用上一章辅助库中提供的基本三维图元构造比较复杂的物体，你不妨也试一试。
OpenGL
OpenGL变换是本篇的重点内容，它包括计算机图形学中最基本的三维变换，即几何变换、投影变
换、裁剪变换、视口变换，以及针对OpenGL的特殊变换概念理解和用法，如相机模拟、矩阵堆栈等。学好了这章，才开始真正走进三维世界。
8.1
8.1.1
在真实世界里，所有的物体都是三维的。但是，这些三维物体在计算机世界中却必须以二维平面物体
的形式表现出来。那么，这些物体是怎样从三维变换到二维的呢？下面我们采用相机（Camera）模拟的
方式来讲述这个概念，如图8-1所示。
8-1
实际上，从三维空间到二维平面，就如同用相机拍照一样，通常都要经历以下几个步骤 （括号内表示的是相应的图形学概念）：
第一步，将相机置于三角架上，让它对准三维景物（视点变换，Viewing Transformation）。
第二步，将三维物体放在适当的位置（模型变换，Modeling Transformation）。
第三步，选择相机镜头并调焦，使三维物体投影在二维胶片上（投影变换，Projection Transformation）。
第四步，决定二维像片的大小（视口变换，Viewport Transformation）。
这样，一个三维空间里的物体就可以用相应的二维平面物体表示了，也就能在二维的电脑屏幕上正确
显示了。
8.1.2
运用相机模拟的方式比较通俗地讲解了三维图形显示的基本过程，但在具体应用OpenGL函数库编程时，还必须了解三维图形世界中的几个特殊坐标系的概念，以及用这些概念表达的三维图形显示流程。
计算机本身只能处理数字，图形在计算机内也是以数字的形式进行加工和处理的。大家都知道，坐标
建立了图形和数字之间的联系。为了使被显示的物体数字化， 要在被显示的物体所在的空间中定义一个坐
标系。这个坐标系的长度单位和坐标轴的方向要适合对被显示物体的描述，这个坐标系称为世界坐标系。
计算机对数字化的显示物体作了加工处理后，要在图形显示器上显示，这就要在图形显示器屏幕上定
义一个二维直角坐标系，这个坐标系称为屏幕坐标系。这个坐标系坐标轴的方向通常取成平行于屏幕的边
缘，坐标原点取在左下角，长度单位常取成一个象素的长度，大小可以是整型数。
为了使显示的物体能以合适的位置、大小和方向显示出来，必须要通过投影。投影的方法有两种，即
正射投影和透视投影。
有时为了突出图形的一部分，只把图形的某一部分显示出来，这时可以定义一个三维视景体（Viewing Volume）。正射投影时一般是一个长方体的视景体，透视投影时一般是一个棱台似的视景体。只有视景
体内的物体能被投影在显示平面上，其他部分则不能。在屏幕窗口内可以定义一个矩形，称为视口
（Viewport），视景体投影后的图形就在视口内显示。
为了适应物理设备坐标和视口所在坐标的差别，还要作一适应物理坐标的变换。这个坐标系称为物理
设备坐标系。根据上面所述，三维图形的显示流程应如图8-2所示。
8-2
8.1.3
下面举一个简单的变换例子，cube.c：
8-4 （cube.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void);
void CALLBACK display (void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
glTranslatef (0.0, 0.0, -5.0); /* viewing transformation */
glScalef (1.0, 2.0, 1.0); /* modeling transformation */
auxWireCube(1.0); /* draw the cube */
glFlush();
}
void myinit (void)
{
glShadeModel (GL_FLAT);
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glMatrixMode (GL_PROJECTION); /* prepare for and then */
glLoadIdentity (); /* define the projection */
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); /* transformation */
glMatrixMode (GL_MODELVIEW); /* back to modelview matrix */
glViewport (0, 0, w, h); /* define the viewport */
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Perspective 3-D Cube");
myinit ();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果就是绘制一个三维的正面透视立方体。其中已经用到了相机模拟中提到的四种基本
变换，即视点变换、模型变换、投影变换和视口变换。
8-3
下面简单分析一下整个程序过程：
1）。视点变换是在视点坐标系中进行的。视点坐标系 于一般的物体所在的世界坐标系不同，
它遵循左手法则，即左手大拇指指向Z正轴，与之垂直的四个手指指向X正轴，四指弯曲90度的方向是Y正轴。而世界坐标 系遵循右手法则的。如图8-4所示。当矩阵初始化glLoadIdentity()后，调用glTranslatef()作视点变换。函数参数(x, y, z)表示视点或相机在视点坐标系中移动的位置，这里z=-5.0，意思是将相机沿Z负轴移动5个单位。
通常相机位置缺省值同场景中的物体一样，都在原点处，而且相机初始方向都指向Z负轴。
这里相机移走后，仍然对准立方体。如果相机需要指向另一方向，则调用glRotatef()可以改变。
8-4
2）。模型变换是在世界坐标系中进行的。在这个坐标系中，可以对物体实施平移 glTranslatef()、旋转glRotatef()和放大缩小glScalef()。例子里只对物体进行比例变换，glScalef(sx, sy, sz)的三个参数分别是X、Y、Z轴向的比例变换因子。缺省时都为1.0，即物体没变化。程序中物体Y轴比例为2.0，其余都为1.0，就是说将立方体变 成长方体。
3）。投影变换类似于选择相机的镜头。本例中调用了一个透视投影函数 glFrustum()，在调用它之前先要用glMatrixMode()说明当前矩阵方式是投影GL_PROJECTION。这个投影函数一共有六个参 数，由它们可以定义一个棱台似的视景体。即视景体内的部分可见，视景体外的部分不可见，这也就
包含了三维裁剪变换。
4）。视口变换就是将视景体内投影的物体显示在二维的视口平面上。通常，都调用函数
glViewport()来定义一个视口，这个过程类似于将照片放大或缩小。
总而言之，一旦所有必要的变换矩阵被指定后，场景中物体的每一个顶点都要按照被指定的变换矩阵
序列逐一进行变换。：OpenGL 中的物体坐标一律采用齐次坐标，即(x, y, z, w)，故所有变换矩阵都采用4X4矩阵。一般说来，每个顶点先要经过视点变换和模型变换，然后进行指定的投影，如果它位于
视景体外，则被裁剪掉。最后，余 下的已经变换过的顶点x、y、z坐标值都用比例因子w除，即x/w、y/w、z/w，再映射到视口区域内，这样才能显示在屏幕上。
8.2
实际上，上述所说的视点变换和模型变换本质上都是一回事，即图形学中的几何变换。
只是视点变换一般只有平移和旋转，没有比例变换。当视点进行平移或旋转时，视点坐标系中的物体
就相当于在世界坐标系中作反方向的平移或旋转。因此，从某 种意义上讲，二者可以统一，只是各自出发
点不一样而已。读者可以根据具体情况，选择其中一个角度去考虑，这样便于理解。
8.2.1
这里先解释两个基本OpenGL矩阵操作函数，便于以后章节的讲述。函数解释如下：
void glLoadMatrix{fd}(const TYPE *m)
设置当前矩阵中的元素值。函数参数*m是一个指向16个元素(m0, m1, ..., m15)的指针，这16个元素就是当前矩阵M中的元素，其排列方式如下：
| m0 m4 m8 m12 |
| m1 m5 m9 m13 | M = | m2 m6 m10 m14 |
| m3 m7 m11 M15 |
void glMultMatrix{fd}(const TYPE *m)
用当前矩阵去乘*m所指定的矩阵，并将结果存放于*m中。当前矩阵可以是用glLoadMatrix() 指定的矩阵，也可以是其它矩阵变换函数的综合结果。
当几何变换时，调用OpenGL的三个变换函数glTranslate*()、glRotate*()和glScale*()，实质上相当于产生了一个 近似的平移、旋转和比例矩阵，然后调用glMultMatrix()与当前矩阵相乘。但是直接调用这三个函数程序运行得快一些，因OpenGL自动能计算 矩阵。
8.2.2
平移变换函数如下：
void glTranslate{fd}(TYPE x,TYPE y,TYPE z)
三个函数参数就是目标分别沿三个轴向平移的偏移量。这个函数表示用这三个偏移量生成的矩阵乘以
当前矩阵。当参数是(0.0,0.0,0.0)时，表示对函数glTranslate*()的操作是单位矩阵，也就是对物体没
有影响。平移示意如图8-5所示。
8-5
8.2.3
旋转变换函数如下：
void glRotate{fd}(TYPE angle,TYPE x,TYPE y,TYPE z)
函数中第一个参数是表示目标沿从点(x, y, z)到原点的方向逆时针旋转的角度，后三个参数是旋转的方向点坐标。这个函数表示用这四个参数生成的矩阵乘以当前矩阵。当角度参数是0.0时，表示对物体没
有影响。旋转示意如图8-6所示。
8-6
8.2.3
缩放和反射变换函数如下：
void glScale{fd}(TYPE x,TYPE y,TYPE z)
三个函数参数值就是目标分别沿三个轴向缩放的比例因子。这个函数表示用这三个比例因子生成的矩
阵乘以当前矩阵。这个函数能完成沿相应的轴对目标进行拉 伸、压缩和反射三项功能。当参数是(1.0, 1.0,
1.0)时，表示对函数glScale*()操作是单位矩阵，也就是对物体没有影响。当其中某个参数为负值时，表
示将对目标进行相应轴的反射变换，且这个 参数不为1.0，则还要进行相应轴的缩放变换。最好不要令三个参数值都为零，这将导致目标沿三轴都缩为零。缩放和反射示意如图8-7所示。
8-7
8.2.5
以上介绍了三个基本几何变换函数，下面举一个简单的例子进一步说明它们的用法。程序如下：
8-5 （geomtrsf.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void draw_triangle(void);
void CALLBACK display(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void draw_triangle(void)
{
glBegin(GL_LINE_LOOP);
glVertex2f(0.0, 25.0);
glVertex2f(25.0, -25.0);
glVertex2f(-25.0, -25.0);
glEnd();
}
void CALLBACK display(void)
{
glClearColor (0.0, 0.0, 0.0, 1.0);
glClear (GL_COLOR_BUFFER_BIT);
/* draw an original triangle */
glLoadIdentity ();
glColor3f (1.0, 1.0, 1.0); /* white */
draw_triangle ();
/* translating a triangle along X_axis */
glLoadIdentity ();
glTranslatef (-20.0, 0.0, 0.0);
glColor3f(1.0,0.0,0.0); /* red */
draw_triangle ();
/* scaling a triangle along X_axis by 1.5 and along Y_axis by 0.5 */
glLoadIdentity();
glScalef (1.5, 0.5, 1.0);
glColor3f(0.0,1.0,0.0); /* green */
draw_triangle ();
/* rotating a triangle in a counterclockwise direction about Z_axis */
glLoadIdentity ();
glRotatef (90.0, 0.0, 0.0, 1.0);
glColor3f(0.0,0.0,1.0); /* blue */
draw_triangle ();
/* scaling a triangle along Y_axis and reflecting it about Y_axis */
glLoadIdentity();
glScalef (1.0, -0.5, 1.0);
glColor3f(1.0,1.0,0.0); /* yellow */
draw_triangle ();
glFlush();
}
void myinit (void)
{
glShadeModel (GL_FLAT);
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-50.0, 50.0, -50.0*(GLfloat)h/(GLfloat)w,
50.0*(GLfloat)h/(GLfloat)w,-1.0,1.0);
else
glOrtho(-50.0*(GLfloat)w/(GLfloat)h, 50.0*(GLfloat)w/(GLfloat)h, -50.0,
50.0,-1.0,1.0);
glMatrixMode(GL_MODELVIEW);
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Geometric Transformations");
myinit ();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果：第一个白色三角形是原始三角形，第二个红色三角形是白三角沿X 负轴平移后
的三角形，第三个绿色三角形是白三角分别沿X轴和Y轴比例变换后的三角形，第四个蓝色三角形是白三角绕Z正轴逆时针转90度后的三角形，第五个 黄色三角形是白三角沿Y轴方向缩小一倍且相对于X轴
作反射后形成的三角形。
8-8
8.3
投影变换是一种很关键的图形变换，OpenGL中只提供了两种投影方式，一种是正射投影，另一种是透视投影。不管是调用哪种投影函数，为了避免不必要的变换，其前面必须加上以下两句：
glMAtrixMode(GL_PROJECTION);
glLoadIdentity();
事实上，投影变换的目的就是定义一个视景体，使得视景体外多余的部分裁剪掉，最终图像只是视景
体内的有关部分。本指南将详细讲述投影变换的概念以及用法。
8.3.1 （Orthographic Projection）
正射投影，又叫平行投影。这种投影的视景体是一个矩形的平行管道，也就是一个长方体，如图8-9所示。正射投影的最大一个特点是无论物体距离相机多远， 投影后的物体大小尺寸不变。这种投影通常用
在建筑蓝图绘制和计算机辅助设计等方面，这些行业要求投影后的物体尺寸及相互间的角度不变，以便施
工或制造时物 体比例大小正确。
8-9
OpenGL正射投影函数共有两个，这在前面几个例子中已用过。一个函数是：
void glOrtho(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top,
GLdouble near,GLdouble far)
它创建一个平行视景体。实际上这个函数的操作是创建一个正射投影矩阵，并且用这个矩阵乘以当前
矩阵。其中近裁剪平面是一个矩形，矩形左下角点三维空间坐 标是（left，bottom，-near），右上角点是（right，top，-near）；远裁剪平面也是一个矩形，左下角点空间坐标是 （left，bottom，-far），右上角点是（right，top，-far）。所有的near和far值同时为正或同时为负。如果没有其他变换， 正射投影的方向平行于Z轴，且视点朝向Z负轴。
这意味着物体在视点前面时far和near都为负值，物体在视点后面时far和near都为正值。另一个函数是：
void gluOrtho2D(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)
它是一个特殊的正射投影函数，主要用于二维图像到二维屏幕上的投影。它的near和far缺省值分别为-1.0和1.0，所有二维物体的Z坐标都为0.0。因此它的裁剪面是一个左下角点为（left，bottom）、
右上角点为（right，top）的矩形。
8.3.2 （Perspective Projection）
透视投影符合人们心理习惯，即离视点近的物体大，离视点远的物体小，远到极点即为消失，成为灭
点。它的视景体类似于一个顶部和底部都被切除掉的棱椎，也就是棱台。这个投影通常用于动画、视觉仿
真以及其它许多具有真实性反映的方面。
OpenGL透视投影函数也有两个，其中函数glFrustum()在8.1.3节中提到过，它所形成的视景体如图8-10所示。
8-10 glFrustum()
这个函数原型为：
void glFrustum(GLdouble left,GLdouble Right,GLdouble bottom,GLdouble top,
GLdouble near,GLdouble far);
它创建一个透视视景体。其操作是创建一个透视投影矩阵，并且用这个矩阵乘以当前矩阵。这个函数
的参数只定义近裁剪平面的左下角点和右上角点的三维空间坐 标，即（left，bottom，-near）和（right，top，-near）；最后一个参数far是远裁剪平面的Z负值，其左下角点和右上角点空 间坐标由函数根据透视投影原理自动生成。near和far表示离视点的远近，它们总为正值。
另一个函数是：
void gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear, GLdouble zFar);
它也创建一个对称透视视景体，但它的参数定义于前面的不同，如图8-11所示。其操作是创建一个对称的透视投影矩阵，并且用这个矩阵乘以当前矩阵。参数 fovy定义视野在X-Z平面的角度，范围是[0.0, 180.0]；参数aspect是投影平面宽度与高度的比率；参数zNear和Far分别是远近裁剪面沿Z负轴到视点的距离，它们总为正值。
8-11 gluPerspective()
以上两个函数缺省时，视点都在原点，视线沿Z轴指向负方向。二者的应用实例将在后续章节中介绍。
8.4
在OpenGL中，空间物体的三维裁剪变换包括两个部分：视景体裁剪和附加平面裁剪。视景体裁剪已
经包含在投影变换里，前面已述，这里不再重复。下面简单讲一下平面裁剪函数的用法。
除了视景体定义的六个裁剪平面（上、下、左、右、前、后）外，用户还可自己再定义一个或多个附
加裁剪平面，以去掉场景中无关的目标，如图8-12所示。
8-12
附加平面裁剪函数为：
void glClipPlane(GLenum plane,Const GLdouble *equation);
函数定义一个附加的裁剪平面。其中参数equation指向一个拥有四个系数值的数组，这四个系数分
别是裁剪平面Ax+By+Cz+D=0的A、B、 C、D值。因此，由这四个系数就能确定一个裁剪平面。参数plane是GL_CLIP_PLANEi(i=0,1,...)，指定裁剪面号。
在调用附加裁剪函数之前，必须先启动glEnable(GL_CLIP_PLANEi)，使得当前所定义的裁剪平面
有效；当不再调用某个附加裁剪平面时，可用glDisable(GL_CLIP_PLANEi)关闭相应的附加裁剪功能。
下面这个例子不仅说明了附加裁剪函数的用法，而且调用了gluPerspective()透视投影函数，读者可
以细细体会其中的用法。例程如下：
8-6 （clipball.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void);
void CALLBACK display(void)
{
GLdouble eqn[4] = {1.0, 0.0, 0.0, 0.0};
glClear(GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 0.0, 1.0);
glPushMatrix();
glTranslatef (0.0, 0.0, -5.0);
/* clip the left part of wire_sphere : x<0 */
glClipPlane (GL_CLIP_PLANE0, eqn);
glEnable (GL_CLIP_PLANE0);
glRotatef (-90.0, 1.0, 0.0, 0.0);
auxWireSphere(1.0);
glPopMatrix();
glFlush();
}
void myinit (void)
{
glShadeModel (GL_FLAT);
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGB);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Arbitrary Clipping Planes");
myinit ();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
8-13
8.5
在前面几节内容中已相继提到过视口变换， 这一节将针对OpenGL来讲述视口变换的原理及其相关函数的用法。运用相机模拟方式，我们很容易理解视口变换就是类似于照片的放大与缩小。在计算机图形 学
中，它的定义是将经过几何变换、投影变换和裁剪变换后的物体显示于屏幕窗口内指定的区域内，这个区
域通常为矩形，称为视口。OpenGL中相关函数是：
glViewport(GLint x,GLint y,GLsizei width, GLsizei height);
这个函数定义一个视口。函数参数(x, y)是视口在屏幕窗口坐标系中的左下角点坐标，参数width和
height分别是视口的宽度和高度。缺省时，参数值即(0, 0, winWidth, winHeight) 指的是屏幕窗口的
实际尺寸大小。所有这些值都是以象素为单位，全为整型数。
： 在实际应用中，视口的长宽比率总是等于视景体裁剪面的长宽比率。如果两个比率不相等，那
么投影后的图像显示于视口内时会发生变形，如图8-14所示。另 外，屏幕窗口的改变一般不明显影响视
口的大小。因此，在调用这个函数时，最好实时检测窗口尺寸，及时修正视口的大小，保证视口内的图像
能随窗口的变化而变 化，且不变形。
8-14
8.6
学过计算机的人也许都知道这个使用频率极 高的名词 — “堆栈”。顾名思义，堆栈指的是一个顶部打开底部封闭的柱状物体，通常用来存放常用的东西。这些东西从顶部依次放入，但取出时也只能从顶部取
出，即“先进 后出，后进先出”。在计算机中，它常指在内存中开辟的一块存放某些变量的连续区域。因此，
OpenGL的矩阵堆栈指的就是内存中专门用来存放矩阵数据的某 块特殊区域。
实际上，在创建、装入、相乘模型变换和投影变换矩阵时，都已用到堆栈操作。一般说来，矩阵堆栈
常用于构造具有继承性的模型，即由 一些简单目标构成的复杂模型。例如，一辆自行车就是由两个轮子、
一个三角架及其它一些零部件构成的。它的继承性表现在当自行车往前走时，首先是前轮旋转， 然后整个
车身向前平移，接着是后轮旋转，然后整个车身向前平移，如此进行下去，这样自行车就往前走了。
矩阵堆栈对复杂模型运动过程中的多个变 换操作之间的联系与独立十分有利。因为所有矩阵操作函数
如glLoadMatrix()、glMultMatrix()、 glLoadIdentity()等只处理当前矩阵或堆栈顶部矩阵，这样堆栈中下面的其它矩阵就不受影响。堆栈操作函数有以下两个：
void glPushMatrix(void);
void glPopMatrix(void);
第一个函数表示将所有矩阵依次压入堆栈中，顶部矩阵是第二个矩阵的备份；压入的矩阵数不能太多，
否则出错。第二个函数表示弹出堆栈顶部的矩阵，令原第二 个矩阵成为顶部矩阵，接受当前操作，故原顶部矩阵被破坏；当堆栈中仅存一个矩阵时，不能进行弹出操作，否则出错。由此看出，矩阵堆栈操作与压
入矩阵的顺序 刚好相反，编程时要特别注意矩阵操作的顺序。
为了更好地理解这两个函数，我们可以形象地认为glPushMatrix()就是“记住自己在哪”，
glPopMatrix()就是“返回自己原来所在地”。请看下面一例：
8-7 （arm.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void drawPlane(void);
void CALLBACK elbowAdd (void);
void CALLBACK elbowSubtract (void);
void CALLBACK shoulderAdd (void);
void CALLBACK shoulderSubtract (void);
void CALLBACK display(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
static int shoulder = 0, elbow = 0;
void CALLBACK elbowAdd (void)
{
elbow = (elbow + 5) % 360;
}
void CALLBACK elbowSubtract (void)
{
elbow = (elbow - 5) % 360;
}
void CALLBACK shoulderAdd (void)
{
shoulder = (shoulder + 5) % 360;
}
void CALLBACK shoulderSubtract (void)
{
shoulder = (shoulder - 5) % 360;
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0, 1.0, 1.0);
glPushMatrix();
glTranslatef (-0.5, 0.0, 0.0);
glRotatef ((GLfloat)
shoulder, 0.0, 0.0, 1.0);
glTranslatef (1.0, 0.0, 0.0);
auxWireBox(2.0, 0.2, 0.5);
glTranslatef (1.0, 0.0, 0.0);
glRotatef ((GLfloat) elbow, 0.0, 0.0, 1.0);
glTranslatef (0.8, 0.0, 0.0);
auxWireBox(1.6, 0.2, 0.5);
glPopMatrix();
glFlush();
}
void myinit (void)
{
glShadeModel (GL_FLAT);
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(65.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glTranslatef (0.0, 0.0, -5.0); /* viewing transform */
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 400, 400);
auxInitWindow ("Composite Modeling Transformations");
myinit ();
auxKeyFunc (AUX_LEFT, shoulderSubtract);
auxKeyFunc (AUX_RIGHT, shoulderAdd);
auxKeyFunc (AUX_UP, elbowAdd);
auxKeyFunc (AUX_DOWN, elbowSubtract);
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
从以上例程可以看出，复杂的机械手臂是由两个简单的长方体依据一定的继承关系构成的，而这个继
承关系是由矩阵堆栈的顺序决定的。
8-15
OpenGL
几乎所有OpenGL应用目的都是在屏幕窗口内绘制彩色图形，所以颜色在OpenGL编程中占有很重要的地位。这里的颜色与绘画中的颜色概念不一样，它属 于RGB颜色空间，只在监视器屏幕上显示。另
外，屏幕窗口坐标是以象素为单位，因此组成图形的每个象素都有自己 的颜色，而这种颜色值是通过对一
系列OpenGL函数命令的处理最终计算出来的。本章将讲述计算机颜色的概念以及OpenGL的颜色模式、颜色定义和两种 模式应用场合等内容，若掌握好颜色的应用，你就能走进缤纷绚丽的色彩世界，从中享受
无穷的乐趣。
9.1
9.1.1
计算机颜色不同于绘画或印刷中的颜色，显示于计算机屏幕上每一个点的颜色都是由监视器内部的电
子枪激发的三束不同颜色的光（红、绿、蓝）混合而成，因此，计算机颜色通 常用R（Red）、G（Green）、B（Blue）三个值来表示，这三个值又称为颜色分量。颜色生成原理 示意图见图9-1所示。
9-1
9.1.2 RGB（RGB Color Cube）
所有监视器屏幕的颜色都属于RGB颜色空间，如果用一个立方体形象地表示RGB颜色组成关系，那么就称这个立方体为RGB色立体，如图9-2所示。
9-2 RGB
在图中，R、G、B三值的范围都是从0.0到1.0。如果某颜色分量越大，则表示对应的颜色分量越亮，
也就是它在此点所贡献的颜色成分越多；反之，则越暗或越少。当R、G、B三个值都为0.0时，此点颜色为黑色（Black）；当三者都为1.0时，此点颜色为白色（White）；当三个颜色分量值相等时，表示
三者贡献一样，因此呈现灰色（Grey），在图中表现为从黑色顶点到白色顶点的那条对角线；当R=1.0、G=1.0、B=0.0时，此点颜色为黄色（Yellow）；同理，R=1.0、G=0.0、B=1.0时为洋红色，也叫品色（Magenta）；R=0.0、G=1.0、B=1.0时为青色（Cyan）。
9.2
OpenGL颜色模式一共有两个：RGB（RGBA）模式和颜色表模式。在RGB模式下，所有的颜色定义全用R、G、B三个值来表示，有时也加上 Alpha值（与透明度有关），即RGBA模式。在颜色表模式下，每一个象素的颜色是用颜色表中的某个颜色索引值表示，而这个索引值指向了相应的R、G、 B值。这样的一个表成为颜色映射（Color Map）。
9.2.1 RGBA（RGBA Mode）
在RGBA模式下，可以用glColor*()来定义当前颜色。其函数形式为：
void glColor3{b s i f d ub us ui}(TYPE r,TYPE g,TYPE b);
void glColor4{b s i f d ub us ui}(TYPE r,TYPE g,TYPE b,TYPE a);
void glColor3{b s i f d ub us ui}v(TYPE *v);
void glColor4{b s i f d ub us ui}v(TYPE *v);
设置当前R、G、B和A值。这个函数有3和4两种方式，在前一种方式下，a值缺省为1.0，后一种Alpha值由用户自己设定，范围从0.0到1.0。 同样，它也可用指针传递参数。另外，函数的第二个
后缀的不同使用，其相应的参数值及范围不同，见下表9-1所示。虽然这些参数值不同，但实际上 OpenGL已自动将它们映射在0.0到1.0或-1.0或范围之内。因此，灵活使用这些后缀，会给你编程带来很大的方
便。
9.2.2 （Color_Index Mode）
在颜色表方式下，可以调用glIndex*()函数从颜色表中选取当前颜色。其函数形式为：
void glIndex{sifd}(TYPE c);
void glIndex{sifd}v(TYPE *c);
设置当前颜色索引值，即调色板号。若值大于颜色位面数时则取模。
9.2.3
在大多情况下，采用RGBA模式比颜色表模式的要多，尤其许多效果处理，如阴影、光照、雾、反走
样、混合等，采用RGBA模式效果会更好些；另外，纹理映射只能在RGBA模式下进行。下面提供几种运用颜色表模式的情况（仅供参考）：
1）若原来应用程序采用的是颜色表模式则转到OpenGL上来时最好仍保持这种模式，便于移植。
2）若所用颜色不在缺省提供的颜色许可范围之内，则采用颜色表模式。
3）在其它许多特殊处理，如颜色动画，采用这种模式会出现奇异的效果。
9.3
颜色是一个极具吸引力的应用，在前面几章中已经逐步介绍了RGBA模式的应用方式，这里就不再多
述。下面着重说一下颜色表模式的应用方法，请看例程：
9-1 （cindex.c）
#include "glos.h"
#include
#include
void myinit(void);
void InitPalette(void);
void DrawColorFans(void);
void CALLBACK myReshape(GLsizei w,GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT);
glShadeModel(GL_FLAT);
}
void InitPalette(void)
{
GLint j;
static GLfloat rgb[][3]={
{1.0,0.0,0.0},{1.0,0.0,0.5},{1.0,0.0,1.0},{0.0,0.0,1.0},
{0.0,1.0,1.0},{0.0,1.0,0.0},{1.0,1.0,0.0},{1.0,0.5,0.0}};
for(j=0;j<8;j++)
auxSetOneColor(j+1,rgb[j][0],rgb[j][1],rgb[j][2]);
}
void CALLBACK myReshape(GLsizei w,GLsizei h)
{
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(w<=h)
glOrtho(-12.0,12.0,-12.0*(GLfloat)h/(GLfloat)w,
12.0*(GLfloat)h/(GLfloat)w,-30.0,30.0);
else
glOrtho(-12.0*(GLfloat)h/(GLfloat)w, 12.0*(GLfloat)h/(GLfloat)w,-12.0,12.0,-30.0,30.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void CALLBACK display(void)
{
InitPalette();
DrawColorFans();
glFlush();
}
void DrawColorFans(void)
{
GLint n;
GLfloat pp[8][2]={
{7.0,-7.0},{0.0,-10.0},{-7.0,-7.0},{-10.0,0.0},
{-7.0,7.0}, {0.0,10.0},{7.0,7.0},{10.0,0.0}};
/* draw some filled_fan_triangles */
glBegin(GL_TRIANGLE_FAN);
glVertex2f(0.0,0.0);
glVertex2f(10.0,0.0);
for(n=0;n<8;n++)
{
glIndexi(n+1);
glVertex2fv(pp[n]);
}
glEnd();
}
void main(void)
{
auxInitDisplayMode(AUX_SINGLE|AUX_INDEX);
auxInitPosition(0,0,500,500);
auxInitWindow("Color Index");
myinit();
auxReshapeFunc(myReshape);
auxMainLoop(display);
}
这个程序运行结果是在屏幕上显示八个连成扇形的不同颜色的三角形，每个三角形的颜色定义采用颜
色表模式。其中，调用了辅助库函数auxSetOneColor()来装载颜色映射表，即调色板。因为将某个颜色
装载到颜色查找表（color lookup table）中的过程必须依赖窗口系统，而OpenGL函数与窗口系统无关，所以这里就调用辅助库的函数来完成这个过程，然后才调用OpenGL自己的函数glIndex()设置当前的颜色号。
9-3
OpenGL
10.1
真实感图形绘制是计算机图形学的一个重要组成部分，它综合利用数学、物理 学、计算机科学和其它科学知识在计算机图形设备上生成象彩色照片那样的具有真实感的图形。一般说来，用计算机在图形设备
上生成真实感图形必须完成以下四个 步骤：一是用建模，即用一定的数学方法建立所需三维场景的几何描
述，场景的几何描述直接影响图形的复杂性和图形绘制的计算耗费；二是将三维几何模型经过一 定变换转为二维平面透视投影图；三是确定场景中所有可见面，运用隐藏面消隐算法将视域外或被遮挡住的不可见
面消去；四是计算场景中可见面的颜色，即根据基 于光学物理的光照模型计算可见面投射到观察者眼中的
光亮度大小和颜色分量，并将它转换成适合图形设备的颜色值，从而确定投影画面上每一象素的颜色，最
终生 成图形。
由于真实感图形是通过景物表面的颜色和明暗色调来表现景物的几何形状、空间位置以及表面材料的，
而一个物体表面所呈现的颜色是由表面向视线方向辐射的光能决定的。在计算机图形学中，常采用一个既
能表示光能大小又能表示其颜色组成的物理量即光亮度（luminance）或光强（intensity of light）来描述物体表面朝某方向辐射光能的颜色。采用这个物理量可以正确描述光在物体表面的反射、透射和吸收现
象，因而可以正确计算处物体表面在空间给定方向上的光能颜色。
物体表面向空间给定方向辐射的光强可应用光照模型进行计算。简单的光照模型通常假定物体表面是
光滑的且由理想材料构成，因此只考虑光源照射在物体表面产 生的反射光，所生成的图形可以模拟处不透
明物体表面的明暗过渡，具有一定的真实感效果。复杂的光照模型除了考虑上述因素外，还要考虑周围环
境的光对物体表 面的影响。如光亮平滑的物体表面会将环境中其它物体映像在表面上，而通过透明物体也
可看到其后的环境景象。这类光照模型称为整体光照模型，它能模拟出镜面 映像、透明等较精致的光照效
果。为了更真实的绘制图形，还要考虑物体表面的细节纹理，这通常使用一种称为“纹理映射”（texture
mapping）的技术把已有的平面花纹图案映射到物体表面上，并在应用光照模型时将这些花纹的颜色考虑
进去，物体表面细节的模拟使绘制的图形更接近自然景物。
以上内容中，真实感图形绘制的四大步骤前两步在前面的章节已经详细介绍过，这里不再重复，第三
步OpenGL将自动完成所有消隐过程，第四步下面几节详述。另外，部分复杂光照模型应用将在后续章节
里介绍。
10.2
10.2.1
当光照射到一个物体表面上时，会出现三种情形。首先，光可以通过物体表面向空间反射，产生反射
光。其次，对于透明体，光可以穿透该物体并从另一端射出， 产生透射光。最后，部分光将被物体表面吸
收而转换成热。在上述三部分光中，仅仅是透射光和反射光能够进入人眼产生视觉效果。这里介绍的简单
光照模型只考虑 被照明物体表面的反射光影响，假定物体表面光滑不透明且由理想材料构成，环境假设为
由白光照明。
一般来说，反射光可以分成三个分量，即环境反射、漫反射和镜面反射。环境反射分量假定入射光均
匀地从周围环境入射至景物表面并等量地向各个方向反射出去，通常物体表面还会受到从周围环境来的反
射光（如来自地面、天空、墙壁等的反射光）的照射，这些光常统称为环境光（Ambient Light）；漫反
射分量表示特定光源在景物表面的反射光中那些向空间各方向均匀反射出去的光，这些光常称为漫射光
（Diffuse Light）；镜面反射光为朝一定方向的反射光，如一个点光源照射一个金属球时会在球面上形成
一块特别亮的区域，呈现所谓“高光（Highlight）”，它是光源在金属球面上产生的镜面反射光（Specular
Light）。对于较光滑物体，其镜面反射光的高光区域小而亮；相反，粗糙表面的镜面反射光呈发散状态，
其高光区域大而不亮。下面先看一个简单的光照例程。
10-1 （light0.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
auxSolidSphere(1.0);
glFlush();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w, -10.0,
10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h, 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0,
10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Simple Lighting");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果是显示一个具有灰色光影的球。其中函数myinit()中包含了关键的设定光源位置、
启动光照等几句，而其它程序语言几乎与以前的没有多大区别，但效果却完全不一样。下面几个小节将详
细介绍有关函数的用法。
10-1
10.2.2 OpenGL
在OpenGL简单光照模型中的几种光分为：辐射光（Emitted Light）、环境光（Ambient Light）、漫射光（Diffuse Light）、镜面光（Specular Light）。
辐射光是最简单的一种光，它直接从物体发出并且不受任何光源影响。
环境光是由光源发出经环境多次散射而无法确定其方向的光，即似乎来自所有方向。一般说来，房间
里的环境光成分要多些，户外的相反要少得多，因为大部分光 按相同方向照射，而且在户外很少有其他物
体反射的光。当环境光照到曲面上时，它在各个方向上均等地发散（类似于无影灯光）。
漫射光来自一个方向，它垂直于物体时比倾斜时更明亮。一旦它照射到物体上，则在各个方向上均匀
地发散出去。于是，无论视点在哪里它都一样亮。来自特定位置和特定方向的任何光，都可能有散射成分。
镜面光来自特定方向并沿另一方向反射出去，一个平行激光束在高质量的镜面上产生100%的镜面反射。光亮的金属和塑料具有很高非反射成分，而象粉笔和地毯等几乎没有反射成分。因此，三某种意义上
讲，物体的反射程度等同于其上的光强（或光亮度）。
10.2.3 （Light Source）
光源有许多特性，如颜色、位置、方向等。选择不同的特性值，则对应的光源作用在物体上的效果也
不一样，这在以后的章节中会逐步介绍的。下面详细讲述定义光源特性的函数glLight*()：
void glLight{if}[v](GLenum light , GLenum pname, TYPE param)
创建具有某种特性的光源。其中第一个参数light指定所创建的光源号，如GL_LIGHT0、GL_LIGHT1、...、GL_LIGHT7。第二个参数pname指定光源特性，这个参数的辅助信息见表10-1所示。最后一个参数设置相应的光源特性值。
：以上列出的GL_DIFFUSE和GL_SPECULAR的缺省值只能用于GL_LIGHT0， 其他几个光
源的GL_DIFFUSE和GL_SPECULAR缺省值为(0.0,0.0,0.0,1.0)。另外，表中后六个参数的应用放在下一篇中介 绍。在上面例程中，光源的创建为：
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
其中light_position是一个指针，指向定义的光源位置齐次坐标数组。其它几个光源特性都为缺省值。
同样，我们也可用类似的方式定义光源的其他几个特性值，例如：
GLfloat light_ambient [] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse [] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
glLightfv(GL_LIGHT0, GL_AMBIENT , light_ambient );
glLightfv(GL_LIGHT0, GL_DIFFUSE , light_diffuse );
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
10.2.4
在OpenGL中，必须明确指出光照是否有效或无效。如果光照无效，则只是简单地将当前颜色映射到
当前顶点上去，不进行法向、光源、材质等复杂计算，那么显示的图形就没有真实感，如前几章例程运行
结果显示。要使光照有效，首先得启动光照，即：
glEnable(GL_LIGHTING);
若使光照无效，则调用gDisable(GL_LIGHTING)可关闭当前光照。然后，必须使所定义的每个光源有效，例light0.c中只用了一个光源，即：
glEnable(GL_LIGHT0);
其它光源类似，只是光源号不同而已。
10.3
在计算机图形学中，光滑的曲面表面常用多边形予以逼近和表示，而每个小多边形轮廓（或内部）就
用单一的颜色或许多不同的颜色来勾画（或填充），这种处理方式就称为明暗处理。在OpenGL中，用单
一颜色处理的称为平面明暗处理（Flat Shading），用许多不同颜色处理的称为光滑明暗处理（Smooth
Shading），也称为Gourand明暗处理（Gourand Shading）。设置明暗处理模式的函数为：
void glShadeModel(GLenum mode);
函数参数为GL_FLAT或GL_SMOOTH，分别表示平面明暗处理和光滑明暗处理。
应用平面明暗处理模式时，多边形内每个点的法向一致，且颜色也一致；应用光滑明暗处理模式时，
多边形所有点的法向是由内插生成的，具有一定的连续性，因此每个点的颜色也相应内插，故呈现不同色。
这种模式下，插值方法采用的是双线性插值法，如图10-2所示。
10-2 Gouraud
Gouraud明暗处理通常算法为：先用多边形顶点的光强线性插值出当前扫描线与多边形边交点处的光
强，然后再用交点的光强线插值处扫描线位 于多边形内区段上每一象素处的光强值。图中显示出一条扫描
线与多边形相交，交线的端点是A点和B点，P点是扫描线上位于多边形内的任一点，多边形三个顶点 的光强分别为I1、I2和I3.取A点的光强Ia为I1和I2的线性插值，B点的光强Ib为I1和I3的线性插值，P点的光强Ip则为Ia和Ib的线性插 值。采用Gouraud明暗处理不但可以使用多边形表示的曲面
光强连续，而且计算量很小。这种算法还可以以增量的形式改进，且能用硬件直接实现算法，从而 广泛用于计算机实时图形生成。请看下面光滑明暗处理的例程：
10-2 （Shading.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void object(void);
void CALLBACK display(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
/* GL_SMOOTH is actually the default shading model. */
void myinit (void)
{
glShadeModel (GL_SMOOTH);
}
void object(void)
{
glBegin (GL_POLYGON);
glColor3f (1.0, 0.0, 0.0);
glVertex2f (4.0, 4.0);
glColor3f(1.0,1.0,1.0);
glVertex2f (12.0, 4.0);
glColor3f(0.0,0.0,1.0);
glVertex2f (12.0, 12.0);
glColor3f(0.0,1.0,0.0);
glVertex2f (4.0, 12.0);
glEnd ();
}
void CALLBACK display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
object ();
glFlush ();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
gluOrtho2D (0.0, 16.0, 0.0, 16.0 * (GLfloat) h/(GLfloat) w);
else
gluOrtho2D (0.0, 16.0 * (GLfloat) w/(GLfloat) h, 0.0, 16.0);
glMatrixMode(GL_MODELVIEW);
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Smooth Shading");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果是在屏幕上显示一个色彩连续变化的三角形。这个程序是用的RGBA显示模式，若改用颜色表模式，则颜色内插实际上是颜色表的内插，因此呈现的颜色可能不连续。网友不妨自己试试。
另外，若在light0.c程序中加上一句定义GL_FLAT明暗处理模式，则又会出现怎样的情形呢？读者
可以仔细比较一下。
10-3
10.4
10.4.1
OpenGL用材料对光的红、绿、蓝三原色的反射率来近似定义材料的颜色。象光源一样，材料颜色
也分成环境、漫反射和镜面反射成分，它们决定了材料对环 境光、漫反射光和镜面反射光的反射程度。在
进行光照计算时，材料对环境光的反射率与每个进入光源的环境光结合，对漫反射光的反射率与每个进入
光源的漫反射 光结合，对镜面光的反射率与每个进入光源的镜面反射光结合。对环境光与漫反射光的反射
程度决定了材料的颜色，并且它们很相似。对镜面反射光的反射率通常是 白色或灰色（即对镜面反射光中红、绿、蓝的反射率相同）。镜面反射高光最亮的地方将变成具有光源镜面光强度的颜色。例如一个光亮
的红色塑料球，球的大部分 表现为红色，光亮的高光将是白色的。
10.4.2
材质的定义与光源的定义类似。其函数为：
void glMaterial{if}[v](GLenum face,GLenum pname,TYPE param);
定义光照计算中用到的当前材质。face可以是GL_FRONT、GL_BACK、GL_FRONT_AND_BACK，
它表明当前材质应该应用到物体 的哪一个面上；pname说明一个特定的材质；param是材质的具体数值，若函数为向量形式，则param是一组值的指针，反之为参数值本身。非向量形 式仅用于设置
GL_SHINESS。pname参数值具体内容见表10-1。另外，参数GL_AMBIENT_AND_DIFFUSE表示
可以用相同的 RGB值设置环境光颜色和漫反射光颜色。
10-3 （light1.c）
#include "glos.h"
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void); void myinit(void)
{
/* 设置材质的各种光的颜色成分反射比率 */
GLfloat mat_ambient[]={0.8,0.8,0.8,1.0};
GLfloat mat_diffuse[]={0.8,0.0,0.8,1.0}; /* 紫色 */
GLfloat mat_specular[] = { 1.0, 0.0, 1.0, 1.0 }; /* 亮紫色 */
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
auxSolidSphere(1.0);
glFlush();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w, -10.0,
10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h, 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0,
10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA | AUX_DEPTH16);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Lighting_1 ");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果是一个紫色的球。在函数myinit()中定义了球的材质颜色，光源的定义仍延用
light0.c中的，而light.c物体的光源定 义为缺省形式。从例子中明显地看出，物体的材质颜色定义与光源颜色定义几乎一样，物体反射到眼中的颜色与二者都有关系，具体关系请看下一小节。
10.4.3 RGBRGB
材质的颜色与光源的颜色有些不同。对于光源，R、G、B值等于R、G、B对其最大强度的百分比。
若光源颜色的R、G、B值都是1.0，则是最强的白光； 若值变为0.5，颜色仍为白色，但强度为原来的
一半，于是表现为灰色；若R＝G＝1.0，B＝0.0，则光源为黄色。对于材质，R、G、B值为材质对光的 R、
G、B成分的反射率。比如，一种材质的R＝1.0、G＝0.5、B＝0.0，则材质反射全部的红色成分，一半
的绿色成分，不反射蓝色成分。也就是说， 若OpenGL的光源颜色为（LR、LG、LB），材质颜色为（MR、
MG、MB），那么，在忽略所有其他反射效果的情况下，最终到达眼睛的光的颜色为 （LR*MR、LG*MG、
LB*MB）。
同样，如果有两束光，相应的值分别为（R1、G1、B1）和（R2、G2、B2），则OpenGL 将各个
颜色成分相加，得到（R1+R2、G1+G2、B1+B2），若任一成分的和值大于1（超出了设备所能显示的
亮度）则约简到1.0。下面一例程就说 明了二者之间的关系。
10-4 RGB（light2.c）
#include "glos.h"
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
GLfloat mat_ambient[]= { 0.8, 0.8, 0.8, 1.0 };
GLfloat mat_diffuse[]= { 0.8, 0.0, 0.8, 1.0 }; /* 紫色 */
GLfloat mat_specular[] = { 1.0, 0.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 50.0 };
GLfloat light_diffuse[]= { 0.0, 0.0, 1.0, 1.0}; /* 蓝色 */
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
auxSolidSphere(1.0);
glFlush();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h, 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA | AUX_DEPTH16);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("Lighting_2 ");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序运行结果是一个蓝色的球，其中高光部分仍为上一例的亮紫色。从上可看出，球漫反射光的
结果是mat_diffuse[]与 light_diffuse[]中的三个颜色分量值相乘，即
(0.0*1.0,0.0*1.0,0.8*1.0,1.0*1.0)=(0.0,0.0,0.8,1.0)，所以球大部分呈现蓝色。
10-4 （）
10.4.4
在实际应用的许多情况下，不同的物体或同一物体的不同部分都有可能设置不同的材质，OpenGL函
数库提供了两种方式实现这种要求。下面一例程采用的是设置矩阵堆栈来保存不同物体的材质信息：
10-5 （chgmat1.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void CALLBACK display(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
/* 初始化z-buffer、光源和光照模型，在此不具体定义材质。*/
void myinit(void)
{
GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat position[] = { 0.0, 3.0, 2.0, 0.0 };
GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glClearColor(0.0, 0.1, 0.1, 0.0);
}
void CALLBACK display(void)
{
GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat mat_ambient[] = { 0.7, 0.7, 0.7, 1.0 };
GLfloat mat_ambient_color[] = { 0.8, 0.8, 0.2, 1.0 };
GLfloat mat_diffuse[] = { 0.1, 0.5, 0.8, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat no_shininess[] = { 0.0 };
GLfloat low_shininess[] = { 5.0 };
GLfloat high_shininess[] = { 100.0 };
GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* 第一行第一列绘制的球仅有漫反射光而无环境光和镜面光。*/
glPushMatrix();
glTranslatef (-3.75, 3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第一行第二列绘制的球有漫反射光和镜面光，并有低高光，而无环境光 。*/
glPushMatrix();
glTranslatef (-1.25, 3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第一行第三列绘制的球有漫反射光和镜面光，并有很亮的高光，而无环境光 。*/
glPushMatrix();
glTranslatef (1.25, 3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第一行第四列绘制的球有漫反射光和辐射光，而无环境和镜面反射光。*/
glPushMatrix();
glTranslatef (3.75, 3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, no_mat);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
auxSolidSphere(1.0);
glPopMatrix();
/* 第二行第一列绘制的球有漫反射光和环境光，而镜面反射光。*/
glPushMatrix();
glTranslatef (-3.75, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第二行第二列绘制的球有漫反射光、环境光和镜面光，且有低高光。*/
glPushMatrix();
glTranslatef (-1.25, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第二行第三列绘制的球有漫反射光、环境光和镜面光，且有很亮的高光。*/
glPushMatrix();
glTranslatef (1.25, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第二行第四列绘制的球有漫反射光、环境光和辐射光，而无镜面光。*/
glPushMatrix();
glTranslatef (3.75, 0.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
auxSolidSphere(1.0); glPopMatrix();
/* 第三行第一列绘制的球有漫反射光和有颜色的环境光，而无镜面光。*/
glPushMatrix();
glTranslatef (-3.75, -3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第三行第二列绘制的球有漫反射光和有颜色的环境光以及镜面光，且有低高光。*/
glPushMatrix();
glTranslatef (-1.25, -3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第三行第三列绘制的球有漫反射光和有颜色的环境光以及镜面光，且有很亮的高光。*/
glPushMatrix();
glTranslatef (1.25, -3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);
auxSolidSphere(1.0);
glPopMatrix();
/* 第三行第四列绘制的球有漫反射光和有颜色的环境光以及辐射光，而无镜面光。*/
glPushMatrix();
glTranslatef (3.75, -3.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient_color);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, no_mat);
glMaterialfv(GL_FRONT, GL_SHININESS, no_shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
auxSolidSphere(1.0);
glPopMatrix();
glFlush();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= (h * 2))
glOrtho (-6.0, 6.0, -3.0*((GLfloat)h*2)/(GLfloat)w,
3.0*((GLfloat)h*2)/(GLfloat)w, -10.0, 10.0);
else
glOrtho (-6.0*(GLfloat)w/((GLfloat)h*2),
6.0*(GLfloat)w/((GLfloat)h*2), -3.0, 3.0, -10.0, 10.0);
glMatrixMode(GL_MODELVIEW);
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGBA);
auxInitPosition (0, 0, 600, 450);
auxInitWindow ("Material");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
10-5
以上程序运行结果是绘制12个球（3行4列）。第一行的球材质都没有环境反射光，第二行的都有
一定的环境反射光，第三行的都有某种颜色的环境 光。而第一列的球材质仅有蓝色的漫反射光；第二列的
不仅有蓝漫反射光，而且还有镜面反射光，较低的高光；第三列的不仅有蓝漫反射光，而且还有镜面反射
光， 很亮的高光；第四列的还包括辐射光，但无镜面光。
这个程序运用矩阵堆栈多次调用glMaterialfv()来设置每个球的材质，也就是改变 同一场景中的不同物体的颜色。但由于这个函数的应用有个性能开销，因此建议最好尽可能少的改变材质，以减少改变材质
时所带来的性能开销，可采用另一种方式 即改变材质颜色，相应函数为glColorMaterial()，说明如下：
void glColorMaterial(GLenum face,GLenum mode);
函数参数face指定面，值有GL_FRONT、GL_BACK或GL_FRONT_AND_BACK（缺省值）。mode指定材质成分，值有 GL_AMBIENT、GL_DIFFUSE、GL_AMBIENT_AND_DIFFUSE（缺省值）、GL_SPECULAR或 GLEMISSION。
：这个函数说明了两个独立的值，第一个参数说明哪一个面和哪些面被修改，而第 二个参数说明这些面的哪一个或哪些材质成分要被修改。OpenGL并不为每一种face保持独立的mode变量。在调用glColorMterial() 以后，首先需要用GL_COLOR_MATERIAL作为参数调用glEnable()来启动颜色材质，然后在绘图时调用glColor*()来改变当前 颜色，或用glMaterial()来改变材质成分。当不用这种方式来
改变材质时，可调用glDisable(GL_COLOR_MATERIAL)来关 闭取消。如下面一段代码：
glColorMaterial(GL_FRONT,GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glColor3f(0.3,0.5,0.7);
/* draw some objects here. */
glcolor3f(0.0,1.0,0.0);
/* draw other objects here.*/
glDisable(GL_COLOR_MATERIAL);
当需要改变场景中大部分方面的单个材质时，最好调用glColorMaterial()；当需要修改不止一个材质参数时，最好调用glMaterial*()。注意，当不需要颜色材质时一定要关闭它，以避免相应的开销。下
面来看一个颜色材质的具体应用例子：
10-6 （chgmat2.c）
#include "glos.h"
#include
#include
#include
void myinit(void);
void CALLBACK myReshape(GLsizei w, GLsizei h);
void CALLBACK display(void);
void myinit(void)
{
GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
void CALLBACK display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* draw one yellow ball */
glLoadIdentity();
glTranslatef(-0.7,0.0,0.0);
glColor3f(1.0,1.0,0.0);
auxSolidSphere(0.5);
/* draw one red cone */
glLoadIdentity();
glRotatef(-65.0,1.0,0.0,0.0);
glTranslatef(0.7,0.0,0.0);
glColor3f(1.0,0.0,0.0);
auxSolidCone(0.4,0.6);
glFlush();
}
void CALLBACK myReshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w, 1.5*(GLfloat)h/(GLfloat)w, -10.0,
10.0);
else
glOrtho (-1.5*(GLfloat)w/(GLfloat)h, 1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0,
10.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void main(void)
{
auxInitDisplayMode (AUX_SINGLE | AUX_RGB | AUX_DEPTH16);
auxInitPosition (0, 0, 500, 500);
auxInitWindow ("ColorMaterial Mode");
myinit();
auxReshapeFunc (myReshape);
auxMainLoop(display);
}
以上程序改变的是漫反射颜色。场景中显示了一个黄色的球和一个红色的锥体。
10-6
浙公网安备 33021202002483