{"id":884,"date":"2009-09-23T18:30:00","date_gmt":"2009-09-23T17:30:00","guid":{"rendered":"http:\/\/it4bus.vn\/itersdesktop\/2009\/09\/23\/interaction-with-mouse-in-opengl-part-2\/"},"modified":"2013-12-01T01:31:12","modified_gmt":"2013-12-01T00:31:12","slug":"interaction-with-mouse-in-opengl-part-2","status":"publish","type":"post","link":"https:\/\/www.itersdesktop.com\/fr\/2009\/09\/23\/interaction-with-mouse-in-opengl-part-2\/","title":{"rendered":"Interaction with Mouse in OpenGL (Part 2)"},"content":{"rendered":"

In fact, transformations are relative to the object. You need to keep track of your transforms and move things as appropriate for the current state of the model view matrix. Everything is relative, so it doesn’t really make sense to talk about absolute position in this way. You can try glPushMatrix(), glLoadIdentity(), glTranslatef(0.1f0, 0.2f0, 0.0f0), draw-gl-scene, and glPopMatrix(), which may or may not be what you actually want to do.<\/p>\n

Moving selected objects in OpenGL<\/span>
\nWhat you need to do is check whenever the mouse is moved AND<\/span> if the player is holding the button you use to move objects. You also need to check if the user has already clicked on an object to move and is then holding the mouse to move it.<\/p>\n

Here’s the steps:
\n1. User mouse clicks down on object
\n2. Call function with mouse down
\n3. User keeps mouse held down and moves mouse
\n4. Call function with mouse motion
\n5. User stops holding mouse down
\n6. Call function with mouse up<\/p>\n

void reshape(int w, int h) {
\nglViewport(0, 0, (GLint) w, (GLint) h);
\nglMatrixMode(GL_PROJECTION);
\nglLoadIdentity();
\nif ( h==0 )
\ngluPerspective(45, (GLdouble)w, 1.0, 2000.0);
\nelse
\ngluPerspective(45, (GLdouble)w\/ (GLdouble)h, 1.0, 2000.0);<\/p>\n

glMatrixMode(GL_MODELVIEW);
\nglLoadIdentity();
\n}<\/p>\n

void mouse ( int button, int state, int x, int y) {
\nif (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
\n{
\nmoving = 1;
\nstartx = x;
\nstarty = y;
\n}
\nif ( button == GLUT_LEFT_BUTTON && state == GLUT_UP )
\nmoving = 0;<\/p>\n

if ( button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN )
\n{
\nmoving = 2;
\nstarty = y;
\n}
\nif ( button == GLUT_RIGHT_BUTTON && state == GLUT_UP )
\nmoving = 0;
\n}<\/p>\n

void motion ( int x, int y )
\n{
\nif ( moving == 1 )
\n{
\nangle = angle + ( x – startx );
\nangle2 = angle2 + ( y – starty );
\nstartx = x;
\nstarty = y;
\nglutPostRedisplay ( );
\n}
\nif ( moving == 2 )
\n{
\nzoom = zoom + ( y – starty );
\nstarty = y;
\nglutPostRedisplay ( );
\n}
\n}<\/p>\n

And make sure you call
\nglutMouseFunc ( mouse );
\nglutMotionFunc ( motion );<\/p>\n

after init() in your main loop<\/p>\n

And needed global variables<\/p>\n

float angle, angle2, cloud_rot;
\nfloat zoom = -25.50;<\/p>\n

int moving, startx, starty;<\/p>\n

See more here<\/a><\/p>\n

Drag Mouse to move Objects<\/span>
\nAccording to the docs, the mouse state has to be checkd like this:
\nUint8 ms;
\nms = SDL_GetMouseState(&x, &y);
\nif(ms & SDL_BUTTON(SDL_BUTTON_LEFT))
\n{
\nMouseButtonUp(x,y,LEFT);
\n}
\nelse if (ms & SDL_BUTTON(SDL_BUTTON_RIGHT))
\n{
\nMouseButtonUp(x,y,RIGHT);
\n}
\nelse if (ms & SDL_BUTTON(SDL_BUTTON_MIDDLE))
\n{
\nMouseButtonUp(x,y,MIDDLE);
\n}<\/p>\n

\/\/ my mouse event code cut from my game engine.
\n\/\/ All the game events go thru here
\nwhile ( SDL_PollEvent(&event) )
\n{
\n\/\/ Send Keyboard events to the keyboard handler
\ndone = HandleKeys(event);<\/p>\n

\/\/ Mouse events
\nint x,y;
\nswitch (event.type)
\n{
\n\/\/ A button on the mouse was pressed
\ncase SDL_MOUSEBUTTONDOWN:
\nswitch(SDL_GetMouseState(&x,&y))
\n{
\ncase SDL_BUTTON(SDL_BUTTON_LEFT):
\nMouseButtonDown(x, y, LEFT);
\nbreak;
\ncase SDL_BUTTON(SDL_BUTTON_RIGHT):
\nMouseButtonDown(x, y, RIGHT);
\nbreak;
\ncase SDL_BUTTON(SDL_BUTTON_MIDDLE):
\nMouseButtonDown(x, y, MIDDLE);
\nbreak;
\ndefault:
\nbreak;
\n}
\nbreak;<\/p>\n

\/\/ It was realeased
\ncase SDL_MOUSEBUTTONUP:
\nswitch(SDL_GetMouseState(&x, &y))
\n{
\ncase SDL_BUTTON(SDL_BUTTON_LEFT):
\nMouseButtonUp(x, y, LEFT);
\nbreak;
\ncase SDL_BUTTON(SDL_BUTTON_RIGHT):
\nMouseButtonUp(x, y, RIGHT);
\nbreak;
\ncase SDL_BUTTON(SDL_BUTTON_MIDDLE):
\nMouseButtonUp(x, y, MIDDLE);
\nbreak;
\ndefault:
\nbreak;
\n}
\nbreak;<\/p>\n

\/\/ Mouse is on the move.
\ncase SDL_MOUSEMOTION:
\nSDL_GetMouseState(&x, &y);
\nMouseMove(x, y);
\nbreak;<\/p>\n

}<\/p>\n

http:\/\/www.gamedev.net\/community\/forums\/topic.asp?topic_id=400975<\/p>\n

Getting mouse button and\/or keyboard events<\/span>
\nHi all,
\nI have a Windows program I am using for an experiment – I am recording people’s reaction times in various situations, and to control the duration of the displays people see, I increase the priority of the current process and the current thread using the Windows functions SetPriorityClass(hProcess,
\nHIGH_PRIORITY_CLASS) and SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST),
\nrespectively. Raising the priority of the current thread locks out other
\nWindows processes (so they don’t affect the timing of my displays), but it also
\nappears to lock out the keyboard and mouse, so I can’t use SDL_PollEvent() to
\nget mouse button presses or key presses. I’m wondering if there is another
\nfunction that will allow me to directly poll the mouse or check for specific key
\npresses that would not be affected by changing the priority of the thread. I
\nrealize that this might be beyond the scope of the forum, but any information
\nwould be helpful and appreciated. (I also realize that recording reaction times
\nwith a mouse or keyboard event is likely to have some built-in variability; I’m
\njust trying to minimize that variability as much as possible). Thank you in
\nadvance.<\/p>\n

Chris Dickinson
\nhttp:\/\/lists.libsdl.org\/pipermail\/sdl-libsdl.org\/2008-October\/066952.html
\nMaybe:
\nUint8* keystates = SDL_GetKeyState(0);
\n…
\nif(keystates[SDLK_SPACE])
\n{
\n\/\/ do stuff
\n}<\/p>\n

and… (from docs)
\nSDL_PumpEvents();
\nif(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1))
\nprintf(\u00ab\u00a0Mouse Button 1(left) is pressed.\\n\u00a0\u00bb);<\/p>\n

Jonny D<\/p>\n

\n

basically, if you’re just wanting a ray in the direction of the mouse click, then its pretty simple using gluUnProject.
\nbelow is a simple usage to get the ray<\/p>\n

GLdouble ray_x, ray_y, ray_z;
\nGLint viewport[4];
\nGLdouble proj[16];
\nGLdouble modelview[16];<\/p>\n

\/\/ we query OpenGL for the necessary matrices etc.
\nglGetIntegerv(GL_VIEWPORT, viewport);
\nglGetDoublev(GL_PROJECTION_MATRIX, proj);
\nglGetDoublev(GL_MODELVIEW_MATRIX, modelview);<\/p>\n

\/\/ assuming you have mouse coordinates as mouseX and mouseY
\n\/\/ gluUnproject assumes coordinates are measured from bottom of screen
\n\/\/ so we invert the mouseY you got from glut or SDL or watever
\nGLdouble _mouseY = viewport[3] – mouseY;<\/p>\n

\/\/ using 1.0 for winZ gives u a ray
\ngluUnProject(mouseX, _mouseY, 1.0f, modelview, proj, viewport, &ray_x, &ray_y, &ray_z);<\/p>\n

and there you have the ray direction coords… it isn’t normalized tho fyi.<\/p>\n

i think you can actually get the z coordinate of the object you clicked.. but i haven’t needed that yet… then you’d pass in something else as winZ, getting it from the Z-buffer… but not too sure.<\/p>\n

hope that helped.
\n—————-
\nIf you just want the 3d coordinates of the point in space the mouse is over, the following code will give you just that:<\/p>\n

GLdouble model_view[16];
\nglGetDoublev(GL_MODELVIEW_MATRIX, model_view);
\nGLdouble projection[16];
\nglGetDoublev(GL_PROJECTION_MATRIX, projection);
\nGLint viewport[4];
\nglGetIntegerv(GL_VIEWPORT, viewport);
\ndouble dx; double dy; double dz;
\nGLfloat depth[2];
\nglReadPixels (x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, depth);
\ngluUnProject(x, y, depth[0], model_view, projection, viewport, &dx, &dy, &dz);
\nx3d = float(dx);
\ny3d = float(dy);
\nz3d = float(dz);<\/p>\n

Zoom in and out a large surface<\/span>
\nThere are 2 common ways to zoom in 3D:<\/p>\n