精华内容
下载资源
问答
  • OpenGL实现鼠标旋转缩放平移操作:VS2015+OpenGL;加载OFF文件,实现鼠标旋转缩放平移操作,添加2个光源。
  • 近日,需要实现鼠标拖动模型的功能,没有在网上找到合适的源代码,就算要也是要收钱,不想承担风险浪费钱财下载下来一堆废代码,故自己尝试实现这一功能,源代码在文章里,喜欢的点个赞就行,感谢~ 实现思路 OpenGL...

    前言

    近日,需要实现鼠标拖动模型的功能,没有在网上找到合适的源代码,就算要也是要收钱,不想承担风险浪费钱财下载下来一堆废代码,故自己尝试实现这一功能,源代码在文章里,喜欢的点个赞就行,感谢~

    实现思路

    本文需要一定OpenGL基础,想学习OpenGL的同学可以参考我之前的博客。
    OpenGL中有变换矩阵可以实现模型绕某个轴进行旋转,这是基础。

    具体步骤:

    1. 获取到鼠标点击控件的坐标,设定在区域内的点击事件才有效,将点击的坐标存下来,这里涉及到将QT界面的坐标转化为OpenGL的坐标。
    void OpenGLWidget::mousePressEvent(QMouseEvent *event)
    {//单击
       QPoint p_ab = event->pos();
       if (p_ab.x()<0 || p_ab.x()>window_size.height() || p_ab.y()<0 || p_ab.y()>window_size.width())
       	return;
    
       // 如果是鼠标左键按下
       if (event->button() == Qt::LeftButton){
       	projection_use = projection_save;
       	setPressPosition(p_ab);
       }
    }
    
    void OpenGLWidget::setPressPosition(QPoint p_ab)
    {
    	translate_point(p_ab);
    	press_position = p_ab;
    }
    
    void OpenGLWidget::translate_point(QPoint &p_ab)
    {
    	int x = p_ab.x() - window_size.width() / 2;
    	int y = -(p_ab.y() - window_size.width() / 2);
    	p_ab.setX(x);
    	p_ab.setY(y);
    }
    
    1. 设置变换矩阵
    • 先计算鼠标移动的向量(将现在的坐标和之前按下鼠标存下来的坐标相减)QPoint sub_point = p_ab - press_position; ,向量的方向是鼠标移动的方向,向量的长度是移动的长度。
    • 再绕垂直于移动向量的轴旋转,旋转轴向量求法为假设轴向量为(x,y),(x,y)·(sub_point.x(),sub_point.y())=0,即可求得垂直于移动向量的旋转轴向量x/y=(–sub_point.y())/sub_point.x();
    • 再以移动向量的长度为角度,垂直方向的向量为轴,就可以旋转整个模型了projection.rotate(angle_now, -sub_point.y(), sub_point.x(), 0.0);
    void OpenGLWidget::mouseMoveEvent(QMouseEvent *event)
    {
       QPoint p_ab = event->pos();
       translate_point(p_ab);
    
       QPoint sub_point = p_ab - press_position;
    
       if (event->buttons() & Qt::LeftButton){
       	projection.setToIdentity();
       	float rate=(float)window_size.height()/(float)window_size.width();
       	projection.ortho(-1.0, 1.0, -1.0*rate, 1.0*rate, 1.0f, 100.0f);
       	// 增加了模型矩阵,需要做一定偏移量,保证物体刚开始渲染出来时可以被看到!
       	projection.translate(0.0f, 0.0f, -2.0f);
    
       	GLfloat angle_now = qSqrt(qPow(sub_point.x(), 2) + qPow(sub_point.y(), 2)) / 5;
       	projection.rotate(angle_now, -sub_point.y(), sub_point.x(), 0.0);
       	projection = projection*projection_use;
    
       	projection_save.setToIdentity();
       	projection_save.rotate(angle_now, -sub_point.y(), sub_point.x(), 0.0);
       	projection_save = projection_save*projection_use;
       }
    }
    

    TIPS:
    每次旋转最后(即将鼠标松开的时候)将变换矩阵存下来,下次在最开始旋转的时候旋转一个上次最后的旋转角度,以达到连续旋转的效果。

    展开全文
  • 我想实现鼠标左键拖动物体,但是我仿照http://blog.csdn.net/yulinxx/article/details/39256965改的代码,鼠标一点击物体就消失了, void CDrawCubeDemoView::OnLButtonDown(UINT nFlags, CPoint point) { m_...
  • OpenGL鼠标点选平移物体

    热门讨论 2012-01-03 15:41:12
    鼠标选中物体后,会出现x,y,z三个轴,点击轴可以沿着相应方向平移物体。
  • 转载:https://blog.csdn.net/trustguan/article/details/50812353
    展开全文
  • 参考文章:openGL 实现绘制、修改多边形 已经实现的功能: 1. 鼠标取点画多边形,用的自带的glBegin(GL_LINE_LOOP)方法,没有填充 2. 删除某个点 3. 拖拽某个点 4. 移动图形 5. 旋转多边形(角度>90有点...

    参考文章:openGL 实现绘制、修改多边形

    已经实现的功能:

    1. 鼠标取点画多边形,用的自带的glBegin(GL_LINE_LOOP)方法,没有填充

    2. 删除某个点

    3. 拖拽某个点

    4. 移动图形

    5. 旋转多边形(角度>90有点问题,可以改为每次转动固定的角度)

    6. 缩放多边形,基准点为极大坐标值与极小坐标值取平均(不是很严谨)

    代码:

    #include <GL/glut.h>
    #include <iostream>
    #include <vector>
    #include <cmath>
    using namespace std;
    
    struct point {
    	float x;
    	float y;
    	bool polygonStart;// 一个多边形的起始点
    };
    
    vector<point> points;
    int mode = 0;
    /*	mode
    	1:新建
    	2:删除点
    	3:移动点
    	4:移动图形
    	5:缩放-放大
    	6:旋转
        7:缩小
    */
    int flag = 0;//标记起点
    bool dragging = false;// 用于标记正在拖动
    int draggedNum = -1;// 被拖动的点的编号
    int old_x, old_y;//记录原来位置
    const double PI = atan(1.)*4.;//圆周率
    
    void myDisplay() {
    	glClearColor(0.0, 0.0, 0.0, 0.0);//设置背景色为黑色
    	glClear(GL_COLOR_BUFFER_BIT);//清除颜色缓冲区
    	glColor3f(1.0, 1.0, 1.0);// 内容显示颜色
    	for (int i = 0; i < points.size(); i++) {
    		if (points[i].polygonStart) {
    			if (i != 0) {
    				glEnd();
    			}
    			glBegin(GL_LINE_LOOP);
    			//glBegin(GL_LINE_STRIP);
    		}
    		// 注意y值的改变
    		glVertex2f(points[i].x, points[i].y);
    	}
    	//polyfill();
    	glEnd();
    	
    	glutSwapBuffers();//清空命令缓冲区并交换帧缓存:
    					//交换前后台两个缓冲区指针
    }
    
    // -1 when no points
    //找到距离最近的点
    int findNearPointNum(float x, float y) {
    	if (points.size() == 0) {
    		return -1;
    	}
    	int near = 0;
    	double min = -1;
    	for (int i = 0; i < points.size(); i++) {
    		double distence = (points[i].x - x)*(points[i].x - x) + (points[i].y - y)*(points[i].y - y);
    		if (min == -1) {
    			min = distence;
    		}
    		else if (min > distence) {
    			min = distence;
    			near = i;
    		}
    	}
    	return near;
    }
    
    //鼠标点击处理函数
    void mouse_click(int button, int state, int x, int y) {
    	y = 600 - y;
    	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {//鼠标左键按下
    		if (mode == 2) {//删除点
    			//找到距离鼠标点击位置最近的点
    			int near = findNearPointNum(x, y);
    			if (near == -1) {//不存在
    				return;
    			}
    
    			//如果是起始点,则让下一个点成为起始点
    			if (points[near].polygonStart) {
    				if (points.size() > near + 1) {
    					points[near + 1].polygonStart = true;
    				}
    			}
    
    			//删除点
    			points.erase(points.begin() + near, points.begin() + near + 1);
    			return;
    		}
    		if (mode == 3) {//移动点
    			dragging = true;
    			//找到距离最近的点
    			draggedNum = findNearPointNum(x, y);
    			return;
    		}
    
    		point t{x,y,false };
    		if (mode == 1) {//新建多边形
    			//mode=0;
    			if (flag == 0) {
    				t.polygonStart = true;//起点
    				flag = 1;
    			}
    			cout << x << " " << y << endl;
    			points.push_back(t);
    		}
    
    		if (mode == 4) {//移动多边形
    			old_x = x;
    			old_y = y;
    			
    		}
    
    		if (mode == 5) {//缩放多边形
    			old_x = x;
    			old_y = y;
    			//cout << old_x << endl << old_y << endl;
    		}
    
    		if (mode == 7) {//缩放多边形
    			old_x = x;
    			old_y = y;
    			//cout << old_x << endl << old_y << endl;
    		}
    
    		if (mode == 6) {//旋转多边形
    			old_x = x;
    			old_y = y;
    			//cout << old_x << endl << old_y << endl;
    		}
    	}
    	else if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) {//鼠标左键松开
    		if (dragging) {	
    			dragging = false;
    			if (draggedNum != -1) {
    				points[draggedNum].x = x;
    				points[draggedNum].y = y;
    				return;
    			}
    		}
    
    		if (mode == 4) {//移动多边形
    			int dx = x - old_x, dy=y - old_y;
    			cout << dx << endl << dy << endl;
    			point t{ 0,0,false };
    			for (size_t i = 0; i < points.size(); i++) {
    				t.x = points[i].x + dx;
    				t.y = points[i].y + dy;
    				t.polygonStart = points[i].polygonStart;
    				points[i] = t;
    			}
    			return;
    		}
    
    		if (mode == 7) {//缩小多边形
    			int max_x = 0, min_x = 1000, max_y = 0, min_y = 600;
    			for (size_t i = 0; i < points.size(); i++) {
    				if (points[i].x > max_x) {
    					max_x = points[i].x;
    				}
    				if (points[i].x < min_x) {
    					min_x = points[i].x;
    				}
    				if (points[i].y > max_y) {
    					max_y = points[i].y;
    				}
    				if(points[i].y < min_y) {
    					min_y = points[i].y;
    				}
    			}
    			float xr = (max_x + min_x) / 2.0, yr = (max_y + min_y) / 2.0;//基准点
    			float s = 0.5;
    
    			point t{ 0,0,false };
    			for (size_t i = 0; i < points.size(); i++) {
    				t.x = xr + (points[i].x - xr)*s;
    				t.y = xr + (points[i].y - yr)*s;
    				//t.x = xr + points[i].x + d1/2;  
    				//t.y = yr + points[i].y + d2/2;    
    				t.polygonStart = points[i].polygonStart;
    				points[i] = t;
    				//cout << "x=" << t.x << " y=" << t.y << endl;
    			}
    
    			return;
    		}
    
    		if (mode == 5) {//放大多边形
    			int max_x = 0, min_x = 1000, max_y = 0, min_y = 600;
    			for (size_t i = 0; i < points.size(); i++) {
    				if (points[i].x > max_x) {
    					max_x = points[i].x;
    				}
    				if (points[i].x < min_x) {
    					min_x = points[i].x;
    				}
    				if (points[i].y > max_y) {
    					max_y = points[i].y;
    				}
    				if (points[i].y < min_y) {
    					min_y = points[i].y;
    				}
    			}
    			float xr = (max_x + min_x) / 2.0, yr = (max_y + min_y) / 2.0;//基准点
    			float s = 2.0;
    
    			point t{ 0,0,false };
    			for (size_t i = 0; i < points.size(); i++) {
    				t.x = xr + (points[i].x - xr)*s;
    				t.y = xr + (points[i].y - yr)*s;
    				//t.x = xr + points[i].x + d1/2;  
    				//t.y = yr + points[i].y + d2/2;    
    				t.polygonStart = points[i].polygonStart;
    				points[i] = t;
    				//cout << "x=" << t.x << " y=" << t.y << endl;
    			}
    
    			return;
    		}
    
    		if (mode == 6) {//旋转多边形
    			int sumx = 0, sumy = 0;
    			for (size_t i = 0; i < points.size(); i++) {
    				sumx += points[i].x;
    				sumy += points[i].y;
    			}
    			int xr = sumx/points.size(), yr = sumy / points.size();//旋转的基准点*/
    			//int xr = 0, yr = 0;
    
    			double a1 = atan((double)(old_y - yr) / (double)(old_x - xr));
    			double a2 = atan((double)(y - yr) / (double)(x - xr));
    			double theta = a2 - a1;//旋转角度
    			/*cout << "a1=" << a1 << endl;
    			cout << "a2=" << a2 << endl;
    			cout << "theta=" << theta << endl;*/
    			
    			point t{ 0,0,false };
    			for (size_t i = 0; i < points.size(); i++) {
    				/*double tmp = theta;
    				 while(tmp - PI/2 > 1e-6) {
    					 t.x = (int)(xr - (points[i].y - yr));
    					 t.y = (int)(yr + (points[i].x - xr));
    					 points[i] = t;
    					 tmp -= PI / 2;
    				}*/
    				t.x = (int)(xr + (points[i].x - xr)*cos(theta) - (points[i].y - yr)*sin(theta));
    				t.y = (int)(yr + (points[i].x - xr)*sin(theta) + (points[i].y - yr)*cos(theta));
    				t.polygonStart = points[i].polygonStart;
    				points[i] = t;
    			}
    
    			return;
    		}
    
    		
    	}
    }
    
    //键盘按键处理函数
    void key_action(unsigned char key,int x,int y) {
    	if (key == '1') {//新建多边形
    		mode = 1;
    		flag = 0;
    	}
    	if (key == '2') {//删除点
    		mode = 2;
    	}
    	if (key == '3') {//移动点
    		mode = 3;
    	}
    	if (key == '4') {//移动图形
    		mode = 4;
    	}
    	if (key == '5') {//放大
    		mode = 5;
    	}
    	if (key == '7') {//缩小
    		mode = 7;
    	}
    	if (key == '6') {//旋转
    		mode = 6;
    	}
    	if (key == 'r') {
    		mode = 0;
    		points.clear();
    	}
    	if (key == 'q') {
    		exit(0);
    	}
    	
    }
    
    int main(int argc, char **argv) {
    	//初始化窗口
    	glutInit(&argc, argv);//初始化GLUT库,处理命令行参数
    	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);//初始化窗口的显示模式:使用RGB颜色 | 双缓冲
    	glutInitWindowPosition(100, 100);//设置窗口的位置
    	glutInitWindowSize(1000, 600);
    	glutCreateWindow("Polygon");//窗口名称
    
    	//glClearColor(0.0, 0.0, 0.0, 0.0);//设置背景色为黑色
    	glClear(GL_COLOR_BUFFER_BIT);//清除颜色缓冲区
    	//glColor3f(1.0, 1.0, 1.0);//设置像素颜色为白色
    	
    	glMatrixMode(GL_PROJECTION);
    	//glLoadIdentity();//加载单位矩阵
    
    	gluOrtho2D(0, 1000, 0, 600);//正交投影:
    	/*指的是视图范围,如果(0,200,0,200)的话就只能在第一象限显示,
    	就1/4圆,第1,3的参数是左下角坐标,第2,4的参数是右上角坐标
    	*/
    	//glViewport(0, 0, 500, 500);//设置视口大小
    
    	glutDisplayFunc(myDisplay);//设置当前窗口的显示回调函数
    	glutIdleFunc(myDisplay);//设置在程序空闲的时候就会被调用的函数
    	glutMouseFunc(mouse_click);//处理鼠标点击事件的函数
    	glutKeyboardFunc(key_action);//处理普通按键消息的函数
    	/*第一个表示按下的键的ASCII码,其余两个提供了,当键按下时当前的鼠标位置。
    	鼠标位置相对于当前客户窗口的左上角而言*/
    	
    	glutMainLoop();//启动主GLUT事件处理循环
    
    	return 0;
    }

    展开全文
  • [OpenGL]用鼠标拖拽图形移动

    千次阅读 2016-12-14 23:29:05
    使用的环境是Code::Blocks + GLUT,Code::Blocks配置GLUT实现OpenGL的教程可以看这篇: http://blog.csdn.net/yang_7_46/article/details/24674849 想要实现用鼠标拖拽使图形移动,首先需要考虑两个问题: 1....

    今天做计算机图形学实验。题目布置了写程序使图形移动,于是我就写了这个程序。

    使用的环境是Code::Blocks + GLUT,Code::Blocks配置GLUT实现OpenGL的教程可以看这篇:

    http://blog.csdn.net/yang_7_46/article/details/24674849


    想要实现用鼠标拖拽使图形移动,首先需要考虑两个问题:

    1.如何接受鼠标产生的信号。

    2.如何判断鼠标在图形内。


    解决第一个问题,只需要了解到OpenGL中的GLUT给的函数就可以。

    glutMouseFunc( (void*)Func(int button, int state, int x, int y) );
    如果没有记错,上面是这个函数的原型。其中x,y是当前鼠标指针所在的位置。

    正好利用这个信息可以得到是否在图形内。


    而获取到了这些,还需要获取鼠标的动作。OpenGL提供了两个函数。

    glutMotionFunc( (void*)func(int x, int y) );
    glutPassiveMotionFunc( (void*)func(int x, int y) );
    利用这些函数就可以解决问题了。


    而第二个问题。涉及到凸包,在一个多边形内如果判断点是否在图形内。这部分因为时间问题并没有写,所以先占个坑,回头补。

    下面实现了简略的代码。运行拖动时会出现闪屏,因为没有加缓存。

    #include <cmath>
    #include <cstdlib>
    #include <iostream>
    #include <windows.h>
    #include <GL/glut.h>
    using namespace std;
    
    GLdouble newMat[4][2] = {0,0, 100,0, 100,100, 0,100};
    const GLdouble mat[4][2] = {0,0, 100,0, 100,100, 0,100};
    
    void init() {
        glClearColor( 0.0, 0.0, 0.0, 0.0 );
        glMatrixMode( GL_PROJECTION );
        gluOrtho2D( 0.0, 800.0, 0.0, 600.0 );
    }
    bool isEqual() {
        for( int i = 0; i < 4; ++i ) {
            if( fabs( mat[i][0] - newMat[i][0] ) >= 1e-6 ) return false;
            if( fabs( mat[i][1] - newMat[i][1] ) >= 1e-6 ) return false;
        }
        return true;
    }
    void display() {
        glClear( GL_COLOR_BUFFER_BIT );
        glBegin( GL_POLYGON );
            glColor3f( 1.0, 0.0, 0.0 );
            for( int i = 0; i < 4; ++i )
                glVertex2d( mat[i][0], mat[i][1] );
        glEnd();
        glFlush();
    
        if( !isEqual() ) {
            glBegin( GL_POLYGON );
                glColor3f( 0.0, 1.0, 0.0 ); //移动后用绿色矩阵表示
                for( int i = 0; i < 4; ++i )
                    glVertex2d( newMat[i][0], newMat[i][1] );
            glEnd();
            glFlush();
        }
    }
    bool isInner( int x, int y ) {
        unsigned short int c = 0;
        if( x < newMat[0][0] ) c |= 1; c <<= 1;
        if( x > newMat[1][0] ) c |= 1; c <<= 1;
        if( y > newMat[2][1] ) c |= 1; c <<= 1;
        if( y < newMat[0][1] ) c |= 1;
        if( c == 0 ) return true;
        else return false;
    }
    void mouse_process( int button, int state, int x, int y ) {
        /*
        if( button == GLUT_LEFT_BUTTON && state == GLUT_DOWN ) {
    
        }
        */
    }
    void mouse_process_active( int x, int y ) {
        y = 600 - y; //因为获取的鼠标位置
        if( isInner( x, y ) ) {
            double avgx = ( newMat[0][0] + newMat[1][0] ) / 2.0;
            double avgy = ( newMat[0][1] + newMat[3][1] ) / 2.0;
    
            double dx = x - avgx;
            double dy = y - avgy;
            for(int i = 0; i < 4; ++i) {
                newMat[i][0] += dx;
                newMat[i][1] += dy;
    
                if( newMat[i][0] > 800) {
                    int dx = newMat[i][0] - 800;
                    for(int j = 0; j < 4; ++j)
                        newMat[j][0] -= dx;
                    MessageBox( NULL, TEXT("Coordinate out of range"), TEXT("Warning"), MB_ICONWARNING | MB_OK );
                    Sleep(1000);
                } else if( newMat[i][0] < 0 ){
                    int dx = 0 - newMat[i][0];
                    for(int j = 0; j < 4; ++j)
                        newMat[j][0] += dx;
                    MessageBox( NULL, TEXT("Coordinate out of range"), TEXT("Warning"), MB_ICONWARNING | MB_OK );
                    Sleep(1000);
                } else if( newMat[i][1] > 600 ){
                    int dy = newMat[i][1] - 600;
                    for(int j = 0; j < 4; ++j)
                        newMat[j][1] -= dy;
                    MessageBox( NULL, TEXT("Coordinate out of range"), TEXT("Warning"), MB_ICONWARNING | MB_OK );
                    Sleep(1000);
                } else if( newMat[i][1] < 0 ) {
                    int dy = 0 - newMat[i][1];
                    for(int j = 0; j < 4; ++j)
                        newMat[j][1] += dy;
                    MessageBox( NULL, TEXT("Coordinate out of range"), TEXT("Warning"), MB_ICONWARNING | MB_OK );
                    Sleep(1000);
                }
            }
            glutPostRedisplay();
        }
    }
    void mouse_process_passtive( int x, int y ) {}
    int main( int argv, char** argc ) {
        glutInit( &argv, argc );
        glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
        glutInitWindowPosition( 100, 100 );
        glutInitWindowSize( 800, 600 );
        glutCreateWindow( "Lab 3" );
        init();
    
        glutDisplayFunc( display );
        glutMouseFunc( mouse_process );
        glutMotionFunc( mouse_process_active );
        glutPassiveMotionFunc( mouse_process_passtive );
    
        glutMainLoop();
        return 0;
    }




    展开全文
  • 中键负责平移,滚轮负责缩放。 着色器部分,只包含最简单的顶点着色器和片元着色器。 本例中使用OpenGL传统管线渲染了坐标轴和屏幕文字,用于输出参考信息,确认着色器的正确性,方便初学者学习着色器。每行代码都有...
  • 使用vs2010作为平台。需要支持鼠标滚轮的GLUT和内置在系统中的OpenGL。新手作品,供初学者参考。
  • 用Qt鼠标事件实现基本几何图形的绘制,支持直线、矩形、圆形、椭圆。后期可以在此基础上进行扩展。使用QGraphics完成。 博客地址:https://blog.csdn.net/luoyayun361/article/details/93890331
  • OpenGL中先移动后旋转与先旋转后移动的最终效果是并不一定相同的,也就是说在Opengl中如果调用函数glTranslatef和函数glRotatef的次序不同,即使参数一样,效果也可能会不同。下面我们通过两段程序说明该问题。 ...
  • 如何实现opengl鼠标拖动物体平移?给个例子程序,谢谢
  • OpenGL与旋转、缩放、平移

    千次阅读 2018-05-09 10:19:19
    对于平移,很重要的一个问题是,对于眼睛在不同的位置,拖动相同的像素距离,camera的真实平移距离是多少?对于旋转,我们只考虑相对角度,平移所对应的绝对距离就是关键问题。首先要确定平移的向量transVec,也可...
  • OpenGL实现二维图的平移

    千次阅读 2016-09-08 21:48:55
    在前面的博客《OpenGL实现二维图的...在本文中,我们正好利用这个功能来实现二维图的平移。 #ifndef WIDGET_H #define WIDGET_H #include #include #include class Widget : public QGLWidget { Q_OBJECT pub
  • 并且对读入的数据进行openGL显示,可以旋转,缩放,平移。 旋转:按下鼠标左键 拖动 缩放:鼠标滚轮上下滚动 平移鼠标左键按下平移鼠标 以及一些光照控制工具栏。 另注:本代码是在 vc6.0 + intel9.0编译器下,...
  • OpenGL的glTranslatef平移变换函数详解

    千次阅读 2017-09-06 15:32:06
    glTranslated()和glTranslatef()这两个函数是定义一个平移矩阵,该矩阵与当前矩阵相乘,使后续的图形进行平移变换。 我们先看定义: void glTranslated(GLdouble x,   GLdouble y,   GLdouble z); ...
  • 2.可以平移这些区域 3.绘制完成后,可以用鼠标选中顶点并随鼠标移动而修改顶点. 4.矩形使用了橡皮框,多边形顶点的修改自定义类 效率不错,不卡,不闪. vc6,vs2008或以上都可以运行. 源代码很详细和规则,相信不让你后悔...
  • 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实现鼠标点选并旋转物体

    热门讨论 2012-01-03 15:38:51
    opengl实现鼠标点选物体,并通过鼠标移动来旋转物体。像3Dmax那样有个轨迹球,点击相应球来绕特定方向旋转。
  • 1. 鼠标显示STL三维模型; 2. 支持旋转、缩放和平移; 3. 该资源为源码,可先下载OpenGL鼠标旋转缩放及STL三维模型显示(demo.exe)预览一下,是否符合自己的要求,然后再下载
  • 读取显示stl和点云文件,鼠标拖动 任意角度旋转 背景:可能由于之前在做 读取显示stl文件和点云文件的项目时候,在各大博客网站留下了些许的踪迹。最近这一两天打开csdn的消息栏,突然发现有私信我。询问我读取stl...
  • OpenGL入门(三):图形随鼠标转动

    万次阅读 2017-03-02 21:36:42
    在屏幕上打开窗口的任务是由窗口系统,而不是OpenGL负责的,在默认情况下,视口被设置为占据打开窗口的整个像素矩形,窗口大小和设置视口大小相同。 x,y——以像素为单位,指定了视口的左下角。 width,height...
  • 二维图形学的变换-平移、旋转、缩放 OpenGL

    万次阅读 多人点赞 2016-12-14 13:34:28
    这里实现的是多点画多边形,然后把这个多边形进行二维的变换。 首先,多点画多边形,为了方便起见,我直接调用...假如我要平移a到b的位置: 那么操作就是:把这个多边形的n个顶点从一个位置移动到另外一个位置,然后
  • 利用OpenGL、VC++编写的C++,三维点云处理程序,对于学习图形学、C++... 有两个数据文件 鼠标默认操作:具体还在头文件中 中键拖动 旋转 中键+Ctrl 平移 中键+Shift 面旋 滚轮滚动 缩放 中键+Ctrl + Shift 局部放大
  • 环境:Qt5.4.2MSVC 2010 OpenGL (32-bit),QT5.5没有OpenGL(好像是吧,我试了不能用) QOpenGLWidget ,QOpenGLFunctions_1_0 旋转是按自带示例复制的 glRotatef(m_xRot / 16.0f, 1, 0, 0); glRotatef...
  • 绘制正方形、圆形、五角星三个图形,利用鼠标选中某个图形进行移动,键盘控制缩放和旋转。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 594
精华内容 237
关键字:

opengl鼠标拖动平移