精华内容
下载资源
问答
  • OpenGL键盘事件处理

    千次阅读 2015-04-19 18:10:13
    GLUT提供了两个函数用于设置键盘事件的回调函数,一个用于处理普通按键,一个处理特殊功能按键(如箭头、F1~F12)。 先看看处理普通按键的函数: void glutKeyboardFunc(void (*func) (unsigned char key, int x, ...

    GLUT提供了两个函数用于设置键盘事件的回调函数,一个用于处理普通按键,一个处理特殊功能按键(如箭头、F1~F12)。

    先看看处理普通按键的函数:

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

    回调函数func的第一个参数是按键的ASCII码,剩下的是按键时候的鼠标坐标。鼠标坐标是相对窗口的左上角的。

    示例:

    void processNormalKeys(unsigned char key, int x, int y) {
        if (key == 27)
            exit(0);
    }
    

    另一个处理特殊按键的函数是:

    void glutSpecialFunc(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键


    后两个参数是鼠标的坐标。

    除了以上两个函数,还有一个函数用于判断CTRL,ALT和SHIFT键的状态:

    int glutGetModifiers(void);
    它的返回值是GLUT_ACTIVE_SHIFT、GLUT_ACTIVE_CTRL和GLUT_ACTIVE_ALT的按位或。示例:

    mod = glutGetModifiers();
    if (mod == (GLUT_ACTIVE_CTRL|GLUT_ACTIVE_ALT)) {
    //TODO
    }
    

    通常这个函数会在键盘事件的回调函数中被调用。


    展开全文
  • perl-opengl键盘事件与色彩

    千次阅读 2013-11-22 17:06:13
    到现在,你应该注意到了,只要你想控制一个事件的处理,你就必须提前告诉GLUT,哪个函数将完成这个任务。到现在为止,我们已经使用GLUT告诉窗口系统,当窗口重绘时我们想调用哪个渲染函数,但系统空闲时,哪个函数被...

    按空格键变换色彩



     

     

    二、 关于色彩

    1. glShadeModel 选择平面明暗模式或光滑明暗模式

    C语言描述

    void glShadeModel( GLenum mode )

    参数

    mode 指定表示明暗模式的符号值,可以选择GL_FLAT(平面明暗模式)和GL_SMOOTH光滑明暗模式),缺省值为GL_SMOOTH

    说明

    OpenGL图元需要进行明暗处理,处理得模式可以为平面明暗模式或光滑(Gouraud着色)明暗模式。光滑明暗模式时,多边形各个内部点的颜色是根据各顶点指定的颜色来插值得到的,这意味着两个顶点之间的颜色是从一顶点的颜色渐变到另一顶点的颜色。对于平面明暗模式,整个图元区域的颜色就是最后一个顶点指定的颜色,唯一例外的是GL_POLYGON,这是整个区域的颜色是第一个顶点所指定的颜色。但要注意,如果激活了光照,计算到的顶点颜色都是光照后的结果颜色,若光照关闭,计算到的颜色就是指定顶点时的当前颜色。

     

    2. glColor 设置当前颜色

    C语言描述

    void glcolor3b(GLbyte redGLbyte greenGLbyte blue);

    void glcolor3d(GLdouble redGLdouble greenGLdouble blue);

    void glcolor3f(GLfloat redGLfloat greenGLfloat blue);

    void glcolor3i(GLint redGLint greenGLint blue);

    void glcolor3s(GLshort redGLshort greenGLshort blue);

    void glcolor3ub(GLubyte redGLubyte greenGLubyte blue);

    void glcolor3ui(GLuint redGLuint greenGLuint blue);

    void glcolor3us(GLushort redGLushort greenGLushort blue);

    void glcolor4b(GLbyte redGLbyte greenGLbyte blueGLbyte alpha);

    void glcolor4d(GLdouble redGLdouble greenGLdouble blueGLdouble alpha);

    void glcolor4f(GLfloat redGLfloat greenGLfloat blueGLfloat alpha);

    void glcolor4i(GLint redGLint greenGLint blueGLint alpha);

    void glcolor4s(GLshort redGLshort greenGLshort blueGLshort alpha);

    void glcolor4ub(GLubyte redGLubyte greenGLubyte blueGLubyte alpha);

    void glcolor4ui(GLuint redGLuint greenGLuint blueGLuint alpha);

       void glcolor4us(GLushort redGLushort greenGLushort blueGLushort alpha);

    void glcolor3bv(const GLbyte *v);

    void glcolor3dv(const GLdouble *v);

    void glcolor3fv(const GLfloat *v);

    void glcolor3iv(const GLint *v);

    void glcolor3sv(const GLshort *v);

    void glcolor3ubv(const GLubyte *v);

    void glcolor3uiv(const GLuint *v);

    void glcolor3usv(const GLushort *v);

    void glcolor4bv(const GLbyte *v);

    void glcolor4dv(const GLdouble *v);

    void glcolor4fv(const GLfloat *v);

    void glcolor4iv(const GLint *v);

    void glcolor4sv(const GLshort *v);

    void glcolor4ubv(const GLubyte *v);

    void glcolor4uiv(const GLuint *v);

       void glcolor4usv(const GLushort *v);

    参数

    redgreen, blue 指定当前颜色中的红、绿和蓝色成分。

    alpha 指定颜色中的α成分。只有在glColor4函数带4个变量时才指定此参数。

    *v 指定一个指向包含红、绿、蓝和alpha值的数组指针。

    说明

    本函数通过指定红、绿、蓝的颜色成分来设置当前的颜色,同时部分函数可以接受α成分。每个成分亮度的表示范围是从零(0.0)到全光强(1.0),当指定了非浮点类型时,该类型从0到最大值的表示法与浮点类型范围的0.01.0相映射。

     

    3. glColorMask 激活或关闭帧缓存颜色分量的写操作

    C语言描述

    void glColorMask(GLboolean redGLboolean greenGLboolean blueGLboolean alpha)

    参数

        redgreenbluealpha 指定红、绿、蓝和α成分是否可以修改。

    说明

    本函数指定是否可以将单个的颜色分量写入帧缓存。例如,若redGL_FALSE,那么不管执行什么样的绘制操作,任何颜色缓存中任何像素的红色分量均不被改变。

    三、 键盘输入 

    GLUT允许我们编写程序,在里面加入键盘输入控制,包括了普通键,和其他特殊键(如F1,UP)。在这一章里我们将学习如何去检测哪个键被按下,可以从GLUT里得到些什么信息,和如何处理键盘输入。 
      
    到现在,你应该注意到了,只要你想控制一个事件的处理,你就必须提前告诉GLUT,哪个函数将完成这个任务。到现在为止,我们已经使用GLUT告诉窗口系统,当窗口重绘时我们想调用哪个渲染函数,但系统空闲时,哪个函数被调用。和当窗口大小改变时,哪个函数又将被调用。
      
    相似的,我们必须做同样的事来处理按键消息。我们必须使用GLUT通知窗口系统,当某个键被按下时,哪个函数将完成所要求的操作。我们同样是调用一个函数注册相关的回调函数。 
      
    当你按下一个键后,GLUT提供了两个函数为这个键盘消息注册回调。第一个是glutKeyboardFunc。这个函数是告诉窗口系统,哪一个函数将会被调用来处理普通按键消息。 
    普通键是指字母,数字,和其他可以用ASCII代码表示的键。函数原型如下: 
    void glutKeyboardFunc(void(*func)(unsigned char key,int x,int y)); 
    参数: 
    func: 处理普通按键消息的函数的名称。如果传递NULL,则表示GLUT忽略普通按键消息。 
    这个作为glutKeyboardFunc函数参数的函数需要有三个形参。第一个表示按下的键的ASCII码,其余两个提供了,当键按下时当前的鼠标位置。鼠标位置是相对于当前客户窗口的左上角而言的。 
      
    一个经常的用法是当按下ESCAPE键时退出应用程序。注意,我们提到过,glutMainLoop函数产生的是一个永无止境的循环。唯一的跳出循环的方法就是调用系统exit函数。这就是我们函数要做的,当按下ESCAPE键调用exit函数终止应用程序(同时要记住在源代码包含头文件stdlib.h)。下面就是这个函数的代码: 
    void processNormalKeys(unsigned char key,int x,int y) 

          if(key==27) 
                Exit(0); 

      
    下面让我们控制特殊键的按键消息。GLUT提供函数glutSpecialFunc以便当有特殊键按下的消息时,你能注册你的函数。函数原型如下: 
    void glutSpecialFunc(void (*func)(int key,int x,int y)); 
    参数: 
    func: 处理特殊键按下消息的函数的名称。传递NULL则表示GLUT忽略特殊键消息。 
      
    下面我们写一个函数,当一些特殊键按下的时候,改变我们的三角形的颜色。这个函数使在按下F1键时三角形为红色,按下F2键时为绿色,按下F3键时为蓝色。 
      
    void processSpecialKeys(int key, int x, int y) { 
      
             switch(key) { 
                     case GLUT_KEY_F1 :  
                                       red = 1.0;  
                                       green = 0.0;  
                                       blue = 0.0; break; 
                     case GLUT_KEY_F2 :  
                                       red = 0.0;  
                                       green = 1.0;  
                                       blue = 0.0; break; 
                     case GLUT_KEY_F3 :  
                                       red = 0.0;  
                                       green = 0.0;  
                                       blue = 1.0; break; 
             } 

    上面的GLUT_KEY_*在glut.h里已经被预定义为常量。这组常量如下: 
    GLUT_KEY_F1               F1 function key 
    GLUT_KEY_F2               F2 function key 
    GLUT_KEY_F3               F3 function key 
    GLUT_KEY_F4               F4 function key 
    GLUT_KEY_F5               F5 function key 
    GLUT_KEY_F6               F6 function key 
    GLUT_KEY_F7               F7 function key 
    GLUT_KEY_F8               F8 function key 
    GLUT_KEY_F9               F9 function key 

     

    LUT_KEY_F10              F10 function key 
    GLUT_KEY_F11              F11 function key 
    GLUT_KEY_F12              F12 function key 
    GLUT_KEY_LEFT             Left function key 
    GLUT_KEY_RIGHT            Up function key 
    GLUT_KEY_UP               Right function key 
    GLUT_KEY_DOWN             Down function key 
    GLUT_KEY_PAGE_UP          Page Up function key 
    GLUT_KEY_PAGE_DOWN        Page Down function key 
    GLUT_KEY_HOME             Home function key 
    GLUT_KEY_END              End function key 
    GLUT_KEY_INSERT           Insert function key 
    为了让上面processSpecialKeys函数能过编译通过,我们还必须定义,red,green,blue三个变量。此外为了得到我们想要的结果,我们还必须修改renderScene函数。 
    ... 
    // 所有的变量被初始化为1,表明三角形最开始是白色的。 
    float red=1.0, blue=1.0, green=1.0; 
      
      
      
    void renderScene(void) { 
             glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); 
             glPushMatrix(); 
             glRotatef(angle,0.0,1.0,0.0); 
      
             // glColor3f设置绘制三角形的颜色。 
             glColor3f(red,green,blue); 
      
             glBegin(GL_TRIANGLES); 
                     glVertex3f(-0.5,-0.5,0.0); 
                     glVertex3f(0.5,0.0,0.0); 
                     glVertex3f(0.0,0.5,0.0); 
             glEnd(); 
             glPopMatrix(); 
             angle++; 
             glutSwapBuffers(); 

     。下面我们就该告诉GLUT,我们刚刚定义的函数用来处理,按键消息。也就是该调用glutKeyboardFunc和glutSpecialFunc函数。我们在main函数里调用它们。下面就是最新的main函数。
    VC工程可以在这里下载(glut3.zip) 
      
    CTRL,ALT和SHIFT 
      
    一些时候我们想知道要是一个组合键(modifier key)也就是CTRL,ALT或者SHIFT被按下该如何处理。GLUT提供了一个函数来检测时候有组合键被按下。这个函数仅仅只能在处理按键消息或者鼠标消息函数里被调用。函数原型如下: 
    int glutGetModifiers(void); 
    这个函数的返回值是三个glut.h里预定义的常量里的一个,或它们的或组合。这三个常量是:
    1:GLUT_ACTIVE_SHIFT: 返回它,当按下SHIFT键或以按下CAPS LOCK,注意两者同时按下时,不会返回这个值。 
    2:GLUT_ACTIVE_CTRL: 返回它,当按下CTRL键。 
    3:GLUT_ACTIVE_ATL:返回它,当按下ATL键。 
    注意,窗口系统可能会截取一些组合键(modifiers),这是就没有回调发生。现在让我们扩充processNormalKeys,处理组合键。按下r键时red变量被设置为0.0,当按下ATL+r时red被设置为1.0。代码如下: 
    void processNormalKeys(unsigned char key, int x, int y) { 
      
             if (key == 27)  
                     exit(0); 
             else if (key=='r') { 
                     int mod = glutGetModifiers(); 
                     if (mod == GLUT_ACTIVE_ALT) 
                              red = 0.0; 
                     else 
                              red = 1.0; 
             } 

    注意如果我们按下R键,将不会有什么发生,因为R与r键的ASCII码不同。即这是两个不同的键。最后就是如何检测按键CTRL+ALT+F1?。这种情况下,我们必须同时检测两个组合键,为了完成操作我们需要使用或操作符。下面的代码段,使你按下CTRL+ALT+F1时颜色改变为红色。 
    void processSpecialKeys(int key, int x, int y) { 
      
             int mod; 
             switch(key) { 
                     case GLUT_KEY_F1 :  
                        mod = glutGetModifiers(); 
                        if (mod == (GLUT_ACTIVE_CTRL|GLUT_ACTIVE_ALT)) { 
                              red = 1.0; green = 0.0; blue = 0.0; 
                        } 
                        break; 
                     case GLUT_KEY_F2 :  
                        red = 0.0;  
                        green = 1.0;  
                        blue = 0.0; break; 
                     case GLUT_KEY_F3 :  
                        red = 0.0;  
                        green = 0.0;  
                        blue = 1.0; break; 
             } 

      



    #!/usr/bin/perl -w
    use strict;
    use warnings;
    use OpenGL qw/ :all /;
    use OpenGL::Config;   
    
    my $a=1;
    my $b=0;
    my $c=0;
    glutInit();
    glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(400,400);
    glutCreateWindow("my  OpenGL program");
    glClearColor(0,0,100,255);
    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-200,200,-200,200);
    glMatrixMode(GL_MODELVIEW);
    glutDisplayFunc(\&mydis);
    glutMouseFunc(\&mymouse);
    glutKeyboardFunc(\&mykey);
    glutMainLoop();
    
    sub mymouse()
    {
    	my ($button,$state,$myx,$myy)=@_;
    	if ($button==GLUT_LEFT_BUTTON  and $state==GLUT_DOWN)
    	{
    		glPointSize(3); 
    		glBegin(GL_LINES);  
            glColor3f($a,$b,$c);
    		glVertex2f($myx-200,200-$myy);	
    		glVertex2f(-200,200-$myy);			
    	    glEnd();
    	    glFlush();	 	      		
    	}
    	print "mouse x:$myx-y:$myy\n";
    }
    
     sub mydis()
    {
     
      glPointSize(3);
    
      glFlush();
    }  
    sub mykey()
    {
       my $keyname=shift @_;
       if ($keyname==32)
       {
          $a=rand(1);
          $b=rand(1);
          $c=rand(1);	  
       }
       print "$a-$b-$c\n";#输当前色彩
       
    }
    
    
    
    


    展开全文
  • OpenGL的鼠标键盘事件

    热门讨论 2009-04-21 16:37:18
    OpenGL的鼠标键盘事件机制,简单的例子代码!
  • openGL 键盘,鼠标响应事件应用

    千次阅读 2014-09-28 21:17:52
    openGl

         openGl提供了对键盘和鼠标事件的响应。GLUT提供了2个键盘注册回调函数。第一个, glutKeyboardFunc, 用来告诉windows系统我们调用哪个函数处理"普通"按键. "普通"按键就是指, 单词,数字,任何有ASCII码的东西。

         这个函数的语法如下:

    extern void APIENTRY glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
     
          第一个参数key指的是键盘按下哪个键的ASCII码。x,y表示按键时鼠标的坐标,该坐标是相对于窗口左上角。

    还有一类键,比如F1,F2.....方向箭头,并不是在上述函数中注册,GLUT提供了一个另外的函数。

        具体如下:

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

        三个参数和上述一样,但是F1,F2.....方向箭头这些键的ASCII码可以在glut.h中找到。

        具体如下:

    /* function keys */
    #define GLUT_KEY_F1			1
    #define GLUT_KEY_F2			2
    #define GLUT_KEY_F3			3
    #define GLUT_KEY_F4			4
    #define GLUT_KEY_F5			5
    #define GLUT_KEY_F6			6
    #define GLUT_KEY_F7			7
    #define GLUT_KEY_F8			8
    #define GLUT_KEY_F9			9
    #define GLUT_KEY_F10			10
    #define GLUT_KEY_F11			11
    #define GLUT_KEY_F12			12
    /* directional keys */
    #define GLUT_KEY_LEFT			100
    #define GLUT_KEY_UP			101
    #define GLUT_KEY_RIGHT			102
    #define GLUT_KEY_DOWN			103
    #define GLUT_KEY_PAGE_UP		104
    #define GLUT_KEY_PAGE_DOWN		105
    #define GLUT_KEY_HOME			106
    #define GLUT_KEY_END			107
    #define GLUT_KEY_INSERT			108
    #endif

    GLUT也提供了鼠标注册回调函数

          具体如下:

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

          button 分别对应鼠标左键,中键,右键。

    /* Mouse buttons. */
    #define GLUT_LEFT_BUTTON		0
    #define GLUT_MIDDLE_BUTTON		1
    #define GLUT_RIGHT_BUTTON		2

         state 对应鼠标状态:按下与弹起

    /* Mouse button  state. */
    #define GLUT_DOWN			0
    #define GLUT_UP				1

          x ,y 对应鼠标的坐标

          这篇博文还对其他一些组合键做了介绍http://www.cnblogs.com/jiaohuang/archive/2011/07/25/2116263.html

     

    我的应用:

       

         在窗口中,第一次点击鼠标左键,绘制直线的起点

                           按 f 键,从起点水平延生,绘制一条直线

                           按 t 键,旋转直线,我设定每次旋转30°

                           按 i 键,直线的长度扩大一倍

                           按 s 键,直线的长度缩小一倍

                           按 r , g , b 键,分别使直线的颜色变成红色,绿色,蓝色

                           按方向键,移动直线

                           第二次点击鼠标左键,重新绘制直线的起点

       功能很简单,但是作为键盘,鼠标事件的应用还是一个不错的练习。

      

      具体代码如下所示:

    #include <gl/glut.h>
    #include<stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    GLint flag = 1;
    GLfloat ori[2]; //起点坐标
    GLfloat next[2];//终点坐标
    GLfloat dir[2]={1,0};//方向向量
    GLint D = 100;//直线长度
    GLfloat angle= 30*3.1415926/180.0;//旋转角度
    GLint n = 1;//直线旋转角度次数
    
    void init()
    {
    		flag = 1;
    		dir[0]=1;
    		dir[1]=0;
    		D=100;
    		n = 1;
    }
    
    void myDisplay(void)
    {
    	glClearColor(0,0,0,0);
        glClear(GL_COLOR_BUFFER_BIT);
    
    	if(flag == 1)
    	{
    		glBegin(GL_POINTS);//画点
    			glVertex2f(ori[0],400-ori[1]);
    		glEnd();
    	}
    	if(flag == 2)
    	{
    		glBegin(GL_LINES);//画线
    			glVertex2f(ori[0],400-ori[1]);
    			glVertex2f(next[0],400-next[1]);
    		glEnd();
    	}
    	glFlush();
    }
    
    void myMouse(int button,int state,int x,int y)
    {
    	switch(button)
    	{
    	case GLUT_LEFT_BUTTON:
    		if(state == GLUT_DOWN)
    			{
    				ori[0] = x;
    				ori[1] = y;
    				init();
    				glutPostRedisplay();
    				break;
    			}	
    	}
    }
    
    void updata()
    {
    	if(flag==1)
    	{
    		next[0] = ori[0] + D * dir[0];
    		next[1] = ori[1] + D * dir[1];
    		flag=2;
    	}
    	else 
    	{
    		next[0] = ori[0] + D * dir[0];
    		next[1] = ori[1] - D * dir[1];
    	}
    	glutPostRedisplay();
    }
    void myKeyboard(unsigned char key,int x,int y)
    {
    	switch(key)
    	{
    		case 'f':
    			{
    				if(flag==1)
    					updata();
    				break;
    			}
    		case 't':
    			{
    				if(flag==2)
    				{
    					dir[0] = cos(angle * n );
    					dir[1] = sin(angle * n );
    					n++;
    					updata();
    				}
    				break;
    			}
    
    		case 'i':
    			{
    				D = D * 2;
    				updata();
    				break;
    			}
    			case 's':
    			{
    				D = D * 0.5;
    				updata();
    				break;
    			}
    		case 'r':
    			{
    				glColor3f(1,0,0);
    				glutPostRedisplay();
    				break;
    			}
    		case 'g':
    			{
    				glColor3f(0,1,0);
    				glutPostRedisplay();
    				break;
    			}
    		case 'b':
    			{
    				glColor3f(0,0,1);
    				glutPostRedisplay();
    				break;
    			}
    		case 27:
    			exit(0);
    	}
    }
    
    void myKeyboard1(int key,int x,int y)
    {
    	switch(key)
    	{
    		case GLUT_KEY_LEFT:
    			{
    				ori[0]-=5;
    				next[0]-=5;
    				glutPostRedisplay();
    				break;
    			}
    		case GLUT_KEY_UP:
    			{
    				ori[1]-=5;
    				next[1]-=5;	
    				glutPostRedisplay();
    					break;
    			}
    		case GLUT_KEY_RIGHT:
    			{
    				ori[0]+=5;
    				next[0]+=5;
    				glutPostRedisplay();
    					break;
    			}
    		case GLUT_KEY_DOWN:
    			{
    				ori[1]+=5;
    				next[1]+=5;	
    				glutPostRedisplay();
    					break;
    			}
    	}
    }
    
    void reshape(int w ,int h)
    {
    	glViewport(0,0,(GLsizei)w,(GLsizei)h);
    	glMatrixMode(GL_PROJECTION);
    	glLoadIdentity();
    	gluOrtho2D(0,(GLdouble)w,0,(GLdouble)h);
    }
    
    int main(int argc, char *argv[])
    {
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
        glutInitWindowPosition(100, 100);
        glutInitWindowSize(400, 400);
        glutCreateWindow("第一个OpenGL程序");
        glutDisplayFunc(myDisplay);
    	glutKeyboardFunc(myKeyboard);
    	glutSpecialFunc(myKeyboard1);
    	glutMouseFunc(myMouse);
    	glutReshapeFunc(reshape);
        glutMainLoop();
        return 0;
    }

    程序部分效果:

         11


    展开全文
  • opengl 键盘操作

    2013-04-15 15:46:28
    opengl键盘响应函数 利用键盘实现橡皮筋技术的例子
  • OpenGL 键盘控制移动

    2011-11-30 18:47:10
    计算机图形学 实验三 OpenGL 键盘控制 移动
  • opengl前后滚轮,鼠标左右中键,键盘f1f2f3等等,可以直接使用,有问题留言,帮助解决,本资源不是那种发起者自己跑都跑不了的
  • 基于OpenGL键盘点击移动视点观察场景,通过键盘点击来控制摄像机的上下左右移动,从而可以从多个视角来查看场景
  • opengl 键盘和鼠标

    千次阅读 2014-07-18 11:07:05
    opengl 键盘和鼠标
    opengl 键盘和鼠标
    还是针对之前的那个立方体,只是键盘和鼠标输入时,实时修改它的透视矩阵和视图矩阵。

    #include "glew.h"
    #include <glfw3.h>
    #include "common/loadShader.h"
    #include "common/controls.h"
    
    #include "glm.hpp"
    #include "ext.hpp"
    GLFWwindow* window;
    int main(void)
    {
    	//GLFWwindow* window;
    
    	/* Initialize the library */
    	if (!glfwInit())
    		return -1;
    
    	/* Create a windowed mode window and its OpenGL context */
    	window = glfwCreateWindow(480, 320, "Hello World", NULL, NULL);
    	if (!window)
    	{
    		glfwTerminate();
    		return -1;
    	}
    
    	/* Make the window's context current */
    	glfwMakeContextCurrent(window);
    
    	// Needed in core profile
    	if( glewInit() != GLEW_OK)
    	{
    		glfwTerminate();
    		return -1;
    	}
    
    	// Our vertices. Tree consecutive floats give a 3D vertex; Three consecutive vertices give a triangle.
    	// A cube has 6 faces with 2 triangles each, so this makes 6*2=12 triangles, and 12*3 vertices
    	static const GLfloat g_vertex_buffer_data[] = {
    		-1.f, 1.f, 1.f,
    		-1.f,-1.f, 1.f,
    		 1.f,-1.f, 1.f,
    
    		 1.f,-1.f, 1.f,
    		 1.f, 1.f, 1.f,
    		 -1.f, 1.f, 1.f,
    
    
    		 1.f, 1.f, 1.f,
    		 1.f,-1.f, 1.f,
    		 1.f,-1.f,-1.f,
    
    		 1.f,-1.f,-1.f,
    		 1.f, 1.f,-1.f,
    		 1.f, 1.f, 1.f,
    
    
    		-1.f, 1.f,-1.f,
    		-1.f, 1.f, 1.f,
    		 1.f, 1.f, 1.f,
    
    		 1.f, 1.f, 1.f,
    	     1.f, 1.f,-1.f,
    		 -1.f, 1.f,-1.f,
    
    
    		-1.f,-1.f,-1.f,
    		-1.f,-1.f, 1.f,
    		 1.f,-1.f, 1.f,
    
    		 1.f,-1.f, 1.f,
    		 1.f,-1.f,-1.f,
    		 -1.f,-1.f,-1.f,
    
    
    		-1.f, 1.f,-1.f,
    		-1.f,-1.f,-1.f,
    		 1.f,-1.f,-1.f,
    
    		 1.f,-1.f,-1.f,
    		 1.f, 1.f,-1.f,
    		 -1.f, 1.f,-1.f,
    
    
    		 -1.f, 1.f, 1.f,
    		 -1.f, 1.f,-1.f,
    		 -1.f,-1.f,-1.f,
    
    		 -1.f,-1.f,-1.f,
    		 -1.f,-1.f, 1.f,
    		-1.f, 1.f, 1.f, 		
     		
    	};
    
    	
    	//This will identify our vertex buffer
    	GLuint vertexbuffer;
    
    	
    	//Generate 1 buffer,put the resulting identifier in vertexbuffer
    	glGenBuffers(1,&vertexbuffer);		
    
    	//The following commands will talk about our 'vertexbuffer' buffer
    	glBindBuffer(GL_ARRAY_BUFFER,vertexbuffer);
    
    	//Give our vertices to OpenGL.
    	glBufferData(GL_ARRAY_BUFFER,sizeof(g_vertex_buffer_data),g_vertex_buffer_data,GL_STATIC_DRAW);
    
    
    	GLuint Texture = loadBMP_custom("./resource/uvtemplate.bmp");
    	// One color for each vertex. They were generated randomly.
    	static const GLfloat g_uv_buffer_data[] = {
    		0.0f, 1.0f,
    		0.0f, 0.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		1.0f, 1.0f,
    		0.0f, 1.0f,
    
    
    		0.0f, 1.0f,
    		0.0f, 0.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		1.0f, 1.0f,
    		0.0f, 1.0f,
    
    
    
    		0.0f, 1.0f,
    		0.0f, 0.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		1.0f, 1.0f,
    		0.0f, 1.0f,
    
    
    		0.0f, 1.0f,
    		0.0f, 0.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		1.0f, 1.0f,
    		0.0f, 1.0f,
    
    
    		0.0f, 1.0f,
    		0.0f, 0.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		1.0f, 1.0f,
    		0.0f, 1.0f,
    
    
    		0.0f, 1.0f,
    		1.0f, 1.0f,
    		1.0f, 0.0f,
    
    		1.0f, 0.0f,
    		0.0f, 0.0f,
    		0.0f, 1.0f		
     		
    	};
    	GLuint uvbuffer;
    	glGenBuffers(1,&uvbuffer);
    	glBindBuffer(GL_ARRAY_BUFFER,uvbuffer);
    	glBufferData(GL_ARRAY_BUFFER,sizeof(g_uv_buffer_data),g_uv_buffer_data,GL_STATIC_DRAW);
    
    
    	GLuint programID = LoadShaders("./shader/vertex.shader","./shader/fragment.shader");
    	
    	glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
    	/* Loop until the user closes the window */
    
    	// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit  100 units
    	//glm::mat4 Projection = glm::ortho(-4.0f/3.0f, 4.0f/3.0f, -1.0f, 1.0f, 0.1f, 100.0f);
    	
    	
    		
    	
    		// Get a handle for our "MVP" uniform.
    		// Only at initialisation time.
    		GLuint MatrixID = glGetUniformLocation(programID,"MVP");
    	
    		// Send our transformation to the currently bound shader,
    		// in the "MVP" uniform
    		// For each model you render, since the MVP will be different (at least the M part)
    		
    
    		GLuint TextureID = glGetUniformLocation(programID,"myTextureSampler");
    		int width,height;	
    		glfwGetWindowSize(window,&width,&height);
    		float centerX = width;
    		float centerY = height;
    		centerX /= 2;
    		centerY /= 2;
    		glfwSetCursorPos(window,centerX,centerY);
    		
    	while (glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS && !glfwWindowShouldClose(window))
    	{
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    		glUseProgram(programID);
    		computeMatricesFromInputs();
    		glm::mat4 Projection = getProjectionMatrix();
    		glm::mat4 View = getViewMatrix();
    		//Model matrix : an identity matrix (model will be at the origin)
    		glm::mat4 Model = glm::mat4(1.0f);
    
    		// Our ModelViewProjection : multiplication of our 3 matrices
    		glm::mat4 MVP = Projection * View * Model;// Remember, matrix multiplication is the other way around
    		glUniformMatrix4fv(MatrixID,1,GL_FALSE,&MVP[0][0]);
    
    
    		glActiveTexture(GL_TEXTURE0);
    		glBindTexture(GL_TEXTURE_2D,Texture);
    		glUniform1i(TextureID, 0);
    		
    
    		glEnableVertexAttribArray(0);
    		glBindBuffer(GL_ARRAY_BUFFER,vertexbuffer);
    		glVertexAttribPointer(
    			0,			// attribute 0. No particular reason for 0, but must match the layout in the shader.
    			3,			// size
    			GL_FLOAT,	// type
    			GL_FALSE,	// normalized?
    			0,			// stride
    			(void*)0	// array buffer offset
    			);
    
    		
    
    		glEnableVertexAttribArray(1);
    		glBindBuffer(GL_ARRAY_BUFFER,uvbuffer);	
    		glVertexAttribPointer(
    			1,			// attribute 0. No particular reason for 0, but must match the layout in the shader.
    			2,			// size
    			GL_FLOAT,	// type
    			GL_FALSE,	// normalized?
    			0,			// stride
    			(void*)0	// array buffer offset
    			);
    
    		glEnable(GL_DEPTH_TEST);
    		glDepthFunc(GL_LESS);
    		glDrawArrays(GL_TRIANGLES,0,12*3);// Starting from vertex 0; 3 vertices total -> 1 triangle
    		
    			
    		
    
    		
    		
    
    		
    		glDisableVertexAttribArray(0);
    		glDisableVertexAttribArray(1);
    		/* Swap front and back buffers */
    		glfwSwapBuffers(window);
    
    		/* Poll for and process events */
    		glfwPollEvents();
    	}
    
    	glfwTerminate();
    	return 0;
    }

    来看键盘和鼠标检测
    #include "controls.h"
    #include <glfw3.h>
    #include "glm.hpp"
    #include "ext.hpp"
    glm::mat4 ProjectionMatrix ;
    glm::mat4 ViewMatrix;
    extern GLFWwindow* window;
    float speed = 3.0f; // 3 units / second
    float mouseSpeed = 0.005f;
    // position
    glm::vec3 position = glm::vec3(0,0,5);
    // horizontal angle : toward -Z
    float horizontalAngle = 3.14f;
    //vertical angle : 0, look at the horizon
    float verticalAngle = 0.0f;
    //Initial Field of View
    float initialFov = 45.0f;
    double lastXpos = 240;
    double lastYpos = 160;
    void computeMatricesFromInputs()
    {
    	
    
    	
    	//FoV is the level of zoom. 80° = very wide angle, huge deformations. 60° – 45° : standard. 20° : big zoom.
    	double xpos,ypos;
    	
    	glfwGetCursorPos(window,&xpos,&ypos);
    
    	
    	
    
    	static double lastTime = glfwGetTime();
    	double currentTime = glfwGetTime();
    	float deltaTime = float(currentTime - lastTime);
    	lastTime = float(currentTime);
    
    	// Compute new orientation
    	horizontalAngle += mouseSpeed  * float(xpos - lastXpos);
    	verticalAngle += mouseSpeed  * float(ypos - lastYpos);
    	lastXpos = xpos;
    	lastYpos = ypos;
    
    	// Direction : Spherical coordinates to Cartesian coordinates conversion
    	glm::vec3 direction(
    		cos(verticalAngle) * sin(horizontalAngle),
    		sin(verticalAngle),
    		cos(verticalAngle) * cos(horizontalAngle)
    		);
    
    	// Right vector
    	glm::vec3 right = glm::vec3(
    		sin(horizontalAngle - 3.14f/2.0f),
    		0,
    		cos(horizontalAngle - 3.14f/2.0f)
    		);
    
    	// Up vector : perpendicular to both direction and right
    	glm::vec3 up = glm::cross( right, direction );
    
    	// Move forward
    	if (glfwGetKey(window, GLFW_KEY_UP ) == GLFW_PRESS){
    		position += direction * deltaTime * speed;
    	}
    	// Move backward
    	if (glfwGetKey(window, GLFW_KEY_DOWN ) == GLFW_PRESS){
    		position -= direction * deltaTime * speed;
    	}
    	// Strafe right
    	if (glfwGetKey(window, GLFW_KEY_RIGHT ) == GLFW_PRESS){
    		position += right * deltaTime * speed;
    	}
    	// Strafe left
    	if (glfwGetKey(window, GLFW_KEY_LEFT ) == GLFW_PRESS){
    		position -= right * deltaTime * speed;
    	}
    
    	float FoV = 45.0f;//initialFoV - 5 * glfwGetMouseButton();
    
    	ProjectionMatrix = glm::perspective(FoV, 4.0f / 3.0f, 0.1f, 100.0f);
    	ViewMatrix       = glm::lookAt(
    		position,           // Camera is here
    		position+direction, // and looks here : at the same position, plus "direction"
    		up      
    		);
    	// For the next frame, the "last time" will be "now"
    	lastTime = currentTime;
    }
    
    glm::mat4 getProjectionMatrix()
    {
    	return ProjectionMatrix;
    }
    
    glm::mat4 getViewMatrix()
    {
    	return ViewMatrix;
    }



    展开全文
  • qt opengl 键盘前后左右输入移动场景,10立方体,键盘控制远近距离。
  • opengl键盘控制旋转

    2012-06-25 18:16:26
    课程设计作业,键盘控制长方体旋转,每个面帖有不同的图。
  • opengl键盘控制一

    千次阅读 2014-08-29 11:58:58
    windows键值表
  • 绘制的雪人是动态旋转效果,可以依据键盘响应事件,将动画效果做出改变,该实验内容中,按‘a’键可以绕y轴旋转,按‘d’键可以绕z轴旋转,按‘s’轴可以绕x轴旋转,按‘w’键可以进行光照渲染,按‘q’键...
  • 这个函数可以用来处理键盘上可以用ascii码表示的键按下的事件,key就是这个键ascii码,x和y则是键摁下时鼠标相对于窗口左上角的位置。 4. void glutSpecialFunc(void (*func)(int key,int x,int y)) 这个函数是...
  • 键盘控制:1控制是否用显示列表绘制,并比较两种绘制方式效率差别2按键控制桌子的显示和消失 对各个物体分别用显示列表进行绘制,重复上面的交互控制。 增加键盘按键来切换显示列表和非显示列表绘制方式,通过动画...
  • openGL键盘控制三角形旋转

    千次阅读 2018-02-10 15:48:09
    #include "stdafx.h"#include&lt;Windows.h&gt;#include"gl.h"#include"glut.h"//确定多边形绕法bool bWinding = TRUE;//旋转参数static GLfloat xRot = 0.0f;...
  • OpenGL(十六) 鼠标、键盘交互响应事件

    万次阅读 多人点赞 2016-11-18 22:56:40
    OpenGL中通过鼠标和键盘跟程序交互的实现需要实现注册鼠标和键盘响应事件,在一定条件下,该事件被触发,事件里的程序被执行,达到交互的目的。 通过glutMouseFunc(&OnMouse)注册鼠标事件,OnMouse是鼠标事件的...
  • OpenGL键盘操作和动画

    千次阅读 2011-05-20 11:33:00
    前面三篇文章已经把OPENGL的编程基本结构描述完毕。以后会在这个基础上逐渐深化,不断增添新内容。这一篇是讲述 键盘操作和动画基础(实际还差的远哪)。只是个简单的能由用户控制的动画,让物体前后移动,...
  • QT键盘事件 立体图形的放大和缩小 上下左右键以及A键D争键控制x y z 轴旋转速度的快慢 开灯关灯以及矢量的实现原理概要多篇讲QT5 opengl的文章,从简单到复杂,几乎每篇都在原来的基友上有所增加新的内容, 感觉越到...
  • 【一步步学OpenGL 14】 -《相机控制1(键盘事件)》

    千次阅读 热门讨论 2016-09-28 15:09:23
    教程14相机控制1(键盘事件)原文: http://ogldev.atspace.co.uk/www/tutorial14/tutorial14.html背景在之前的教程中我们学习了如何将相机至于3d世界的任意一个位置,下一步就要实现让用户来控制它。移动应该是不受...
  • Opengl事件及回调函数

    2015-06-07 19:54:15
    Opengl中的事件事件循环,回调函数的介绍,包括鼠标回调函数和键盘回调函数
  • opengl鼠标和键盘交互

    2014-06-02 21:43:50
    opengl实现鼠标和键盘交互,关键是掌握那两个函数,也可以通过MFC实现
  • http://blog.csdn.net/yulinxx/article/details/59538755在上篇的基础上,添加键盘的控制,实现物体的缩放,平移,旋转操作 分析: 放大: 当摄像机沿Z轴靠近物体,则物体显示会变大,反之则小 左右平移: 摄像机往左移,则...
  • OpenGL】-009 GLUT中处理键盘鼠标事件   键盘和鼠标是GUI程序获取用户输入的重要方式,在windows程序中,通过WM_KEY_DOWN/WM_KEY_UP/WM_LBUTTONDOWN/WM_RBUTTONDOWN等消息的响应,用户可以方便的处理键盘鼠标的...
  • * Phase 07 - Create an OpenGL Context. * * The main goal of this phase is to see if it makes sense to structure the Xlib * code without the OpenGL code, or if they are married together. * *...
  • //键盘事件 void keyboard(unsigned char c,int x,int y){ if(c==27){ exit(0); } } void render(void){ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBegin(GL_TRIANGLES); //分别设置三点的...
  • 我需要从glut OpenGL中的图像执行像素操作(我知道它很旧,但是我受许多其他原因的束缚)。 我需要多次更改图像,同时还要显示它们。 我正在尝试使用键事件来执行该操作。 另外,我正在使用SOIL库加载我的...
  • 1 成功调研不能省略 b在字母字符前 def MYkeyboard(key, x, y):  if key in ( b 'Y', b 'y'):   print("UP-y, Left-x Camera\n") ... glutSpecialFunc(MYkeyboard) 对应键盘上的方向键 和功能键F1~F0
  • opengl光照和键盘响应

    2015-06-01 17:04:50
    opengl进行光照,通过键盘控制光照的开启和关闭,以及关照物体的位置等。并且通过键盘按键,动态切换三种模式的贴图纹理,线性、最简以及mipmapped
  • opengl通过键盘对3d图像进行颜色,光照,旋转等变化,VS2013上可运行,opengl通过键盘对3d图像进行颜色,光照,旋转等变化,opengl通过键盘对3d图像进行颜色,光照,旋转等变化,opengl通过键盘对3d图像进行颜色,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,278
精华内容 6,911
关键字:

opengl键盘事件