| layout | title |
|---|---|
default |
FAQ |
This page attempts to address some of the most commonly asked questions that we have received from GLFW users.
If your questions are not answered here, please do contact us.
- 1.1 What is GLFW?
- 1.2 What is GLFW not?
- 1.3 Why yet another OpenGL toolkit?
- 1.4 What platforms are supported by GLFW?
- 1.5 What versions of OpenGL are supported by GLFW?
- 2.1 Why use separate red/green/blue bit depths?
- 2.2 Why is it not possible to change video modes after a window has been opened?
- 2.3 Will image or texture loading support be added to GLFW?
- 2.4 Will sound support be added to GLFW?
- 2.5 Will font or text rendering support be added to GLFW?
- 2.6 Will pop-up menu support be added to GLFW?
- 2.7 Will message box support be added to GLFW?
- 2.8 What is Unicode and ISO 8859-1?
- 2.9 Is GLFW thread safe?
- 2.10 Can I check several keys at once?
- 2.11 What timer APIs does GLFW use?
- 2.12 What window system APIs does GLFW use?
- 2.13 Why doesn't your gl.h have the functions I need?
- 2.14 Why do my objects look all wrong?
- 2.15 Can I use GLEW with GLFW?
- 2.16 How do I use C++ methods as callbacks?
- 3.1 What compilers are supported by GLFW?
- 3.2 Why do I get link errors when trying to build my program?
- 3.3 Why doesnt glfwSwapInterval work?
- 4.1 Why can I not focus or interact with my program window?
- 4.2 How do I create an OpenGL 3.2 context?
GLFW is a small C library that lets you create and manage an OpenGL context and its associated window, enumerate and change display modes, as well as handle inputs such as keyboard, mouse, joystick and time.
GLFW provides a thin, multi-platform abstraction layer, primarily for applications whose sole graphics output is through the OpenGL API. While GLFW is very useful when developing multi-platform OpenGL applications, single-platform developers can also benefit from avoiding the drudgery of kludgy platform-specific APIs.
The reason that libraries like GLFW are needed is that OpenGL by itself does not provide any mechanisms for creating the necessary context, managing windows, user input, timing etc. As stated in the OpenGL 3.1 Specification (chapter 2, first paragraph):
OpenGL is concerned only with rendering into a framebuffer (and reading values stored in that framebuffer). There is no support for other peripherals sometimes associated with graphics hardware, such as mice and keyboards. Programmers must rely on other mechanisms to obtain user input.
GLFW matches the description of other mechanisms quite well.
GLFW is by design not...
- a user interface library. It allows you to create a single, OpenGL-capable window. No menus, no buttons.
- an image loading library. It has a legacy facility for loading Targa files for testing purposes, nothing more.
- a Windows-only library. Requests for features that cannot be portably
implemented will be denied unless they are unobtrusive (like the Win32 port
looking for a
GLFW_ICONresource). - capable of rendering text. There are already several libraries that render text with OpenGL, and consistent cross-platform text rendering cannot depend on the platform's text rendering facilities anyway.
- capable of rendering anything at all. Rendering is up to you and/or other libraries.
- equipped with a menu system.
- integrated into any user interface toolkit on any platform. Good UI toolkits already provide OpenGL-capable widgets.
- able to play back sound.
- GLUT or SDL.
There are already several toolkits available for aiding OpenGL development. The most commonly used are freeglut, an Open Source implementation of GLUT, and SDL.
However, GLUT is getting quite old and freeglut is mostly concerned with providing a stable clone of it, while SDL is too large for some people and has never had OpenGL as its main focus.
We therefore believe that there is room for a lightweight, modern library for managing OpenGL contexts, windows and input.
Currently, GLFW supports Windows, Mac OS X and Unix-like operating systems with the X Window System, such as Linux and FreeBSD.
GLFW is designed to be as portable as possible, and the code has been written with portability in mind.
This question likely stems from the original version of the
WGL_ARB_create_context
and
GLX_ARB_create_context
extensions, which stated that the old context creation mechanism would be
limited to OpenGL version 2.1. However, this is no longer the case and the
specifications have been updated accordingly.
GLFW 2.6 and earlier use only the older context creation mechanism, which
on Windows and X11 may return contexts of any version, however new, provided
they implement the
ARB_compatibility
extension. Most modern drivers do this.
Explicit creation of OpenGL contexts of version 3.0 and above on Windows and X11, including profiles and flags, is supported by GLFW 2.7 and later.
However, Mac OS X did not support OpenGL 3.0 or later at the time that GLFW 2.7 was released, and the support that Apple has since added only includes forward-compatible OpenGL 3.2 core profile contexts. Additionally, creating such contexts requires new code, so older versions of GLFW cannot create OpenGL 3.0 contexts on Mac OS X.
The first version to support creation of OpenGL 3.2 contexts on OS X Lion was GLFW 2.7.2.
In short, because it more closely matches the way most platforms describe OpenGL-capable pixel formats, which in the past actually mattered.
Today, when nearly everyone just asks for 24-bit color and gets it, it matters less. It does, however, make the API slightly more future-proof, as the values specified can be passed nearly unmodified to the window system.
This doesn't, of course, prevent you from presenting the familiar, single value color depths to the user.
There is limited support for mode switching in the form of glfwSetWindowSize.
In fullscreen mode, this will change the video mode to that closest matching the
current mode, with refresh mode and color depth preserved.
However, some cards do not behave well when the video mode is changed once the window has been opened. Also, under X Window System it is only possible to set the color depth of an OpenGL window at the time of creating the OpenGL context (i.e. when opening the window).
No.
No.
However, if you are looking for an OpenGL-like API for sound, have a look at OpenAL.
No.
There are already several competent font rendering toolkits available for OpenGL, none of which require integration with a context or window management library.
No.
Not right now.
The main issue keeping this from being added is the lack of a standard, Unicode-enabled UI toolkit on Unix-like systems such as Linux and FreeBSD. Depending on, say, Gtk+, would therefore introduce a dependency on a huge amount of code not necessarily present on the user's machine.
As there is no reason why message box code has to be integrated into GLFW, it is better to leave that functionality to a separate library.
Unicode (sometimes referred to as ISO 10646), is a character coding standard that encodes virtually every character from every written language in the world into a common character set. It is gaining acceptance worldwide, and today most platforms, computer languages and APIs have some sort of support for Unicode (GLFW now being one of them).
Visit The Unicode Consortium for more information about Unicode.
See also Wikipedia on Unicode.
ISO 8859-1 (also known as Latin 1), is a very limited subset of the Unicode character set. It represents the lowest 0-255 codes of the Unicode character set, and can thus be coded with a single byte. Character codes 32-126 are equal to the US-ASCII character set. However, with the additional character codes 160-255, ISO 8859-1 is able to support many European languages.
See also Wikipedia on ISO 8859-1.
Some parts are, specifically those needed to allow rendering from secondary threads.
Yes, you can.
The function glfwGetKey lets you check the state of any keyboard key
(including special keys). You can even call the function from within a callback
function, which makes it possible to check for things like CTRL+F3 key events
(when you get a GLFW_KEY_F3 key press event, check the state of the left or
right CTRL key with glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) or
glfwGetKey(window, GLFW_KEY_RIGHT_CONTROL), or both).
On Windows, the QueryPerformanceCounter API is used if available, with
timeGetTime as a fallback.
On Mac OS X, the Cocoa port uses mach_absolute_time and the legacy Carbon port
uses gettimeofday.
On Unix-like operating systems using the X11 port, the POSIX CLOCK_MONOTONIC
time source is used if available, with gettimeofday as a fallback.
On Windows, plain Win32 is used for window and input management, and WGL (with extensions) is used to create contexts.
On Mac OS X, Cocoa is used for window and input management, and NSOpenGL for context creation.
On Unix-like systems using the X Window System, the Xlib API is used for window and input management, the XRandR or XF86VidMode extension (if available) for display mode management, and GLX (with extensions) for context creation.
GLFW does not provide any version of either gl.h or glu.h. The glfw3.h
header file includes the versions already present in your development
environment.
However, if you are using Windows, you cannot get anything newer than OpenGL 1.2 without using extensions. As the extension management in GLFW is very rudimentary, we recommend that you use a dedicated extension loading library such as GLEW or GLee.
GLFW does not exist between your code and OpenGL. Think instead of GLFW as connecting your code to OpenGL and then getting out of the way. If you get incorrect rendering results, it is therefore most likely due to errors in your code, the OpenGL implementation or both.
The OpenGL.org wiki has an extensive article on common mistakes that may be able to help you locate the problem.
Yes, as long as you include the GLEW header before the GLFW one. The GLEW
header defines all the necessary magic macros to make sure the gl.h that GLFW
attempts to include doesn't interfere.
You cannot use regular methods as callbacks, as GLFW is a C library and doesn't
know about objects and this pointers. If you wish to receive callbacks to
a C++ object, use static methods or regular functions as callbacks, store the
pointer to the object you wish to call in some location reachable from the
callbacks and use it to call methods on your object.
Currently, GLFW releases are tested with Visual C++ 2008, 2010 and 2012, standalone MinGW, MinGW with MSYS, and the Cygwin packages for MinGW.
The Windows binary distribution of GLFW contains pre-compiled libraries for all of the compilers mentioned above.
If your compiler is not supported, please don't hesitate to contact us.
If you get errors like this one when you try to compile a program using GLFW:
error LNK2001: unresolved external symbol _glfwGetWindowAttrib
(Example from Microsoft Visual C++)
then you have most likely not linked your program against GLFW correctly. How
to do this is described in section 4.2.2 of the readme.html file that is
included in the GLFW source and binary distributions.
This is a known problem with certain ATI/AMD card/driver combinations, where the
driver apparently ignores requests for enabling vertical sync. GLFW itself only
only passes the specified interval to the wglSwapIntervalEXT function and the
rest is up to the driver.
However, if you encounter this problem on non-ATI/AMD hardware and you have verified in your display driver settings that vertical sync has not been forcibly disabled, please report this as a bug in GLFW.
Your program most likely lacks an application bundle.
To learn more about bundles, see the Bundle Programming Guide on the Apple Developer Connection.
The only OpenGL 3.0+ context configuration currently supported by Mac OS X is forward-compatible, core profile OpenGL 3.2. To create such a context, you should set the following hints:
{% highlight c %} glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); {% endhighlight %}