我自己的毕业设计的1.0版本. 采用四叉树LOD算法实现地形渲染.已经传至共享邮箱里,希望对学3D的朋友有帮助
质数的定义
一个数，如果只有1和它本身两个因数，这样的数叫做质数，又称素数。
在上文 《素数算法大全，及C程序实现优化详解 (一) 试除法》中我们已经探讨了求解素数的一类算法，并且将试除法从最初的低效版本优化的高效的V2。那么，还有没有其它更佳算法呢？这就是下面三藏要和大家探讨的内容
合数过滤筛选法
算法描述：我们知道，素数N不能被2~(N-1)间的任何数整除；反过来看，只要能被2~(N-1)间的任何数整除的N，都不是素数。所以我们可以采用一个简单的排除法：就是对N以内的所有数，只要逐个去除值为2~(N-1)的倍数的数，剩下的就是素数。
C语言实现
// 合数过滤筛选法 Ver1
// 参数：n 求解n以内(包括n)的素数
// 返回值：n以内素数个数
int CompositeNumFilterV1(int n)
{
int i, j;
// 素数数量统计
int count = 0;
// 分配素数标记空间，结合后文思考为何+1
char* flag = (char*)malloc( n+1 );
// 初始化素数标记
for (i=2; i<=n; i++)
{
// 为什么*(p+i)要写成flag[i]呢？可读性更佳尔
flag[i] = 1;
}
// 写程序要注意排版和留空，方便阅读，也可减少出错几率
// 以2~(N-1)为因子过滤合数
for (i=2; i < n; i++)
{
for (j=2; i*j <= n; j++)
{
// i*j是由i,j两整数相乘而得，显然不是素数
flag[i*j] = 0;
}
}
// 统计素数个数
for (i=2; i<=n; i++)
{
// 其实if(flag)就其同样作用了，但这么写是有留言的
// 请参阅《C语言程序设计常见错误剖析及解决之道》一文
if (1 == flag[i]) count++;
}
// 因输出费时，且和算法核心相关不大，故略
// 释放内存，别忘了传说中的内存泄漏
free(flag);
return count;
}
在上文给出的main函数中以不同参数调用CompositeNumFilterV1函数，得到执行结果如下：
[100000]以内素数个数：9592, 计算用时：15毫秒
[1000000]以内素数个数：78498, 计算用时：125毫秒
[5000000]以内素数个数：348513, 计算用时：2578毫秒
[10000000]以内素数个数：664579, 计算用时：6281毫秒
注：因程序是非独占性运行的，所以时间不是完全精确的，但基本能反映实情
显然，比上文中的试除法要快，而且谁都可以看到上例是一个未经优化的粗陋版本，好多地方是三藏故意采用比较低效做法，为了与后文的优化版比较，凸显优化之重要，也为了初学者记住别采用类似低效做法，下面我们开始优化之旅
优化分析
上面CompositeNumFilterV1函数存在的问题有：
- 在外层循环，需要一直执行到n-1吗？不要，因为n/2~n-1间的数显然不能整出n
- 在内层循环中重复使用i*j显然是低效的，考虑到计算机中加减运算速度比乘除快，可以考虑变乘法为加法
- 在循环修改flag过程中，其实有很多数会被重复计算若干次，比如6=2*3=3*2，会被重复置0，类似操作很多，所以我们得设法避免或减少flag重复置0
据上述分析，我们可将程序优化如下：
// 合数过滤筛选法 Ver2
// 参数：n 求解n以内(包括n)的素数
// 返回值：n以内素数个数
int CompositeNumFilterV2(int n)
{
int i, j;
// 素数数量统计
int count = 0;
// 分配素数标记空间，明白+1原因了吧，因为浪费了一个flag[0]
char* flag = (char*)malloc( n+1 );
// 初始化素数标记，要高效点咯
flag[2] = 1;
// 注意是i<n不是上例中的i<=n了，理由自思
for (i=3; i<n; i++)
{
flag[i++] = 1;
// 偶数自然不是素数，直接置0好了
flag[i] = 0;
}
// n为奇数
if (n%2 != 0)
{
flag[n] = 1;
}
// 从3开始filter，因为2的倍数早在初始化时代就干掉了
// 到n/2止的理由还要说吗
for (i=3; i <= n/2; i++)
{
// i是合数，请歇着吧，因为您的工作早有您的质因子代劳了
if (0 == flag[i]) continue;
// 从i的2倍开始过滤，变乘法为加法
for (j=i+i; j <= n; j+=i)
{
flag[j] = 0;
}
}
// 统计素数个数
for (i=2; i<=n; i++)
{
if (flag[i]) count++;
}
// 因输出费时，且和算法核心相关不大，故略
// 释放内存，别忘了传说中的内存泄漏
free(flag);
return count;
}
再来调用CompositeNumFilterV2得到执行结果：
[100000]以内素数个数：9592, 计算用时：n太小，时间精度不够
[1000000]以内素数个数：78498, 计算用时：31毫秒
[5000000]以内素数个数：348513, 计算用时：453毫秒
[10000000]以内素数个数：664579, 计算用时：1062毫秒
[100000000]以内素数个数：5761455, 计算用时：12973毫秒
哇哇，比昨天的试除发快了好多倍，可见算法的威力，值得好好学习，别说学算法没用咯。
上例着那个计算一亿以内的素数只要约13秒，应该算不错了，今天是否可以休息了呢？No，我们要追求极限！
int CompositeNumFilterV3(int n)
{
int i, j;
// 素数数量统计
int count = 0;
// 分配素数标记空间，明白+1原因了吧，因为浪费了一个flag[0]
char* flag = (char*)malloc( n+1 );
// 干嘛用的，请仔细研究下文
int mpLen = 2*3*5*7*11*13;
char magicPattern[mpLen];
// 奇怪的代码，why，思考无法代劳，想！
for (i=0; i<mpLen; i++)
{
magicPattern[i++] = 1;
magicPattern[i++] = 0;
magicPattern[i++] = 0;
magicPattern[i++] = 0;
magicPattern[i++] = 1;
magicPattern[i] = 0;
}
for (i=4; i<=mpLen; i+=5)
magicPattern[i] = 0;
for (i=6; i<=mpLen; i+=7)
magicPattern[i] = 0;
for (i=10; i<=mpLen; i+=11)
magicPattern[i] = 0;
for (i=12; i<=mpLen; i+=13)
magicPattern[i] = 0;
// 新的初始化方法,将2,3,5,7,11,13的倍数全干掉
// 而且采用memcpy以mpLen长的magicPattern来批量处理
int remainder = n%mpLen;
char* p = flag+1;
char* pstop = p+n-remainder;
while (p < pstop)
{
memcpy(p, magicPattern, mpLen);
p += mpLen;
}
if (remainder > 0)
{
memcpy(p, magicPattern, remainder);
}
flag[2] = 1;
flag[3] = 1;
flag[5] = 1;
flag[7] = 1;
flag[11] = 1;
flag[13] = 1;
// 从17开始filter，因为2,3,5,7,11,13的倍数早被kill了
// 到n/13止的，哈哈，少了好多吧
int stop = n/13;
for (i=17; i <= stop; i++)
{
// i是合数，请歇着吧，因为您的工作早有您的质因子代劳了
if (0 == flag[i]) continue;
// 从i的17倍开始过滤
int step = i*2;
for (j=i*17; j <= n; j+=step)
{
flag[j] = 0;
}
}
// 统计素数个数
for (i=2; i<=n; i++)
{
if (flag[i]) count++;
}
// 因输出费时，且和算法核心相关不大，故略
// 释放内存，别忘了传说中的内存泄漏
free(flag);
return count;
}
再看CompositeNumFilterV3执行结果：
[1000000]以内素数个数：78498, 计算用时：15毫秒
[5000000]以内素数个数：348513, 计算用时：203毫秒
[10000000]以内素数个数：664579, 计算用时：515毫秒
[100000000]以内素数个数：5761455, 计算用时：6421毫秒
再次优化后速度提升了又一倍左右，三藏不禁有点满足了，睡觉也！
转自：http://www.doforfun.net/article/20090504/543.htm
经常有初学者询问求解N内所有素数（质数）的问题，对此，网上的解答也很多，但很多要么不够专业，要么只有程序没有算法解析，所以三藏大厦对此问题做个小结，探讨一下求解素数的常见算法，同时给出相应的C语言程序及其解析。为了方便初学者理解，本文将从易到难阐述不同算法，高手可以直接看后面的高效算法
质数的定义
一个数，如果只有1和它本身两个因数，这样的数叫做质数，又称素数。
试除判断法
算法描述：从上述定义可知，素数不能被1和它本身之外的数整除，所以，判断一个数x是否素数只要看它是否能被2~sqrt(x)间的数整除即可；而求N内所有素数则是循环重复上述过程。
C语言实现：
#include <time.h>
#include <malloc.h>
#define N 100000
// 简单试除判断法 Ver1
int SimpleDivisionV1(int n)
{
int i,j;
// 素数数量统计
int count = 0;
// 分配存放结果的空间
int* primes = (int*)malloc( sizeof(int)*n );
// 2是素数谁都知道，不算了
primes[count++] = 2;
// 循环计算3~n间的数
for (i=3; i<=n; i++)
{
// 为什么是sqrt(i)，思考一下
for (j=2; j<=sqrt(i); j++)
{
// i被j整除，显然不是素数了
if (i%j == 0) break;
}
// i不能被2~sqrt(i)间的数整除,素数也
if (j > sqrt(i))
{
primes[count++] = i;
}
}
// 因输出费时，且和算法核心相关不大，故略
// 释放内存，别忘了传说中的内存泄漏
free(primes);
return count;
}
void main()
{
int count;
clock_t start, end;
// time函数不够精确，用clock凑合一下吧
start = clock();
count = SimpleDivisionV1(N);
end = clock();
printf("[%d]以内素数个数：%d, 计算用时：%d毫秒\n", N, count, end-start);
getch();
}
计算结果：
[100000]以内素数个数：9592, 计算用时：468毫秒
[1000000]以内素数个数：78498, 计算用时：10859毫秒
[5000000]以内素数个数：348513, 计算用时：103560毫秒
噢噢，算算十万还行，百万就10秒多了，而且时间增长很快，这不行，得优化一下！
优化分析：
仔细研究一下SimpleDivisionV1我们可以发现以下几个问题：
- 在循环条件中重复调用sqrt(i)显然是比较浪费时间的
- 判断素数，真的需要拿2~sqrt(i)间的所有整数去除吗？我们知道，合数都可以分解成若干质数，所以只要2~sqrt(i)间的质数不能整除i即可
根据上面两点，我们可将SimpleDivisionV1升级为SimpleDivisionV2，如下
// 简单试除判断法 Ver2
int SimpleDivisionV2(int n)
{
int i, j, k, stop;
// 素数数量统计
int count = 0;
// 分配存放结果的空间
int* primes = (int*)malloc( sizeof(int)*n );
// 2是素数谁都知道，不算了
primes[count++] = 2;
stop = count;
// 循环计算3~n间的数
for (i=3; i<=n; i++)
{
k = sqrt(i);
// 在循环条件中重复调用sqrt是低效做法，故引入k
while (primes[stop] <= k && stop < count)
stop++;
// stop干什么用，思考一下
for (j=0; j<stop; j++)
{
if (i%primes[j] == 0) break;
}
// i不能被2~sqrt(i)间的素数整除，自然也不能被其他数整除,素数也
if (j == stop)
{
primes[count++] = i;
}
}
// 因输出费时，且和算法核心相关不大，故略
// 释放内存，别忘了传说中的内存泄漏
free(primes);
return count;
}
然后将main中调用的函数替换为SimpleDivisionV2，在看一下执行结果：
[100000]以内素数个数：9592, 计算用时：46毫秒
[1000000]以内素数个数：78498, 计算用时：546毫秒
[5000000]以内素数个数：348513, 计算用时：3515毫秒
[10000000]以内素数个数：664579, 计算用时：8000毫秒
很开心的看到，经过优化，速度提高了几十倍，尤其是时间增长曲线的坡度变小了，N值越大，V2函数比V1的效率就越高
对于试除判断这种质数算法来说，三藏认为SimpleDivisionV2基本已经接近极限，不大可能有量级上的突破了，有兴趣的朋友可以自己进一步优化。初学者除了参看上述例子外，可以尝试做各种修改及细节优化，也可以将除法变乘法，多加练习是学习编程的好方法。
虽然，上例中V2已经比V1快了很多了，但随着N的增大，耗时还是不少，那么我们还有更好的方法吗？
转自：
http://hi.baidu.com/sunguangran/blog/item/ded90ced94779dd2b31cb11c.html终于搞明白gluPerspective和gluLookAt的关系了
函数原型
gluLookAt(GLdoble eyex,GLdouble eyey,GLdouble eyez,GLdouble centerx,GLdouble centery,GLdouble centerz,GLdouble upx,GLdouble upy,GLdouble upz);
gluPerspective(GLdouble fovy,GLdouble aspect,GLdouble zNear,GLdouble zFar)
一个一个来,首先得设置gluPerspective,来看看它的参数都表示什么意思
fovy,这个最难理解,我的理解是,眼睛睁开的角度,即,视角的大小,如果设置为0,相当你闭上眼睛了,所以什么也看不到,如果为180,那么可以认为你的视界很广阔,
aspect,这个好理解,就是实际窗口的纵横比,即x/y
zNear,这个呢,表示你近处,的裁面,
zFar表示远处的裁面,
如果还没有理解就继续看,
我们知道,远处的东西看起来要小一些,近处的东西看起来会大一些,这就是透视原理
如下图所示
假设那两条线表示公路,理论上讲,它们的两条边是平行的,
但现实情况中,它们在远方(可以无限远)总要相交于一点,
实际线段AB的长度=CD的长度,只是在此例中使用了透视角,故会有如上的效果,是不是很接近现实的情况?
结合我们刚才这两个函数
zNear,眼睛距离近处的距离,假设为10米远,请不要设置为负值,OpenGl就傻了,不知道怎么算了,
zFar表示远处的裁面,假设为1000米远,
就是这两个参数的意义了,
再解释下那个"眼睛睁开的角度"是什么意思,
首先假设我们现在距离物体有50个单位距离远的位置,
在眼睛睁开角度设置为45时,请看大屏幕:
我们可以看到,在远处一个球,,很好玩哈,
现在我们将眼睛再张开点看,将"眼睛睁开的角度"设置为178
(180度表示平角,那时候我们将什么也看不到,眼睛睁太大了,眼大无神)
我们只看到一个点,,,,,,,,,,,,,,,,,,,,,,,,,,,
因为我们看的范围太大了,这个球本身大小没有改变,但是它在我们的"视界"内太小了,
反之,我们将眼睛闭小些,改为1度看看会出现什么情况呢?
在我们距离该物体3000距离远,"眼睛睁开的角度"为1时,我们似乎走进了这个球内,这个是不是类似于相机的焦距?
当我们将"透视角"设置为0时,我们相当于闭上双眼,这个世界清静了,
我们什么也看不到,,,,,,,,,
现在来看gluLookAt(GLdoble eyex,GLdouble eyey,GLdouble eyez,GLdouble centerx,GLdouble centery,GLdouble centerz,GLdouble upx,GLdouble upy,GLdouble upz);
它共接受三对坐标,
分别为eye,center,up
故名思义,eye表示我们眼睛在"世界坐标系"中的位置,
center表示眼睛"看"的那个点的坐标,
最后那个up坐标表示观察者本身的方向,如果将观察点比喻成我们的眼睛,那么这个up则表示我们是正立还是倒立异或某一个角度在看,所看的影像大不相同,故此时需要指明我们现在正立,那么X,Z轴为0,Y轴为正即可,通常将其设置为1,只要表示一个向上的向量(方向)即可
球是画在世界坐标系的原点上的,即O(0,0,0)坐标上,我们的眼睛位于观察点A(0,0,100),Z轴向屏幕里看去的方向为负,屏幕外我们的位置,Z轴为正值,其实很好理解,即我们距离原点的距离,设置100,将观察到如下图所示的影像
如果我们向前或向后移动,则相应的图像会变大或变小,这里其实就是运用了透视原理,近处的物体大,远处的物体小,实际物体的大小是不变的,
同理改变center坐标(眼睛看去的那个点,可简单理解为视线的终点)也会影响球的大小,同样可以认为是改变了物体与观察点的距离所致,
最后那个up坐标表示观察者本身的方向,如果将观察点比喻成我们的眼睛,那么这个up则表示我们是正立还是倒立异或某一个角度在看,所看的影像大不相同,故此时需要指明我们现在正立,那么X,Z轴为0,Y轴为正即可,通常将其设置为1,只要表示一个向上的向量(方向)即可,我们指定0.1f或0.00001f异或1000.0f,效果是一样的,只要能表示方向即可,
以上理解了之后,来做一个测试
透视图不变,最远处仍为3000,近处为0.1
gluPerspective // 设置透视图
(45, // 透视角设置为 45 度,在Y方向上以角度为单位的视野
(GLfloat)x/(GLfloat)y, // 窗口的宽与高比
0.1f, // 视野透视深度:近点1.0f
3000.0f // 视野透视深度:始点0.1f远点1000.0f
);将我们的观察点置于A(0,10,0),
将观察位置(视线终点)坐标置于(0,0,0)
然后在原点开始绘图,画一个V字形,并将Z轴的值从-1000递增加到+1000,增量为10,
代码如下
glColor3f(0.5f, 0.7f, 1.0f);
glBegin(GL_LINES);
for(int i=-1000;i<=1000;i+=10)
{
glVertex3f(0,0,i);
glVertex3f(10,10,i);
glVertex3f(0,0,i);
glVertex3f(-10,10,i);
}
glEnd();
F5运行效果如下图
上图证实了我们的推测
//---------------------------------------------
//生成网络
glColor3f(0.5f, 0.7f, 1.0f);
int x=(int)(40*2);
glBegin(GL_LINES);
for(int i=-x;i<=x;i+=4)
{
glVertex3i(-x,0,i);
glVertex3i(x,0,i);
glVertex3i(i,0,x);
glVertex3i(i,0,-x);
}
glEnd();
//生成球体
GLUquadricObj * pObj;
pObj = gluNewQuadric();
gluQuadricDrawStyle(pObj,GLU_LINE);
gluQuadricNormals(pObj,GLU_SMOOTH);
=============================================================
以下是个小总结：
1、模视矩阵（ModelView Matrix）的作用是将模型从局部坐标系变换到世界坐标系，并最终变换到视点坐标系中。它由模型变换矩阵和视点变换矩阵组成。
2、gluLookAt影响的是视点矩阵，它显式的标明了视点坐标系与世界坐标系的关系，即视点被安置在世界坐标系的哪个位置，视线的方向朝向何处。
3、gluPerspective用于规定视景体范围，与模视矩阵无关，它影响的是投影矩阵和规一化矩阵。投影矩阵的作用是使模型产生近大远小的效果，规一化矩阵是将模型的z值规一化到0~1之间。
4、在编程的时候，需要glMatrixMode来指定矩阵堆栈的类型，然后对该矩阵进行修改。
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
的作用是初始化模视矩阵，将坐标原点重新设置在世界坐标系的原点。之后的glTranslate、glScale、glRotate都会改变模视矩阵中的模型变换矩阵。而glLookAt则设置视点变换矩阵。它们共同作用，使得模型能在世界坐标系中正确安放，并能从合适的角度去观察。
一个Vector模板类,开始的时候是这样写的：
template <class T>
class Vector
{
public:
Vector(unsigned n=8):_size(n),_data(new T[_size]){}
//.........
protected:
T* _data;
unsigned _size;
};
结果一运行，机子就慢了，打开任务管理器，占内存超大。后来想起来初始化列表是按照成员变量的声明顺序初始化的，所以在构造函数里_data数组先被初始化，这时_size没被初始化，即_size还是个随机值，估计随机的很大，呵呵，比方说_size为1234567，于是就申请了1234567的内存。。。。
于是修改如下就OK了：
template <class T>
class Vector
{
public:
Vector(unsigned n=8):_size(n),_data(new T[_size]){}
//.........
protected:
unsigned _size;//先声明_size，先初始化它
T* _data;
};
昨天写个类，碰到个问题，我这里用简单的例子说明，比方说写个学生类，性别用枚举来表示，然后有个获得性别的函数GetGender(),返回值类型为Gender。
class Student
{
enum Gender{MALE,FEMALE};
//...
Gender GetGender();
};
函数的实现如下
Gender Student::GetGender
{//...
}
结果出错。感觉挺莫名其妙的，呵呵。后来一琢磨，改成了
Student::Gender Student::GetGender
{//...
}
成功！！！！这个写法有意思.^_^
鉴于网上找资料是件痛苦的，所以我把我自己的一些电子书，以及下载的一些小程序放在了邮箱里，跟大家分享，仅大家学习交流（这些资料一般已经在网上广为流传，我想应该没有触及版权的问题吧，呵呵）。大家有需要的可以去邮箱去下，目前只放了一部分，以后会陆续添加邮箱地址和密码如下：
账号：percyph1@163.com密码：xcc123456
如果大家有c++，openGL，密码学等等计算机方面的好资料，也可以发给我，我的邮箱是
percyph@163.com大家也可以回帖要资料，如果有的话我会第一时间发上。
相信来我这儿的朋友都是有素质的，请不要删除和移动邮箱里的文件，谢谢！
目前已经上传的资料有：（以后会陆续更新）
VC编程助手（小软件VC++ assistant，能使编程更方便）
C++Primer3（电子书）
glut函数说明（电子书）
C++技能百练（经典算法）.rar
ROAM地形算法演示程序.rar
OpenGL 参考手册
c&c++深层探索
C++必知必会
VC6.0编程实例精解
高质量C++编程指南&编程新手真言&MFC类库详解
Windows程序设计
MFC类库详解.chm
C++ 数据结构第三版
C++ 数据结构第三版
程序员面试宝典&程序员超级开发宝典
c++和OpenGL函数手册
Essential C++中文版.pdf
Effective C++(电子书)
C++编程思想（电子书）
3.11号上传（kuafoo发的） Windows环境下32位汇编语言.chm(2.78M)
深入浅出MFC
深入浅出MFC第二版
另外最近几个月写的数据结构的程序也传上去了，有兴趣的朋友可以看看！
里面包括：
线性表——静态链表2009.7.30
线性表——链表的内部类实现2008.8
线性表——链表的友元类实现2008.8
线性表——双向链表2009.8.11
线性表——顺序表2009.8.3
线性表——友元模板类2009.8
约瑟夫问题——四种解法2009.8.11（数组，链表，循环链表等）
队列——队列的顺序表示循环队列2009.8.11
队列——链队列2009.8.11
栈——汉诺塔2009.8.6
栈——进制转换2009.8.6
栈——括号匹配2009.8.6
栈——模板链栈2009.8.3
栈——模板顺序栈2009.7
栈——顺序栈2009.8.6
栈——算术表达式求值2009.7.13
栈——行编辑2009.8.6
二叉树——二叉树的常见操作2009.9.3
2010.3.9 更新
树的应用—仿DOS文件夹管理程序
200位大数乘法.rar
200位大数加法.rar
连连看单机程序MFC
分三块来讲述：
1 首先： 在C中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可：Stu stu1;
如果没有typedef就必须用struct Student stu1;来声明
这里的Stu实际上就是struct Student的别名。
另外这里也可以不写Student（于是也不能struct Student stu1;了）
typedef struct
{
int a;
}Stu;
但在c++里很简单，直接
struct Student
{
int a;
};
于是就定义了结构体类型Student，声明变量时直接Student stu2；
===========================================
2其次：在c++中如果用typedef的话，又会造成区别：
struct Student
{
int a;
}stu1;//stu1是一个变量
typedef struct Student2
{
int a;
}stu2;//stu2是一个结构体类型
使用时可以直接访问stu1.a
但是stu2则必须先 stu2 s2;
然后 s2.a=10;
===========================================
3 掌握上面两条就可以了，不过最后我们探讨个没多大关系的问题
如果在c程序中我们写：
typedef struct
{
int num;
int age;
}aaa,bbb,ccc;
这算什么呢？
我个人观察编译器（VC6）的理解，这相当于
typedef struct
{
int num;
int age;
}aaa；
typedef aaa bbb;
typedef aaa ccc;
也就是说aaa,bbb,ccc三者都是结构体类型。声明变量时用任何一个都可以,在c++中也是如此。但是你要注意的是这个在c++中如果写掉了typedef关键字，那么aaa，bbb，ccc将是截然不同的三个对象。
*再次声明"glut"函数详解系列转自：
阿杰－－江南暖冬int glutVideoResizeGet(GLenum param);
返回glut视频大小调整的信息.
参数:
param:
GLUT_VIDEO_RESIZE_POSSIBLE:如果底层支持视频大小调整,则返回非0值,否则返回0.如果返回0,则其他视频大小调整函数的调用将不起作用.
GLUT_VIDEO_RESIZE_IN_USE
GLUT_VIDEO_RESIZE_X_DELTA
GLUT_VIDEO_RESIZE_Y_DELTA
GLUT_VIDEO_RESIZE_WIDTH_DELTA
GLUT_VIDEO_RESIZE_HEIGHT_DELTA
GLUT_VIDEO_RESIZE_X
GLUT_VIDEO_RESIZE_Y
GLUT_VIDEO_RESIZE_WIDTH
GLUT_VIDEO_RESIZE_HEIGHT
后面几个常量值在网上没有搜到解释.
//*******************************************************************************************
void glutSetupVideoResizing(void);
void glutStopVideoResizing(void);
void glutVideoResize(int x, int y, int width, int height);
void glutVideoPan(int x, int y, int width, int height);
我把glut的头文件中的所有函数都整理了一遍,只可惜 video resize sub-API中的几个函数网上都没有具体的介绍,本菜鸟也无能为力,幸好这些函数都不是常用的,我想一般用不着.除了和视频有关的API,前面几个帖子的内容已经基本把glut的所有函数都过了一遍,本专题也就算是完成了,以后如果找到相关资料,会把这里的补上,也希望达人能够指点一二.
所谓游戏模式其实就是一种全屏模式,这里可以对该模式下的屏幕显示方式进行简单设置.详见下面具体解释.
//*******************************************************************************************
void glutGameModeString(const char *string);
通过一个字符串对game mode(游戏模式,也即全屏模式)进行设置,即对屏幕进行设置.
参数:
string:一个指向字符串的指针,字符串的内容即是对屏幕的设置.字符串的格式如下所示:
"W*H"
"W*H:Bpp"
"W*H@Rr"
"W*H:Bpp@Rr"
"@Rr"
":Bpp"
"Bpp:@Rr"
(注:W:屏幕宽度,以像素单位;H:屏幕高度,以像素为单位;Bpp:每个像素的内存大小(位数);Rr:屏幕的刷新率.)
例子:
1.如果我们只关心屏幕大小(800*600)而不关心每个像素的内存占用和刷新频率,可以写成:
glutGameModeString("800*600");
2.如果只想把每个像素的内存占用设置成32位,可以写成:
glutGameModeString(":32");
3.如果只想把刷新率设置成75赫兹,可以写成:
glutGameModeString("@75");
4.如果前三种情况都考虑,可以写成:
glutGameModeString("800*600:32@75");
其他情况按照上面给出的字符串格式写出即可.
注:
1.这个函数只是对硬件的请求,如果设置不合法,则将被忽略.
2.这个函数并不返回错误值,如果要获得错误信息,则要用glutGameModeGet()函数.
//*******************************************************************************************
int glutEnterGameMode(void);
进入相应的game mode,即让glutGameModeString()的设置生效.
//*******************************************************************************************
void glutLeaveGameMode(void);
离开glutGameModeString()设置的game mode.
//*******************************************************************************************
int glutGameModeGet(GLenum mode);
检测设置的模式是否有效
参数:
mode:
GLUT_GAME_MODE_ACTIVE:如果程序运行在game mode,则返回非0值,如果运行在窗口模式,则返回0.
GLUT_GAME_MODE_POSSIBLE:判断glutAameModeString()的设置是否有效,如果有效则返回非0值,否则返回0.但是glut手册中有一个警告,即使这个设置是有效的,也不能保证屏幕设置可以一定成功生效.
GLUT_GAME_MODE_WIDTH:返回屏幕的宽度.
GLUT_GAME_MODE_HEIGHT:返回屏幕的高度.
GLUT_GAME_MODE_PIXEL_DEPTH:返回当前模式下每个像素所占用的内存空间(位数).
GLUT_GAME_MODE_REFRESH_RATE:返回实际的刷新率(单位赫兹).
GLUT_GAME_MODE_DISPLAY_CHANGED:正如前面所说,不能保证屏幕显示模式一定根据设置发生改变,这个常量可以用来测试是否真的进入了game mode(先前是窗口模式下的情况下),如果先前已经是game mode,则可以用来测试设置是否发生改变.返回非0值表示进入了game mode或设置已经发生改变,否则返回0.