posts - 15,  comments - 0,  trackbacks - 0
 

OpenGL入门学习

OpenGL作为当前主流的图形API之一,它在一些场合具有比DirectX更优越的特性。

1、与C语言紧密结合

OpenGL命令最初就是用C语言函数来进行描述的,对于学习过C语言的人来讲,OpenGL是容易理解和学习的。如果你曾经接触过TCgraphics.h,你会发现,使用OpenGL作图甚至比TC更加简单

2、强大的可移植性

微软的Direct3D虽然也是十分优秀的图形API,但它只用于Windows系统(现在还要加上一个XBOX游戏机)。而OpenGL不仅用于 Windows,还可以用于Unix/Linux等其它系统,它甚至在大型计算机、各种专业计算机(如:医疗用显示设备)上都有应用。并且,OpenGL 的基本命令都做到了硬件无关,甚至是平台无关。

3、高性能的图形渲染

OpenGL是一个工业标准,它的技术紧跟时代,现今各个显卡厂家无一不对OpenGL提供强力支持,激烈的竞争中使得OpenGL性能一直领先。

总之,OpenGL是一个很NB的图形软件接口。至于究竟有多NB,去看看DOOM3QUAKE4等专业游戏就知道了。

OpenGL官方网站(英文)

http://www.opengl.org

 

linux下编写OpenGL程序的一些准备工作

需要用到的软件包有两个,glut tmake,分别可以从以下两个网址下载:

http://www.opengl.org/resources/libraries/glut/glut-3.7.tar.gz

ftp://ftp.trolltech.com/freebies/tmake/tmake-1.8.tar.gz

下载后的文件假设都放在/usr/src

首先是安装glut库,以下是从www.linux.com找到的编译glut库的手册。

Install GLUT 3.7 Distribution (optional)

If you installed the MesaDemos/MesaLib package, then you have already installed GLUT 3.7 since it is included with MesaDemos. However, you may be interested in installing the GLUT

manpages and you can skip right to the "Install GLUT manual pages", below ...

Installing GLUT is a bit tricky. I'm not too familiar with imake, the program that it uses to manage the Makefiles, and didn't quite see how to get GLUT to install to where I wanted it (/usr/lib,

but MesaDemos will do this without any trouble though). It can be done manually anyhow:

 cd /usr/src

 tar -xvzf glut-3.7.tar.gz

 cd glut-3.7

 Read the file: README.linux

 cd linux

 READ the file: README

 cp Glut.cf ..

 cd ..

 Edit Glut.cf: remove any Mesa references.

 Replace any -lMesaGL -lMesaGLU with -lGL -lGLU if needed.

 In particular, replace:

  OPENGL = $(TOP)/../lib/libMesaGL.so

  GLU = $(TOP)/../lib/libMesaGLU.so

 with:

  OPENGL = -lGL

  GLU = -lGLU

 ./mkmkfiles.imake

 cd lib/glut

 cp /usr/src/glut-3.7/linux/Makefile .

 Edit the Makefile: remove any Mesa references.

 Replace any -lMesaGL -lMesaGLU with -lGL -lGLU if needed.

 In particular, replace:

  OPENGL = $(TOP)/../lib/libMesaGL.so

  GLU = $(TOP)/../lib/libMesaGLU.so

 with:

  OPENGL = -lGL

  GLU = -lGLU

 make

 ln -s libglut.so.3.7 libglut.so

 ln -s libglut.so.3.7 libglut.so.3

 cp -d libglut.* /usr/lib

 cd ..

 cd gle

 # make a shared lib for libgle

 make

 gcc -shared -o libgle.so.3.7 *.o

 ln -s libgle.so.3.7 libgle.so

 ln -s libgle.so.3.7 libgle.so.3

 cp -d libgle.* /usr/lib

 cd ..

 cd mui

 # make a shared lib for libmui

 make

 gcc -shared -o libmui.so.3.7 *.o

 ln -s libmui.so.3.7 libmui.so

 ln -s libmui.so.3.7 libmui.so.3

 cp -d libmui.* /usr/lib

        # Install the GLUT manual pages (not included with MesaDemos)

 cd /usr/src/glut-3.7

 make SUBDIRS=man Makefile

 cd man/glut

 make install.man

 ldconfig

 cd ../../progs/demos/ideas

 # edit the Makefile, change OPENGL = -lGL and GLU = -lGLU

 make

 ./ideas

 # test compiling some demos

 # take a look at which libraries have to be linked (-lX11 ...) in

 # the Makefiles.  Qt's tmake program available at www.troll.no

 # is a quick way to make a Makefile but you have to edit it

 # and add the -l needed.

ideas如果运行成功的话,说明glut已经可以用了。

上面的几步中,下载的glut包放在/usr/src目录下,如果放在其他目录下,将/usr/src改为相应的目录即可。

此外应该注意的是两个Makefile文件的修改

  

·  OPENGL = $(TOP)/../lib/libMesaGL.so

  GLU = $(TOP)/../lib/libMesaGLU.so

 

  OPENGL = -lGL

  GLU = -lGLU

因为所指定的目录中没有libMesaGL.solibMesaGLU.so

之后是tmake的配置,后面我们可以用它来生成pro工程文件和makefile文件。

先将下载的tmake解压缩,tar  -zxvf  tmake-1.8.tar.gz

得到tmake-1.8目录,之后设置两个环境变量:PATHTMAKEPATH

PATH=$PATH:/usr/src/tmake-1.8/bin

export PATH

TMAKEPATH=/usr/src/tmake-1.8/lib/linux-g++

export TMAKEPATH

新建一个测试目录test,将glut-3.7目录下的progs/redbook目录下的hello.c复制到test目录中

之后生成一个pro文件:progen  -o hello.pro

然后生成makefile文件:tmake hello.pro -o Makefile

编辑生成的Makefile文件,在加载动态连接库的行里面加入 -lglut -lXi -lXmu

保存,make

./hello 可以看到运行结果就可以了。

 

下面将对Windows下的OpenGL编程进行简单介绍。

学习OpenGL前的准备工作

第一步,选择一个编译环境

现在Windows系统的主流编译环境有Visual StudioBroland C++ BuilderDev-C++等,它们都是支持OpenGL的。但这里我们选择Visual Studio 2005作为学习OpenGL的环境。

第二步,安装GLUT工具包

GLUT不是OpenGL所必须的,但它会给我们的学习带来一定的方便,推荐安装。

Windows VS2005环境下环境下安装GLUT的步骤:

1、将下载的压缩包解开,将得到5个文件

2、在我的电脑中搜索“gl.h”,并找到其所在文件夹(如果是VisualStudio2005,则应该是其安装目录下面的“VC\PlatformSDK\include\gl文件夹)。把解压得到的glut.h放到这个文件夹。

3、把解压得到的glut.libglut32.lib放到静态函数库所在文件夹(如果是VisualStudio2005,则应该是其安装目录下面的“VC\lib”文件夹)。

4、把解压得到的glut.dllglut32.dll放到操作系统目录下面的system32文件夹内。(典型的位置为:C:\Windows\System32

 

Windows VS2008环境下环境下安装GLUT的步骤:

如果是VisualStudio2008,把解压得到的glut.h放到“Microsoft Visual Studio 9.0\VC\include”;

如果是VisualStudio2008,把解压得到的glut.dllglut32.dll放到“Microsoft Visual Studio 9.0\VC\lib”。

 

第三步,建立一个OpenGL工程

这里以VisualStudio2005为例。

选择File->New->Project,然后选择Win32 Console Application,选择一个名字,然后按OK

在谈出的对话框左边点Application Settings,找到Empty project并勾上,选择Finish

然后向该工程添加一个代码文件,取名为“OpenGL.c”,注意用.c来作为文件结尾。

搞定了,就跟平时的工程没什么两样的。

 

第一个OpenGL程序

一个简单的OpenGL程序如下:(注意,如果需要编译并运行,需要正确安装GLUT,安装方法如上所述)

#include <GL/glut.h>

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glRectf(-0.5f, -0.5f, 0.5f, 0.5f);

    glFlush();

}

 

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

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);

    glutInitWindowPosition(100, 100);

    glutInitWindowSize(400, 400);

    glutCreateWindow("第一个OpenGL程序");

    glutDisplayFunc(&myDisplay);

    glutMainLoop();

    return 0;

}

 

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

首先,需要包含头文件#include <GL/glut.h>,这是GLUT的头文件。

本来OpenGL程序一般还要包含<GL/gl.h><GL/glu.h>,但GLUT的头文件中已经自动将这两个文件包含了,不必再次包含。

 

然后看main函数。

int main(int argc, char *argv[]),这个是带命令行参数的main函数,各位应该见过吧?没见过的同志们请多翻翻书,等弄明白了再往下看。

注意main函数中的各语句,除了最后的return之外,其余全部以glut开头。这种以glut开头的函数都是GLUT工具包所提供的函数,下面对用到的几个函数进行介绍。

1glutInit,对GLUT进行初始化,这个函数必须在其它的GLUT使用之前调用一次。其格式比较死板,一般照抄这句glutInit(&argc, argv)就可以了。

2 glutInitDisplayMode,设置显示方式,其中GLUT_RGB表示使用RGB颜色,与之对应的还有GLUT_INDEX(表示使用索引颜色)。GLUT_SINGLE表示使用单缓冲,与之对应的还有GLUT_DOUBLE(使用双缓冲)。更多信息,请自己Google。当然以后的教程也会有一些讲解。

3glutInitWindowPosition,这个简单,设置窗口在屏幕中的位置。

4glutInitWindowSize,这个也简单,设置窗口的大小。

5glutCreateWindow,根据前面设置的信息创建窗口。参数将被作为窗口的标题。注意:窗口被创建后,并不立即显示到屏幕上。需要调用glutMainLoop才能看到窗口。

6glutDisplayFunc,设置一个函数,当需要进行画图时,这个函数就会被调用。(这个说法不够准确,但准确的说法可能初学者不太好理解,暂时这样说吧)。

7glutMainLoop,进行一个消息循环。(这个可能初学者也不太明白,现在只需要知道这个函数可以显示窗口,并且等待窗口关闭后才会返回,这就足够了。)

 

glutDisplayFunc函数中,我们设置了当需要画图时,请调用myDisplay函数。于是myDisplay函数就用来画图。观察myDisplay中的三个函数调用,发现它们都以gl开头。这种以gl开头的函数都是OpenGL的标准函数,下面对用到的函数进行介绍。

1glClear,清除。GL_COLOR_BUFFER_BIT表示清除颜色,glClear函数还可以清除其它的东西,但这里不作介绍。

2glRectf,画一个矩形。四个参数分别表示了位于对角线上的两个点的横、纵坐标。

3glFlush,保证前面的OpenGL命令立即执行(而不是让它们在缓冲区中等待)。其作用跟fflush(stdout)类似。


 

 

OpenGL入门学习(二)(转)

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

 

一、点、直线和多边形

我们知道数学(具体的说,是几何学)中有点、直线和多边形的概念,但这些概念在计算机中会有所不同。

数学上的点,只有位置,没有大小。但在计算机中,无论计算精度如何提高,始终不能表示一个无穷小的点。另一方面,无论图形输出设备(例如,显示器)如何精确,始终不能输出一个无穷小的点。一般情况下,OpenGL中的点将被画成单个的像素(像素的概念,请自己搜索之~),虽然它可能足够小,但并不会是无穷小。同一像素上,OpenGL可以绘制许多坐标只有稍微不同的点,但该像素的具体颜色将取决于OpenGL的实现。当然,过度的注意细节就是钻牛角尖,我们大可不必花费过多的精力去研究多个点如何画到同一像素上

同样的,数学上的直线没有宽度,但OpenGL的直线则是有宽度的。同时,OpenGL的直线必须是有限长度,而不是像数学概念那样是无限的。可以认为,OpenGL直线概念与数学上的线段接近,它可以由两个端点来确定。

多边形是由多条线段首尾相连而形成的闭合区域。OpenGL规定,一个多边形必须是一个凸多边形(其定义为:多边形内任意两点所确定的线段都在多边形内,由此也可以推导出,凸多边形不能是空心的)。多边形可以由其边的端点(这里可称为顶点)来确定。(注意:如果使用的多边形不是凸多边形,则最后输出的效果是未定义的——OpenGL为了效率,放宽了检查,这可能导致显示错误。要避免这个错误,尽量使用三角形,因为三角形都是凸多边形)

 

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

 

二、在OpenGL中指定顶点

由以上的讨论可以知道,是一切的基础。

如何指定一个点呢?OpenGL提供了一系列函数。它们都以glVertex开头,后面跟一个数字和1~2个字母。例如:

glVertex2d

glVertex2f

glVertex3f

glVertex3fv

等等。

数字表示参数的个数,2表示有两个参数,3表示三个,4表示四个(我知道有点罗嗦~)。

字母表示参数的类型,s表示16位整数(OpenGL中将这个类型定义为GLshort),

                  i表示32位整数(OpenGL中将这个类型定义为GLintGLsizei),

                  f表示32位浮点数(OpenGL中将这个类型定义为GLfloatGLclampf),

                  d表示64位浮点数(OpenGL中将这个类型定义为GLdoubleGLclampd)。

                  v表示传递的几个参数将使用指针的方式,见下面的例子。

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

(一)glVertex2i(1, 3);

(二)glVertex2f(1.0f, 3.0f);

(三)glVertex3f(1.0f, 3.0f, 0.0f);

(四)glVertex4f(1.0f, 3.0f, 0.0f, 1.0f);

(五)GLfloat VertexArr3[] = {1.0f, 3.0f, 0.0f};

     glVertex3fv(VertexArr3);

以后我们将用glVertex*来表示这一系列函数。

注意:OpenGL的很多函数都是采用这样的形式,一个相同的前缀再加上参数说明标记,这一点会随着学习的深入而有更多的体会。

 

 

三、开始绘制

假设现在我已经指定了若干顶点,那么OpenGL是如何知道我想拿这些顶点来干什么呢?是一个一个的画出来,还是连成线?或者构成一个多边形?或者做其它什么事情?

为了解决这一问题,OpenGL要求:指定顶点的命令必须包含在glBegin函数之后,glEnd函数之前(否则指定的顶点将被忽略)。并由glBegin来指明如何使用这些点。

例如我写:

glBegin(GL_POINTS);

    glVertex2f(0.0f, 0.0f);

    glVertex2f(0.5f, 0.0f);

glEnd();

则这两个点将分别被画出来。如果将GL_POINTS替换成GL_LINES,则两个点将被认为是直线的两个端点,OpenGL将会画出一条直线。

我们还可以指定更多的顶点,然后画出更复杂的图形。

另一方面,glBegin支持的方式除了GL_POINTSGL_LINES,还有GL_LINE_STRIPGL_LINE_LOOPGL_TRIANGLESGL_TRIANGLE_STRIPGL_TRIANGLE_FAN等,每种方式的大致效果见下图:

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

 

程序代码:

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glBegin( /* 在这里填上你所希望的模式 */ );

        /* 在这里使用glVertex*系列函数 */

        /* 指定你所希望的顶点位置 */

    glEnd();

    glFlush();

}

把这段代码改成你喜欢的样子,然后用它替换第一课中的myDisplay函数,编译后即可运行。

 

两个例子

例一、画一个圆

/*

正四边形,正五边形,正六边形,……,直到正n边形,当n越大时,这个图形就越接近圆

n大到一定程度后,人眼将无法把它跟真正的圆相区别

这时我们已经成功的画出了一个

(注:画圆的方法很多,这里使用的是比较简单,但效率较低的一种)

试修改下面的const int n的值,观察当n=3,4,5,8,10,15,20,30,50等不同数值时输出的变化情况

GL_POLYGON改为GL_LINE_LOOPGL_POINTS等其它方式,观察输出的变化情况

*/

#include <math.h>

const int n = 20;

const GLfloat R = 0.5f;

const GLfloat Pi = 3.1415926536f;

void myDisplay(void)

{

    int i;

    glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_POLYGON);

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

        glVertex2f(R*cos(2*Pi/n*i), R*sin(2*Pi/n*i));

    glEnd();

    glFlush();

}

 

 

例二、画一个五角星

/*

设五角星的五个顶点分布位置关系如下:

     A

 E       B

 

   D   C

首先,根据余弦定理列方程,计算五角星的中心到顶点的距离a

(假设五角星对应正五边形的边长为.0

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

然后,根据正弦和余弦的定义,计算Bx坐标bxy坐标by,以及Cy坐标

(假设五角星的中心在坐标原点)

bx = a * cos(18 * Pi/180);

by = a * sin(18 * Pi/180);

cy = -a * cos(18 * Pi/180);

五个点的坐标就可以通过以上四个量和一些常数简单的表示出来

*/

#include <math.h>

const GLfloat Pi = 3.1415926536f;

void myDisplay(void)

{

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

    GLfloat bx = a * cos(18 * Pi/180);

    GLfloat by = a * sin(18 * Pi/180);

    GLfloat cy = -a * cos(18 * Pi/180);

    GLfloat

        PointA[2] = { 0, a },

        PointB[2] = { bx, by },

        PointC[2] = { 0.5, cy },

        PointD[2] = { -0.5, cy },

        PointE[2] = { -bx, by };

 

    glClear(GL_COLOR_BUFFER_BIT);

    // 按照A->C->E->B->D->A的顺序,可以一笔将五角星画出

    glBegin(GL_LINE_LOOP);

        glVertex2fv(PointA);

        glVertex2fv(PointC);

        glVertex2fv(PointE);

        glVertex2fv(PointB);

        glVertex2fv(PointD);

    glEnd();

    glFlush();

}

 

 

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

/*

由于OpenGL默认坐标值只能从-11,(可以修改,但方法留到以后讲)

所以我们设置一个因子factor,把所有的坐标值等比例缩小,

这样就可以画出更多个正弦周期

试修改factor的值,观察变化情况

*/

#include <math.h>

const GLfloat factor = 0.1f;

void myDisplay(void)

{

    GLfloat x;

    glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_LINES);

        glVertex2f(-1.0f, 0.0f);

        glVertex2f(1.0f, 0.0f);        // 以上两个点可以画x

        glVertex2f(0.0f, -1.0f);

        glVertex2f(0.0f, 1.0f);        // 以上两个点可以画y

    glEnd();

    glBegin(GL_LINE_STRIP);

    for(x=-1.0f/factor; x<1.0f/factor; x+=0.01f)

    {

        glVertex2f(x*factor, sin(x)*factor);

    }

    glEnd();

    glFlush();

}

 

 

小结

本课讲述了点、直线和多边形的概念,以及如何使用OpenGL来描述点,并使用点来描述几何图形。

大家可以发挥自己的想象,画出各种几何图形,当然,也可以用GL_LINE_STRIP把很多位置相近的点连接起来,构成函数图象。如果有兴趣,也可以去找一些图象比较美观的函数,自己动手,用OpenGL把它画出来。

 

=====================   第二课    =====================

OpenGL入门学习(三)(转)

在第二课中,我们学习了如何绘制几何图形,但大家如果多写几个程序,就会发现其实还是有些郁闷之处。例如:点太小,难以看清楚;直线也太细,不舒服;或者想画虚线,但不知道方法只能用许多短直线,甚至用点组合而成。

这些问题将在本课中被解决。

 

下面就点、直线、多边形分别讨论。

 

 

1、关于点

点的大小默认为1个像素,但也可以改变之。改变的命令为glPointSize,其函数原型如下:

void glPointSize(GLfloat size);

size必须大于0.0f,默认值为1.0f,单位为像素

注意:对于具体的OpenGL实现,点的大小都有个限度的,如果设置的size超过最大值,则设置可能会有问题。

例子:

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glPointSize(5.0f);

    glBegin(GL_POINTS);

        glVertex2f(0.0f, 0.0f);

        glVertex2f(0.5f, 0.5f);

    glEnd();

    glFlush();

}

 

2、关于直线

1)直线可以指定宽度:

void glLineWidth(GLfloat width);

其用法跟glPointSize类似。

2)画虚线。

首先,使用glEnable(GL_LINE_STIPPLE);来启动虚线模式(使用glDisable(GL_LINE_STIPPLE)可以关闭之)。

然后,使用glLineStipple来设置虚线的样式。

void glLineStipple(GLint factor, GLushort pattern);

pattern是由10组成的长度为16的序列,从最低位开始看,如果为1,则直线上接下来应该画的factor个点将被画为实的;如果为0,则直线上接下来应该画的factor个点将被画为虚的。

以下是一些例子:

声明:该图片来自www.opengl.org,该图片是《OpenGL编程指南》一书的附图,由于该书的旧版(第一版,1994年)已经流传于网络,我希望没有触及到版权问题。

示例代码:

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glEnable(GL_LINE_STIPPLE);

    glLineStipple(2, 0x0F0F);

    glLineWidth(10.0f);

    glBegin(GL_LINES);

        glVertex2f(0.0f, 0.0f);

        glVertex2f(0.5f, 0.5f);

    glEnd();

    glFlush();

}

 

 

3、关于多边形

多边形的内容较多,我们将讲述以下四个方面。

1)多边形的两面以及绘制方式。

虽然我们目前还没有真正的使用三维坐标来画图,但是建立一些三维的概念还是必要的。

从三维的角度来看,一个多边形具有两个面。每一个面都可以设置不同的绘制方式:填充、只绘制边缘轮廓线、只绘制顶点,其中填充是默认的方式。可以为两个面分别设置不同的方式。

glPolygonMode(GL_FRONT, GL_FILL);           // 设置正面为填充方式

glPolygonMode(GL_BACK, GL_LINE);            // 设置反面为边缘绘制方式

glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); // 设置两面均为顶点绘制方式

 

 

2)反转

一般约定为顶点以逆时针顺序出现在屏幕上的面正面,另一个面即成为反面。生活中常见的物体表面,通常都可以用这样的正面反面合理的被表现出来(请找一个比较透明的矿泉水瓶子,在正对你的一面沿逆时针画一个圆,并标明画的方向,然后将背面转为正面,画一个类似的圆,体会一下正面反面。你会发现正对你的方向,瓶的外侧是正面,而背对你的方向,瓶的内侧才是正面。正对你的内侧和背对你的外侧则是反面。这样一来,同样属于瓶的外侧这个表面,但某些地方算是正面,某些地方却算是反面了)。

但也有一些表面比较特殊。例如麦比乌斯带(请自己Google一下),可以全部使用正面或全部使用背面来表示。

可以通过glFrontFace函数来交换正面反面的概念。

glFrontFace(GL_CCW);  // 设置CCW方向为正面CCWCounterClockWise,逆时针

glFrontFace(GL_CW);   // 设置CW方向为正面CWClockWise,顺时针

下面是一个示例程序,请用它替换第一课中的myDisplay函数,并将glFrontFace(GL_CCW)修改为glFrontFace(GL_CW),并观察结果的变化。

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glPolygonMode(GL_FRONT, GL_FILL); // 设置正面为填充模式

    glPolygonMode(GL_BACK, GL_LINE);  // 设置反面为线形模式

    glFrontFace(GL_CCW);              // 设置逆时针方向为正面

    glBegin(GL_POLYGON);              // 按逆时针绘制一个正方形,在左下方

        glVertex2f(-0.5f, -0.5f);

        glVertex2f(0.0f, -0.5f);

        glVertex2f(0.0f, 0.0f);

        glVertex2f(-0.5f, 0.0f);

    glEnd();

    glBegin(GL_POLYGON);              // 按顺时针绘制一个正方形,在右上方

        glVertex2f(0.0f, 0.0f);

        glVertex2f(0.0f, 0.5f);

        glVertex2f(0.5f, 0.5f);

        glVertex2f(0.5f, 0.0f);

    glEnd();

    glFlush();

}

3)剔除多边形表面

在三维空间中,一个多边形虽然有两个面,但我们无法看见背面的那些多边形,而一些多边形虽然是正面的,但被其他多边形所遮挡。如果将无法看见的多边形和可见的多边形同等对待,无疑会降低我们处理图形的效率。在这种时候,可以将不必要的面剔除。

首先,使用glEnable(GL_CULL_FACE);来启动剔除功能(使用glDisable(GL_CULL_FACE)可以关闭之)

然后,使用glCullFace来进行剔除。

glCullFace的参数可以是GL_FRONTGL_BACK或者GL_FRONT_AND_BACK,分别表示剔除正面、剔除反面、剔除正反两面的多边形。

注意:剔除功能只影响多边形,而对点和直线无影响。例如,使用glCullFace(GL_FRONT_AND_BACK)后,所有的多边形都将被剔除,所以看见的就只有点和直线。

 

4)镂空多边形

直线可以被画成虚线,而多边形则可以进行镂空。

首先,使用glEnable(GL_POLYGON_STIPPLE);来启动镂空模式(使用glDisable(GL_POLYGON_STIPPLE)可以关闭之)。

然后,使用glPolygonStipple来设置镂空的样式。

void glPolygonStipple(const GLubyte *mask);

其中的参数mask指向一个长度为128字节的空间,它表示了一个32*32的矩形应该如何镂空。其中:第一个字节表示了最左下方的从左到右(也可以是从右到左,这个可以修改)8个像素是否镂空(1表示不镂空,显示该像素;0表示镂空,显示其后面的颜色),最后一个字节表示了最右上方的8个像素是否镂空。

但是,如果我们直接定义这个mask数组,像这样:

static GLubyte Mask[128] =

{

    0x00, 0x00, 0x00, 0x00,   //  这是最下面的一行

    0x00, 0x00, 0x00, 0x00,

    0x03, 0x80, 0x01, 0xC0,   //  

    0x06, 0xC0, 0x03, 0x60,   //  

    0x04, 0x60, 0x06, 0x20,   //  

    0x04, 0x30, 0x0C, 0x20,   //  

    0x04, 0x18, 0x18, 0x20,   //  

    0x04, 0x0C, 0x30, 0x20,   //  

    0x04, 0x06, 0x60, 0x20,   //  

    0x44, 0x03, 0xC0, 0x22,   //  

    0x44, 0x01, 0x80, 0x22,   //  

    0x44, 0x01, 0x80, 0x22,   //  

    0x44, 0x01, 0x80, 0x22,   //  使

    0x44, 0x01, 0x80, 0x22,   //  

    0x44, 0x01, 0x80, 0x22,

    0x44, 0x01, 0x80, 0x22,

    0x66, 0x01, 0x80, 0x66,

    0x33, 0x01, 0x80, 0xCC,

    0x19, 0x81, 0x81, 0x98,

    0x0C, 0xC1, 0x83, 0x30,

    0x07, 0xE1, 0x87, 0xE0,

    0x03, 0x3F, 0xFC, 0xC0,

    0x03, 0x31, 0x8C, 0xC0,

    0x03, 0x3F, 0xFC, 0xC0,

    0x06, 0x64, 0x26, 0x60,

    0x0C, 0xCC, 0x33, 0x30,

    0x18, 0xCC, 0x33, 0x18,

    0x10, 0xC4, 0x23, 0x08,

    0x10, 0x63, 0xC6, 0x08,

    0x10, 0x30, 0x0C, 0x08,

    0x10, 0x18, 0x18, 0x08,

    0x10, 0x00, 0x00, 0x08   // 这是最上面的一行

};

这样一堆数据非常缺乏直观性,我们需要很费劲的去分析,才会发现它表示的竟然是一只苍蝇。

如果将这样的数据保存成图片,并用专门的工具进行编辑,显然会方便很多。下面介绍如何做到这一点。

 

 

首先,用Windows自带的画笔程序新建一副图片,取名为mask.bmp,注意保存时,应该选择单色位图。在图象”->“属性对话框中,设置图片的高度和宽度均为32

用放大镜观察图片,并编辑之。黑色对应二进制零(镂空),白色对应二进制一(不镂空),编辑完毕后保存。

然后,就可以使用以下代码来获得这个Mask数组了。

static GLubyte Mask[128];

FILE *fp;

fp = fopen("mask.bmp", "rb");

if( !fp )

    exit(0);

// 移动文件指针到这个位置,使得再读sizeof(Mask)个字节就会遇到文件结束

// 注意-(int)sizeof(Mask)虽然不是什么好的写法,但这里它确实是正确有效的

// 如果直接写-sizeof(Mask)的话,因为sizeof取得的是一个无符号数,取负号会有问题

if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )

    exit(0);

// 读取sizeof(Mask)个字节到Mask

if( !fread(Mask, sizeof(Mask), 1, fp) )

    exit(0);

fclose(fp);

 

 

好的,现在请自己编辑一个图片作为mask,并用上述方法取得Mask数组,运行后观察效果。

说明:绘制虚线时可以设置factor因子,但多边形的镂空无法设置factor因子。请用鼠标改变窗口的大小,观察镂空效果的变化情况。

#include <stdio.h>

#include <stdlib.h>

void myDisplay(void)

{

    static GLubyte Mask[128];

    FILE *fp;

    fp = fopen("mask.bmp", "rb");

    if( !fp )

        exit(0);

    if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )

        exit(0);

    if( !fread(Mask, sizeof(Mask), 1, fp) )

        exit(0);

    fclose(fp);

    glClear(GL_COLOR_BUFFER_BIT);

    glEnable(GL_POLYGON_STIPPLE);

    glPolygonStipple(Mask);

    glRectf(-0.5f, -0.5f, 0.0f, 0.0f);  // 在左下方绘制一个有镂空效果的正方形

    glDisable(GL_POLYGON_STIPPLE);

    glRectf(0.0f, 0.0f, 0.5f, 0.5f);    // 在右上方绘制一个无镂空效果的正方形

    glFlush();

}

 

 

小结

本课学习了绘制几何图形的一些细节。

点可以设置大小。

直线可以设置宽度;可以将直线画成虚线。

多边形的两个面的绘制方法可以分别设置;在三维空间中,不可见的多边形可以被剔除;可以将填充多边形绘制成镂空的样式。

了解这些细节会使我们在一些图象绘制中更加得心应手。

另外,把一些数据写到程序之外的文件中,并用专门的工具编辑之,有时可以显得更方便。

 

=====================   第三课    =====================

OpenGL入门学习(四)(转)

本次学习的是颜色的选择。终于要走出黑白的世界了~~

 

 

OpenGL支持两种颜色模式:一种是RGBA,一种是颜色索引模式。

无论哪种颜色模式,计算机都必须为每一个像素保存一些数据。不同的是,RGBA模式中,数据直接就代表了颜色;而颜色索引模式中,数据代表的是一个索引,要得到真正的颜色,还必须去查索引表。

 

1. RGBA颜色

RGBA模式中,每一个像素会保存以下数据:R值(红色分量)、G值(绿色分量)、B值(蓝色分量)和A值(alpha分量)。其中红、绿、蓝三种颜色相组合,就可以得到我们所需要的各种颜色,而alpha不直接影响颜色,它将留待以后介绍。

RGBA模式下选择颜色是十分简单的事情,只需要一个函数就可以搞定。

glColor*系列函数可以用于设置颜色,其中三个参数的版本可以指定RGB的值,而A值采用默认;四个参数的版本可以分别指定RGBA的值。例如:

void glColor3f(GLfloat red, GLfloat green, GLfloat blue);

void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

(还记得吗?3f表示有三个浮点参数~请看第二课中关于glVertex*函数的叙述。)

将浮点数作为参数,其中0.0表示不使用该种颜色,而1.0表示将该种颜色用到最多。例如:

glColor3f(1.0f, 0.0f, 0.0f);   表示不使用绿、蓝色,而将红色使用最多,于是得到最纯净的红色。

glColor3f(0.0f, 1.0f, 1.0f);   表示使用绿、蓝色到最多,而不使用红色。混合的效果就是浅蓝色。

glColor3f(0.5f, 0.5f, 0.5f);   表示各种颜色使用一半,效果为灰色。

注意:浮点数可以精确到小数点后若干位,这并不表示计算机就可以显示如此多种颜色。实际上,计算机可以显示的颜色种数将由硬件决定。如果OpenGL找不到精确的颜色,会进行类似四舍五入的处理。

 

大家可以通过改变下面代码中glColor3f的参数值,绘制不同颜色的矩形。

void myDisplay(void)

{

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(0.0f, 1.0f, 1.0f);

    glRectf(-0.5f, -0.5f, 0.5f, 0.5f);

    glFlush();

}

 

注意:glColor系列函数,在参数类型不同时,表示最大颜色的值也不同。

采用fd做后缀的函数,以1.0表示最大的使用。

采用b做后缀的函数,以127表示最大的使用。

采用ub做后缀的函数,以255表示最大的使用。

采用s做后缀的函数,以32767表示最大的使用。

采用us做后缀的函数,以65535表示最大的使用。

这些规则看似麻烦,但熟悉后实际使用中不会有什么障碍。

 

2、索引颜色

在索引颜色模式中,OpenGL需要一个颜色表。这个表就相当于画家的调色板:虽然可以调出很多种颜色,但同时存在于调色板上的颜色种数将不会超过调色板的格数。试将颜色表的每一项想象成调色板上的一个格子:它保存了一种颜色。

在使用索引颜色模式画图时,我说我把第i种颜色设置为某某,其实就相当于将调色板的第i格调为某某颜色。我需要第k种颜色来画图,那么就用画笔去蘸一下第k格调色板。

颜色表的大小是很有限的,一般在256~4096之间,且总是2的整数次幂。在使用索引颜色方式进行绘图时,总是先设置颜色表,然后选择颜色。

 

2.1、选择颜色

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

void glIndexi(GLint c);

是的,这的确很简单。

 

2.2、设置颜色表

OpenGL 并直接没有提供设置颜色表的方法,因此设置颜色表需要使用操作系统的支持。我们所用的Windows和其他大多数图形操作系统都具有这个功能,但所使用的函数却不相同。正如我没有讲述如何自己写代码在Windows下建立一个窗口,这里我也不会讲述如何在Windows下设置颜色表。

GLUT工具包提供了设置颜色表的函数glutSetColor,但我测试始终有问题。现在为了让大家体验一下索引颜色,我向大家介绍另一个OpenGL工具包: aux。这个工具包是VisualStudio自带的,不必另外安装,但它已经过时,这里仅仅是体验一下,大家不必深入。

#include <windows.h>

#include <GL/gl.h>

#include <GL/glaux.h>

 

#pragma comment (lib, "opengl32.lib")

#pragma comment (lib, "glaux.lib")

 

#include <math.h>

const GLdouble Pi = 3.1415926536;

void myDisplay(void)

{

    int i;

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

        auxSetOneColor(i, (float)(i&0x04), (float)(i&0x02), (float)(i&0x01));

    glShadeModel(GL_FLAT);

    glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_TRIANGLE_FAN);

    glVertex2f(0.0f, 0.0f);

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

    {

        glIndexi(i);

        glVertex2f(cos(i*Pi/4), sin(i*Pi/4));

    }

    glEnd();

    glFlush();

}

 

int main(void)

{

    auxInitDisplayMode(AUX_SINGLE|AUX_INDEX);

    auxInitPosition(0, 0, 400, 400);

    auxInitWindow(L"");

    myDisplay();

    Sleep(10 * 1000);

    return 0;

}

 

其它部分大家都可以不管,只看myDisplay函数就可以了。首先,使用auxSetOneColor设置颜色表中的一格。循环八次就可以设置八格。

glShadeModel等下再讲,这里不提。

然后在循环中用glVertex设置顶点,同时用glIndexi改变顶点代表的颜色。

最终得到的效果是八个相同形状、不同颜色的三角形。

 

索引颜色虽然讲得多了点。索引颜色的主要优势是占用空间小(每个像素不必单独保存自己的颜色,只用很少的二进制位就可以代表其颜色在颜色表中的位置),花费系统资源少,图形运算速度快,但它编程稍稍显得不是那么方便,并且画面效果也会比RGB颜色差一些。星际争霸可能代表了256色的颜色表的画面效果,虽然它在一台很烂的PC上也可以运行很流畅,但以目前的眼光来看,其画面效果就显得不足了。

目前的PC机性能已经足够在各种场合下使用RGB颜色,因此PC程序开发中,使用索引颜色已经不是主流。当然,一些小型设备例如GBA、手机等,索引颜色还是有它的用武之地。

 

 

3、指定清除屏幕用的颜色

我们写:glClear(GL_COLOR_BUFFER_BIT);意思是把屏幕上的颜色清空。

但实际上什么才叫呢?在宇宙中,黑色代表了;在一张白纸上,白色代表了;在信封上,信封的颜色才是

OpenGL用下面的函数来定义清楚屏幕后屏幕所拥有的颜色。

RGB模式下,使用glClearColor来指定的颜色,它需要四个参数,其参数的意义跟glColor4f相似。

在索引颜色模式下,使用glClearIndex来指定的颜色所在的索引,它需要一个参数,其意义跟glIndexi相似。

void myDisplay(void)

{

    glClearColor(1.0f, 0.0f, 0.0f, 0.0f);

    glClear(GL_COLOR_BUFFER_BIT);

    glFlush();

}

呵,这个还真简单~

 

 

4、指定着色模型

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

#include <math.h>

const GLdouble Pi = 3.1415926536;

void myDisplay(void)

{

    int i;

    // glShadeModel(GL_FLAT);

    glClear(GL_COLOR_BUFFER_BIT);

    glBegin(GL_TRIANGLE_FAN);

    glColor3f(1.0f, 1.0f, 1.0f);

    glVertex2f(0.0f, 0.0f);

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

    {

        glColor3f(i&0x04, i&0x02, i&0x01);

        glVertex2f(cos(i*Pi/4), sin(i*Pi/4));

    }

    glEnd();

    glFlush();

}

在默认情况下,OpenGL会计算两点顶点之间的其它点,并为它们填上合适的颜色,使相邻的点的颜色值都比较接近。如果使用的是RGB模式,看起来就具有渐变的效果。如果是使用颜色索引模式,则其相邻点的索引值是接近的,如果将颜色表中接近的项设置成接近的颜色,则看起来也是渐变的效果。但如果颜色表中接近的项颜色却差距很大,则看起来可能是很奇怪的效果。

使用glShadeModel函数可以关闭这种计算,如果顶点的颜色不同,则将顶点之间的其它点全部设置为与某一个点相同。(直线以后指定的点的颜色为准,而多边形将以任意顶点的颜色为准,由实现决定。)为了避免这个不确定性,尽量在多边形中使用同一种颜色。

glShadeModel的使用方法:

glShadeModel(GL_SMOOTH);   // 平滑方式,这也是默认方式

glShadeModel(GL_FLAT);     // 单色方式

 

小结:

本课学习了如何设置颜色。其中RGB颜色方式是目前PC机上的常用方式。

可以设置glClear清除后屏幕所剩的颜色。

可以设置颜色填充方式:平滑方式或单色方式。

 

=====================   第四课    =====================

OpenGL入门学习(五)(转)

今天要讲的是三维变换的内容,课程比较枯燥。主要是因为很多函数在单独使用时都不好描述其效果,我只好在最后举一个比较综合的例子。希望大家能一口气看到底了。只看一次可能不够,如果感觉到迷糊,不妨多看两遍。有疑问可以在下面跟帖提出。

我也使用了若干图形,希望可以帮助理解。

 

 

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

 

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

1、从不同的位置去观察它。(视图变换)

2、移动或者旋转它,当然了,如果它只是计算机里面的物体,我们还可以放大或缩小它。(模型变换)

3、如果把物体画下来,我们可以选择:是否需要一种近大远小的透视效果。另外,我们可能只希望看到物体的一部分,而不是全部(剪裁)。(投影变换)

4、我们可能希望把整个看到的图形画下来,但它只占据纸张的一部分,而不是全部。(视口变换)

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

 

OpenGL变换实际上是通过矩阵乘法来实现。无论是移动、旋转还是缩放大小,都是通过在当前矩阵的基础上乘以一个新的矩阵来达到目的。关于矩阵的知识,这里不详细介绍,有兴趣的朋友可以看看线性代数(大学生的话多半应该学过的)。

OpenGL可以在最底层直接操作矩阵,不过作为初学,这样做的意义并不大。这里就不做介绍了。

 

 

1、模型变换和视图变换

相对移动的观点来看,改变观察点的位置与方向和改变物体本身的位置与方向具有等效性。在OpenGL中,实现这两种功能甚至使用的是同样的函数。

由于模型和视图的变换都通过矩阵运算来实现,在进行变换前,应先设置当前操作的矩阵为模型视图矩阵。设置的方法是以GL_MODELVIEW为参数调用glMatrixMode函数,像这样:

glMatrixMode(GL_MODELVIEW);

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

glLoadIdentity();

 

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

glTranslate*,把当前矩阵和一个表示移动物体的矩阵相乘。三个参数分别表示了在三个坐标上的位移值。

glRotate*,把当前矩阵和一个表示旋转物体的矩阵相乘。物体将绕着(0,0,0)(x,y,z)的直线以逆时针旋转,参数angle表示旋转的角度。

glScale*,把当前矩阵和一个表示缩放物体的矩阵相乘。x,y,z分别表示在该方向上的缩放比例。

 

注意我都是说XX相乘,而不是直接说这个函数就是旋转或者这个函数就是移动,这是有原因的,马上就会讲到。

假设当前矩阵为单位矩阵,然后先乘以一个表示旋转的矩阵R,再乘以一个表示移动的矩阵T,最后得到的矩阵再乘上每一个顶点的坐标矩阵v。所以,经过变换得到的顶点坐标就是((RT)v)。由于矩阵乘法的结合率,((RT)v) = (R(Tv)),换句话说,实际上是先进行移动,然后进行旋转。即:实际变换的顺序与代码中写的顺序是相反的。由于先移动后旋转先旋转后移动得到的结果很可能不同,初学的时候需要特别注意这一点。

OpenGL之所以这样设计,是为了得到更高的效率。但在绘制复杂的三维图形时,如果每次都去考虑如何把变换倒过来,也是很痛苦的事情。这里介绍另一种思路,可以让代码看起来更自然(写出的代码其实完全一样,只是考虑问题时用的方法不同了)。

让我们想象,坐标并不是固定不变的。旋转的时候,坐标系统随着物体旋转。移动的时候,坐标系统随着物体移动。如此一来,就不需要考虑代码的顺序反转的问题了。

 

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

 

 

2、投影变换

投影变换就是定义一个可视空间,可视空间以外的物体不会被绘制到屏幕上。(注意,从现在起,坐标可以不再是-1.01.0了!)

OpenGL支持两种类型的投影变换,即透视投影和正投影。投影也是使用矩阵来实现的。如果需要操作投影矩阵,需要以GL_PROJECTION为参数调用glMatrixMode函数。

glMatrixMode(GL_PROJECTION);

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

glLoadIdentity();

 

透视投影所产生的结果类似于照片,有近大远小的效果,比如在火车头内向前照一个铁轨的照片,两条铁轨似乎在远处相交了。

使用glFrustum函数可以将当前的可视空间设置为透视投影空间。其参数的意义如下图:

声明:该图片来自www.opengl.org,该图片是《OpenGL编程指南》一书的附图,由于该书的旧版(第一版,1994年)已经流传于网络,我希望没有触及到版权问题。

也可以使用更常用的gluPerspective函数。其参数的意义如下图:

声明:该图片来自www.opengl.org,该图片是《OpenGL编程指南》一书的附图,由于该书的旧版(第一版,1994年)已经流传于网络,我希望没有触及到版权问题。

 

正投影相当于在无限远处观察得到的结果,它只是一种理想状态。但对于计算机来说,使用正投影有可能获得更好的运行速度。

使用glOrtho函数可以将当前的可视空间设置为正投影空间。其参数的意义如下图:

声明:该图片来自www.opengl.org,该图片是《OpenGL编程指南》一书的附图,由于该书的旧版(第一版,1994年)已经流传于网络,我希望没有触及到版权问题。

 

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

 

 

3、视口变换

当一切工作已经就绪,只需要把像素绘制到屏幕上了。这时候还剩最后一个问题:应该把像素绘制到窗口的哪个区域呢?通常情况下,默认是完整的填充整个窗口,但我们完全可以只填充一半。(即:把整个图象填充到一半的窗口内)

声明:该图片来自www.opengl.org,该图片是《OpenGL编程指南》一书的附图,由于该书的旧版(第一版,1994年)已经流传于网络,我希望没有触及到版权问题。

 

使用glViewport来定义视口。其中前两个参数定义了视口的左下脚(0,0表示最左下方),后两个参数分别是宽度和高度。

 

4、操作矩阵堆栈

介于是入门教程,先简单介绍一下堆栈。你可以把堆栈想象成一叠盘子。开始的时候一个盘子也没有,你可以一个一个往上放,也可以一个一个取下来。每次取下的,都是最后一次被放上去的盘子。通常,在计算机实现堆栈时,堆栈的容量是有限的,如果盘子过多,就会出错。当然,如果没有盘子了,再要求取一个盘子,也会出错。

我们在进行矩阵操作时,有可能需要先保存某个矩阵,过一段时间再恢复它。当我们需要保存时,调用glPushMatrix函数,它相当于把矩阵(相当于盘子)放到堆栈上。当需要恢复最近一次的保存时,调用glPopMatrix函数,它相当于把矩阵从堆栈上取下。OpenGL规定堆栈的容量至少可以容纳32个矩阵,某些OpenGL实现中,堆栈的容量实际上超过了32个。因此不必过于担心矩阵的容量问题。

通常,用这种先保存后恢复的措施,比先变换再逆变换要更方便,更快速。

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

 

5、综合举例

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

 

我们要制作的是一个三维场景,包括了太阳、地球和月亮。假定一年有12个月,每个月30天。每年,地球绕着太阳转一圈。每个月,月亮围着地球转一圈。即一年有360天。现在给出日期的编号(0~359),要求绘制出太阳、地球、月亮的相对位置示意图。(这是为了编程方便才这样设计的。如果需要制作更现实的情况,那也只是一些数值处理而已,与OpenGL关系不大)

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

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

让我们假想一些数据,将三个天体的半径分别修改为:69600000(放大100倍),15945000(放大2500倍),4345000(放大5000倍)。将地球到月亮的距离修改38000000(放大100倍)。地球到太阳的距离保持不变。

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

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

 

 

5、综合举例

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

 

我们要制作的是一个三维场景,包括了太阳、地球和月亮。假定一年有12个月,每个月30天。每年,地球绕着太阳转一圈。每个月,月亮围着地球转一圈。即一年有360天。现在给出日期的编号(0~359),要求绘制出太阳、地球、月亮的相对位置示意图。(这是为了编程方便才这样设计的。如果需要制作更现实的情况,那也只是一些数值处理而已,与OpenGL关系不大)

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

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

让我们假想一些数据,将三个天体的半径分别修改为:69600000(放大100倍),15945000(放大2500倍),4345000(放大2500倍)。将地球到月亮的距离修改38000000(放大100倍)。地球到太阳的距离保持不变。

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

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

 

 

现在我们来看看如何绘制这三个天体。

为了简单起见,我们把三个天体都想象成规则的球体。而我们所使用的glut实用工具中,正好就有一个绘制球体的现成函数:glutSolidSphere,这个函数在原点绘制出一个球体。由于坐标是可以通过glTranslate*glRotate*两个函数进行随意变换的,所以我们就可以在任意位置绘制球体了。函数有三个参数:第一个参数表示球体的半径,后两个参数代表了的数目,简单点说就是球体的精确程度,数值越大越精确,当然代价就是速度越缓慢。这里我们只是简单的设置后两个参数为20

太阳在坐标原点,所以不需要经过任何变换,直接绘制就可以了。

地球则要复杂一点,需要变换坐标。由于今年已经经过的天数已知为day,则地球转过的角度为day/一年的天数*360度。前面已经假定每年都是360天,因此地球转过的角度恰好为day。所以可以通过下面的代码来解决:

glRotatef(day, 0, 0, -1);

/* 注意地球公转是自西向东的,因此是饶着Z轴负方向进行逆时针旋转 */

glTranslatef(地球轨道半径, 0, 0);

glutSolidSphere(地球半径, 20, 20);

月亮是最复杂的。因为它不仅要绕地球转,还要随着地球绕太阳转。但如果我们选择地球作为参考,则月亮进行的运动就是一个简单的圆周运动了。如果我们先绘制地球,再绘制月亮,则只需要进行与地球类似的变换:

glRotatef(月亮旋转的角度, 0, 0, -1);

glTranslatef(月亮轨道半径, 0, 0);

glutSolidSphere(月亮半径, 20, 20);

但这个月亮旋转的角度,并不能简单的理解为day/一个月的天数30*360度。因为我们在绘制地球时,这个坐标已经是旋转过的。现在的旋转是在以前的基础上进行旋转,因此还需要处理这个差值。我们可以写成:day/30*360 - day,即减去原来已经转过的角度。这只是一种简单的处理,当然也可以在绘制地球前用glPushMatrix保存矩阵,绘制地球后用glPopMatrix恢复矩阵。再设计一个跟地球位置无关的月亮位置公式,来绘制月亮。通常后一种方法比前一种要好,因为浮点的运算是不精确的,即是说我们计算地球本身的位置就是不精确的。拿这个不精确的数去计算月亮的位置,会导致 不精确的成分累积,过多的不精确会造成错误。我们这个小程序没有去考虑这个,但并不是说这个问题不重要。

还有一个需要注意的细节: OpenGL把三维坐标中的物体绘制到二维屏幕,绘制的顺序是按照代码的顺序来进行的。因此后绘制的物体会遮住先绘制的物体,即使后绘制的物体在先绘制的物体的后面也是如此。使用深度测试可以解决这一问题。使用的方法是:1、以GL_DEPTH_TEST为参数调用glEnable函数,启动深度测试。2、在必要时(通常是每次绘制画面开始时),清空深度缓冲,即:glClear(GL_DEPTH_BUFFER_BIT);其中,glClear (GL_COLOR_BUFFER_BIT)glClear(GL_DEPTH_BUFFER_BIT)可以合并写为:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

且后者的运行速度可能比前者快。

 

 

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

 

 

Code:

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

// 太阳、地球和月亮

// 假设每个月都是30

// 一年12个月,共是360

static int day = 200; // day的变化:从0359

void myDisplay(void)

{

    glEnable(GL_DEPTH_TEST);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluPerspective(75, 1, 1, 400000000);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);

 

    // 绘制红色的太阳

    glColor3f(1.0f, 0.0f, 0.0f);

    glutSolidSphere(69600000, 20, 20);

    // 绘制蓝色的地球

    glColor3f(0.0f, 0.0f, 1.0f);

    glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f);

    glTranslatef(150000000, 0.0f, 0.0f);

    glutSolidSphere(15945000, 20, 20);

    // 绘制黄色的月亮

    glColor3f(1.0f, 1.0f, 0.0f);

    glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f);

    glTranslatef(38000000, 0.0f, 0.0f);

    glutSolidSphere(4345000, 20, 20);

 

    glFlush();

}

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

 

 

 

试修改day的值,看看画面有何变化。

 

 

小结:本课开始,我们正式进入了三维的OpenGL世界。

OpenGL通过矩阵变换来把三维物体转变为二维图象,进而在屏幕上显示出来。为了指定当前操作的是何种矩阵,我们使用了函数glMatrixMode

我们可以移动、旋转观察点或者移动、旋转物体,使用的函数是glTranslate*glRotate*

我们可以缩放物体,使用的函数是glScale*

我们可以定义可视空间,这个空间可以是正投影的(使用glOrthogluOrtho2D),也可以是透视投影的(使用glFrustumgluPerspective)。

我们可以定义绘制到窗口的范围,使用的函数是glViewport

矩阵有自己的堆栈,方便进行保存和恢复。这在绘制复杂图形时很有帮助。使用的函数是glPushMatrixglPopMatrix

 

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

 

=====================   第五课    =====================

OpenGL入门学习(六)(转)

今天要讲的是动画制作——可能是各位都很喜欢的。除了讲授知识外,我们还会让昨天那个太阳、地球和月亮天体图画动起来。缓和一下枯燥的气氛。本次课程,我们将进入激动人心的计算机动画世界。

 

想必大家都知道电影和动画的工作原理吧?是的,快速的把看似连续的画面一幅幅的呈现在人们面前。一旦每秒钟呈现的画面超过24幅,人们就会错以为它是连续的。我们通常观看的电视,每秒播放2530幅画面。但对于计算机来说,它可以播放更多的画面,以达到更平滑的效果。如果速度过慢,画面不够平滑。如果速度过快,则人眼未必就能反应得过来。对于一个正常人来说,每秒60~120幅图画是比较合适的。具体的数值因人而异。

 

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

显示第1幅画面,然后等待一小段时间,直到下一个1/24

显示第2幅画面,然后等待一小段时间,直到下一个1/24

……

显示第n幅画面,然后等待一小段时间,直到下一个1/24

结束

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

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

{

    DrawScene(i);

    Wait();

}

 

1、双缓冲技术

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

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

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

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

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

glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);

其中GLUT_SINGLE表示单缓冲,如果改成GLUT_DOUBLE就是双缓冲了。

当然还有需要更改的地方——每次绘制完成时,我们需要交换两个缓冲区,把绘制好的信息用于屏幕显示(否则无论怎么绘制,还是什么都看不到)。如果使用GLUT工具包,也可以很轻松的完成这一工作,只要在绘制完成时简单的调用glutSwapBuffers函数就可以了。

 

2、实现连续动画

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

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

{

    DrawScene(i);

    glutSwapBuffers();

    Wait();

}

但事实上,这样做不太符合窗口系统的程序设计思路。还记得我们的第一个OpenGL程序吗?我们在main函数里写:glutDisplayFunc(&myDisplay);

意思是对系统说:如果你需要绘制窗口了,请调用myDisplay这个函数。为什么我们不直接调用myDisplay,而要采用这种看似舍近求远的做法呢?原因在于——我们自己的程序无法掌握究竟什么时候该绘制窗口。因为一般的窗口系统——拿我们熟悉一点的来说——WindowsX窗口系统,都是支持同时显示多个窗口的。假如你的程序窗口碰巧被别的窗口遮住了,后来用户又把原来遮住的窗口移开,这时你的窗口需要重新绘制。很不幸的,你无法知道这一事件发生的具体时间。因此这一切只好委托操作系统来办了。

现在我们再看上面那个循环。既然DrawScene都可以交给操作系统来代办了,那让整个循环运行起来的工作是否也可以交给操作系统呢?答案是肯定的。我们先前的思路是:绘制,然后等待一段时间;再绘制,再等待一段时间。但如果去掉等待的时间,就变成了绘制,绘制,……,不停的绘制。——当然了,资源是公用的嘛,杀毒软件总要工作吧?我的下载不能停下来吧?我的mp3播放还不能给耽搁了。总不能因为我们的动画,让其他的工作都停下来。因此,我们需要在CPU空闲的时间绘制。

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

 

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

 

Code:


#include <GL/glut.h>

// 太阳、地球和月亮

// 假设每个月都是30

// 一年12个月,共是360

static int day = 200; // day的变化:从0359

void myDisplay(void)

{

    /****************************************************

     这里的内容照搬上一课的,只因为使用了双缓冲,补上最后这句

    *****************************************************/

    glutSwapBuffers();

}

 

void myIdle(void)

{

    /* 新的函数,在空闲时调用,作用是把日期往后移动一天并重新绘制,达到动画效果 */

    ++day;

    if( day >= 360 )

        day = 0;

    myDisplay();

}

 

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

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); // 修改了参数为GLUT_DOUBLE

    glutInitWindowPosition(100, 100);

    glutInitWindowSize(400, 400);

    glutCreateWindow("太阳,地球和月亮");   // 改了窗口标题

    glutDisplayFunc(&myDisplay);

    glutIdleFunc(&myIdle);               // 新加入了这句

    glutMainLoop();

    return 0;

}

3、关于垂直同步

代码是写好了,但相信大家还有疑问。某些朋友可能在运行时发现,虽然CPU几乎都用上了,但运动速度很快,根本看不清楚,另一些朋友在运行时发现CPU使用率很低,根本就没有把空闲时间完全利用起来。但对于上面那段代码来说,这些现象都是合理的。这里就牵涉到关于垂直同步的问题。

大家知道显示器的刷新率是比较有限的,一般为60~120Hz,也就是一秒钟刷新60~120次。但如果叫计算机绘制一个简单的画面,例如只有一个三角形,则一秒钟可以绘制成千上万次。因此,如果最大限度的利用计算机的处理能力,绘制很多幅画面,但显示器的刷新速度却跟不上,这不仅造成性能的浪费,还可能带来一些负面影响(例如,显示器只刷新到一半时,需要绘制的内容却变化了,由于显示器是逐行刷新的,于是显示器上半部分和下半部分实际上是来自两幅画面)。采用垂直同步技术可以解决这一问题。即,只有在显示器刷新时,才把绘制好的图象传输出去供显示。这样一来,计算机就不必去绘制大量的根本就用不到的图象了。如果显示器的刷新率为85Hz,则计算机一秒钟只需要绘制85幅图象就足够,如果场景足够简单,就会造成比较多的CPU空闲。

几乎所有的显卡都支持垂直同步这一功能。

垂直同步也有它的问题。如果刷新频率为60Hz,则在绘制比较简单的场景时,绘制一幅图画需要的时间很段,帧速可以恒定在60FPS(即60/秒)。如果场景变得复杂,绘制一幅图画的时间超过了1/60秒,则帧速将急剧下降。

如果绘制一幅图画的时间为1/50,则在第一个1/60秒时,显示器需要刷新了,但由于新的图画没有画好,所以只能显示原来的图画,等到下一个1/60秒时才显示新的图画。于是显示一幅图画实际上用了1/30秒,帧速为30FPS。(如果不采用垂直同步,则帧速应该是50FPS

如果绘制一幅图画的时间更长,则下降的趋势就是阶梯状的:60FPS30FPS20FPS……60/160/260/3……

如果每一幅图画的复杂程度是不一致的,且绘制它们需要的时间都在1/60上下。则在1/60时间内画完时,帧速为60FPS,在1/60时间未完成时,帧速为30FPS,这就造成了帧速的跳动。这是很麻烦的事情,需要避免它——要么想办法简化每一画面的绘制时间,要么都延迟一小段时间,以作到统一。

回过头来看前面的问题。如果使用了大量的CPU而且速度很快无法看清,则打开垂直同步可以解决该问题。当然如果你认为垂直同步有这样那样的缺点,也可以关闭它。——至于如何打开和关闭,因操作系统而异了。具体步骤请自己搜索之。

当然,也有其它办法可以控制动画的帧速,或者尽量让动画的速度尽量和帧速无关。不过这里面很多内容都是与操作系统比较紧密的,况且它们跟OpenGL关系也不太大。这里就不做介绍了。

4、计算帧速

不知道大家玩过3D Mark这个软件没有,它可以运行各种场景,测出帧速,并且为你的系统给出评分。这里我也介绍一个计算帧速的方法。

根据定义,帧速就是一秒钟内播放的画面数目(FPS)。我们可以先测量绘制两幅画面之间时间t,然后求它的倒数即可。假如t=0.05s,则FPS的值就是1/0.05=20

理论上是如此了,可是如何得到这个时间呢?通常C语言的time函数精确度一般只到一秒,肯定是不行了。clock函数也就到十毫秒左右,还是有点不够。因为FPS60FPS100的时候,t的值都是十几毫秒。

你知道如何测量一张纸的厚度吗?一个粗略的办法就是:用很多张纸叠在一起测厚度,计算平均值就可以了。我们这里也可以这样办。测量绘制50幅画面(包括垂直同步等因素的等待时间)需要的时间t',由t'=t*50很容易的得到FPS=1/t=50/t'

下面这段代码可以统计该函数自身的调用频率,(原理就像上面说的那样),程序并不复杂,并且这并不属于OpenGL的内容,所以我不打算详细讲述它。

Code:


#include <time.h>

double CalFrequency()

{

    static int count;

    static double save;

    static clock_t last, current;

    double timegap;

 

    ++count;

    if( count <= 50 )

        return save;

    count = 0;

    last = current;

    current = clock();

    timegap = (current-last)/(double)CLK_TCK;

    save = 50.0/timegap;

    return save;

}


 

最后,要把计算的帧速显示出来,但我们并没有学习如何使用OpenGL把文字显示到屏幕上。——但不要忘了,在我们的图形窗口背后,还有一个命令行窗口~使用printf函数就可以轻易的输出文字了。

#include <stdio.h>

double FPS = CalFrequency();

printf("FPS = %f\n", FPS);

最后的一步,也被我们解决了——虽然做法不太雅观,没关系,以后我们还会改善它的。

时间过得太久,每次给的程序都只是一小段,一些朋友难免会出问题。

现在,我给出一个比较完整的程序,供大家参考。

Code:


#include <GL/glut.h>

#include <stdio.h>

#include <time.h>

 

// 太阳、地球和月亮

// 假设每个月都是12

// 一年12个月,共是360

static int day = 200; // day的变化:从0359

 

double CalFrequency()

{

    static int count;

    static double save;

    static clock_t last, current;

    double timegap;

 

    ++count;

    if( count <= 50 )

        return save;

    count = 0;

    last = current;

    current = clock();

    timegap = (current-last)/(double)CLK_TCK;

    save = 50.0/timegap;

    return save;

}

 

void myDisplay(void)

{

    double FPS = CalFrequency();

    printf("FPS = %f\n", FPS);

 

    glEnable(GL_DEPTH_TEST);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

 

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluPerspective(75, 1, 1, 400000000);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    gluLookAt(0, -200000000, 200000000, 0, 0, 0, 0, 0, 1);

 

    // 绘制红色的太阳

    glColor3f(1.0f, 0.0f, 0.0f);

    glutSolidSphere(69600000, 20, 20);

    // 绘制蓝色的地球

    glColor3f(0.0f, 0.0f, 1.0f);

    glRotatef(day/360.0*360.0, 0.0f, 0.0f, -1.0f);

    glTranslatef(150000000, 0.0f, 0.0f);

    glutSolidSphere(15945000, 20, 20);

    // 绘制黄色的月亮

    glColor3f(1.0f, 1.0f, 0.0f);

    glRotatef(day/30.0*360.0 - day/360.0*360.0, 0.0f, 0.0f, -1.0f);

    glTranslatef(38000000, 0.0f, 0.0f);

    glutSolidSphere(4345000, 20, 20);

 

    glFlush();

    glutSwapBuffers();

}

 

void myIdle(void)

{

    ++day;

    if( day >= 360 )

        day = 0;

    myDisplay();

}

 

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

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

    glutInitWindowPosition(100, 100);

    glutInitWindowSize(400, 400);

    glutCreateWindow("太阳,地球和月亮");

    glutDisplayFunc(&myDisplay);

    glutIdleFunc(&myIdle);

    glutMainLoop();

    return 0;

}


 

小结:

OpenGL动画和传统意义上的动画相似,都是把画面一幅一幅的呈现在观众面前。一旦画面变换的速度快了,观众就会认为画面是连续的。

双缓冲技术是一种在计算机图形中普遍采用的技术,绝大多数OpenGL实现都支持双缓冲技术。

通常都是利用CPU空闲的时候绘制动画,但也可以有其它的选择。

介绍了垂直同步的相关知识。

介绍了一种简单的计算帧速(FPS)的方法。

最后,我们列出了一份完整的天体动画程序清单。

 

=====================   第六课    =====================

posted on 2010-09-27 14:52 王秋林 阅读(987) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


<2010年9月>
2930311234
567891011
12131415161718
19202122232425
262728293012
3456789

常用链接

留言簿(1)

随笔档案(15)

搜索

  •  

最新评论

阅读排行榜

评论排行榜