精华内容
下载资源
问答
  • OpenGL 键盘控制移动

    2011-11-30 18:47:10
    计算机图形学 实验三 OpenGL 键盘控制 移动
  • 基于OpenGL键盘点击移动视点观察场景,通过键盘点击来控制摄像机的上下左右移动,从而可以从多个视角来查看场景
  • qt opengl 键盘前后左右输入移动场景,10立方体,键盘控制远近距离。
  • OPENGL鼠标键盘移动3d物体

    热门讨论 2013-04-07 10:38:25
    OPENGL鼠标键盘移动3d物体 void CCY457OpenGLView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) { // TODO: Add your message handler code here and/or call default switch (nChar) { case VK_UP: m_...
  • 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 绘图移动

    2019-05-19 09:18:31
    在上一篇OpenGL 环境搭建基础上修改main.cpp文件,完成使用OpenGL图片绘制和移动效果。 代码 详细代码已做注释: #include "GLShaderManager.h" #include "GLTools.h" #include <GLUT/GLUT.h> //着色管理器 ...

    前言

    在上一篇OpenGL 环境搭建基础上修改main.cpp文件,完成使用OpenGL图片绘制和移动效果。

    代码

    详细代码已做注释:

    
    #include "GLShaderManager.h"
    #include "GLTools.h"
    #include <GLUT/GLUT.h>
    
    //着色管理器
    GLShaderManager shaderManager;
    
    //批次容器
    GLBatch quadsBatch;
    
    //矩形坐标长度
    GLfloat blockSize = 0.1f;
    
    //顶点坐标
    GLfloat vVerts[] = {
        -blockSize,-blockSize,0.0f,
        blockSize,-blockSize,0.0f,
        blockSize,blockSize,0.0f,
        -blockSize,blockSize,0.0f
    };
    
    //窗口大小修改回调
    void changeSize(int w, int h) {
        glViewport(0, 0, w, h);
    }
    
    //区域渲染
    void renderScene(void) {
        //清除一个缓存区
        glClear(GL_COLOR_BUFFER_BIT);
        
        GLfloat vBlue[] = {0.0,0.0,1.0,1.0f};
        //使用着色器渲染
        shaderManager.UseStockShader(GLT_SHADER_IDENTITY,vBlue);
        quadsBatch.Draw();
        //后台缓冲区渲染完毕后交给前台显示
        glutSwapBuffers();
        
    }
    
    //初始化
    void setupRC() {
        glClearColor(0.5f, 0.5f, 0.5f, 0.5f);
        shaderManager.InitializeStockShaders();
        quadsBatch.Begin(GL_QUADS, 4);
        quadsBatch.CopyVertexData3f(vVerts);
        quadsBatch.End();
    }
    
    //处理键盘控制图形移动
    void specialKeys(int key, int x, int y) {
        
        GLfloat stepSize = 0.01f;
        
        GLfloat blockX = vVerts[0];
        GLfloat blockY = vVerts[10];
        
        if (key == GLUT_KEY_UP) {
            
            blockY += stepSize;
        }
        
        if (key == GLUT_KEY_DOWN) {
            
            blockY -= stepSize;
        }
        
        if (key == GLUT_KEY_LEFT) {
            blockX -= stepSize;
        }
        
        if (key == GLUT_KEY_RIGHT) {
            blockX += stepSize;
        }
        
        if (blockX < -1.0f) {
            blockX = -1.0f;
        }
        
        if (blockX > (1.0 - blockSize * 2)) {
            blockX = 1.0f - blockSize * 2;
        }
        
        if (blockY < -1.0f + blockSize * 2 ) {
            
            blockY = -1.0f + blockSize * 2;
        }
        
        if (blockY > 1.0f) {
            
            blockY = 1.0f;
            
        }
        
        //处理顶点
        vVerts[0] = blockX;
        vVerts[1] = blockY - blockSize*2;
        
        vVerts[3] = blockX + blockSize*2;
        vVerts[4] = blockY - blockSize*2;
        
        vVerts[6] = blockX + blockSize*2;
        vVerts[7] = blockY;
        
        vVerts[9] = blockX;
        vVerts[10] = blockY;
        
        quadsBatch.CopyVertexData3f(vVerts);
        glutPostRedisplay();
    }
    
    
    int main(int argc, char *argv[]) {
        //设置工作目录
        gltSetWorkingDirectory(argv[0]);
        //初始化glut库
        glutInit(&argc, argv);
        //初始化一个双缓冲区,离屏区渲染,窗口区显示
        glutInitDisplayMode(GLUT_DOUBLE);
        glutInitWindowSize(600, 600);
        glutCreateWindow("dowZhange");
        
        //注册重塑函数
        glutReshapeFunc(changeSize);
        //注册显示函数
        glutDisplayFunc(renderScene);
        
        glutSpecialFunc(specialKeys);
        
        //用于检查OpenGL API对程序可用
        GLenum status = glewInit();
        
        if (GLEW_OK != status) {
            return 1;
        }
        
        setupRC();
        glutMainLoop();
        
        return 0;
    }
    
    复制代码

    转载于:https://juejin.im/post/5ce11e0bf265da1ba647bcd6

    展开全文
  • 在模型变换实验的基础上,通过实现下述实验内容,掌握OpenGL中三维观察、透视投影、正交投影的参数设置,并能使用键盘移动观察相机,在透视投影和正交投影间切换,验证课程中三维观察的内容; 进一步加深对OpenGL三...
  • OpenGL绘制移动机械臂,定时器定时刷新画面,键盘控制关节运动。
  • OpenGL键盘操作和动画

    千次阅读 2011-05-20 11:33:00
    前面三篇文章已经把OPENGL的编程基本结构描述完毕。以后会在这个基础上逐渐深化,不断增添新内容。这一篇是讲述 键盘操作和动画基础(实际还差的远哪)。只是个简单的能由用户控制的动画,让物体前后移动,...

    	前面三篇文章已经把OPENGL的编程基本结构描述完毕。以后会在这个基础上逐渐深化,不断增添新内容。这一篇是讲述
    键盘操作和动画基础(实际还差的远哪)。只是个简单的能由用户控制的动画,让物体前后移动,左右旋转。是我们自
    己的第一个QUAKE!当然这个版本谁买谁上当,呵呵。
    	这篇的另一个目的就是加深前面对于CALLBACK函数的认识以及对于变换的直观解释,任何变换你都可以从屏幕上通过自
    己的操作看出来:
    我只把和以前变化的部分标记中文解释
    
    
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glaux.h>
    
    #pragma comment(lib, "OpenGl32.lib")
    #pragma comment(lib, "glu32.lib")
    #pragma comment(lib, "glaux.lib")
    
    #pragma warning(disable : 4244)		// MIPS
    #pragma warning(disable : 4136)		// X86
    #pragma warning(disable : 4051)		// ALPHA
    
    void myinit(void);
    void CALLBACK  display(void);
    void CALLBACK  reshape(GLsizei w,GLsizei h);
    
    //注意到乐吗?这里新加乐4个CALLBACK函数
    //类似display() reshape(),也由主函数调用它们
    //实现对键盘输入的响应
    void CALLBACK  left(void);//按 LEFT
    void CALLBACK  right(void);//按 RIGHT
    void CALLBACK  up(void);//按 UP
    void CALLBACK  down(void);//按 DOWN
    
    //两个全局变量,z_motion用来控制物体远近
    //rotate用来控制物体旋转
    static int z_motion=0,rotate=0;
    
    void myinit(void)
    {
        	auxInitDisplayMode(AUX_SINGLE | AUX_RGBA);
            auxInitPosition(0,0,500,500);
            auxInitWindow("sample1");
            glClearColor(0.0,0.0,0.0,0.0);
            glClear(GL_COLOR_BUFFER_BIT);
    }
    
    void CALLBACK reshape(GLsizei w,GLsizei h)
    {
    	if(w<=500&&h<=500)
    		glViewport(0,0,w,h);
    	if(w>500&&h<=500)
    		glViewport(0,0,500,h);
    	if(w<=500&&h>500)
    		glViewport(0,0,w,500);
    	if(w>500&&h>500)
    		glViewport(0,0,500,500);
    
    
    	glMatrixMode(GL_PROJECTION);
    	glLoadIdentity();
    ///*if(w<=h)
    // glOrtho(-20.0,20.0,-20.0*(GLfloat)h/(GLfloat)w,
    //         20.0*(GLfloat)h/(GLfloat)w,-50.0,50.0);
    //else
    //  glOrtho(-20.0*(GLfloat)h/(GLfloat)w,
    //         20.0*(GLfloat)h/(GLfloat)w,-20.0,20.0,-50.0,50.0);
    //*/
    /************************************************************/
    //这里我们换一种投影方法:透射投影,有立体感的说
    //取代上次的平行投影。前4个参数是控制第一个截取面的
    //left right top bottom,然后两个参数控制近截取面的
    //Z坐标,远截取面的Z作标,函数声名如下:
    //void glFrustum(GLdouble left,GLdouble right,
    //               GLdouble bottom,GLdouble top,
    //               GLdouble near,GLdouble far);
    /************************************************************/
    	glFrustum(-20.0,20.0,-20.0,20.0,10.0,50.0);
    	glMatrixMode(GL_MODELVIEW);
    	glLoadIdentity();
    }
    
    void draw(void)
    {
    	glBegin(GL_TRIANGLE_STRIP);
    	glColor3f(1.0,0.0,0.0);
    	glVertex3f(15.0,0.0,0.0);
    	glColor3f(0.0,1.0,0.0);
    	glVertex3f(-15.0,0.0,0.0);
    	glColor3f(0.0,0.0,1.0);
    	glVertex3f(0.0,15.0,15.0);
    //
    	glColor3f(0.0,1.0,1.0);
    	glVertex3f(10.0,15.0,-15.0);
    //
    	glColor3f(1.0,1.0,0.0);
    	glVertex3f(15.0,0.0,0.0);
    //
    	glEnd();
    }
    
    void CALLBACK display(void)
    {
    	glClearColor(0.0,0.0,0.0,1.0);
    	glClear(GL_COLOR_BUFFER_BIT);
    
    //glPushMatrix();
    	glLoadIdentity();
    
    //根据z_motion rotate两个参数确定变换的具体数值:
    //z_motion改变时,物体从原Z坐标-25,平移z_motion个单位
    	glTranslatef(0.0,0.0,-25.0+z_motion);
    //rotate改变时,物体延Y轴(上下方向)旋转5*rotate度
    	glRotatef(rotate*5.0,0.0,1.0,0.0);
    
    	draw();
    //glPopMatrix();
    
    	glFlush();
    }
    void CALLBACK left(void)
    {
    //每当按下LEFT,rotate数值 +1
    //以下函数都类似
    	rotate++;
    }
    void CALLBACK right(void)
    {
    	rotate--;
    }
    void CALLBACK up(void)
    {
    	z_motion++;
    }
    void CALLBACK down(void)
    {
    z_motion--;
    }
    void main(void)
    {
            myinit();
    
    //用辅助库的函数调用把left() right() up() down()
    //设为标准键盘输入处理函数
        auxKeyFunc(AUX_LEFT,left);
        auxKeyFunc(AUX_RIGHT,right);
        auxKeyFunc(AUX_UP,up);
        auxKeyFunc(AUX_DOWN,down);
    
        auxReshapeFunc(reshape);
        auxMainLoop(display);
    }
    //end of sample
    
    如果运行这个程序会发现有较明显的闪烁感,这是单缓存模式
    造成的以后会讲到动画应采用双缓存模式,这样可以避免闪烁

    展开全文
  • OpenGL实现物体移动

    2015-05-23 20:54:54
    OpenGL super Bible(5th)中提供的API实现物体的移动,可以用键盘按键移动或旋转物体
  • http://blog.csdn.net/yulinxx/article/details/59538755在上篇的基础上,添加键盘的控制,实现物体的缩放,平移,旋转操作 分析: 放大: 当摄像机沿Z轴靠近物体,则物体显示会变大,反之则小 左右平移: 摄像机往左移,则...

    http://blog.csdn.net/yulinxx/article/details/59538755

    在上篇的基础上,添加键盘的控制,实现物体的缩放,平移,旋转操作

    这里写图片描述

    这里写图片描述
    分析:
    放大: 当摄像机沿Z轴靠近物体,则物体显示会变大,反之则小
    左右平移: 摄像机往左移,则看到的物体往右移
    旋转: 以相机到物体的距离为半径进行旋转
    当旋转后,再平移,比如相机到了b位置,再平移,以绿线为向量进行平移. 已知相机到物体的向量,已知相机的向上up向量0,1,0,可以叉乘得到垂直的绿线向量,再以此向量进行平移即可.
    旋转后的放大缩小,则以相机到物体的向量进行平移.
    代码如下:
    定义两个全局变量:
    glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f); // 相机位置
    glm::vec3 cameraTarg = glm::vec3(0.0f, 0.0f, 0.0f); // 物体位置

    WSAD移动相机, QE旋转相机,X还原视图

    这里写图片描述

    #define GLEW_STATIC
    #include <GL/glew.h>
    
    #include <GLFW/glfw3.h>
    
    #include <glm/glm.hpp>
    #include <glm/gtc/matrix_transform.hpp>
    #include <glm/gtc/type_ptr.hpp>
    
    #include <SOIL/SOIL.h>
    
    #include "Shader.h"
    
    #pragma comment(lib, "SOIL.lib")
    
    #pragma comment (lib, "opengl32.lib")
    #pragma comment (lib, "glew32s.lib")
    #pragma comment (lib, "glfw3.lib") 
    #pragma comment (lib, "glfw3dll.lib") 
    #pragma comment (lib, "glew32mxs.lib")
    #pragma comment (lib, "assimp.lib")
    
    #define  WIDTH 800
    #define  HEIGH 600
    
    
    GLfloat g_nX = 0;
    GLfloat g_nY = 0;
    GLfloat g_nZ = 0;
    
    glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
    glm::vec3 cameraTarg = glm::vec3(0.0f, 0.0f, 0.0f);
    
    //glm::mat4 view;           // 视图矩阵
    GLfloat fRotateAngle = 0.0f;
    
    void keyFun(GLFWwindow* pWnd, int nKey, int nScanCode, int nAction, int nMode);
    
    int main()
    {
        glfwInit();
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
        glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    
        GLFWwindow* pWnd = glfwCreateWindow(WIDTH, HEIGH, "OGL Geometry Shader", nullptr, nullptr);
        glfwMakeContextCurrent(pWnd);
    
        glfwSetKeyCallback(pWnd, keyFun);
    
        glewExperimental = GL_TRUE;
    
        glewInit();
    
        glViewport(0, 0, WIDTH, HEIGH); 
    
        GLfloat fPoint[] = {
            0.0f, 0.0f, 0.0f,       1.0f, 0.0f, 0.0f,
            0.5f, -0.6f, 0.0f,      0.0f, 1.0f, 0.0f,
            0.5f, 0.5f, 0.0f,       0.0f, 0.0f, 1.0f,
            -0.5f, 0.6f, 0.0f,      0.0f, 1.0f, 1.0f,
            -0.2f, -0.5f, 0.0f, 0.0f, 0.4f, 1.0f,
            - 0.8f, 0.3f, 0.0f,     1.0f, 0.30f, 1.0f   };
    
        GLuint nVAO, nVBO;
        glGenVertexArrays(1, &nVAO);
        glBindVertexArray(nVAO);
        {
            glGenBuffers(1, &nVBO);
            glBindBuffer(GL_ARRAY_BUFFER, nVBO);
            {
                glBufferData(GL_ARRAY_BUFFER, sizeof(fPoint), fPoint, GL_STATIC_DRAW);
    
                glEnableVertexAttribArray(0);   // vertex
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6* sizeof(GLfloat), (GLvoid*)0);
    
                glEnableVertexAttribArray(1);   // color
                glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6* sizeof(GLfloat), (GLvoid*)(3 * sizeof(GL_FLOAT)));
            }
            glBindBuffer(GL_ARRAY_BUFFER, 0);
        }
        glBindVertexArray(0);
    
        glEnable(GL_PROGRAM_POINT_SIZE);
    
        //Shader shader("./Shader/vertex.vx", "./Shader/geo.geo", "./Shader/frag.fg");
        Shader shader("./Shader/vertex.vx", "./Shader/frag.fg");
        shader.userShaderProg();
    
        glm::mat4 model;        // 模型矩阵
        glm::mat4 view;         // 视图矩阵
        // 后移(观察点与物体在同一平面)  否则无法显示物体
        view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f));
    
        // 投影矩阵                 视角      宽高比                     近        远截面
        glm::mat4 proj = glm::perspective(45.0f, GLfloat(WIDTH / HEIGH), 0.1f, 100.0f);
    
        // 获取Shader中 uniform 变量位置
        GLint nModelLoc = glGetUniformLocation(shader.getProg(), "model");
        GLint nViewLoc = glGetUniformLocation(shader.getProg(), "view");
        GLint nProjLoc = glGetUniformLocation(shader.getProg(), "projection");  
        // 将矩阵传至Shader
        glUniformMatrix4fv(nModelLoc, 1, GL_FALSE, glm::value_ptr(model));
        glUniformMatrix4fv(nViewLoc, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(nProjLoc, 1, GL_FALSE, glm::value_ptr(proj));
    
        GLfloat radius = 6.0f;
    
        while (!glfwWindowShouldClose(pWnd))
        {
            glfwPollEvents();
    
            glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
            glClear(GL_COLOR_BUFFER_BIT);
    
            GLfloat camX = sin(glfwGetTime()) * radius;
            GLfloat camZ = cos(glfwGetTime()) * radius;
    
            view = glm::lookAt(cameraPos, cameraTarg, glm::vec3(0.0, 1.0, 0.0));
            glUniformMatrix4fv(nViewLoc, 1, GL_FALSE, glm::value_ptr(view));
    
            glBindVertexArray(nVAO);
            {
                //glDrawArrays(GL_TRIANGLES, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
                //glDrawArrays(GL_POINTS, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
                glDrawArrays(GL_LINE_STRIP, 0, sizeof(fPoint) / sizeof(GLfloat) / 6);
            }
            glBindVertexArray(0);
    
            glfwSwapBuffers(pWnd);
        }
    
        return 0;
    }
    
    
    void keyFun(GLFWwindow* pWnd, int nKey, int nScanCode, int nAction, int nMode)
    {
        if (nAction == GLFW_PRESS)
        {
            if (nKey == GLFW_KEY_W )
            {
                // 物体到相机的单位向量
                glm::vec3 direction = glm::normalize(cameraTarg - cameraPos);
                direction *= 0.2;   // 移动0.2个单位向量
                cameraPos += direction;
            }
            else if (nKey == GLFW_KEY_S)
            {
                glm::vec3 direction = glm::normalize(cameraTarg - cameraPos);
                direction *= 0.2;
                cameraPos -= direction;
            }
            else if (nKey == GLFW_KEY_A)
            {
                // 物体到相机的单位向量
                glm::vec3 direction = glm::normalize(cameraTarg - cameraPos);
                // 物体到相机的单位向量 与 相机的向上向量相乘,得到垂直向量,即平移向量
                glm::vec3 vertical = glm::normalize(glm::cross(direction, glm::vec3(0.0f, 1.0f, 0.0f)));
                vertical *= 0.2;
                cameraPos += vertical;  // 移动相机位置
                cameraTarg += vertical; //相机的指向位置也一起平衡(不平移则以原来的目标转圈)
    
            }
            else if (nKey == GLFW_KEY_D)
            {
                glm::vec3 direction = glm::normalize(cameraTarg - cameraPos);
                glm::vec3 vertical = glm::normalize(glm::cross(direction, glm::vec3(0.0f, 1.0f, 0.0f)));
                vertical *= 0.2;
                cameraPos -= vertical;
                cameraTarg -= vertical;
            }
            else if (nKey == GLFW_KEY_Q)
            {
                GLfloat radius = glm::distance(cameraPos, cameraTarg);
                fRotateAngle += 0.2;
    
                GLfloat camX = sin(fRotateAngle) * radius + cameraTarg.x;
                GLfloat camZ = cos(fRotateAngle) * radius + cameraTarg.z;
    
                cameraPos =  glm::vec3(camX, 0.0, camZ);
            }
            else if (nKey == GLFW_KEY_E)
            {
                GLfloat radius = glm::distance(cameraPos, cameraTarg);
                fRotateAngle -= 0.2;
    
                GLfloat camX = sin(fRotateAngle) * radius + cameraTarg.x;
                GLfloat camZ = cos(fRotateAngle) * radius + cameraTarg.z;
    
                cameraPos = glm::vec3(camX, 0.0, camZ);
            }
            else if (nKey == GLFW_KEY_X)    // 还原视图
            {
                cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
                cameraTarg = glm::vec3(0.0f, 0.0f, 0.0f);
            }
        }
    }

    这里写图片描述

    源码下载:
    http://download.csdn.net/detail/yulinxx/9769945

    展开全文
  • 这一篇是讲述键盘操作和动画基础(实际还差的远哪)。只是个简单的能由用户控制的动画,让物体前后移动,左右旋转。是我们自己的第一个QUAKE!当然这个版本谁买谁上当,呵呵。 这篇的另一个目的就是加深前面对于...
  • 一、控制相机的视角 //禁用光标 glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); ...glfwSetCursorPosCallback(window, mouse_callback); void mouse_callback(GLFWwindow* window, double xpos, double...
  • 1、键盘控制摄像机自由移动; 2、鼠标控制摄像机旋转; 3、鼠标滚轮放大缩小视野。 二、程序运行结果 三、自由移动 view = lookAt(cameraPos, cameraPos + cameraFront, cameraUp) cameraPos为摄像机位置 cameraPos...
  • OpenGL利用键盘控制模型旋转

    千次阅读 2017-04-27 16:35:58
    之前用OpenGL完成了STL模型的读入和显示,并且使用了旋转函数,将模型进行旋转显示。之后考虑通过键盘对模型进行旋转控制,能够更好的显示模型的整个细节。 首先定义键盘控制函数:void SpecialKeys(int key, int x...
  • OpenGL键盘操作和动画基础(转)

    千次阅读 2007-10-08 11:27:00
    这一篇是讲述键盘操作和动画基础(实际还差的远哪)。只是个简单的能由用户控制的动画,让物体前后移动,左右旋转。是我们自己的第一个QUAKE!当然这个版本谁买谁上当,呵呵。 这篇的另一个目的就是加深前面对于...
  • opengl太阳系 地球月亮太阳 贴图 比较简单的太阳系制作,在MFC下
  • 创建一个单文档结构的MFC程序, 绘制XYZ轴,并能通过鼠标键盘进行控制,缩放,旋转,移动...窗口大小改变,图形也保持不变形
  • http://www.cnblogs.com/tiandsp/archive/2012/01/23/2329049.html #include // Windows的头文件 #include #include // OpenGL32库的头文件 #include // GLu32库的头文件 #include // GLaux库的头文件 //#in
  • from OpenGL.GL import * from OpenGL.GLU import * from OpenGL.GLUT import * angle = 0 move = 0 size = 1 def perp(): glClearColor(0.0, 0.0, 0.0,0.0) glClear(GL_COLOR_BUFFER_BIT) glMatrixMode(GL_...
  • 适合初学者,赚点积分,计算机图形学实验课完全自学,不容易啊QAQ
  • 实验三 OpenGL键盘交互绘制 二、实验内容 1.调出实验一的源代码运行,调整修改是的显示窗口在屏幕中央保持默认大小(300*300),绘制的矩形在显示窗口中央 2.在实验一的基础上添加键盘交互,按W键绘制的矩形上移,...
  • //响应键盘 glutMainLoop(); return 0; }  参考 http://blog.csdn.net/iaccepted/article/details/43802347   绕y轴旋转   #ifndef GLUT_DISABLE_ATEXIT_HACK #define GLUT_DISABLE_ATEXIT_HACK #...
  • 整体和绘制三角形流程差不多,只是自定义里面的函数实现是有差距的,正方形移动多了个特殊函数的注册,这个函数就是用来实现正方形根据键盘移动相对应顶点数据的更改。 这里要特别说明一下,以上是我们代码在main...
  • 学习书籍: OpenGL 超级...上一节我们学了如何在窗口上渲染一个三角形,这节我们在此基础上加入图形的移动,并且图形从三角形变成矩形。 画矩形 上一节我们设置三角形数据代码如下: //开始构建批次,GL_TRIANGLES ...
  • 一个关于opengl摄像机移动的demo.......................................
  • http://www.cnblogs.com/tiandsp/archive/2012/01/23/2329049.html
  • 计算机图形学OpenGL  — —键盘控制三维汽车  最终实现效果:        源代码: #includ
  • 键盘按上下左右键,实现让图形可以上下左右移动。用VS2017+opengl工具包环境,有效可用,基础可参考学习
  • VC OpenGL仿摄像头视角移动动画源码演示,也就是模拟出的动态效果,用键盘可控制摄像头的运动和角度改变,可看到雷达视角的改变,类似漫游的效果。本实例源码重点是展示OpenGL的使用以及效果演示,这种技术广泛应用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,143
精华内容 3,257
关键字:

opengl键盘移动