当前位置:文档之家› OpenGL学习14-16

OpenGL学习14-16

OpenGL学习14-16
OpenGL学习14-16

OpenGL入门学习(十四)

OpenGL从推出到现在,已经有相当长的一段时间了。其间,OpenGL不断的得到更新。到今天为止,正式的OpenGL已经有九个版本。(1.0, 1.1, 1.2, 1.2.1, 1.3, 1.4, 1.5, 2.0, 2.1)

每个OpenGL版本的推出,都增加了一些当时流行的或者迫切需要的新功能。同时,到现在为止,OpenGL 是向下兼容的,就是说如果某个功能在一个低版本中存在,则在更高版本中也一定存在。这一特性也为我们编程提供了一点方便。

当前OpenGL的最新版本是OpenGL 2.1,但是并不是所有的计算机系统都有这样最新版本的OpenGL实现。举例来说,Windows系统如果没有安装显卡驱动,或者显卡驱动中没有附带OpenGL,则Windows系统默认提供一个软件实现的OpenGL,它没有使用硬件加速,因此速度可能较慢,版本也很低,仅支持1.1版本(听说Windows Vista默认提供的OpenGL支持到1.4版本,我也不太清楚)。nVidia和ATI这样的显卡巨头,其主流显卡基本上都提供了对OpenGL 2.1的支持。但一些旧型号的显卡因为性能不足等原因,只能支持到OpenGL 2.0或者OpenGL 1.5。Intel的集成显卡,很多都只提供了OpenGL 1.4(据说目前也有更高版本的了,但是我没有见到)。

OpenGL 2.0是一次比较大的改动,也因此升级了主版本号。可以认为OpenGL 2.0版本是一个分水岭,是否支持OpenGL 2.0版本,直接关系到运行OpenGL程序时的效果。如果要类比一下的话,我觉得OpenGL 1.5和OpenGL 2.0的差距,就像是DirectX 8.1和DirectX 9.0c的差距了。

检查自己的OpenGL版本

可以很容易的知道自己系统中的OpenGL版本,方法就是调用glGetString函数。

const char* version = (const char*)glGetString(GL_VERSION);

printf("OpenGL 版本:%s\n", version);

glGetString(GL_VERSION);会返回一个表示版本的字符串,字符串的格式为X.X.X,就是三个整数,用小数点隔开,第一个数表示OpenGL主版本号,第二个数表示OpenGL次版本号,第三个数表示厂商发行代号。比如我在运行时得到的是"2.0.1",这表示我的OpenGL版本为2.0(主版本号为2,次版本号为0),是厂商的第一个发行版本。

通过sscanf函数,也可以把字符串分成三个整数,以便详细的进行判断。

int main_version, sub_version, release_version;

const char* version = (const char*)glGetString(GL_VERSION);

sscanf(version, "%d.%d.%d", &main_version, &sub_version, &release_version);

printf("OpenGL 版本:%s\n", version);

printf("主版本号:%d\n", main_version);

printf("次版本号:%d\n", sub_version);

printf("发行版本号:%d\n", release_version);

glGetString还可以取得其它的字符串。

glGetString(GL_VENDOR); 返回OpenGL的提供厂商。

glGetString(GL_RENDERER); 返回执行OpenGL渲染的设备,通常就是显卡的名字。

glGetString(GL_EXTENSIONS); 返回所支持的所有扩展,每两个扩展之间用空格隔开。详细情况参见下面的关于“OpenGL扩展”的叙述。

版本简要历史

版本不同,提供功能的多少就不同。这里列出每个OpenGL版本推出时,所增加的主要功能。当然每个版本的修改并不只是下面的内容,读者如果需要知道更详细的情形,可以查阅OpenGL标准。

OpenGL 1.1

顶点数组。把所有的顶点数据(颜色、纹理坐标、顶点坐标等)都放到数组中,可以大大的减少诸如glColor*, glVertex*等函数的调用次数。虽然显示列表也可以减少这些函数的调用次数,但是显示列表中的数据是不可以修改的,顶点数组中的数据则可以修改。

纹理对象。把纹理作为对象来管理,同一时间OpenGL可以保存多个纹理(但只使用其中一个)。以前没有纹理对象时,OpenGL只能保存一个“当前纹理”。要使用其它纹理时,只能抛弃当前的纹理,重新载入。原来的方式非常影响效率。

OpenGL 1.2

三维纹理。以前的OpenGL只支持一维、二维纹理。

像素格式。新增加了GL_BGRA等原来没有的像素格式。允许压缩的像素格式,例如GL_UNSIGNED_SHORT_5_5_5_1格式,表示两个字节,存放RGBA数据,其中R, G, B各占5个二进制位,A 占一个二进制位。

图像处理。新增了一个“图像处理子集”,提供一些图像处理的专用功能,例如卷积、计算柱状图等。这个子集虽然是标准规定,但是OpenGL实现时也可以选择不支持它。

OpenGL 1.2.1

没有加入任何新的功能。但是引入了“ARB扩展”的概念。详细情况参见下面的关于“OpenGL扩展”的叙述。

OpenGL 1.3

压缩纹理。在处理纹理时,使用压缩后的纹理而不是纹理本身,这样可以节省空间(节省显存)和传输带宽(节省从内存到显存的数据流量)

多重纹理。同时使用多个纹理。

多重采样。一种全屏抗锯齿技术,使用后可以让画面显示更加平滑,减轻锯齿现象。对于nvidia显卡,在设置时有一项“3D平滑处理设置”,实际上就是多重采样。通常可以选择2x, 4x,高性能的显卡也可以选择8x, 16x。其它显卡也几乎都有类似的设置选项,但是也有的显卡不支持多重采样,所以是0x。OpenGL 1.4

深度纹理。可以把深度值像像素值一样放到纹理中,在绘制阴影时特别有用。

辅助颜色。顶点除了有颜色外还有辅助颜色。在使用光照时可以表现出更真实的效果。

OpenGL 1.5

缓冲对象。允许把数据(主要指顶点数据)交由OpenGL保存到较高性能的存储器中,提高绘制速度。比顶点数组有更多优势。顶点数组只是减少函数调用次数,缓冲对象不仅减少函数调用次数,还加快数据访问速度。

遮挡查询。可以计算一个物体有几个像素会被绘制到屏幕上。如果物体没有任何像素会被绘制,则不需要加载相关的数据(例如纹理数据)。

OpenGL 2.0

可编程着色。允许编写一小段代码来代替OpenGL原来的顶点操作/片段操作。这样提供了巨大的灵活性,可以实现各种各样的丰富的效果。

纹理大小不再必须是2的整数次方。

点块纹理。把纹理应用到一个点(大小可能不只一个像素)上,这样比绘制一个矩形可能效率更高。OpenGL 2.1

可编程着色,编程语言由原来的1.0版本升级为1.2版本。

缓冲对象,原来仅允许存放顶点数据,现在也允许存放像素数据。

获得新版本的OpenGL

要获得新版本OpenGL,首先应该登陆你的显卡厂商网站,并查询相关的最新信息。根据情况,下载最新的驱动或者OpenGL软件包。

如果自己的显卡不支持高版本的OpenGL,或者自己的操作系统根本就没有提供OpenGL,怎么办呢?有一个被称为MESA的开源项目,用C语言编写了一个OpenGL实现,最新的mesa 7.0已经实现了OpenGL 2.1标准中所规定的各种功能。下载MESA的代码,然后编译,就可以得到一个最新版本的OpenGL了。呵呵,不要高兴的太早。MESA是软件实现的,就是说没有用到硬件加速,因此运行起来会较慢,尤其是使用新版本的OpenGL所规定的一些高级特性时,慢得几乎无法忍受。MESA不能让你用旧的显卡玩新的游戏(很可能慢得没法玩),但是如果你只是想学习或尝试一下新版本OpenGL的各种功能,MESA可以满足你的一部分要求。

OpenGL扩展

OpenGL版本的更新并不快。如果某种技术变得流行起来,但是OpenGL标准中又没有相关的规定对这种技术提供支持,那就只能通过扩展来实现了。

厂商在发行OpenGL时,除了遵照OpenGL标准,提供标准所规定的各种功能外,往往还提供其它一些额外的功能,这就是扩展。

扩展的存在,使得各种新的技术可以迅速的被应用到OpenGL中。比如“多重纹理”,它是在OpenGL 1.3中才被加入到标准中的,在OpenGL 1.3出现以前,很多OpenGL实现都通过扩展来支持“多重纹理”。这样,即使OpenGL版本不更新,只要增加新的扩展,也可以提供新的功能了。这也说明,即使OpenGL版本较低,也不一定不支持一些高版本OpenGL才提供的功能。实际上某些OpenGL 1.5的实现,也可能提供了最新的OpenGL 2.1版本所规定的大部分功能。

当然扩展也有缺点,那就是程序在运行的时候必须检查每个扩展功能是否被支持,导致编写程序代码复杂。

扩展的名字

每个OpenGL扩展,都必须向OpenGL的网站注册,确认后才能成为扩展。注册后的扩展有编号和名字。编号仅仅是一个序号,名字则与扩展所提供的功能相关。

名字用下划线分为三部分。举例来说,一个扩展的名字可能为:GL_NV_half_float,其意义如下:

第一部分为扩展的目标。比如GL表示这是一个OpenGL扩展。如果是WGL则表示这是一个针对Windows的OpenGL扩展,如果是GLX则表示这是一个针对linux的X Window系统的OpenGL扩展。

第二部分为提供扩展的厂商。比如NV表示这是nVidia公司所提供的扩展。相应的还有ATI, IBM, SGI, APPLE, MESA等。

剩下的部分就表示扩展所提供的内容了。比如half_float,表示半精度的浮点数,每个浮点数的精度只有单精度浮点数的一半,因此只需要两个字节就可以保存。这种扩展功能可以节省内存空间,也节省从内存到显卡的数据传输量,代价就是精确度有所降低。

EXT扩展和ARB扩展

最初的时候,每个厂商都提供自己的扩展。这样导致的结果就是,即使是提供相同的功能,不同的厂商却提供不同的扩展,这样在编写程序的时候,使用一种功能就需要依次检查每个可能支持这种功能的扩展,非常繁琐。

于是出现了EXT扩展和ARB扩展。

EXT扩展是由多个厂商共同协商后形成的扩展,在扩展名字中,“提供扩展的厂商”一栏将不再是具体的厂商名,而是EXT三个字母。比如GL_EXT_bgra,就是一个EXT扩展。

ARB扩展不仅是由多个厂商共同协商形成,还需要经过OpenGL体系结构审核委员会(即ARB)的确认。在扩展名字中,“提供扩展的厂商”一栏不再是具体的厂商名字,而是ARB三个字母。比如GL_ARB_imaging,就是一个ARB扩展。

通常,一种功能如果有多个厂商提出,则它成为EXT扩展。在以后的时间里,如果经过了ARB确认,则它成为ARB扩展。再往后,如果OpenGL的维护者认为这种功能需要加入到标准规定中,则它不再是扩展,而

成为标准的一部分。

例如point_parameters,就是先有GL_EXT_point_parameters,再有GL_ARB_point_parameters,最后到OpenGL 1.4版本时,这个功能为标准规定必须提供的功能,不再是一个扩展。

在使用OpenGL所提供的功能时,应该按照标准功能、ARB扩展、EXT扩展、其它扩展这样的优先顺序。例如有ARB扩展支持这个功能时,就不使用EXT扩展。

在程序中,判断OpenGL是否支持某个扩展

前面已经说过,glGetString(GL_EXTENSIONS)会返回当前OpenGL所支持的所有扩展的名字,中间用空格分开,这就是我们判断是否支持某个扩展的依据。

#include

// 判断OpenGL是否支持某个指定的扩展

// 若支持,返回1。否则返回0。

int hasExtension(const char* name) {

const char* extensions = (const char*)glGetString(GL_EXTENSIONS);

const char* end = extensions + strlen(extensions);

size_t name_length = strlen(name);

while( extensions < end ) {

size_t position = strchr(extensions, ' ') - extensions;

if( position == name_length &&

strncmp(extensions, name, position) == 0 )

return 1;

extensions += (position + 1);

}

return 0;

}

上面这段代码,判断了OpenGL是否支持指定的扩展,可以看到,判断时完全是靠字符串处理来实现的。循环检测,找到第一个空格,然后比较空格之前的字符串是否与指定的名字一致。若一致,说明扩展是被支持的;否则,继续比较。若所有内容都比较完,则说明扩展不被支持。

编写程序调用扩展的功能

扩展的函数、常量,在命名时与通常的OpenGL函数、常量有少许区别。那就是扩展的函数、常量将以厂商的名字作为后缀。

比如ARB扩展,所有ARB扩展的函数,函数名都以ARB结尾,常量名都以_ARB结尾。例如:glGenBufferARB(函数)

GL_ARRAY_BUFFER_ARB(常量)

如果已经知道OpenGL支持某个扩展,则如何调用扩展中的函数?大致的思路就是利用函数指针。但是不幸的是,在不同的操作系统中,取得这些函数指针的方法各不相同。为了能够在各个操作系统中都能顺利的使用扩展,我向大家介绍一个小巧的工具:GLEE。

GLEE是一个开放源代码的项目,可以从网络上搜索并下载。其代码由两个文件组成,一个是GLee.c,一个是GLee.h。把两个文件都放到自己的源代码一起编译,运行的时候,GLee可以自动的判断所有扩展是否被支持,如果支持,GLEE会自动读取对应的函数,供我们调用。

我们自己编写代码时,需要首先包含GLee.h,然后才包含GL/glut.h(注意顺序不能调换),然后就可以方便的使用各种扩展功能了。

#include"GLee.h"

#include // 注意顺序,GLee.h要在glut.h之前使用

GLEE也可以帮助我们判断OpenGL是否支持某个扩展,因此有了GLEE,前面那个判断是否支持扩展的函数就不太必要了。

示例代码

让我们用一段示例代码结束本课。

我们选择一个目前绝大多数显卡都支持的扩展GL_ARB_window_pos,来说明如何使用GLEE来调用OpenGL 扩展功能。通常我们在绘制像素时,需要用glRasterPos*函数来指定绘制的位置。但是,glRasterPos*函数使用的不是屏幕坐标,例如指定(0, 0)不一定是左下角,这个坐标需要经过各种变换(参见第五课,变换),最后才得到屏幕上的窗口位置。

通过GL_ARB_window_pos扩展,我们可以直接用屏幕上的坐标来指定绘制的位置,不再需要经过变换,这样在很多场合会显得简单。

#include"GLee.h"

#include

void display(void) {

glClear(GL_COLOR_BUFFER_BIT);

if( GLEE_ARB_window_pos ) { // 如果支持GL_ARB_window_pos

// 则使用glWindowPos2iARB函数,指定绘制位置

printf("支持GL_ARB_window_pos\n");

printf("使用glWindowPos函数\n");

glWindowPos2iARB(100, 100);

} else { // 如果不支持GL_ARB_window_pos

// 则只能使用glRasterPos*系列函数

// 先计算出一个经过变换后能够得到

// (100, 100)的坐标(x, y, z)

// 然后调用glRasterPos3d(x, y, z);

GLint viewport[4];

GLdouble modelview[16], projection[16];

GLdouble x, y, z;

printf("不支持GL_ARB_window_pos\n");

printf("使用glRasterPos函数\n");

glGetIntegerv(GL_VIEWPORT, viewport);

glGetDoublev(GL_MODELVIEW_MATRIX, modelview);

glGetDoublev(GL_PROJECTION_MATRIX, projection);

gluUnProject(100, 100, 0.5, modelview, projection, viewport,

&x, &y, &z);

glRasterPos3d(x, y, z);

}

{ // 绘制一个5*5的像素块

GLubyte pixels[5][5][4];

// 把像素中的所有像素都设置为红色

int i, j;

for(i=0; i<5; ++i)

for(j=0; j<5; ++j) {

pixels[i][j][0] = 255; // red

pixels[i][j][1] = 0; // green

pixels[i][j][2] = 0; // blue

pixels[i][j][3] = 255; // alpha

}

glDrawPixels(5, 5, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

}

glutSwapBuffers();

}

int main(int argc, char* argv[]) {

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

glutInitWindowPosition(100, 100);

glutInitWindowSize(512, 512);

glutCreateWindow("OpenGL");

glutDisplayFunc(&display);

glutMainLoop();

}

可以看到,使用了扩展以后,代码会简单得多了。不支持GL_ARB_window_pos扩展时必须使用较多的代码才能实现的功能,使用GL_ARB_window_pos扩展后即可简单的解决。

如果把代码修改一下,不使用扩展而直接使用else里面的代码,可以发现运行效果是一样的。

工具软件

在课程的最后我还向大家介绍一个免费的工具软件,这就是OpenGL Extension Viewer(各大软件网站均有下载,请自己搜索之),目前较新的版本是3.0。

这个软件可以查看自己计算机系统的OpenGL信息。包括OpenGL版本、提供厂商、设备名称、所支持的扩展等。

软件可以查看的信息很详细,比如查看允许的最大纹理大小、最大光源数目等。

在查看扩展时,可以在最下面一栏输入扩展的名字,按下回车后即可连接到OpenGL官方网站,查找关于这个扩展的详细文档,非常不错。

可以根据电脑的配置情况,自动连接到对应的官方网站,方便下载最新驱动。(比如我是nVidia的显卡,则连接到nVidia的驱动下载页面)

可以进行OpenGL测试,看看运行起来性能如何。

可以给出总体报告,如果一些比较重要的功能不被支持,则会用粗体字标明。

软件还带有一个数据库,可以查询各厂商、各型号的显卡对OpenGL各种扩展的支持情况。

小结

本课介绍了OpenGL版本和OpenGL扩展。

OpenGL从诞生到现在,经历了1.0, 1.1, 1.2, 1.2.1, 1.3, 1.4, 1.5, 2.0, 2.1这些版本。

每个系统中的OpenGL版本可能不同。使用glGetString(GL_VERSION);可以查看当前的OpenGL版本。

新版本的OpenGL将兼容旧版本的OpenGL,同时提供更多的新特性和新功能。

OpenGL在实现时可以通过扩展,来提供额外的功能。

OpenGL扩展有厂家扩展、EXT扩展、ARB扩展。通常应该尽量使用标准功能,其次才是ARB扩展、EXT扩展、厂家扩展。

GLEE是一个可以免费使用的工具,使用它可以方便的判断当前的OpenGL是否支持某扩展,也可以方便的调用扩展。

OpenGL Extension Viewer是一个软件,可以检查系统所支持OpenGL的版本、支持的扩展、以及很多的详细信息。

OpenGL入门学习(十五)

这次讲的所有内容都装在一个立方体中,呵呵。

呵呵,绘制一个立方体,简单呀,我们学了第一课第二课,早就会了。

先别着急,立方体是很简单,但是这里只是拿立方体做一个例子,来说明OpenGL在绘制方法上的改进。

从原始一点的办法开始

一个立方体有六个面,每个面是一个正方形,好,绘制六个正方形就可以了。

glBegin(GL_QUADS);

glVertex3f(...);

glVertex3f(...);

glVertex3f(...);

glVertex3f(...);

// ...

glEnd();

为了绘制六个正方形,我们为每个正方形指定四个顶点,最终我们需要指定6*4=24个顶点。但是我们知道,一个立方体其实总共只有八个顶点,要指定24次,就意味着每个顶点其实重复使用了三次,这样可不是好的现象。最起码,像上面这样重复烦琐的代码,是很容易出错的。稍有不慎,即使相同的顶点也可能被指定成不同的顶点了。

如果我们定义一个数组,把八个顶点都放到数组里,然后每次指定顶点都使用指针,而不是使用直接的数据,这样就避免了在指定顶点时考虑大量的数据,于是减少了代码出错的可能性。

// 将立方体的八个顶点保存到一个数组里面

static const GLfloat vertex_list[][3] = {

-0.5f, -0.5f, -0.5f,

0.5f, -0.5f, -0.5f,

// ...

};

// 指定顶点时,用指针,而不用直接用具体的数据

glBegin(GL_QUADS);

glVertex3fv(vertex_list[0]);

glVertex3fv(vertex_list[2]);

glVertex3fv(vertex_list[3]);

glVertex3fv(vertex_list[1]);

// ...

glEnd();

修改之后,虽然代码变长了,但是确实易读得多。很容易就看出第0, 2, 3, 1这四个顶点构成一个正方形。稍稍观察就可以发现,我们使用了大量的glVertex3fv函数,其实每一句都只有其中的顶点序号不一样,因此我们可以再定义一个序号数组,把所有的序号也放进去。这样一来代码就更加简单了。

// 将立方体的八个顶点保存到一个数组里面

static const GLfloat vertex_list[][3] = {

-0.5f, -0.5f, -0.5f,

0.5f, -0.5f, -0.5f,

-0.5f, 0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

-0.5f, -0.5f, 0.5f,

0.5f, -0.5f, 0.5f,

-0.5f, 0.5f, 0.5f,

0.5f, 0.5f, 0.5f,

};

// 将要使用的顶点的序号保存到一个数组里面

static const GLint index_list[][4] = {

0, 2, 3, 1,

0, 4, 6, 2,

0, 1, 5, 4,

4, 5, 7, 6,

1, 3, 7, 5,

2, 6, 7, 3,

};

int i, j;

// 绘制的时候代码很简单

glBegin(GL_QUADS);

for(i=0; i<6; ++i) // 有六个面,循环六次

for(j=0; j<4; ++j) // 每个面有四个顶点,循环四次

glVertex3fv(vertex_list[index_list[i][j]]);

glEnd();

这样,我们就得到一个比较成熟的绘制立方体的版本了。它的数据和程序代码基本上是分开的,所有的顶点放到一个数组中,使用顶点的序号放到另一个数组中,而利用这两个数组来绘制立方体的代码则很简单。关于顶点的序号,下面这个图片可以帮助理解。

正对我们的面,按逆时针顺序,背对我们的面,则按顺时针顺序,这样就得到了上面那个index_list数组。为什么要按照顺时针逆时针的规则呢?因为这样做可以保证无论从哪个角度观察,看到的都是“正面”,而不是背面。在计算光照时,正面和背面的处理可能是不同的,另外,剔除背面只绘制正面,可以提高程序的运行效率。(关于正面、背面,以及剔除,参见第三课,绘制几何图形的一些细节问题)

例如在绘制之前调用如下的代码:

glFrontFace(GL_CCW);

glCullFace(GL_BACK);

glEnable(GL_CULL_FACE);

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

则绘制出来的图形就只有正面,并且只显示边线,不进行填充。

效果如图:

顶点数组

(提示:顶点数组是OpenGL 1.1所提供的功能)

前面的方法中,我们将数据和代码分离开,看起来只要八个顶点就可以绘制一个立方体了。但是实际上,循环还是执行了6*4=24次,也就是说虽然代码的结构清晰了不少,但是程序运行的效率,还是和最原始的那个方法一样。

减少函数的调用次数,是提高运行效率的方法之一。于是我们想到了显示列表。把绘制立方体的代码装到一个显示列表中,以后只要调用这个显示列表即可。

这样看起来很不错,但是显示列表有一个缺点,那就是一旦建立后不可再改。如果我们要绘制的不是立方体,而是一个能够走动的人物,因为人物走动时,四肢的位置不断变化,几乎没有办法把所有的内容装到一个显示列表中。必须每种动作都使用单独的显示列表,这样会导致大量的显示列表管理困难。

顶点数组是解决这个问题的一个方法。使用顶点数组的时候,也是像前面的方法一样,用一个数组保存所有的顶点,用一个数组保存顶点的序号。但最后绘制的时候,不是编写循环语句逐个的指定顶点了,而是通知OpenGL,“保存顶点的数组”和“保存顶点序号的数组”所在的位置,由OpenGL自动的找到顶点,并进行绘制。

下面的代码说明了顶点数组是如何使用的:

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertex_list);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, index_list);

其中:

glEnableClientState(GL_VERTEX_ARRAY); 表示启用顶点数组。

glVertexPointer(3, GL_FLOAT, 0, vertex_list); 指定顶点数组的位置,3表示每个顶点由三个量构成(x, y, z),GL_FLOAT表示每个量都是一个GLfloat类型的值。第三个参数0,参见后面介绍“stride

参数”。最后的vertex_list指明了数组实际的位置。

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, index_list); 根据序号数组中的序号,查找到相应的顶点,并完成绘制。GL_QUADS表示绘制的是四边形,24表示总共有24个顶点,GL_UNSIGNED_INT表示序号数组内每个序号都是一个GLuint类型的值,index_list指明了序号数组实际的位置。

上面三行代码代替了原来的循环。可以看到,原来的glBegin/glEnd不再需要了,也不需要调用glVertex*系列函数来指定顶点,因此可以明显的减少函数调用次数。另外,数组中的内容可以随时修改,比显示列表更加灵活。

详细一点的说明。

顶点数组实际上是多个数组,顶点坐标、纹理坐标、法线向量、顶点颜色等等,顶点的每一个属性都可以指定一个数组,然后用统一的序号来进行访问。比如序号3,就表示取得颜色数组的第3个元素作为颜色、取得纹理坐标数组的第3个元素作为纹理坐标、取得法线向量数组的第3个元素作为法线向量、取得顶点坐标数组的第3个元素作为顶点坐标。把所有的数据综合起来,最终得到一个顶点。

可以用glEnableClientState/glDisableClientState单独的开启和关闭每一种数组。glEnableClientState(GL_VERTEX_ARRAY);

glEnableClientState(GL_COLOR_ARRAY);

glEnableClientState(GL_NORMAL_ARRAY);

glEnableClientState(GL_TEXTURE_COORD_ARRAY);

用以下的函数来指定数组的位置:

glVertexPointer

glColorPointer

glNormalPointer

glTexCoordPointer

为什么不使用原来的glEnable/glDisable函数,而要专门的规定一个

glEnableClientState/glDisableClientState函数呢?这跟OpenGL的工作机制有关。OpenGL在设计时,认为可以将整个OpenGL系统分为两部分,一部分是客户端,它负责发送OpenGL命令。一部分是服务端,它负责接收OpenGL命令并执行相应的操作。对于个人计算机来说,可以将CPU、内存等硬件,以及用户编写的OpenGL程序看做客户端,而将OpenGL驱动程序、显示设备等看做服务端。

通常,所有的状态都是保存在服务端的,便于OpenGL使用。例如,是否启用了纹理,服务端在绘制时经常需要知道这个状态,而我们编写的客户端OpenGL程序只在很少的时候需要知道这个状态。所以将这个状态放在服务端是比较有利的。

但顶点数组的状态则不同。我们指定顶点,实际上就是把顶点数据从客户端发送到服务端。是否启用顶点数组,只是控制发送顶点数据的方式而已。服务端只管接收顶点数据,而不必管顶点数据到底是用哪种方式指定的(可以直接使用glBegin/glEnd/glVertex*,也可以使用顶点数组)。所以,服务端不需要知道顶点数组是否开启。因此,顶点数组的状态放在客户端是比较合理的。

为了表示服务端状态和客户端状态的区别,服务端的状态用glEnable/glDisable,客户端的状态则用glEnableClientState/glDisableClientState。

stride参数。

顶点数组并不要求所有的数据都连续存放。如果数据没有连续存放,则指定数据之间的间隔即可。

例如:我们使用一个struct来存放顶点中的数据。注意每个顶点除了坐标外,还有额外的数据(这里是一个int类型的值)。

typedef struct __point__ {

GLfloat position[3];

int id;

} Point;

Point vertex_list[] = {

-0.5f, -0.5f, -0.5f, 1,

0.5f, -0.5f, -0.5f, 2,

-0.5f, 0.5f, -0.5f, 3,

0.5f, 0.5f, -0.5f, 4,

-0.5f, -0.5f, 0.5f, 5,

0.5f, -0.5f, 0.5f, 6,

-0.5f, 0.5f, 0.5f, 7,

0.5f, 0.5f, 0.5f, 8,

};

static GLint index_list[][4] = {

0, 2, 3, 1,

0, 4, 6, 2,

0, 1, 5, 4,

4, 5, 7, 6,

1, 3, 7, 5,

2, 6, 7, 3,

};

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, sizeof(Point), vertex_list);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, index_list);

注意最后三行代码,可以看到,几乎所有的地方都和原来一样,只在glVertexPointer函数的第三个参数有所不同。这个参数就是stride,它表示“从一个数据的开始到下一个数据的开始,所相隔的字节数”。这里设置为sizeof(Point)就刚刚好。如果设置为0,则表示数据是紧密排列的,对于3个GLfloat的情况,数据紧密排列时stride实际上为3*4=12。

混合数组。如果需要同时使用颜色数组、顶点坐标数组、纹理坐标数组、等等,有一种方式是把所有的数据都混合起来,指定到同一个数组中。这就是混合数组。

GLfloat arr_c3f_v3f[] = {

1, 0, 0, 0, 1, 0,

0, 1, 0, 1, 0, 0,

0, 0, 1, -1, 0, 0,

};

GLuint index_list[] = {0, 1, 2};

glInterleavedArrays(GL_C3F_V3F, 0, arr_c3f_v3f);

glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, index_list);

glInterleavedArrays,可以设置混合数组。这个函数会自动调用glVertexPointer, glColorPointer等函数,并且自动的开启或禁用相关的数组。

函数的第一个参数表示了混合数组的类型。例如GL_C3F_V3F表示:三个浮点数作为颜色、三个浮点数作为顶点坐标。也可以有其它的格式,比如GL_V2F, GL_V3F, GL_C4UB_V2F, GL_C4UB_V3F, GL_C3F_V3F,

GL_N3F_V3F, GL_C4F_N3F_V3F, GL_T2F_V3F, GL_T4F_V4F, GL_T2F_C4UB_V3F, GL_T2F_C3F_V3F,

GL_T2F_N3F_V3F, GL_T2F_C4F_N3F_V3F, GL_T4F_C4F_N3F_V4F等等。其中T表示纹理坐标,C表示颜色,N 表示法线向量,V表示顶点坐标。

再来说说顶点数组与显示列表的区别。两者都可以明显的减少函数的调用次数,但是还是各有优点的。

对于顶点数组,顶点数据是存放在内存中的,也就是存放在客户端。每次绘制的时候,需要把所有的顶点数据从客户端(内存)发送到服务端(显示设备),然后进行处理。对于显示列表,顶点数据是放在显示列表中的,显示列表本身又是存放在服务器端的,所以不会重复的发送数据。

对于顶点数组,因为顶点数据放在内存中,所以可以随时修改,每次绘制的时候都会把当前数组中的内容作为顶点数据发送并进行绘制。对于显示列表,数据已经存放到服务器段,并且无法取出,所以无法修改。也就是说,显示列表可以避免数据的重复发送,效率会较高;顶点数组虽然会重复的发送数据,但由于数据可以随时修改,灵活性较好。

顶点缓冲区对象

(提示:顶点缓冲区对象是OpenGL 1.5所提供的功能,但它在成为标准前是一个ARB扩展,可以通过

GL_ARB_vertex_buffer_object扩展来使用这项功能。前面已经讲过,ARB扩展的函数名称以字母ARB结尾,常量名称以字母_ARB结尾,而标准函数、常量则去掉了ARB字样。很多的OpenGL实现同时支持vertex buffer object的标准版本和ARB扩展版本。我们这里以ARB扩展来讲述,因为目前绝大多数个人计算机都支持ARB 扩展版本,但少数显卡仅支持OpenGL 1.4,无法使用标准版本。)

前面说到顶点数组和显示列表在绘制立方体时各有优劣,那么有没有办法将它们的优点集中到一起,并且尽可能的减少缺点呢?顶点缓冲区对象就是为了解决这个问题而诞生的。它数据存放在服务端,同时也允许客户端灵活的修改,兼顾了运行效率和灵活性。

顶点缓冲区对象跟纹理对象有很多相似之处。首先,分配一个缓冲区对象编号,然后,为对应编号的缓冲区对象指定数据,以后可以随时修改其中的数据。下面的表格可以帮助类比理解。

纹理对象顶点缓冲区对象

分配编号 glGenTextures glGenBuffersARB

绑定(指定为当前所使用的对象) glBindTexture glBindBufferARB

指定数据 glTexImage* glBufferDataARB

修改数据 glTexSubImage* glBufferSubDataARB

顶点数据和序号各自使用不同的缓冲区。具体的说,就是顶点数据放在GL_ARRAY_BUFFER_ARB类型的缓冲区中,序号数据放在GL_ELEMENT_ARRAY_BUFFER_ARB类型的缓冲区中。

具体的情况可以用下面的代码来说明:

static GLuint vertex_buffer;

static GLuint index_buffer;

// 分配一个缓冲区,并将顶点数据指定到其中

glGenBuffersARB(1, &vertex_buffer);

glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buffer);

glBufferDataARB(GL_ARRAY_BUFFER_ARB,

sizeof(vertex_list), vertex_list, GL_STATIC_DRAW_ARB);

// 分配一个缓冲区,并将序号数据指定到其中

glGenBuffersARB(1, &index_buffer);

glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);

glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,

sizeof(index_list), index_list, GL_STATIC_DRAW_ARB);

在指定缓冲区数据时,最后一个参数是关于性能的提示。一共有STREAM_DRAW, STREAM_READ, STREAM_COPY, STATIC_DRAW, STATIC_READ, STATIC_COPY, DYNAMIC_DRAW, DYNAMIC_READ, DYNAMIC_COPY这九种。每一种都表示了使用频率和用途,OpenGL会根据这些提示进行一定程度的性能优化。

(提示仅仅是提示,不是硬性规定。也就是说,即使使用了STREAM_DRAW,告诉OpenGL这段缓冲区数据一旦指定,以后不会修改,但实际上以后仍可修改,不过修改时可能有较大的性能代价)

当使用glBindBufferARB后,各种使用指针为参数的OpenGL函数,行为会发生变化。

以glColor3fv为例,通常,这个函数接受一个指针作为参数,从指针所指的位置取出连续的三个浮点数,作为当前的颜色。

但使用glBindBufferARB后,这个函数不再从指针所指的位置取数据。函数会先把指针转化为整数,假设转化后结果为k,则会从当前缓冲区的第k个字节开始取数据。特别一点,如果我们写glColor3fv(NULL);因为NULL转化为整数后通常是零,所以从缓冲区的第0个字节开始取数据,也就是从缓冲区最开始的位置取数据。

这样一来,原来写的

glVertexPointer(3, GL_FLOAT, 0, vertex_list);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, index_list);

在使用缓冲区对象后,就变成了

glVertexPointer(3, GL_FLOAT, 0, NULL);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, NULL);

以下是完整的使用了顶点缓冲区对象的代码:

static GLfloat vertex_list[][3] = {

-0.5f, -0.5f, -0.5f,

0.5f, -0.5f, -0.5f,

-0.5f, 0.5f, -0.5f,

0.5f, 0.5f, -0.5f,

-0.5f, -0.5f, 0.5f,

0.5f, -0.5f, 0.5f,

-0.5f, 0.5f, 0.5f,

0.5f, 0.5f, 0.5f,

};

static GLint index_list[][4] = {

0, 2, 3, 1,

0, 4, 6, 2,

0, 1, 5, 4,

4, 5, 7, 6,

1, 3, 7, 5,

2, 6, 7, 3,

};

if( GLEE_ARB_vertex_buffer_object ) {

// 如果支持顶点缓冲区对象

static int isFirstCall = 1;

static GLuint vertex_buffer;

static GLuint index_buffer;

if( isFirstCall ) {

// 第一次调用时,初始化缓冲区

isFirstCall = 0;

// 分配一个缓冲区,并将顶点数据指定到其中

glGenBuffersARB(1, &vertex_buffer);

glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buffer);

glBufferDataARB(GL_ARRAY_BUFFER_ARB,

sizeof(vertex_list), vertex_list, GL_STATIC_DRAW_ARB);

// 分配一个缓冲区,并将序号数据指定到其中

glGenBuffersARB(1, &index_buffer);

glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);

glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,

sizeof(index_list), index_list, GL_STATIC_DRAW_ARB);

}

glBindBufferARB(GL_ARRAY_BUFFER_ARB, vertex_buffer);

glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, index_buffer);

// 实际使用时与顶点数组非常相似,只是在指定数组时不再指定实际的数组,改为指定NULL即可 glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, NULL);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, NULL);

} else {

// 不支持顶点缓冲区对象

// 使用顶点数组

glEnableClientState(GL_VERTEX_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, vertex_list);

glDrawElements(GL_QUADS, 24, GL_UNSIGNED_INT, index_list);

}

可以分配多个缓冲区对象,顶点坐标、颜色、纹理坐标等数据,可以各自单独使用一个缓冲区。

每个缓冲区可以有不同的性能提示,比如在绘制一个运动的人物时,顶点坐标数据经常变化,但法线向量、纹理坐标等则不会变化,可以给予不同的性能提示,以提高性能。

小结

本课从绘制一个立方体出发,描述了OpenGL在各个版本中对于绘制的处理。

绘制物体的时候,应该将数据单独存放,尽量不要到处写类似glVertex3f(1.0f, 0.0f, 1.0f)这样的代码。将顶点坐标、顶点序号都存放到单独的数组中,可以让绘制的代码变得简单。

可以把绘制物体的所有命令装到一个显示列表中,这样可以避免重复的数据传送。但是因为显示列表一旦建立,就无法修改,所以灵活性很差。

OpenGL 1.1版本,提供了顶点数组。它可以指定数据的位置、顶点序号的位置,从而有效的减少函数调用次数,达到提高效率的目的。但是它没有避免重复的数据传送,所以效率还有待进一步提高。

OpenGL 1.5版本,提供了顶点缓冲区对象。它综合了显示列表和顶点数组的优点,同时兼顾运行效率和灵活性,是绘制物体的一个好选择。如果系统不支持OpenGL 1.5,也可以检查是否支持扩展GL_ARB_vertex_buffer_object。

OpenGL入门学习(十六)

https://www.doczj.com/doc/4818828517.html,/jxchinaren/archive/2009/01/02/3686649.aspx

计算机图形学OpenGL中绘制太阳_地球_月亮的运动模型源代码

#include static int day = 148; // 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.0, 0.0, 0.0); glutSolidSphere(69600000, 100, 100); // 蓝色的“地球” glColor3f(0.0, 0.0, 1.0); glRotatef(day/360.0*360.0, 0.0, 0.0, -1.0); glTranslatef(150000000, 0.0, 0.0); glutSolidSphere(15945000, 100, 100); // 黄色的“月亮” glColor3f(1.0, 1.0, 0.0); glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0, 0.0, -1.0); glTranslatef(38000000, 0.0, 0.0); glutSolidSphere(4345000, 100, 100); 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(450, 450);

研究生计算机图形学课程室内场景OpenGL--实验报告Word版

《高级计算机图形学》实验报告 姓名:学号:班级: 【实验报告要求】 实验名称:高级计算机图形学室内场景 实验目的:掌握使用OpenGL生成真实感复杂对象的方法,进一步熟练掌握构造实体几何表示法、扫描表示法、八叉树法、BSP树法等建模方法。 实验要求:要求利用OpenGL生成一个真实感的复杂对象及其周围场景,并显示观测点变化时的几何变换,要具备在一个纹理复杂的场景中漫游功能。要求使用到光线跟踪算法、 纹理映射技术以及实时绘制技术。 一、实验效果图 图1:正面效果图

图2:背面效果图 图4:背面效果图

图4:室内场景细节效果图 图5:场景角度转换效果图

二、源文件数据代码: 共6个文件,其实现代码如下: 1、DlgAbout.cpp #include "StdAfx.h" #include "DlgAbout.h" CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) { } void CAboutDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); } BEGIN_MESSAGE_MAP(CAboutDlg, CDialog) END_MESSAGE_MAP() 2、FormCommandView.cpp #include "stdafx.h" #include "Tool.h" #include "MainFrm.h" #include "FormCommandView.h" #include "ToolDoc.h" #include "RenderView.h" // Download by https://www.doczj.com/doc/4818828517.html, #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif // CFormCommandView IMPLEMENT_DYNCREATE(CFormCommandView, CFormView) CFormCommandView::CFormCommandView() : CFormView(CFormCommandView::IDD) { //{{AFX_DATA_INIT(CFormCommandView)

计算机图形学真实图形

#include #include /* Initialize material property, light source, lighting model, * and depth buffer. */ void init(void) { GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_shininess[] = { 50.0 }; GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 }; GLfloat lightPos[]={0.0f,0.0f,75.0f,1.0f}; GLfloat ambientLight[]={0.0f,0.0f,75.0f,1.0f}; GLfloat specular[]={0.0f,0.0f,75.0f,1.0f}; GLfloat specref[]={0.0f,0.0f,75.0f,1.0f}; GLfloat spotDir[]={0.0f,0.0f,75.0f,1.0f}; glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_SMOOTH);//设置阴影模型 glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);//镜面光分量强度glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);//镜面光反射指数glLightfv(GL_LIGHT0, GL_POSITION, light_position);//设置光源的位置 glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambientLight); glLightfv(GL_LIGHT1,GL_DIFFUSE,ambientLight); glLightfv(GL_LIGHT1,GL_SPECULAR,specular); glLightfv(GL_LIGHT1,GL_POSITION,lightPos); glLightf(GL_LIGHT1,GL_SPOT_CUTOFF,50.0f); glEnable(GL_LIGHT1); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT,GL_SPECULAR,specref); glMateriali(GL_FRONT,GL_SHININESS,128); glEnable(GL_LIGHTING);//启动光照 glEnable(GL_LIGHT0);//激活光源 glEnable(GL_LIGHT1);//激活光源 glEnable(GL_DEPTH_TEST); } /* 调用glut函数绘制一个球*/ void display(void) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

OPenGL的基本程序结构

O p enGL的基本程序结构 常用的程序设计语言,如C、C++、Pascal、Fortran和Java等,都支持OpenGL的开发。这里只讨论C版本下OpenGL的语法。 程序的基本结构 OpenGL程序的基本结构可分为三个部分: 第一部分是初始化部分。主要是设置一些OpenGL的状态开关,如颜色模式(RGBA或ALPHA)的选择,是否作光照处理(若有的话,还需设置光源的特性),深度检验,裁剪等等。这些状态一般都用函数glEnable(???), glDisable(???)来设置,???表示特定的状态。 第二部分设置观察坐标系下的取景模式和取景框位置大小。主要利用了三个函数: 函数void glViewport(left,top,right,bottom):设置在屏幕上的窗口大小,四个参数描述屏幕窗口四个角上的坐标(以象素表示); 函数void glOrtho(left,right,bottom,top,near,far):设置投影方式为正交投影(平行投影),其取景体积是一个各面均为矩形的六面体; 函数void gluPerspective(fovy,aspect,zNear,zFar):设置投影方式为透视投影,其取景体积是一个截头锥体。

第三部分是OpenGL的主要部分,使用OpenGL的库函数构造几何物体对象的数学描述,包括点线面的位置和拓扑关系、几何变换、光照处理等等。 以上三个部分是OpenGL程序的基本框架,即使移植到使用MFC的Windows程序中,也是如此。只是由于Windows自身有一套显示方式,需要进行一些必要的改动以协调这两种不同显示方式。 OpenGL基本函数均使用gl作为函数名的前缀,如glClearColor();实用函数则使用glu作为函数名的前缀,如gluSphere()。 OpenGL基本常量的名字以GL_开头,如GL_LINE_LOOP;实用常量的名字以GLU_开头,如GLU_FILL。一些函数如glColor* ()(定义颜色值),函数名后可以接不同的后缀以支持不同的数据类型和格式。如glColor3b(...)、glColor3d(...)、 glColor3f(...)和 glColor3bv(...)等,这几个函数在功能上是相似的,只是适用于不同的数据类型和格式,其中3表示该函数带有三个参数,b、d、f分别表示参数的类型是字节型、双精度浮点型和单精度浮点型,v则表示这些参数是以向量形式出现的。 OpenGL定义了一些特殊标识符,如GLfloat,GLvoid。它们其实就是C中的 float和void。在gl.h文件中可以看到以下定义: …… typedef float GLfloat; typedef void GLvoid; ……

计算机图形学 实验 利用OpenGL实现图形的平移、旋转、缩放

XXXXXXXX大学(计算机图形学)实验报告 实验名称利用OpenGL实现图形的平移、旋转、缩放 实验时间年月日 专业姓名学号 预习操作座位号 教师签名总评 一、实验目的: 1.了解OpenGL下简单图形的平移、旋转、缩放变换的编程的基本思想; 2.掌握OpenGL下简单图形的平移、旋转、缩放变换的编程的基本步骤; 二、实验原理: 在OpenGL中,可以使用下面三个函数便捷地实现简单图形平移、旋转、缩放变换的功能: glRotatef(theta, vx, vy, vz); glTranslatef(dx, dy, dz); glScalef(sx,sy,sz); 三、实验内容: // 1.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "glut.h" #include "math.h" void display() { glClear( GL_COLOR_BUFFER_BIT); // Clear the frame buffer glColor3f( 0.0, 1.0, 1.0); // Set current color to green glBegin( GL_POLYGON); // Draw the triangle glV ertex2f( 0.0, -0.2); glV ertex2f( 0.2, 0.0); glV ertex2f( 0.0, 0.0); glEnd(); glFlush(); } void dsp()

图形学实验一 三维分形(附源代码)

实验报告 实验名称:三维分形算法 姓名:陈怡东 学号:09008406 程序使用说明: 程序打开后会呈现出3次分形后的四面体,因为考虑到观察效果的清晰所以就用了3次分形作为演示。 与用户的交互: 1键盘交互:分别按下键盘上的数字键1,2,3,4可以分别改变四面体的4个面的颜色。 按下字母c(不区别大小写)可以改变视图函数,这里循环切换3种视图 函数:glOrtho,glFrustum,gluPerspective,但是改变视图函数后要窗口形状变化后才能显现出来 按下字母键q(不区别大小写)可以退出程序 2鼠标交互:打开后在绘图的区域按下鼠标左键不放便可以拖动图形的视角,这里为了展现图形的3D效果因此固定了其中一点不放,这样就可以看到3D的效果。 鼠标右击则有弹出菜单显示,其中改变颜色则是同时改变4个面的颜色,本程序中运用了8组配色方案。 改变视图函数也是上述的3种函数,这里的效果立刻显现,但是还有很多问题达不到所要的效果,希望老师能帮忙解决一下。 设计思路: 分形算法:把四面体细分成更小的四面体,先找出其6个棱的中点并连接起来,这样就在4个顶点处各有一个小的四面体,原来四面体中剩下的部分应当去掉。仿效二维的生成方法,我们对保留的四个小四面体进行迭代细分。这样细分结束后通过绘制4个三角形来绘制每一个剩下的四面体。 交互的实现:键盘交互,即通过对按键的响应写上响应函数实现对视图和颜色的改变。 鼠标交互:通过对鼠标左右按键的 实现: 该部分只做了必要的介绍,具体实现见代码(附注释) 分形算法:void tetra(GLfloat *a,GLfloat *b,GLfloat *c,GLfloat *d)函数实现的是绘制四面体并且给四个面绘上不同的颜色。以区别开来,函数的实现细节见代码,有注释介绍。 void triangle3(GLfloat *a,GLfloat *b,GLfloat *c)函数用来绘制每个平面细分后的三角形。其中顶点设置为3维坐标glVertex3fv(a); void divide_tetra(GLfloat *a,GLfloat *b,GLfloat *c,GLfloat *d,int m)细分四面体的函数实现。前四个参数为传入点的坐标,最后参数m则是细分次数。先计算六个中点的坐标mid[1][j]=(a[j]+c[j])/2;3次循环则是对x,y,z三个坐标的一次计算,然后再递归调用绘制4个小四面体。 然后是显示回调函数void mydisplay3FX();这跟程序模板差不多不做过多介绍。 分形算法中必要重要的一点是隐藏面的消除。即书上2.10.3介绍的内容。对对象进行排

计算机图形学试验指导一–OpenGL基础

计算机图形学实验指导(一) –OpenGL基础 1.综述 这次试验的目的主要是使大家初步熟悉OpenGL这一图形系统的用法,编程平台是Visual C++,它对OpenGL提供了完备的支持。 尽管OpenGL包括渲染命令,但却独立于任何窗口系统和操作系统。因此,OpenGL并不包括用来打开窗口以及从键盘或鼠标读取事件的命令。在这里,我们应用GLUT库简化Windows窗口操作。 2.准备GLUT库 下载glut压缩包后,解压,把glut32.dll放在Windows的system32目录下,将glut32.lib 放在C:\program files\Microsoft Visual Studio\VC98\Lib目录中,将glut.h放在C:\program files\Microsoft Visual Studio\VC98\Include\GL目录中 2.在VC中新建项目 新建一个项目。 选择菜单File中的New选项,弹出一个分页的对话框,选中页Projects中的Win32 Console Application项,然后填入你自己的Project name,回车即可。VC为你创建一个工作区(WorkSpace),你的项目就放在这个工作区里。 为项目添加文件 为了使用OpenGL,我们需要在项目中加入相关的Lib文件:glut32.lib 选中菜单Project->Settings项,在link选项卡中的Object/Library modules栏中加入glut32.lib。 选择菜单File中的New选项,弹出一个分页的对话框,选中页Files中的C++sourcefile,填入文件名,钩选添加到刚才建的那个工程里,然后就可以开始编程了。 3.一个OpenGL的例子 #include //初始化OpenGL void init(void) { glClearColor(0.0f, 0.0f, 0.0f, 0.0f);//设置背景颜色 glShadeModel(GL_FLAT);//设置明暗处理 } //主要的绘制过程 void display(void) { glClear(GL_COLOR_BUFFER_BIT);//清除颜色缓存 glBegin(GL_LINES);//开始画直线 glColor3f(1.0f, 1.0f, 1.0f);//设置颜色为白色 glVertex2f(30.0f, 30.0f);//第一根线的两个端点 glVertex2f(200.0f, 400.0f);

计算机图形学 实验一:生成彩色立方体(含源代码)

实验一 实验目的:生成彩色立方体 实验代码://ColorCube1.java import java.applet.Applet; //可以插入html import java.awt.BorderLayout; //窗口采用BorderLayout方式布局import com.sun.j3d.utils.applet.MainFrame; //application import com.sun.j3d.utils.geometry.ColorCube;//调用生成ColorCube的Utility import com.sun.j3d.utils.geometry.Primitive; import com.sun.j3d.utils.universe.*; //观测位置的设置 import javax.media.j3d.*; //核心类 import javax.vecmath.*; //矢量计算 import com.sun.j3d.utils.behaviors.mouse.*; public class ColorCube1 extends Applet { public BranchGroup createSceneGraph() { BranchGroup objRoot=new BranchGroup(); //BranchGroup的一个对象objRoot(放置背景、灯光)BoundingSphere bounds=new BoundingSphere(new Point3d(0.0,0.0,0.0),100.0);//有效范围 TransformGroup objTrans=new TransformGroup(); objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE); objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ); objRoot.addChild(objTrans); MouseRotate behavior = new MouseRotate(); behavior.setTransformGroup(objTrans); objRoot.addChild(behavior); behavior.setSchedulingBounds(bounds); MouseZoom behavior2 = new MouseZoom(); behavior2.setTransformGroup(objTrans); objRoot.addChild(behavior2); behavior2.setSchedulingBounds(bounds); MouseTranslate behavior3 = new MouseTranslate(); behavior3.setTransformGroup(objTrans); objRoot.addChild(behavior3); behavior3.setSchedulingBounds(bounds);

OpenGL的库函数介绍

OpenGL的库函数介绍 开发基于OpenGL的应用程序,必须先了解OpenGL的库函数。 OpenGL库函数的命名方式非常有规律。所有OpenGL函数采用了以下格式: <库前缀><根命令><可选的参数个数><可选的参数类型> 库前缀有gl、glu、aux、glut、wgl、glx、agl等等,分别表示该函数属于OpenGL那个开发库。从函数名后面中还可以看出需要多少个参数以及参数的类型。I代表int型,f代表float型,d代表double型,u代表无符号整型。例如:glVertex3fv()表示了该函数属于gl库,参数是三个float型参数指针。我们用glVertex*() 来表示这一类函数。 OpenGL函数库相关的API有核心库(gl)、实用库(glu)、辅助库(aux)、实用工具库(glut)、窗口库(glx、agl、wgl)和扩展函数库等。从下图可以看出,核心库(gl)是核心,实用库(glu)是对gl的部分封装。窗口库(glx、agl、wgl)是针对不同窗口系统的函数。实用工具库(glut)是跨平台的OpenGL程序的工具包,比aux功能强大。扩展函数库是硬件厂商为实现硬件更新利用OpenGL的扩展机制开发的函数。下面逐一对这些库进行详细介绍。 1.OpenGL核心库(GL) 核心库包含有115个函数,函数名的前缀为gl。这部分函数用于常规的、核心的图形处理。由于许多函数可以接收不同数据类型的参数,因此派生出来的函数原形多达300多个。核心库在Windows平台上的头文件为“GL.H”,库文件为“OPENGL32.LIB”,动态链接库为“OPENGL32.DLL”。核心库可以在所有的OpenGL平台上运行。 核心库中的函数主要分为以下几类: ●基本几何图元的绘制函数:glBegain()、glEnd()、glNormal*()、glVertex*(); ●矩阵操作、几何变换和投影变换的函数:如矩阵入栈函数glPushMatrix(),矩阵出 栈函数glPopMatrix(),装载矩阵函数glLoadMatrix(),矩阵相乘函数glMultMatrix(), 当前矩阵函数glMatrixMode()和矩阵标准化函数glLoadIdentity(),几何变换函数 glTranslate*()、glRotate*()和glScale*(),投影变换函数glOrtho()、glFrustum()和视 口变换函数glViewport(); ●颜色、光照和材质的函数:如设置颜色模式函数glColor*()、glIndex*(),设置光照 效果的函数glLight*() 、glLightModel*()和设置材质效果函数glMaterial(); ●显示列表函数:主要有创建、结束、生成、删除和调用显示列表的函数glNewList()、 glEndList()、glGenLists()、glCallList()和glDeleteLists(); ●纹理映射函数:主要有一维纹理函数glTexImage1D()、二维纹理函数 glTexImage2D()、设置纹理参数、纹理环境和纹理坐标的函数glTexParameter*()、 glTexEnv*()和glTetCoord*();

计算机图形学实验_透视茶壶源代码

#include #include #include using namespace std; float fTranslate; float fRotate; float fScale=1.0f;//set inital scale value to 1.0f bool bPersp=false; bool bAnim=false; bool bWire=false; int wHeight=0; int wWidth=0; //todo //hint:some additional parameters may needed here when you operate the teapot void Draw_Leg() { glScalef(1,1,3); glutSolidCube(1.0f); //glutWireCone(1.0f); } //定义操作茶壶的操作参数 int tx=1; int ty=0; int tz=0; int tangle=90; //定义设置scale的参数 float sx=0.3f; float sy=0.3f; float sz=0.3f; void Draw_Scene() { glPushMatrix(); glTranslatef(0,0,5); glRotatef(tangle,tx,ty,tz); // glutSolidTeapot(1); glutSolidSphere(1.0f,10,10);

glPopMatrix(); glPushMatrix(); glTranslatef(0,0,3.5); glScalef(5,4,1); glutSolidCube(1.0); glPopMatrix(); //leg1 glPushMatrix(); glTranslatef(1.5,1,1.5); Draw_Leg(); glPopMatrix(); //leg2 glPushMatrix(); glTranslatef(-1.5,1,1.5); Draw_Leg(); glPopMatrix(); //leg3 glPushMatrix(); glTranslatef(1.5,-1,1.5); Draw_Leg(); glPopMatrix(); //leg4 glPushMatrix(); glTranslatef(-1.5,-1,1.5); Draw_Leg(); glPopMatrix(); } void updateView(int width,int height) { glViewport(0,0,width,height);//reset the current viewport glMatrixMode(GL_PROJECTION);//select the projection matrix glLoadIdentity();//reset the projection matrix float whRatio=(GLfloat)width/(GLfloat)height; if(bPersp) { //todo when 'p'operation ,hint:use function glupersPective } else glOrtho(-3,3,-3,3,-100,100); glMatrixMode(GL_MODELVIEW);//select the modelview matrix

OpenGL 函数 gluLookAt

OpenGL 函数gluLookAt() glScalef() glTranslatef() glRotatef() glFrustum() glPerspective() 的使用 1.gluLookAt()——视图变换函数 把自己的眼睛当成是照相机,前三个参数表示眼睛的坐标,中间三个参数表示要拍照的物体的中心位置,可以理解成焦点吧, 后三个参数表示头顶的朝向,比如说头可以歪着(哈哈)。但是我测试过,如果歪的不对,原来的正前方现在已经不是正前方 了,那么就看不见物体了。举个例子: gluLookAt (0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);//这个就表示头顶是朝着y方向 gluLookAt (0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0);//这个表示头歪了45度,头顶朝着(1.0,1.0,0.0)这个方向 2.glScalef() ——模型变换函数缩放 void glScalef(GLfloat x, GLfloat y, GLfloat z); 模型变换的目的是设置模型的位置和方向,例如可以对模型进行旋转、移动和缩放,或者联合这几种操作。 这个函数表示模型在各轴上是如果进行缩放的。举个例子: glScalef (1.0, 2.0, 1.0);//表示y坐标值扩大两倍,这样原本方的物体就变成长的了。 3.glTranslatef() ——模型变换函数移动 void glTranslatef(GLfloat x, GLfloat y, GLfloat z); 这个函数表示模型是怎样移动的。举个例子: glTranslatef(-1.0,0.0,-2.0);//表示物体沿x负方向移动1.0,沿z轴负方向移动2.0。所以就好像能看见侧面一样

计算机图形学实验--完整版-带结果--vc++实现

计算机图形学实验报告信息学院计算机专业20081060183 周建明 综括: 利用计算机编程语言绘制图形,主要实现以下内容: (1)、中点算法生成任意斜率直线,并设置线型线宽。 (2)、中点算法生成圆 (3)、中点算法生成椭圆 (4)、扫描算法实现任意多边形填充 (5)、Cohen_Sutherland裁剪 (6)、自由曲线与曲面的绘制 (7)、二维图形变换 (8)、三视图变换 实验一、直线的生成 一、实验内容 根据提供的程序框架,修改部分代码,完成画一条直线的功能(中点画线法或者Bresenham画线法任选一),只要求实现在第一象限内的直线。 二、算法原理介绍 双击直线生成.dsw打开给定的程序,或者先启动VC++,文件(file)→打开工作空间(open workspace)。打开直线生成view.cpp,按注释改写下列函数: 1.void CMyView::OnDdaline() (此为DDA生成直线) 2.void CMyView::OnBresenhamline()(此为Bresenham画直线) 3.void CMYView::OnMidPointLine()(此为中点画线法) 三、程序源代码 1.DDA生成直线画法程序: float x,y,dx,dy,k; dx=(float)(xb-xa); dy=(float)(yb-ya); k=dy/dx; x=xa; y=ya;

if(abs(k)<1) { for (x=xa;x<=xb;x++) { pdc->SetPixel(x, int(y+0.5),COLOR); y=y+k; } } if(abs(k)>=1) { for(y=ya;y<=yb;y++) { pdc->SetPixel(int(x+0.5),y,COLOR); x=x+1/k; } } //DDA画直线结束 } 2.Bresenham画直线源程序: float b,d,xi,yi; int i; float k; k=(yb-ya)/(xb-xa); b=(ya*xb-yb*xa)/(xb-xa); if(k>0&&k<=1) for(i=0;i=0) { xi=xa+1; yi=ya; xa++; ya=ya+0.5; } if(d<0) { xi=xa+1; yi=ya+1; xa++; ya=ya+1.5; } pdc->SetPixel(xi,yi,COLOR); }

计算机图形学实验指导(含源码附报告模板)

计算机图形学实验指导 目录 实验1 直线的绘制 (2) 实验2 圆和椭圆的绘制 (4) 实验3 图形填充 (7) 实验4 二维图形几何变换 (10) 实验5 二维图形裁剪 (13) 实验6 曲线生成算法的实现 (18) 附录:实验报告模板 (20)

实验1 直线的绘制 实验目的 1、通过实验,进一步理解和掌握DDA和Bresenham算法; 2、掌握以上算法生成直线段的基本过程; 3、通过编程,会在TC环境下完成用DDA或中点算法实现直线段的绘制。实验环境 计算机、Turbo C或其他C语言程序设计环境 实验学时 2学时,必做实验。 实验内容 用DDA算法或Besenham算法实现斜率k在0和1之间的直线段的绘制。实验步骤 1、算法、原理清晰,有详细的设计步骤; 2、依据算法、步骤或程序流程图,用C语言编写源程序; 3、编辑源程序并进行调试; 4、进行运行测试,并结合情况进行调整; 5、对运行结果进行保存与分析; 6、把源程序以文件的形式提交; 7、按格式书写实验报告。 实验代码:DDA: # include # include void DDALine(int x0,int y0,int x1,int y1,int color) { int dx,dy,epsl,k; float x,y,xIncre,yIncre; dx=x1-x0; dy=y1-y0; x=x0; y=y0; if(abs(dx)>abs(dy)) epsl=abs(dx); else epsl=abs(dy);

xIncre=(float)dx/(float)epsl; yIncre=(float)dy/(float)epsl; for(k=0;k<=epsl;k++) { putpixel((int)(x+0.5),(int)(y+0.5),4); x+=xIncre; y+=yIncre; } } main(){ int gdriver ,gmode ; gdriver = DETECT; initgraph(&gdriver , &gmode ,"C:\\TC20\\BGI"); DDALine(0,0,35,26,4); getch ( ); closegraph ( ); } Bresenham: #include #include void BresenhamLine(int x0,int y0,int x1,int y1,int color) { int x,y,dx,dy,e; dx=x1-x0; dy=y1-y0; e=-dx;x=x0;y=y0; while(x<=x1){ putpixel(x,y,color); x++; e=e+2*dy; if(e>0){ y++; e=e-2*dx; } } } main(){ int gdriver ,gmode ; gdriver = DETECT; initgraph(&gdriver , &gmode ,"c:\\TC20\\BGI"); BresenhamLine(0, 0 , 120, 200,5 ); getch ( ); closegraph ( ); }

计算机图形学_有效边表算法源代码

#include #include #include #include #define EPSILON 0.000001 //最小浮点数 //点结构体 struct Point { int x; //x坐标 int y; //y坐标 }; //线结构体 struct Line { Point high_point; //高端点 Point low_point; //低端点 int is_active; //是否为有效边,水平边(0),非水平边(1) double inverse_k; //斜率k的倒数 }; //边结点 struct EdgeNode { double x; //扫描线与边交点的x坐标(边的低端点的x坐标)int y_max; //边的高端点的y坐标ymax double inverse_k; //斜率k的倒数 EdgeNode *next; //下一个边结点的指针 }; //有效边表 struct ActiveEdgeTable { int y; //扫描线y EdgeNode *head; //边链表的头指针 }; //桶结点 typedef struct Bucket { int y; //扫描线y EdgeNode *head; //边链表的头指针

Bucket *next; //下一个桶的指针 } EdgeTable; int compare(Point p1, Point p2); Line* create_lines(Point points[], int n); Point get_lowest_point(Line lines[], int n); Point get_highest_point(Line lines[], int n); void swap(Line &l1, Line &l2); void sort(Line lines[], int n); EdgeTable* create_edge_table(Line lines[], int n); ActiveEdgeTable* init_active_table(EdgeTable *edge_table); void delete_edge(ActiveEdgeTable *active_table, int y_max); void add_edge(ActiveEdgeTable *active_table, EdgeNode edge); ActiveEdgeTable* update_active_table(ActiveEdgeTable *active_table, EdgeTable *edge_table); void DrawPolygon(Point points, int n); void DrawGrid(int x, int y); void Fill(Point points[], int n); void Initial(); void Display(); int main(int argc, char* argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(400, 300); glutInitWindowPosition(100, 120); glutCreateWindow("Polygon Filling"); glutDisplayFunc(Display); Initial(); glutMainLoop(); return 0; } //比较2个点的高度 int compare(Point p1, Point p2) { if (p1.y > p2.y) return 1; else if (p1.y == p2.y) return 0; return -1; }

OpenGL使用手册.

OpenGL函数使用手册 (一)OpenGL函数库 格式: <库前缀><根命令><可选的参数个数><可选的参数类型> 库前缀有 gl、glu、aux、glut、wgl、glx、agl 等等, 1,核心函数库主要可以分为以下几类函数: (1) 绘制基本的几何图元函数。如:glBegain(). (2) 矩阵操作、几何变换和投影变换的函数。如:矩阵入栈 glPushMatrix(),还有矩阵的出栈、转载、相乘,此外还有 几何变换函数glTranslate*(),投影变换函数glOrtho()和 视口变换函数glViewport()等等。 (3) 颜色、光照和材质函数。 (4) 显示列表函数,主要有创建、结束、生成、删除和调用 显示列表的函数glNewList()、glEndList()、 glGenLists()、glDeleteLists()和glCallList()。(5) 纹理映射函数,主要有一维和二维纹理函数,设置纹理 参数、纹理环境和纹理坐标的函数glTexParameter*()、 glTexEnv*()和glTetCoord*()等。 (6) 特殊效果函数。 (7) 选着和反馈函数。 (8) 曲线与曲面的绘制函数。 (9) 状态设置与查询函数。 (10) 光栅化、像素函数。 2,OpenGL实用库(The OpenGL Utility Library)(GLU) 包含有43个函数,函数名的前缀名为glu. (1) 辅助纹理贴图函数。 (2) 坐标转换和投影变换函数。 (3) 多边形镶嵌工具。 (4) 二次曲面绘制工具。

(5) 非均匀有理B样条绘制工具。 (6) 错误反馈工具,获取出错信息的字符串gluErrorString() 3,OpenGL辅助库 包含有31个函数,函数名前缀名为aux 这部分函数提供窗口管理、输入输出处理以及绘制一些简单的三维物体。 4,OpenGL工具库(OpenGL Utility Toolkit) 包含大约30多个函数,函数前缀名为glut,此函数由glut.dll来负责解释执行。 (1) 窗口操作函数。窗口初始化、窗口大小、窗口位置等函 数glutInit() glutInitDisplayMode()、glutInitWindowSize() glutInitWindowPosition()等。 (2) 回调函数。响应刷新消息、键盘消息、鼠标消息、定时 器函数等,GlutDisplayFunc()、glutPostRedisplay()、 glutReshapeFunc()、glutTimerFunc()、 glutKeyboardFunc()、 glutMouseFunc()。 (3) 创建复杂的三维物体。这些和aux库函数功能相同。如创 建球体glutWireSphere(). (4) 函数菜单 (5) 程序运行函数 glutAttachMenu() 5,16个WGL函数,专门用于OpenGL和Windows窗口系统的联接,其前缀名为wgl。 (1) 绘制上下文函数。 wglCreateContext()、 wglDeleteContext()、wglGetCurrentContent()、 wglGetCurrentDC() wglDeleteContent()等。 (2) 文字和文本处理函数。wglUseFontBitmaps()、 wglUseFontOutlines()。 (3) 覆盖层、地层和主平面处理函数。wglCopyContext()、 wglCreateLayerPlane()、wglDescribeLayerPlane()、wglReakizeLayerPlatte()等。 (4) 其他函数。wglShareLists()、wglGetProcAddress()等。

相关主题
相关文档 最新文档