C++博客-小虫虫的书架-随笔分类-OpenGL

（转）glut函数详解(13)--视频大小调整API

小虫虫 — Tue, 03 Mar 2009 07:41:00 GMT

*再次声明"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的所有函数都过了一遍,本专题也就算是完成了,以后如果找到相关资料,会把这里的补上,也希望达人能够指点一二.

小虫虫 2009-03-03 15:41 发表评论

（转）glut函数详解(12)--游戏模式API

小虫虫 — Tue, 03 Mar 2009 07:38:00 GMT

所谓游戏模式其实就是一种全屏模式,这里可以对该模式下的屏幕显示方式进行简单设置.详见下面具体解释.

//*******************************************************************************************
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.

小虫虫 2009-03-03 15:38 发表评论

（转）glut函数详解(10)--设备控制API

小虫虫 — Tue, 03 Mar 2009 07:37:00 GMT

void glutIgnoreKeyRepeat(int ignore);

确认是否忽略自动的连续击键(即当一个键被长时间按下不松开时,判断其为一次击键或是多次击键).只对当前窗口有效.对glutKeyboardFunc()和glutSpecialFunc()两个回调函数起作用.

参数:
ignore:(相当于布尔值)
     0 :不忽略,即认为是连续击键
    非0:忽略,即认为是一次击键

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

void glutSetKeyRepeat(int repeatMode);

设置自动连续击键模式的状态

参数:repeatMode:
GLUT_KEY_REPEAT_OFF    :关闭自动连续击键
GLUT_KEY_REPEAT_ON     :打开自动连续击键
GLUT_KEY_REPEAT_DEFAULT:将自动连续击键模式重置为默认状态
注意:这个函数工作在全局范围内,即它会影响所有窗口而不仅仅是当前窗口,所以当关闭了自动连续击键模式后,确保在关闭当前程序销毁前,将自动连续击键模式重置为默认状态.

这个函数的安全性不好,最好使用安全性高的glutIgnoreKeyRepeat(),尽量将操作限制在当前窗口,而不要轻易使用工作在全局状态下的函数.

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

void glutForceJoystickFunc(void);
强制调用当前窗口注册的操纵杆回调函数glutJoystickFunc()一次.

小虫虫 2009-03-03 15:37 发表评论

（转）glut函数详解(11)--状态查询API

小虫虫 — Tue, 03 Mar 2009 07:37:00 GMT

int glutGet(GLenum state);

检索指定的GLUT状态

参数:
state:指定要检索的状态类型,为以下常量:
GLUT_WINDOW_X:当前窗口的x坐标,以像素为单位.
GLUT_WINDOW_Y:当前窗口的y坐标,以像素为单位.
GLUT_WINDOW_WIDTH:当其窗口的宽度,以像素为单位.
GLUT_WINDOW_HEIGHT:当前窗口的高度,以像素为单位.
GLUT_WINDOW_BUFFER_SIZE:当前窗口中,颜色分量占用的位数,即用多少bit表示颜色分量.
GLUT_WINDOW_STENCIL_SIZE:当前窗口中,蒙板分量占用的位数,即用多少bit表示蒙板分量.
GLUT_WINDOW_DEPTH_SIZE:当前窗口中,深度分量占用的位数,即用多少bit表示深度分量.
GLUT_WINDOW_RED_SIZE:当前窗口中,红色分量占用的位数,即用多少bit表示红色分量.
GLUT_WINDOW_GREEN_SIZE:当前窗口中,绿色分量占用的位数,即用多少bit表示绿色分量.
GLUT_WINDOW_BLUE_SIZE:当前窗口中,蓝色分量占用的位数,即用多少bit表示蓝色分量.
GLUT_WINDOW_ALPHA_SIZE:当前窗口中,alpha色分量占用的位数,即用多少bit表示alpha色分量.
GLUT_WINDOW_ACCUM_RED_SIZE:当前窗口累积缓存中,红色分量占用的位数,即用多少bit表示红色分量.
GLUT_WINDOW_ACCUM_GREEN_SIZE:当前窗口累积缓存中,绿色分量占用的位数,即用多少bit表示绿色分量.
GLUT_WINDOW_ACCUM_BLUE_SIZE:当前窗口累积缓存中,蓝色分量占用的位数,即用多少bit表示蓝色分量.
GLUT_WINDOW_ACCUM_ALPHA_SIZE:当前窗口累积缓存中,alpha色分量占用的位数,即用多少bit表示alpha色分量.
GLUT_WINDOW_DOUBLEBUFFER:如果窗口式双缓存模式,返回1,否则返回0.
GLUT_WINDOW_RGBA:如果窗口是RGBA模式,返回1,否则返回0.
GLUT_WINDOW_PARENT:查询当前窗口的父窗口个数,如果为顶层窗口返回0.
GLUT_WINDOW_NUM_CHILDREN:查询当前窗口的子窗口个数.
GLUT_WINDOW_NUM_SAMPLES:查询多重采样的采样点个数.
GLUT_WINDOW_STEREO:查询是否使用立体模式,是则返回1,否则返回0.
GLUT_WINDOW_CURSOR:返回光标的整数标示.
GLUT_SCREEN_HEIGHT:屏幕的高度,以像素为单位.
GLUT_SCREEN_WIDTH:屏幕的宽度,以像素为单位.
GLUT_SCREEN_WIDTH_MM:屏幕的宽度,以毫米为单位.
GLUT_SCREEN_HEIGHT_MM:屏幕的高度,以毫米为单位.
GLUT_MENU_NUM_ITEMS:查询当前菜单包含的菜单项的个数.
GLUT_DISPLAY_MODE_POSSIBLE:查询窗口系统是否支持当前的显示模式,1表示支持,0表示不支持.
GLUT_INIT_DISPLAY_MODE:初始窗口的显示模式.
GLUT_INIT_WINDOW_X:初始窗口的x坐标.
GLUT_INIT_WINDOW_Y:初始窗口的y坐标.
GLUT_INIT_WINDOW_WIDTH:初始窗口的宽度.
GLUT_INIT_WINDOW_HEIGHT:初始窗口的高度.
GLUT_ELAPSED_TIME:返回两次调用glutGet(GLUT_ELAPSED_TIME)的时间间隔,单位为毫秒,返回值根据查询的内容返回相应的值,无效的状态名返回-1.
GLUT_WINDOW_COLORMAP_SIZE:返回颜色索引表的大小.

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

int glutDeviceGet(GLenum type);

检索设备信息

参数:
type:要检索的设备信息的名字,为以下常量:
GLUT_HAS_KEYBOARD 如果键盘可用,返回非0值,否则,返回0.
GLUT_HAS_MOUSE 如果鼠标可用,返回非0值,否则,返回0.
GLUT_NUM_MOUSE_BUTTONS 返回鼠标支持的按键数,如果鼠标不可用,返回0,返回值0,表示检索的设备不存在,非0表示设备可用.
GLUT_HAS_SPACEBALL:如果spaceball可用,返回非0值,否则,返回0.
GLUT_HAS_DIAL_AND_BUTTON_BOX:如果拨号按键盒可用,返回非0值,否则,返回0.
GLUT_HAS_TABLET:如果图形板可用,返回非0值,否则,返回0.
GLUT_NUM_SPACEBALL_BUTTONS:返回spaceball支持的按键数,如果spaceball不存在,返回0.
GLUT_NUM_BUTTON_BOX_BUTTONS:返回拨号按键盒支持的按键数,如果拨号按键盒不存在,返回0.
GLUT_NUM_DIALS:返回拨号按键盒支持的拨号数,如果拨号按键盒不存在,返回0.
GLUT_NUM_TABLET_BUTTONS:返回图形板支持的按键数,如果图形板不存在,返回0.
GLUT_DEVICE_IGNORE_KEY_REPEAT:如果当前窗口被设置成关闭自动重复按键,则返回非0值.
GLUT_DEVICE_KEY_REPEAT:返回自动重复按键的设置状态.(说明文件上说是返回连续击键的速率,其实此说法有误.)
GLUT_HAS_JOYSTICK:如果操纵杆可用,返回非0值,否则,返回0.
GLUT_OWNS_JOYSTICK:如果glut认为已经成功获得操纵杆的使用权,则返回非0值.否则,返回0.
GLUT_JOYSTICK_BUTTONS:返回操纵杆支持的按键数,如果操纵杆不存在,返回0.
GLUT_JOYSTICK_AXES:返回操纵杆支持的操纵轴数,如果操纵杆不存在,返回0.
GLUT_JOYSTICK_POLL_RATE:返回当前窗口操纵杆被拉动的速率.
(注:对操纵杆的查询限制在操纵杆的数量为1;鼠标被默认为存在,并且其按键数默认是3.)

//******************************************************************************************
int glutExtensionSupported(const char *name);

判定是否支持特定的OpenGL扩展

参数:
extension:指定要测试的OpenGL扩展的名称,如果给定扩展获得支持,函数返回非0,否则返回0.
必须要有一个有效的当前窗口来调用glutExtensionSupported().它只返回OpenGL扩展信息,这意味着窗口系统依赖的扩展不被glutExtensionSupported()反映.
例子:
if(!glutExtensionSupported("GL_EXT_texture"))
{
fprintf(stderr, "Missing the texture extension!");
exit(1);
}

//******************************************************************************************
int glutGetModifiers(void);

返回组合功能键的状态

返回值为以下定义的常量
GLUT_ACTIVE_SHIFT:当按下shift键时
GLUT_ACTIVE_CTRL:当按下ctrl键时
GLUT_ACTIVE_ALT:当按下alt键时

//******************************************************************************************
int glutLayerGet(GLenum type);

查询属于当前窗口的重叠层的状态

参数:
type:查询的重叠层状态常量:
GLUT_OVERLAY_POSSIBLE:在给定的初始显示模式下,能否为当前窗口创建重叠层.如果能,返回1;如果不能,返回0.
GLUT_LAYER_IN_USE:返回当前的使用层,为GLUT_NORMAL(使用正常的颜色层)或GLUT_OVERLAY(使用重叠层).
GLUT_HAS_OVERLAY:判断当前窗口是否创建了重叠层.
GLUT_NORMAL_DAMAGED:如果当前窗口的图像层在上一次显示回调函数调用后已经破坏,则返回TRUE.
GLUT_OVERLAY_DAMAGED:如果当前窗口的重叠层在上一次显示回调函数调用后已经破坏,则返回TRUE.
GLUT_TRANSPARENT_INDEX:返回当前窗口覆盖层的透明颜色索引值,如果没有覆盖层则返回-1.

小虫虫 2009-03-03 15:37 发表评论

（转）glut函数详解(9)--回调API

小虫虫 — Tue, 03 Mar 2009 07:36:00 GMT

void glutDisplayFunc(void (*func)(void));

注册当前窗口的显示回调函数

参数:
func:形为void func()的函数,完成具体的绘制操作

这个函数告诉GLUT当窗口内容必须被绘制时,那个函数将被调用.当窗口改变大小或者从被覆盖的状态中恢复,或者由于调用glutPostRedisplay()函数要求GLUT更新时,执行func参数指定的函数.

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

void glutReshapeFunc(void (*func)(int width, int height));

指定当窗口的大小改变时调用的函数

参数:
func:形如void func(int width, int height)
处理窗口大小改变的函数.
width,height:为窗口改变后长宽.

这个函数确定一个回调函数,每当窗口的大小或形状改变时(包括窗口第一次创建),GLUT将会调用这个函数,这个回调函数接受这个窗口新的长宽作为输入参数.

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

void glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));

注册当前窗口的键盘回调函数

参数:
func:形如void func(unsigned char key, int x, int y)
key:按键的ASCII码
x,y:当按下键时鼠标的坐标,相对于窗口左上角,以像素为单位

当敲击键盘按键(除了特殊按键,即glutSpecialFunc()中处理的按键,详见glutSpecialFunc())时调用.

//******************************************************************************************
void glutMouseFunc(void (*func)(int button, int state, int x, int y));

注册当前窗口的鼠标回调函数

参数:
func:形如void func(int button, int state, int x, int y);
button:鼠标的按键,为以下定义的常量
GLUT_LEFT_BUTTON:鼠标左键
GLUT_MIDDLE_BUTTON:鼠标中键
GLUT_RIGHT_BUTTON:鼠标右键
state:鼠标按键的动作,为以下定义的常量
GLUT_UP:鼠标释放
GLUT_DOWN:鼠标按下
x,y:鼠标按下式,光标相对于窗口左上角的位置

当点击鼠标时调用.

//******************************************************************************************
void glutMotionFunc(void (*func)(int x, int y));

当鼠标在窗口中按下并移动时调用glutMotionFunc注册的回调函数

void glutPassiveMotionFunc(void (*func)(int x, int y));

当鼠标在窗口中移动时调用glutPassiveMotionFunc注册的回调函数

参数:
func:形如void func(int x, int y);
x,y:鼠标按下式,光标相对于窗口左上角的位置,以像素为单位

//*******************************************************************************************
void glutEntryFunc(void (*func)(int state));

设置鼠标的进出窗口的回调函数

参数:
func:形如void func(int state);注册的鼠标进出回调函数
state:鼠标的进出状态,为以下常量之一
GLUT_LEFT 鼠标离开窗口
GLUT_RIGHT 鼠标进入窗口

当窗口取得焦点或失去焦点时调用这个函数,当鼠标进入窗口区域并点击时,state为GLUT_RIGHT,当鼠标离开窗口区域点击其他窗口时,state为GLUT_LEFT.

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

void glutVisibilityFunc(void (*func)(int state));

设置当前窗口的可视回调函数

参数:
func:形如void func(int state);指定的可视回调函数
state:窗口的可视性,为以下常量
GLUT_NOT_VISIBLE 窗口完全不可见
GLUT_VISIBLE 窗口可见或部分可见

这个函数设置当前窗口的可视回调函数,当窗口的可视性改变时,该窗口的可视回调函数被调用.只要窗口中的任何一个像素是可见的,或者他的任意一个子窗口中任意一个像素是可见的,GLUT则认为窗口是可见的.

//*******************************************************************************************
void glutIdleFunc(void (*func)(void));

设置空闲回调函数

参数:
func:形如void func(void);

当系统空闲时调用.

//*******************************************************************************************
void glutTimerFunc(unsigned int millis, void (*func)(int value), int value);

注册一个回调函数,当指定时间值到达后,由GLUT调用注册的函数一次

参数:
millis:等待的时间,以毫秒为单位
unc:形如void func(int value)
value:指定的一个数值,用来传递到回调函数func中

这个函数注册了一个回调函数,当指定的毫秒数到达后,这个函数就调用注册的函数,value参数用来向这个注册的函数中传递参数. 但只能触发一次,若要连续触发,则需在func中重新设置计时函数glutTimerFunc();

//*******************************************************************************************
void glutMenuStateFunc(void (*func)(int state));

注册菜单状态回调函数

参数:
func:形如void func(int state);
state:
GLUT_MENU_IN_USE:菜单被使用.
GLUT_MENU_NOT_IN_USE:菜单不再被使用,即菜单被关闭.
如果state代入GLUT_MENU_IN_USE,则当菜单被使用时调用该函数;
如果state代入GLUT_MENU_NOT_IN_USE,则当菜单被关闭时调用该函数.

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

void glutMenuStatusFunc(void (*func)(int status, int x, int y));
设置菜单状态回调函数
参数:
func:形如void func(int status, int x, int y);
status:当前是否使用菜单,为以下定义的常量
GLUT_MENU_IN_USE:菜单正在使用
GLUT_MENU_NOT_IN_USE:菜单未被使用
x,y:鼠标按下时,光标相对于窗口左上角的位置
这个函数调用时glut程序判定是否正在使用菜单,当弹出菜单时,调用注册的菜单状态回调函数,同时status设置为常量GLUT_MENU_IN_USE,当菜单使用完毕时,也调用菜单状态回调函数,此时status变量变为GLUT_MENU_NOT_IN_USE.从已弹出的菜单中再弹出的菜单不产生菜单状态回调过程.每个glut程序只有一个菜单状态回调函数. 此函数与上面一个函数相比,只是多传了一个光标位置,其他相同.

//*******************************************************************************************
void glutSpecialFunc(void (*func)(int key, int x, int y));

设置当前窗口的特定键的回调函数

参数:
Func:形如void func(int key, int x, int y);
key:按下的特定键,为以下定义的常量
GLUT_KEY_F1:F1功能键
GLUT_KEY_F2:F2功能键
GLUT_KEY_F3:F3功能键
GLUT_KEY_F4:F4功能键
GLUT_KEY_F5:F5功能键
GLUT_KEY_F6:F6功能键
GLUT_KEY_F7:F7功能键
GLUT_KEY_F8:F8功能键
GLUT_KEY_F9:F9功能键
GLUT_KEY_F10:F10功能键
GLUT_KEY_F11:F11功能键
GLUT_KEY_F12:F12功能键
GLUT_KEY_LEFT:左方向键
GLUT_KEY_UP:上方向键
GLUT_KEY_RIGHT:右方向键
GLUT_KEY_DOWN:下方向键
GLUT_KEY_PAGE_UP:PageUp键
GLUT_KEY_PAGE_DOWN:PageDown键
GLUT_KEY_HOME:Home键
GLUT_KEY_END:End键
GLUT_KEY_INSERT:Insert键
x,y:当按下键时鼠标的坐标,相对于窗口左上角,以像素为单位

注意:ESC,回车和delete键由ASCII码产生,即可以用glutKeyboardFunc()处理. 当在键盘上敲击上述按键时调用该函数.注意与glutKeyboardFunc()的区别.

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

void glutSpaceballMotionFunc(void (*func)(int x, int y, int z));

注册一个当前窗口的spaceball平移的回调函数

参数:
func:形如void func(int x, int y, int z);
x,y,z:spaceball的三维空间坐标.
paceball即一种特殊的带3D滚轮的鼠标,不仅可以前后转动,更可以在三维空间里滚动,具体图片,可以在百度里搜索.

当spaceball在当前注册的窗口内平移时,调用该函数.

//*******************************************************************************************
void glutSpaceballRotateFunc(void (*func)(int x, int y, int z));

注册一个当前窗口的spaceball转动的回调函数

参数:
func:形如void func(int x, int y, int z);
当spaceball在当前注册的窗口内滚动时调用.

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

void glutSpaceballButtonFunc(void (*func)(int button, int state));

注册当前窗口的spaceball的按键回调函数.

参数:
func:形如void func(int button, int state);
button:按键编号,从1开始,可用的按键编号可以通过glutDeviceGet(GLUT_NUM_SPACEBALL_BUTTONS)查询.
state:按键状态
GLUT_UP:按键释放
GLUT_DOWN:按键按下

当spaceball在当前窗口中敲击相应的按键时调用.

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

void glutButtonBoxFunc(void (*func)(int button, int state));

注册当前窗口的拨号按键盒按键回调函数

参数:
func:形如void func(int button, int state);
button:按键编号,从1开始,可用的按键号可通过glutDeviceGet(GLUT_NUM_BUTTON_BOX_BUTTONS)查询
state:按键状态
GLUT_UP:按键释放
GLUT_DOWN:按键按下

当拨号按键盒按键被按下时调用.

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

void glutDialsFunc(void (*func)(int dial, int value));

注册当前窗口的拨号按键盒拨号回调函数.

参数:
func:形如void func(int dial, value);
dial:dial的编号,从1开始,可通过glutDeviceGet(GLUT_NUM_DIALS)查询可用编号.
value:dial所拨的值,value是每次所拨的值的累加,直到溢出.

当拨号按键盒拨号时被调用.

//*******************************************************************************************
void glutTabletMotionFunc(void (*func)(int x, int y));

注册图形板移动回调函数

参数:
func:形如void func(int x, int y);
x,y:图形板移动的坐标.

当图形板移动时调用.

//******************************************************************************************
void glutTabletButtonFunc(void (*func)(int button, int state, int x, int y));

注册当前窗口的图形板按键回调函数

参数:
func:形如void func(int button, int state, int x, int y);
button:按键号,通过glutDeviceGet(GLUT_NUM_TABLET_BUTTONS)查询可用键号.
state:按键状态.
GLUT_UP:按键被按下
GLUT_DOWN:按键被释放

x,y:当按键状态改变时,相对于窗口的坐标.

//******************************************************************************************
void glutOverlayDisplayFunc(void (*func)(void));

注册当前窗口的重叠层的显示回调函数

参数:
func:形如void func(void);指向重叠层的显示回调函数.

这个函数告诉GLUT当窗口内容必须被绘制时,那个函数将被调用.当窗口改变大小或者从被覆盖的状态中恢复,或者由于调用glutPostOverlayRedisplay()函数要求GLUT更新时,执行func参数指定的函数.

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

void glutWindowStatusFunc(void (*func)(int state));

注册当前窗口状态的回调函数.

参数:
func:形如void func(int state);
state:窗口状态.
GLUT_HIDDEN:窗口不可见
GLUT_FULLY_RETAINED:窗口完全未被遮挡
GLUT_PARTIALLY_RETAINED:窗口部分遮挡
GLUT_FULLY_COVERED:窗口被全部遮挡

当窗口状态发生相应改变时调用.

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

void glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y));

注册释放普通按键的回调函数

参数:
func:形如void func(unsigned char key, int x, int y);
key:按键的ASCII码.
x,y:释放按键时鼠标相对于窗口的位置,以像素为单位.

当普通按键被释放时调用.

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

void glutSpecialUpFunc(void (*func)(int key, int x, int y));

注册释放特殊按键的回调函数

参数:
func:形如void func(int key, int x, int y);
key:特殊按键的标识
GLUT_KEY_F1:F1功能键
GLUT_KEY_F2:F2功能键
GLUT_KEY_F3:F3功能键
GLUT_KEY_F4:F4功能键
GLUT_KEY_F5:F5功能键
GLUT_KEY_F6:F6功能键
GLUT_KEY_F7:F7功能键
GLUT_KEY_F8:F8功能键
GLUT_KEY_F9:F9功能键
GLUT_KEY_F10:F10功能键
GLUT_KEY_F11:F11功能键
GLUT_KEY_F12:F12功能键
GLUT_KEY_LEFT:左方向键
GLUT_KEY_UP:上方向键
GLUT_KEY_RIGHT:右方向键
GLUT_KEY_DOWN:下方向键
GLUT_KEY_PAGE_UP:PageUp键
GLUT_KEY_PAGE_DOWN:PageDown键
GLUT_KEY_HOME:Home键
GLUT_KEY_END:End键
GLUT_KEY_INSERT:Insert键
x,y:释放特殊按键时鼠标相对于窗口的位置,以像素为单位.

当特殊按键被释放时调用.

//******************************************************************************************
void glutJoystickFunc(void (*func)(unsigned int buttonMask, int x, int y, int z), int pollInterval);

注册操纵杆的回调函数

参数:
buttonMask:操纵杆按键
GLUT_JOYSTICK_BUTTON_A
GLUT_JOYSTICK_BUTTON_B
GLUT_JOYSTICK_BUTTON_C
GLUT_JOYSTICK_BUTTON_D
x,y,z:操纵杆在三维空间内移动的位移量
pollInterval:确定检测操纵杆的间隔时间,其单位为毫秒.

该函数在两种情况下被调用:
1.在pollInterval所规定的时间间隔内调用.
2.在调用glutForceJoystickFunc()函数时调用一次glutJoystickFunc();

小虫虫 2009-03-03 15:36 发表评论

（转）glut函数详解(8)--调试API

小虫虫 — Tue, 03 Mar 2009 07:34:00 GMT

void glutReportErrors(void);

这个函数打印出OpenGL的运行时错误,它应该只被用在debug中,因为它的调用会降低OpenGL的速度,它所做的仅仅是不断调用glGetError()直到没有错误产生.每一个错误都以GLUT warning形式报告,并由gluErrorString()产生相应的错误信息.

小虫虫 2009-03-03 15:34 发表评论

（转）glut函数详解(7)--字体处理API

小虫虫 — Tue, 03 Mar 2009 07:32:00 GMT

void glutBitmapCharacter(void *font, int character);

绘制一个图像字符

int glutBitmapWidth(void *font, int character);

返回一个图像字符的宽度

参数:
font:要使用的图像字体,如下表所示:
GLUT_BITMAP_8_BY_13:一种固定宽度字体,每个字符都放在一个8x13像素的矩形框内
GLUT_BITMAP_9_BY_15:一种固定宽度字体,每个字符都放在一个9x15像素的矩形框内
GLUT_BITMAP_TIMES_ROMAN_10:一种10点均匀间距的Times Roman字体
GLUT_BITMAP_TIMES_ROMAN_24:一种24点均匀间距的Times Roman字体
GLUT_BITMAP_HELVETICA_10:一种10点均匀间距的Helvetica字体
GLUT_BITMAP_HELVETICA_12:一种12点均匀间距的Helvetica字体
GLUT_BITMAP_HELVETICA_18:一种18点均匀间距的Helvetica字体 character:绘制的字符的ASCII码.

int glutBitmapLength(void *font, const unsigned char *string);

获取一个图像字符串的宽度.

参数:
font:同上.
string:想要测量宽度的字符串.

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

void glutStrokeCharacter(void *font, int character);

绘制一个图形字符

int glutStrokeWidth(void *font, int character);

返回一个图形字体的宽度

参数:
font:要使用的图形字体,如下表所示:
GLUT_STROKE_ROMAN 一种等间距的Roman Simplex字体,仅包括32到127的ASCII字符
GLUT_STROKE_MONO_ROMAN 一种单一间距的Roman Simplex字体,仅包括32到127的ASCII字符
Character:绘制的字符的ASCII码.

int glutStrokeLength(void *font, const unsigned char *string);

获取一个图形字符串的宽度

参数:
font:同上.
string:想要测量宽度的字符串.

小虫虫 2009-03-03 15:32 发表评论

（转）glut函数详解(6)--颜色索引表管理API

小虫虫 — Tue, 03 Mar 2009 07:31:00 GMT

void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue);

设置当前窗口当前层一个颜色表单元的颜色
参数:
cell:索引值,标记在颜色表中的位置,其值从0开始,并且必须小于颜色表的最大单元数.
当前颜色表的大小可通过调用glutGet(GLUT_WINDOW_COLORMAP_SIZE)获得.
red:红色成分
green:绿色成分
blue:蓝色成分

//*******************************************************************************************
GLfloat glutGetColor(int cell, int component);

获取指定的颜色索引的颜色值.
参数:
cell:索引值,标记在颜色表中的位置,其值从0开始,并且必须小于颜色表的最大单元数.
当前颜色表的大小可通过调用glutGet(GLUT_WINDOW_COLORMAP_SIZE)获得.
component:选择下列的值:
GLUT_RED:让函数返回该索引的红色成分.
GLUT_GREEN:让函数返回该索引的绿色成分.
GLUT_BLUE:让函数返回该索引的蓝色成分.

//*******************************************************************************************
void glutCopyColormap(int win);

将逻辑颜色表从指定的窗口拷贝到当前窗口
参数:win:窗口标识符,逻辑颜色表从该窗口拷贝到当前的窗口.

小虫虫 2009-03-03 15:31 发表评论

（转）glut函数详解(5)--内建模型API

小虫虫 — Tue, 03 Mar 2009 07:30:00 GMT

void glutWireSphere(GLdouble radius, GLint slices, GLint stacks);

绘制线框球体

void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks);

绘制实心球体

参数:
radius:球体的半径
slices:球体围绕z轴分割的数目
stacks:球体沿着z轴分割的数目
绘制中心在模型坐标原点,半径为radius的球体,球体围绕z轴分割slices次,球体沿着z轴分割stacks次

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

void glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);

绘制线框圆锥体

void glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks);

绘制实心圆锥体

参数:
radius:圆锥体的半径
height:圆锥体的高
slices:圆锥体围绕z轴分割的数目
stacks:圆锥体沿着z轴分割的数目
圆锥体的轴为z轴方向,它的基底位于z=0的平面内,顶点z=height,圆锥体围绕z轴分割slices个数目,沿着z轴分割stacks个数目.

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

void glutWireCube(GLdouble size);

绘制线框立方体

void glutSolidCube(GLdouble size);

绘制实心立方体

参数:size:立方体的边长

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

void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);

绘制线框圆环

void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings);

绘制实心圆环

参数:
innerRadius:圆环的内半径
outerRadius:圆环的外半径
nsides:圆环腔的分割数
rings:圆环的环线数

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

void glutWireDodecahedron(void);

绘制线框十二面体

void glutSolidDodecahedron(void);

绘制实心十二面体

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

void glutWireTeapot(GLdouble size);

绘制线框茶壶

void glutSolidTeapot(GLdouble size);

绘制实心茶壶

参数:size:茶壶的相对大小

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

void glutWireOctahedron(void);

绘制线框八面体

void glutSolidOctahedron(void);

绘制实心八面体

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

void glutWireTetrahedron(void);

绘制线框四面体

void glutSolidTetrahedron(void);

绘制实心四面体

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

void glutWireIcosahedron(void);

绘制线框二十面体

void glutSolidIcosahedron(void);

绘制实心二十面体

小虫虫 2009-03-03 15:30 发表评论

（转）glut函数详解(4)--菜单API

小虫虫 — Tue, 03 Mar 2009 07:29:00 GMT

int glutCreateMenu(void (*func)(int value));

创建一个新的弹出示菜单
参数:
func:形如void func(int a);当点击菜单时,调用这个回调函数
value:传递给回调函数的数值,它由所选择的菜单条目对应的整数值所决定
这个函数创建一个新的弹出式菜单,并返回一个唯一的标识次菜单的整型标识符,并将新建的弹出菜单与func函数关联在一起,这样,当选择此菜单中的一个菜单条目时,调用回调函数func.

//******************************************************************************************
void glutDestroyMenu(int menu);

删除指定的菜单
menu:被删除的菜单的标识符

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

int glutGetMenu(void);

获取当前菜单的标识符

//******************************************************************************************
void glutSetMenu(int menu);

设置为当前菜单
menu:被设置为当前菜单的标识符

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

void glutAddMenuEntry(const char *label, int value);

添加一个菜单条目
参数:
label:菜单条目的名称
value:传递到菜单处理函数的值,即在glutCreateMenu中注册的回调函数
如果用户选择了这个菜单条目,对应的菜单回调函数就被调用,并以value值作为传递给此回调函数的参数:

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

void glutAddSubMenu(const char *label, int submenu);

在当前菜单的底部增加一个子菜单的触发条目
参数:
label:子菜单触发条目的名称
submenu:子菜单的标识符

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

void glutChangeToMenuEntry(int item, const char *label, int value);

更改当前菜单中指定菜单项
参数:
item:更改菜单项的索引(最顶层的菜单项的索引为1)
label:菜单条目的名称
value:传递到菜单处理函数的值,即在glutCreateMenu中注册的回调函数

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

void glutChangeToSubMenu(int item, const char *label, int submenu);

将指定的当前菜单中菜单项变为子菜单触发条目
参数:
item:更改菜单项的索引(最顶层的菜单项的索引为1)
label:子菜单触发条目的名称
submenu:子菜单的标识符

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

void glutRemoveMenuItem(int item);

删除指定的菜单项
参数:
item:当前菜单中要删除的菜单项的索引(最顶层的菜单项的索引为1)

//*****************************************************************************************
void glutAttachMenu(int button);

把当前窗口的一个鼠标按键与当前菜单关联起来

void glutDetachMenu(int button);

解除鼠标按键与弹出式菜单的关联关系

参数:
button:指明何种鼠标按键,可用的符号为以下三种:
GLUT_LEFT_BUTTON 鼠标左键
GLUT_RIGHT_BUTTON 鼠标右键
GLUT_MIDDLE_BUTTON 鼠标中键

小虫虫 2009-03-03 15:29 发表评论

（转）glut函数详解(3)--重叠层API

小虫虫 — Tue, 03 Mar 2009 07:27:00 GMT

void glutEstablishOverlay(void);

创建当前窗口的重叠层,该重叠层的显示模式由初始显示模式决定,应在调用glutEstablishOverlay之前调用,glutInitDisplayMode函数来设置初始的显示模式. 实现重叠层需要硬件的支持,并不是所有的系统都提供该支持,如果系统不支持重叠层,那么对glutEstablishOverlay函数的调用就会引起运行错误,GLUT将终止程序的运行.可以调用glutLayerGet(GLUT_OVERPLAY_POSSIBLE)来判断系统是否支持在当前窗口中当前的显示模式下创建重叠层.

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

void glutRemoveOverlay(void);

删除当前层的重叠层

//*****************************************************************************************
void glutUseLayer(GLenum layer);

改变当前窗口的使用层
参数:layer:指定窗口的使用层,为
GLUT_NORMAL:使用正常的颜色层
GLUT_OVERLAY:使用重叠层

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

void glutPostOverlayRedisplay(void);

标记当前窗口的重叠层需要重绘

//****************************************************************************************
void glutPostWindowOverlayRedisplay(int win);

标记指定窗口的重叠层需要重绘
参数:win:需要重绘的窗口的重叠层的标识符

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

void glutShowOverlay(void);

显示当前窗口的重叠层

void glutHideOverlay(void);

隐藏当前窗口的重叠层

这两条语句即时执行.注意一下,只有窗口可视时,使用glutShowOverlay才能使其覆盖图层可视.当窗口被其他窗口遮挡时,其覆盖图层也被遮挡从而不可视.

小虫虫 2009-03-03 15:27 发表评论

（转）glut函数详解(2)--窗口API

小虫虫 — Tue, 03 Mar 2009 07:26:00 GMT

int glutCreateWindow(const char *title);

产生一个顶层的窗口.title作为窗口的名字,也就是窗口标题栏显示的内容.
返回值是生成窗口的标记符,可用函数glutGetWindow()加以引用.

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

int glutCreateSubWindow(int win, int x, int y, int width, int height);

创建一个子窗口.win是其父窗口的标记符.x,y是子窗口左上角相对父窗口的位移,以像素表示.width,height是子窗口的宽和高.

//*****************************************************************************************
void glutDestroyWindow(int win);

销毁窗口,win是所要销毁的窗口的标识符.这个函数销毁指定的窗口以及与窗口关联的OpenGL上下文,重叠层,子窗口等一切与此窗口相关的内容.

//*****************************************************************************************
void glutPostRedisplay(void);

标记当前窗口的图像层需要重新绘制,在glutMainLoop函数的事件处理循环的下一个循环中,将调用该窗口的显示回调函数重绘该窗口的图像层.

//******************************************************************************************
void glutPostWindowRedisplay(int win);

标记指定的窗口需重绘,在glutMainLoop函数的事件处理循环的下一个循环中,将调用该窗口的显示回调函数重绘该窗口的图像层.
参数:win:需刷新的窗口标识符

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

void glutSwapBuffers(void);

当窗口模式为双缓存时,此函数的功能就是把后台缓存的内容交换到前台显示.当然,只有单缓存时,使用它的功能跟用glFlush()一样.而使用双缓存是为了把完整图画一次性显示在窗口上,或者是为了实现动画.

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

int glutGetWindow(void);

返回当前窗口的标识符

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

void glutSetWindow(int win);

设置标记符为win的窗口为当前窗口

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

void glutSetWindowTitle(const char *title);

设置当前窗口（必须是顶层窗口）的标题,窗口一旦建立后,窗口标题就可以由这个函数来改变

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

void glutSetIconTitle(const char *title);

设置当前窗口（必须是顶层窗口）图标化时的标题.

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

void glutPositionWindow(int x, int y);

改变当前窗口的位置：当前窗口是顶层窗口时,x,y是相对于屏幕的的位移;当前窗口若是子窗口时,x,y是相对其父窗口原点的位移.

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

void glutReshapeWindow(int width, int height);

改变当前窗口的大小.width,height是当前窗口新的宽度和高度值,当然只能是正值.

//***************************************************************************************
void glutPopWindow(void);

在同一个父窗口的子窗口中,使当前的子窗口与排列在它前一个位置的子窗***换位置

void glutPushWindow(void);

在同一个父窗口的子窗口中,使当前的子窗口与排列在它后一个位置的子窗***换位置

这两个函数对顶层窗口和子窗口都起作用,但函数的结果并不立即发生,直到下一个事件循环.

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

void glutIconifyWindow(void);

让当前窗口成为一个图标,也即是最小化,使当前窗口图标化显示.

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

void glutShowWindow(void);

显示当前窗口（这时它还是可能被其它窗口挡住）.

//*****************************************************************************************
void glutHideWindow(void);

隐藏当前窗口

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

void glutFullScreen(void);

把当前窗口用全屏显示,当前窗口是顶层窗口时才有效.

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

void glutSetCursor(int cursor);

设置当前窗口的光标样式.
参数:
cursor:指定鼠标的形状,为下面的一种值光标的形状
/* Basic arrows. */
GLUT_CURSOR_RIGHT_ARROW
GLUT_CURSOR_LEFT_ARROW
/* Symbolic cursor shapes. */
GLUT_CURSOR_INFO
GLUT_CURSOR_DESTROY
GLUT_CURSOR_HELP
GLUT_CURSOR_CYCLE
GLUT_CURSOR_SPRAY
GLUT_CURSOR_WAIT
GLUT_CURSOR_TEXT
GLUT_CURSOR_CROSSHAIR
/* Directional cursors. */
GLUT_CURSOR_UP_DOWN
GLUT_CURSOR_LEFT_RIGHT
/* Sizing cursors. */
GLUT_CURSOR_TOP_SIDE
GLUT_CURSOR_BOTTOM_SIDE
GLUT_CURSOR_LEFT_SIDE
GLUT_CURSOR_RIGHT_SIDE
GLUT_CURSOR_TOP_LEFT_CORNER
GLUT_CURSOR_TOP_RIGHT_CORNER
GLUT_CURSOR_BOTTOM_RIGHT_CORNER
GLUT_CURSOR_BOTTOM_LEFT_CORNER
/* Fullscreen crosshair (if available). */
GLUT_CURSOR_FULL_CROSSHAIR:
(在全屏模式下使用,等同于GLUT_CURSOR_CROSSHAIR)
/* Blank cursor. */
GLUT_CURSOR_NONE:不显示鼠标
/* Inherit from parent window. */
GLUT_CURSOR_INHERIT:使用父窗口的鼠标

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

void glutWarpPointer(int x, int y);

这个函数将鼠标指针移动到一个相对于当前窗口左上角的新的位置,以窗口左上角为原点,右为X轴正方向,下为Y轴正方向,参数x,y是在这个坐标系中的点,可以为负值.如果坐标值超出屏幕可见范围,则将该值强行控制在屏幕可见范围以内.一般情况下这个函数最好不要使用, 因为鼠标动作还是留给用户控制比较人性化.

小虫虫 2009-03-03 15:26 发表评论

（转）glut函数详解(1)--glut初始化API

小虫虫 — Tue, 03 Mar 2009 07:15:00 GMT

*转自：http://old.blog.edu.cn/user3/zjdukang/archives/2007/1751751.shtml
(1)    void glutInit(int *argc, char **argv);
     这个函数用来初始化GLUT库.这个函数从main函数获取其两个参数.对应main函数的形式应是：int main(int argc,char* argv[]);
//*******************************************************************************************
(2)    void glutInitDisplayMode(unsigned int mode);
设置图形显示模式.参数mode的可选值为:
     GLUT_RGBA:当未指明GLUT—RGBA或GLUT—INDEX时,是默认使用的模式.表明欲建立RGBA模式的窗口.
     GLUT_RGB:与GLUT—RGBA作用相同.
     GLUT_INDEX:指明为颜色索引模式.
     GLUT_SINGLE:只使用单缓存
     GLUT_DOUBLE:使用双缓存.以避免把计算机作图的过程都表现出来,或者为了平滑地实现动画.
     GLUT_ACCUM:让窗口使用累加的缓存.
     GLUT_ALPHA:让颜色缓冲区使用alpha组件.
     GLUT_DEPTH:使用深度缓存.
     GLUT_STENCIL:使用模板缓存.
     GLUT_MULTISAMPLE:让窗口支持多例程.
     GLUT_STEREO:使窗口支持立体.
     GLUT_LUMINACE:luminance是亮度的意思.但是很遗憾,在多数OpenGL平台上,不被支持.
//******************************************************************************************
(3)    void glutInitWindowPosition(int x, int y);
设置初始窗口的位置(窗口左上角相对于桌面坐标(x,y))
//******************************************************************************************
(4)    void glutInitWindowSize(int width, int height);
设置初始窗口的大小
//******************************************************************************************
(5)    void glutMainLoop(void);
让glut程序进入事件循环.在一个glut程序中最多只能调用一次,且必须调用.一旦调用,会直到程序结束才返回.
//******************************************************************************************
(6)    void glutInitDisplayString(const char *string);
通过一个字符串初始化display mode
参数:string:display mode的描述字符串
这个描述字符串用在创建顶级窗口,子窗口和重叠层时,给将要被创建的窗口或重叠层设置display mode.
这个字符串是由0个或多个功能描述参数组成,每个功能描述参数用空格或tab键隔开.(若未给参数限制缓存精度大小,则采用默认值)

例如:
glutInitDisplayString("stencil~2 rgb double depth>=16 samples");
上例将窗口初始化为至少2位的模板缓存,RGB模式alpha占用位数为0,深度缓存至少为16位,如果平台支持的话使用mutlisampling技术.
可以使用的符号有:
=   等号
!= 不等号
<   小于号(越小越好)
>   大于号(越大越好)
<= 小于等于(越小越好)
>= 大于等于(尽可能选择大的数值,主要用于颜色缓存或深度缓存等对位数要求高的参数设置)
~   大于等于(但尽可能选择小的数值,有效利用资源,主要用于模板缓存等)

主要参数:
alpha : alpaha缓存精度, 默认值>=1,即大于等于1位;
acca : red, green, blue, 和alpha累积缓存精度, 默认值>=1
acc : red, green, blue累积缓存精度, 默认值>=1,alpha累积缓存精度为0;
blue : blue颜色缓存精度, 默认值>=1;
buffer: 颜色索引缓存精度, 默认值>=1;
conformant :布尔值,指示帧缓存配置是否一致,该值基于GLX的EXT_visual_rationg扩展的支持,若不支持,则默认为一致, 默认值=1;
depth : 深度缓存精度, 默认值>=12;
double: 布尔值,指示颜色缓存是否是双倍缓存. 默认值=1;
green : green颜色缓存精度,默认值>=1;
index : 布尔值,指示是否为颜色索引,true表示是颜色索引, 默认值>=1;
num : 专用名词,指示数值表示的第n个帧缓存配置与这个描述字符串相符合的地方,当没有指定,则glutInitDisplayString也返回初始(最佳符合)配置.
red :   red颜色缓存精度, 默认值>=1;
rgba : rgba模式,颜色缓存精度默认值>=1;
rgb :   rgb模式,颜色缓存精度默认值>=1,alpha精度=0;
luminance: 设置red颜色缓存精度,默认值>=1,其他颜色缓存精度=0(alpha没有指定);
stencil: 模板缓存精度
single: 布尔值,指示颜色缓存是否为单缓存, 默认值=1;
stereo :布尔值,标示颜色缓存支持OpenGL的三维系统,默认值=1;
samples: 标示multisamples的值,这个值是基于GLX的SGIS_multisample的扩展.默认值<=4.这个默认值表示如果支持的话可以在glutInitDisplayString中添加描述参数让glut请求multipsampling;
slow : 布尔值,标示帧缓存配置是否是slow的.对于X11对glut的执行,slow信息是基于GLX的EXT_visual_rating扩展的支持,如果不支持,就认为是fast;对于win32对glut的执行,slow是基于像素格式描述(pixel format Descriptor即PFD)被标记为"generic"并且未被标记为"accelerated",这说明Microsoft关于slow的OpenGL执行只用在PFD中.这个参数的作用是帮助程序避免对于当前机器的帧缓存配置越来越慢.默认值>=0,表示slow visuals优先于fast visuals,但fast visuals仍然被允许.
win32pdf : 只在win32系统中识别glut的请求,这个参数与win32中的像素格式(pixel format)相匹配,它的值是个数字
xvisual: 只在X Window系统中识别glut的请求,这个参数与X visual ID相匹配,它的值是个数字
xstaticgray: 只在X Window系统中识别glut请求,是个布尔值,标示帧缓存配置的X visual是否是StaticGray. 默认值=1
xgrayscale : 只在X Window系统中识别glut的请求,是个布尔值,标示帧缓存配置的X visual是否是GrayScale. 默认值=1;
xstaticcolor: 只在X Window系统中识别glut的请求,是个布尔值,标示帧缓存配置的X visual是否是StaticColor. 默认值=1;
xpseudocolor : 只在X Window系统中识别glut的请求,是个布尔值,标示帧缓存配置的X visual是否是PsuedoColor. 默认值=1;
xtruecolor : 只在X Window系统中识别glut的请求,是个布尔值,标示帧缓存配置的X visual是否是TrueColor. 默认值=1;
xdirectcolor : 只在X Window系统中识别glut的请求,是个布尔值,标示帧缓存配置的X visual是否是DirectColor. 默认值=1;
//*******************************************************************************************
网上没有搜到关于glut的完整资料,于是下狠心自己花时间整理了一下.这里只是glut初始化的API,其中void glutInitDisplayString(const char *string);在国内网站上没搜到具体解释,是从国外网站上翻译过来的,本人英文水平有限,可能有错误,下面贴上英文原文,望达人指点.(其他API 会在以后分类后陆续给出).

void glutInitDisplayString(const char *string) - sets the initial display mode via a string.
string:Display mode description string, see below.
Description:
The initial display mode description string is
used when creating top-level windows,subwindows,
and overlays to determine the OpenGL display mode
for the to-be-created window or overlay.
The string is a list of zero or more capability
descriptions separated by spaces and tabs.Each
capability description is a capability name that
is optionally followed by a comparator and a
numeric value.For example,"double" and "depth>=12"
are both valid criteria.
The capability descriptions are translated into
a set of criteria used to select the appropriate
frame buffer configuration.
The criteria are matched in strict left to right
order of precdence.That is,the first specified
criteria(leftmost) takes precedence over the later
criteria for nonexact criteria (greater than,less
than,etc.comparators).Exact criteria (equal, not
equal compartors) must match exactly so precedence
is not relevant.
The numeric value is an integer that is parsed
according to ANSI C's strtol(str,strptr,0) behavior.
This means that decimal,octal(leading 0),and
hexidecimal values(leading 0x) are accepeted.
The valid compartors are:
= Equal.
!= Not equal.
< Less than and preferring larger difference
   (theleast is best).
> Greater than and preferring larger differences
   (the most is best).
<= Less than or equal and preferring larger
   difference(the least is best).
>= Greater than or equal and preferring more
   instead of less. This comparator is useful for
   allocating resources like color precsion or
   depth buffer precision where the maximum
   precison is generally preferred.Contrast with
   the tilde (~) comprator.
~ Greater than or equal but preferring less
   instead of more.This compartor is useful for
   allocating resources such as stencil bits or
   auxillary color buffers where you would rather
   not over allocate.
   When the compartor and numeric value are not
   specified,each capability name has a different
   default(one default is to require a compartor
   and numeric value).
The valid capability names are:
alpha:Alpha color buffer precision in bits.Default
      is ">=1".
acca:Red,green,blue,and alpha accumulation buffer
     precision in bits.Default is ">=1" for red,
     green,blue,and alpha capabilities.
acc:Red,green,and green accumulation buffer
    precision in bits and zero bits of alpha
    accumulation buffer precision.Default is ">=1"
    for red,green,and blue capabilities,and "~0"
    for the alpha capability.
blue:Blue color buffer precision in bits.Default
     is ">=1".
buffer:Number of bits in the color index color
       buffer.Default is ">=1".
conformant:
       Boolean indicating if the frame buffer
       configuration is conformant or not.
       Conformance information is based on GLX's
       EXT_visual_rating extension if supported.
       If the extension is not supported,all
       visuals are assumed conformat.Default is
       "=1".
depth:Number of bits of precsion in the depth
      buffer.Default is ">=12".
double:Boolean indicating if the color buffer is
       double buffered.Default is "=1".
green:Green color buffer precision in bits.Default
      is ">=1".
index:Boolean if the color model is color index or
      not.True is color index.Default is ">=1".
num:A special capability name indicating where the
    value represents the Nth frame buffer
    configuration matching the description string.
    When not specified,glutInitDisplayString also
    returns the first(best matching) configuration.
    num requires a compartor and numeric value.
red;Red color buffer precision in bits.Default is
        ">=1".
rgba:Number of bits of red,green,blue,and alpha
     in the RGBA color buffer.Default is ">=1"
     for red,green,blue,and alpha capabilities,
     and "=1" for the RGBA color model capability.
rgb:Number of bits of red,green,and blue in the
    RGBA color buffer and zero bits of alpha color
    buffer precision.Default is ">=1" for the red,
    green,and blue capabilities,and "~0" for alpha
    capability,and "=1" for the RGBA color model
    capability.
luminance:
    Number of bits of red in the RGBA and zero
    bits of green,blue(alpha not specified) of
    color buffer precision.Default is ">=1"
    for the red capabilitis,and "=0" for the green
    and blue capabilities,and "=1" for the RGBA
    color model capability,and,for X11,"=1" for the
    StaticGray ("xstaticgray")capability.SGI
    InfiniteReality(and other future machines)
    support a 16-bit luminance (single channel)
    display mode(an additional 16-bit alpha channel
    can also be requested).The red channel maps to
    gray scale and green and blue channels are not
    available.A 16-bit precision luminance display
    mode is often appropriate for medical imaging
    applications.Do not expect many machines to
    support extended precision luminance display
    modes.
stencil:Number of bits in the stencil buffer.
single:Boolean indicate the color buffer is single
       buffered.Double buffer capability "=1".
stereo:Boolean indicating the color buffer is
       supports OpenGL-style stereo.Default is "=1".
samples:Indicates the number of multisamples to use
        based on GLX's SGIS_multisample extension(for
        antialiasing).Default is "<=4". This default
        means that a GLUT application can request
        multipsampling if available by simply
        specifying "samples".
slow:Boolean indicating if the frame buffer
     configuration is slow or not.For the X11
     implementation of GLUT,slowness information is
     based on GLX's EXT_visual_rating extension if
     supported.If the EXT_visual_rating extension is
     not supported,all visuals are assumed fast.For
     the Win32 implementation of GLUT,slowness is
     based on if the underlying Pixel Format Descriptor
     (PFD)is marked "generic" and not "accelerated".
     This implies that Microsoft's relatively slow
     software OpenGL implementation is used by this
     PFD.Note that slowness is a relative designation
     relative to other frame buffer configurations
     available.The intent of the slow capability is to
     help programs avoid frame buffer configurations
     that are slower(but perhaps higher precision) for
     the current machine.Default is ">=0" if not
     comparator and numeric value are provided.This
     default means that slow visuals are used in
     preference to fast visuals,but fast visuals will
     still be allowed.
win32pfd:
     Only recognized on GLUT implementations for Win32,
     this capability name matches the Win32 Pixel For-
     mat Descriptor by numer. win32pfd requires a com-
     partor and numeric value.
xvisual:Only recongized on GLUT implementations for the
        X Window System,this capability name matches
        the X visual ID by number.xvisual requires a
        compartor and numeric value.
xstaticgray:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type Stat-
        icGray.Default is "=1".
xgrayscale:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type
        GrayScale.Default is "=1".
xstaticcolor:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type
        StaticColor.Default is "=1".
xpseudocolor:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type
        PsuedoColor.Default is "=1".
xtruecolor:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type
        TrueColor.Default is "=1".
xdirectcolor:
        Only recongized on GLUT implementations for the
        X Window System,boolean indicating if the frame
        buffer configuration's X visual is of type
        DirectColor.Default is "=1".
Unspecifed capability descriptions will result in
unspecified criteria being generated.These unspecified
criteria help glutInitDisplayString behave sensibly
with terse display mode description strings.For
example,if no "slow" capability description is provided,
fast frame buffer configurations will be choosen in
preference to slow frame buffer configurations,but slow
frame buffer configurations will still be choosen if
no better fast frame buffer configuration is available.
Example:
Here is an examples using glutInitDisplayString:
glutInitDisplayString("stencil~2 rgb double depth>=16 samples");
The above call requests a window with an RGBA color
model(but requesting no bits of alpha),a depth buffer
with at least 16 bits of precsion but preferring more,
mutlisampling if available,and at least 2 bits of
stencil(favoring less stencil to more as long as 2 bits
are available).

小虫虫 2009-03-03 15:15 发表评论

（转）glut中去掉控制台

小虫虫 — Tue, 03 Mar 2009 07:10:00 GMT

*文章转自：http://old.blog.edu.cn/user3/zjdukang/archives/2007/1765297.shtml
glut是OpenGL应用工具包(OpenGL Utility Toolkit),它为OpenGL提供了一个简易的窗口平台,使程序员不用过多的关心与平台相关的窗口系统.
建立工程时,我们一般都建立控制台程序(在vc6中即console win32 application)来使用glut库.但是在控制台程序下,运行时都会跳出控制台窗口,很不美观,我们可以用下面的方法将控制台窗口去掉:
#pragma comment( linker,"/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
在主函数所在的.cpp文件的顶部加上上面的宏,就可以轻松将控制台窗口去掉,这样就只剩下glut窗口了.

小虫虫 2009-03-03 15:10 发表评论

glut函数说明

小虫虫 — Tue, 03 Mar 2009 07:02:00 GMT

摘要: Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 st1\:*{behavior:url(#ieooui) } /* Style Definitions */ table.MsoNormalT... 阅读全文

小虫虫 2009-03-03 15:02 发表评论

VC下OpenGL配置以及glut配置

小虫虫 — Tue, 03 Mar 2009 06:57:00 GMT

OpenGL官方网站（英文）
http://www.opengl.org

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

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

现在Windows系统的主流编译环境有Visual Studio，Broland C++ Builder，Dev-C++等，它们都是支持OpenGL的。但这里我们选择VC++ 6.0作为学习OpenGL的环境。

第二步：安装GLUT工具包

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

Windows环境下的GLUT下载地址：（大小约为150k）
http://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip

无法从以上地址下载的话请使用下面的连接:
http://upload.programfan.com/upfile/200607311626279.zip

Windows环境下安装GLUT的步骤：
1、将下载的压缩包解开，将得到5个文件
2、以我的安装目录为例：
（1）“d:\Program Files\Microsoft Visual Studio\VC98\include\GL文件夹”。把解压得到的glut.h放到这个GL文件夹里。没有GL文件夹可以自己建一个，一般都有的。
（2）“d:\Program Files\Microsoft Visual Studio\VC98\lib文件夹”。把解压得到的glut.lib和glut32.lib放到静态函数库所在文件夹，即lib文件夹。
（3）把解压得到的glut.dll和glut32.dll放到操作系统目录下面的system32文件夹内。（典型的位置为：C:\Windows\System32）这是非常重要的动态链接库设置！

第三步，创建工程，其步骤如下：

（1）创建一个Win32 Console Application。（以我创建的为例，工程名为simpleGL）
（2）链接OpenGL libraries:在Visual C++中先单击Project，再单击Settings，再找到Link单击，最后在Object/library modules 的最前面加上opengl32.lib Glut32.lib Glaux.lib glu32.lib 。
（3）单击Project Settings中的C/C++标签，将Preprocessor definitions 中的_CONSOLE改为__WINDOWS。最后单击OK。

现在，准备工作基本上完成了，可不要轻视这一步，如果你没有设置好在编译及运行过程中总会出错的。

对于VS2005可以如下设置：
1、把 glut.h 复制到 VC 安装路径下的 PlatFormSDK\include\gl 文件夹
2、把 glut32.lib 复制到 VC 安装路径下的 PlatFormSDK\lib 文件夹
3、把 glut32.dll 复制到 Windows\System32 文件夹
4、在 VC 中创建控制台应用程序，在选项中清除“使用预编译头”（以免影响可移植性）
5、在 VC 中打开项目->属性对话框进行如下设置：
        将“配置”下拉框选则为“所有配置”
        打开 “链接器--输入”项
        在“附加依赖项”中增加：
        OpenGL32.lib
        glu32.lib
        glut32.lib

第四步，创建一个最简单的opengl程序

#include

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，这是GLUT的头文件。
本来OpenGL程序一般还要包含和，但GLUT的头文件中已经自动将这两个文件包含了，不必再次包含。

然后看main函数。
int main(int argc, char *argv[])，这个是带命令行参数的main函数，各位应该见过吧？没见过的同志们请多翻翻书，等弄明白了再往下看。
注意main函数中的各语句，除了最后的return之外，其余全部以glut开头。这种以glut开头的函数都是GLUT工具包所提供的函数，下面对用到的几个函数进行介绍。
1、glutInit，对GLUT进行初始化，这个函数必须在其它的GLUT使用之前调用一次。其格式比较死板，一般照抄这句glutInit(&argc, argv)就可以了。
2、glutInitDisplayMode，设置显示方式，其中GLUT_RGB表示使用RGB颜色，与之对应的还有GLUT_INDEX（表示使用索引颜色）。GLUT_SINGLE表示使用单缓冲，与之对应的还有GLUT_DOUBLE（使用双缓冲）。更多信息，请自己Google。当然以后的教程也会有一些讲解。
3、glutInitWindowPosition，这个简单，设置窗口在屏幕中的位置。
4、glutInitWindowSize，这个也简单，设置窗口的大小。
5、glutCreateWindow，根据前面设置的信息创建窗口。参数将被作为窗口的标题。注意：窗口被创建后，并不立即显示到屏幕上。需要调用glutMainLoop才能看到窗口。
6、glutDisplayFunc，设置一个函数，当需要进行画图时，这个函数就会被调用。（这个说法不够准确，但准确的说法可能初学者不太好理解，暂时这样说吧）。
7、glutMainLoop，进行一个消息循环。（这个可能初学者也不太明白，现在只需要知道这个函数可以显示窗口，并且等待窗口关闭后才会返回，这就足够了。）

在glutDisplayFunc函数中，我们设置了“当需要画图时，请调用myDisplay函数”。于是myDisplay函数就用来画图。观察 myDisplay中的三个函数调用，发现它们都以gl开头。这种以gl开头的函数都是OpenGL的标准函数，下面对用到的函数进行介绍。
1、glClear，清除。GL_COLOR_BUFFER_BIT表示清除颜色，glClear函数还可以清除其它的东西，但这里不作介绍。
2、glRectf，画一个矩形。四个参数分别表示了位于对角线上的两个点的横、纵坐标。
3、glFlush，保证前面的OpenGL命令立即执行（而不是让它们在缓冲区中等待）。其作用跟fflush(stdout)类似。

小虫虫 2009-03-03 14:57 发表评论