All the same Lynda. Plus, personalized course recommendations tailored just for you. All the same access to your Lynda learning history and certifications. Same instructors. New platform. In our app class we have a mesh, a texture, and a shader.
A: Newer macs running OS X You may have it if you upgraded to Mavericks from a previous version of OS X, but it will not be on a new computer or a clean install of the operating system. Are you sure you want to mark all the videos in this course as unwatched?OpenGL Tutorial 18 - GLFW Mouse Input
This will not affect your course history, your reports, or your certificates of completion for this course. Type in the entry box, then click Enter to save your note. Start My Free Month. You started this assessment previously and didn't complete it.
You can pick up where you left off, or start over. Develop in-demand skills with access to thousands of expert-led courses on business, tech and creative topics.
Video: Adding mouse input. You are now leaving Lynda. To access Lynda. Visit our help center. Preview This Course. Resume Transcript Auto-Scroll. Author Pablo Colapinto. OpenGL is widely used in CAD, virtual reality, scientific visualization, and video games, where it is particularly useful for game developers who benefit from its hardware-accelerated rendering and advanced programmable pipeline.
In this course, Pablo Colapinto will show you how to render real-time content, starting with building a window for your graphics with the GFLW library. Then he'll focus on drawing in 2D and 3D with both the legacy immediate mode and the more modern method of using buffer objects. Plus, learn about texturing and lighting with the GLSL shading language, and accepting keyboard and mouse input for increased interactivity. Start accelerating your graphics with OpenGL today.
Topics include: What is OpenGL? Skill Level Intermediate. Show More Show Less. You can download Xcode for free from the Mac App Store. Make sure you open Xcode at least once before proceeding, as it needs to authenticate your administrative privileges before it finishes installing all its components.
To install brew, enter this command in terminal:. To run brew doctor, simply type:.In the previous tutorial, we dealt with capturing and processing keyboard messages.
This tutorial will deal with capturing messages sent from the mouse.
Tutorial 6 : Keyboard and Mouse
A number of activities will be discussed such as clicking of the mouse, dragging of the mouse, and the entering and exiting of the mouse from the main window. The first step we take in this tutorial is to create a global boolean variable to hold whether the left mouse button is currently down. Like the keyboard function, a mouse function needs to be created. This function must accept 4 parameters. The second parameter is also an integer which determines what state the mouse is currently in.
This obviously shows whether the button has been pressed or released. The last 2 parameters are integers indicating the coordinate at which the mouse was clicked.
This is measured in pixels and is relative to the top-left corner of the window. Note that the glutGetModifiers method can also be called in this function to determine if any modifiers are currently being held down.
The code below displays a message if the right mouse button is pressed. The code below therefore displays a message when the right mouse button is lifted along with the coordinates of the mouse at the time of the release. Our next piece of code changes the lbuttonDown variable depending on whether the left mouse button is down or up.
This variable will be used at a later stage in the tutorial. Our next mouse function is the motion function. This function must accept two integer parameters indicating the position at which the event occurred.
A motion event is triggered when a mouse button is held while moving the mouse. The code below therefore prints out a dragged message if the left mouse button is currently down. You may want to capture the motion of the mouse when a button is not held. This is useful for tracking the location of the cursor.
This can be done by using a passive mouse function. This must accepts the same parameters as above. The last mouse function that we will discuss is the entry function. This function must accept one integer parameter indicating the state of the mouse.
The code below prints out the appropriate message depending if the cursor has entered or left the window. Note that this function does not seem to work correctly under windows. In windows, it seems to only work when minimizing and maximizing the window. As with the keyboard functions, we need to let GLUT know about our mouse functions.
Upon running the program, you will be presented with a window. Moving the mouse around in the window will generate messages. Holding down the left mouse button while doing this will display a different message. Pressing and releasing the right mouse button will display more messages.
You should now be comfortable with capturing and processing messages from the mouse. This is extremely useful to know as most applications require human interaction through the use of the mouse. Please let me know of any comments you may have : Contact Me. Latest News Archive.
View Full Source. What tutorial would you like to see next?The code of tutorial The major modification is that instead of computing the MVP matrix once, we now have to do it every frame. This is just one way to do it, of course. FoV is the level of zoom. We will first recompute position, horizontalAngle, verticalAngle and FoV according to the inputs, and then compute the View and Projection matrices from position, horizontalAngle, verticalAngle and FoV. You can use glfwGetWindowSize if you want, too.
Here is an example of to cameras with the same position, the same target, but a different up:. In our case, the only constant is that the vector goes to the right of the camera is always horizontal.
You can check this by putting your arm horizontal, and looking up, down, in any direction. A useful mathematical tool makes this very easy : the cross product. Just recall the Right Hand Rule from Tutorial 3. The first vector is the thumb; the second is the index; and the result is the middle finger. The code is pretty straightforward.
The only special thing here is the deltaTime. For fun, we can also bind the wheel of the mouse to the Field Of View, so that we can have a cheap zoom :. Computing the matrices is now straightforward. We use the exact same functions than before, but with our new parameters. This can seem obvious, but this remark actually opens an opportunity for optimisation.
As a matter of fact, in a usual application, you are never inside a cube. The idea is to let the GPU check if the camera is behind, or in front of, the triangle.
The GPU computes the normal of the triangle using the cross product, remember? This comes at a cost, unfortunately : the orientation of the triangle is implicit. We will now learn how to use the mouse and the keyboard to move the camera just like in a FPS.This guide introduces the input related functions of GLFW. For details on a specific function in this category, see the Input reference. There are also guides for the other areas of GLFW. GLFW provides many kinds of input. While some can only be polled, like time, or only received via callbacks, like scrolling, many provide both callbacks and polling.
Callbacks are more work to use than polling but is less CPU intensive and guarantees that you do not miss state changes.
All input callbacks receive a window handle. By using the window user pointeryou can access non-global structures or objects from your callbacks. To get a better feel for how the various events callbacks behave, run the events test program.
It register every callback supported by GLFW and prints out all arguments provided for every event, along with time and sequence information. GLFW needs to poll the window system for events both to provide input to the application and to prove to the window system that the application hasn't locked up.
Event processing is normally done each frame after buffer swapping. Even when you have no windows, event polling needs to be done in order to receive monitor and joystick connection events. There are three functions for processing pending events.
If you only need to update the contents of the window when you receive new input, glfwWaitEvents is a better choice. It puts the thread to sleep until at least one event has been received and then processes all received events. This saves a great deal of CPU cycles and is useful for, for example, editing tools.
If you want to wait for events but have UI elements or other tasks that need periodic updates, glfwWaitEventsTimeout lets you specify a timeout.
It puts the thread to sleep until at least one event has been received, or until the specified number of seconds have elapsed. It then processes any received events. If the main thread is sleeping in glfwWaitEventsyou can wake it from another thread by posting an empty event to the event queue with glfwPostEmptyEvent. Do not assume that callbacks will only be called in response to the above functions. While it is necessary to process events in one or more of the ways above, window systems that require GLFW to register callbacks of its own can pass events to GLFW in response to many window system function calls.
GLFW will pass those events on to the application callbacks before returning. For example, on Windows the system function that glfwSetWindowSize is implemented with will send window size events directly to the event callback that every window has and that GLFW implements for its windows.
If you have set a window size callback GLFW will call it in turn with the new size before everything returns back out of the glfwSetWindowSize call. GLFW divides keyboard input into two categories; key events and character events. Key events relate to actual physical keyboard keys, whereas character events relate to the Unicode code points generated by pressing some of them. Keys and characters do not map A single key press may produce several characters, and a single character may require several keys to produce.
This may not be the case on your machine, but your users are likely not all using the same keyboard layout, input method or even operating system as you. If you wish to be notified when a physical key is pressed or released or when it repeats, set a key callback. The callback function receives the keyboard keyplatform-specific scancode, key action and modifier bits.
The scancode is unique for every key, regardless of whether it has a key token. Scancodes are platform-specific but consistent over time, so keys will have different scancodes depending on the platform but they are safe to save to disk. You can query the scancode for any named key on the current platform with glfwGetKeyScancode.
The last reported state for every named key is also saved in per-window state arrays that can be polled with glfwGetKey.It can be useful to click on, or "pick" a 3d object in our scene using the mouse cursor.
One way of doing this is to project a 3d ray from the mouse, through the camera, into the scene, and then check if that ray intersects with any objects.
This is usually called ray casting. This is an entirely mathematical exercise - we don't use any OpenGL code or draw any graphics - this means that it will apply to any 3d application the same way. The mathematical subject is usually called geometric intersection testing. With ray picking we usually simplify a scene into bounding spheres or boxes.
This makes the calculation a bit easier than testing all of the individual triangles. We don't need to create a 3d sphere out of triangles that can be rendered; we just represent the sphere as a simple function. The premise is that we have a mathematical formula for the points along a ray, and a mathematical formula for the points on a sphere. If we substitute the points on the sphere with the equation for points on a ray, then we get the intersection of points that are common to both.
Subscribe to RSS
It's interesting to do this technique now because it shows us how we can use the transformation pipeline in reverse; from 2d screen to a 3d world space by using the inverse of our matrices e. In a later tutorial we will look at an alternative technique using unique colours to determine where the mouse is hovering or clicking.
All ray casting starts with a ray. In this case it has an origin O at the position of the camera. We can do ray intersections in any space world, eye, etc.
This means that our ray origin is going to be the world x,y,z position of the camera. We are starting with mouse cursor coordinates. These are 2d, and in the viewport coordinate system. First we need to get the mouse x,y pixel coordinates. You might have set up a call-back function with e.
This gives us an x in the range of 0:width and y from height Remember that 0 is at the top of the screen here, so the y-axis direction is opposed to that in other coordinate systems. The next step is to transform it into 3d normalised device coordinates.
This should be in the ranges of x  y  and z . We have an x and y already, so we scale their range, and reverse the direction of y. We want our ray's z to point forwards - this is usually the negative z direction in OpenGL style. We can add a wjust so that we have a 4d vector. Note: we do not need to reverse perspective division here because this is a ray with no intrinsic depth.
Other tutorials on ray-casting will, incorrectly, tell you to do this. Ignore the false prophets! We would do that only in the special case of points, for certain special effects. Normally, to get into clip space from eye space we multiply the vector by a projection matrix.
We can go backwards by multiplying by the inverse of this matrix. Now, we only needed to un-project the x,y part, so let's manually set the z,w part to mean "forwards, and not a point".
Same again, to go back another step in the transformation pipeline. Remember that we manually specified a -1 for the z component, which means that our ray isn't normalised. We should do this before we use it.
This should balance the up-and-down, left-and-right, and forwards components for us. So, assuming our camera is looking directly along the -Z world axis, we should get [0,0,-1] when the mouse is in the centre of the screen, and less significant z values when the mouse moves around the screen.
This will depend on the aspect ratio, and field-of-view defined in the view and projection matrices.Hi, I am new to opengl, and I need some help with how to get keyboard and mouse input. Please somebody help. How about using the keyboard as user input to manipulate shapes in the program?
Whenever I use glutKeyboardFunc or glutSpecialFunc to do this, I get jumpy movement as these functions only call when a key is struck or when the key repeats when it is held for a while.
How do I get fluid movement out of opengl when reading from the keyboard? Use flags to determine wether a key is pressed or not, and use the keyboard function to set the flags. Originally posted by vgm2: Hi, I am new to opengl, and I need some help with how to get keyboard and mouse input.
Thanks for your reply. I would like to know if the MenuHandler function arguments are the asci values of the characters. If not could you please tell me where I can get those value?
Hi again, I think I asked the wrong question. Please if there is a way, can someone tell me? Thanks for your time. Originally posted by Hermann: One question fist: what are you using?
GLUT, win32, linux? Thanks Thanks for your reply. One question fist: what are you using? Hi, Thanks for your reply, I am using WinFreeglut's glutMouseWheelFunc callback is version dependant and not reliable in X. Use standard mouse function and test for buttons 3 and 4. Due to lack of information about the mouse, it is impossible to implement this correctly on X at this time.
Use of this function limits the portability of your application. This feature does work on X, just not reliably. You are encouraged to use the standard, reliable mouse-button reporting, rather than wheel events. How do I do that? Declare a callback function that shall be called whenever the scroll wheel is scrolled. This is the prototype:. Define the callback function. The second parameter gives the direction of the scroll.
The OpenGlut notes on glutMouseWheelFunc state: Due to lack of information about the mouse, it is impossible to implement this correctly on X at this time. He was just wrong. Here is how: Declare a callback function that shall be called whenever the scroll wheel is scrolled. What are the differences between glu, glew, glut, qt, sdl, openGL and webGL?