News

Showcase

Documentation

Download

FAQ

Community

Links

Get GLFW at SourceForge.net. Fast, secure and Free Open Source software downloads

Frequently Asked Questions

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.

Table of Contents

Introduction

General Questions

Windows Specific Questions

Mac OS X Specific Questions

Introduction

1.1 What is GLFW?

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.

1.2 What is GLFW not?

GLFW is by design not...

1.3 Why yet another OpenGL toolkit?

There are already several toolkits available for aiding OpenGL development. The most widespread are GLUT (and its modern, Open Source incarnation freeglut) and SDL.

However, GLUT is getting quite old and freeglut is mostly concerned with providing a stable clone of it, while SDL is sometimes tricky to integrate into existing code and has never had OpenGL as its main focus.

1.4 What platforms are supported by GLFW?

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. That being said, the code is not yet 64-bit clean.

1.5 What versions of OpenGL are supported by GLFW?

GLFW 2.6 used the older context creation mechanism, which may return contexts of version 4.0 and above provided it implements the ARB_compatibility extension.

Explicit creation of contexts of version 3.0 and above, including profiles and flags, is supported by version 2.7, which is the current stable version.

General Questions

2.1 Why use separate red/green/blue bit depths?

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.

2.2 Why is it not possible to change video modes after a window has been opened?

Some cards do not behave well when the video mode is changed once the window has been opened. The most important reason though is that under the 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).

2.3 What texture file formats does GLFW support?

Note that the image and texture loading facilities are deprecated and will be removed in future versions of GLFW.

Through the glfwReadImage and glfwLoadTexture2D functions, GLFW supports the Truevision Targa version 1 (TGA) file format.

Supported pixel formats are: 8-bit gray-scale, 24-bit RGB, 32-bit RGBA and colormap (24/32-bit colors). Note that colormap images are always converted to 24-bit or 32-bit true color. Files that are RLE encoded (compressed) are also supported.

2.4 Will sound support be added to GLFW?

No.

However, if you are looking for an OpenGL-like API for sound, have a look at OpenAL.

2.5 Will font or text rendering support be added to GLFW?

No.

There are already several competent font rendering toolkits available for OpenGL, none of which require integration with a context or window management library.

2.6 Will pop-up menu support be added to GLFW?

No.

2.7 Will message box support be added to GLFW?

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.

2.8 What is Unicode and ISO 8859-1?

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.

2.9 Is GLFW thread safe?

No. However, neither is OpenGL.

Note that the threading facilities are deprecated and will be removed in future versions of GLFW.

The threading part of the GLFW API (threads, mutexes and condition variables) is thread safe, as is the glfwSleep function. Other functions are NOT thread safe, and calling them from different threads may result in an inconsistent GLFW state.

It is recommended that all OpenGL and GLFW calls (except for thread management and synchronization calls) are made from the main thread, which should not be a big problem since only a single window is supported. This method is also compatible with the future direction of GLFW.

2.10 Can I check several keys at once?

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(GLFW_KEY_LCTRL) or glfwGetKey(GLFW_KEY_RCTRL), or both).

2.11 What timer APIs does GLFW use?

On Windows, the QueryPerformance* API is used, if available, with timeGetTime as a fallback.

On Mac OS X and other Unix-like operating systems, gettimeofday is used.

2.12 What window system APIs does GLFW use?

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.

There is also a legacy Carbon port available for use on older versions of Mac OS X, using AGL for windowed context creation and CGL for fullscreen context creation. Note that this port only allows 32-bit applications.

2.13 Why doesn't your gl.h have the functions I need?

GLFW does not provide any version of either gl.h or glu.h. The glfw.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.

2.14 Why do my objects look all wrong?

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.

2.15 Can I use GLEW with GLFW?

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.

Windows Specific Questions

3.1 What compilers are supported by GLFW?

Currently, GLFW releases are tested with Visual C++ Express, MinGW and Cygwin (through cross-compilation).

The Windows binary distribution of GLFW contains pre-compiled libraries for all of the compilers mentioned above.

The 3.x line of GLFW (as well as the current Lite branch) uses CMake and may thus be easier to adapt to new compilers.

If your compiler is not supported, please don't hesitate to contact us.

3.2 Why do I get link errors when trying to build my program?

If you get errors like this one when you try to compile a program using GLFW:

error LNK2001: unresolved external symbol _glfwGetWindowParam

(Example from Microsoft Visual C++)

then you have most likely not linked your program correctly. How to do this is described in the readme.html file that is included in the GLFW source and binary distributions.

3.3 Why doesnt glfwSwapInterval work?

This is a known problem with certain ATI card/driver combinations, where the driver apparently ignores requests for enabling vertical sync. From the point of view of GLFW, the only thing we do is pass the specified interval to the wglSwapIntervalEXT function, if avilable, so the room for possible errors is very small.

However, if you encounter this problem on non-ATI 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.

Mac OS X Specific Questions

4.1 Why can I not focus or interact with my program window?

Your program most likely lacks an application bundle.

A simple shell script for creating application bundles sufficient for running GLFW applications can be found in the source distribution as examples/bundle.sh.

To learn more about bundles, see the Bundle Programming Guide on the Apple Developer Connection.

Copyright © elmindreda