Getting started

So you want to take advantage of the power of the OpenGL API? If you are visiting this page because a game or software implements the OpenGL API, you need to install the appropriate graphic driver which enables usage of the functionality provided.

Besides the OpenGL Wiki FAQ linked above, there is an older FAQ

If you are running Windows 98/Me/NT/2000/XP/2003/Vista, the OpenGL library has already been installed on your system.

Remember that GL is a system component on Windows. DO NOT modify or copy OpenGL32.dll from one OS to another. The filename is OpenGL32.dll and is either in WINDOWS\SYSTEM. WINNT\SYSTEM32 or WINDOWS\SYSTEM32. This also means that you do not have to ship a copy of the library with your application since it will already be available on the system.

The standard Windows OpenGL32.dll library alone will not provide you with hardware acceleration for OpenGL. In order to get hardware acceleration, you will need to install the latest drivers for your graphics card. The second reason to install new drivers is to have the latest version of GL on your system (the max version supported by your GPU):

Some sites also distribute beta versions of graphics drivers, which may give you access to bug fixes or new functionality before an official driver release from the manufacturer:

Without drivers, you will default to a software version of OpenGL 1.1 (on Win98, ME, and 2000), a Direct3D wrapper that supports OpenGL 1.1 (WinXP), or a Direct3D wrapper that supports OpenGL 1.1 (Windows Vista and Windows 7). None of these options are particularly fast, so installing drivers is always a good idea.

Other libraries like GLUT, freeGLUT, QT, etc are not part of the OS. These should be downloaded from the net. GLUT and OpenGL Utility Libraries

If you are running a 64 bit version of Windows, you might be wondering if there is a OpenGL64.dll file. The answer is no, there isn't. On all versions of Windows, Windows\System32 contains all the 64 bit DLLs. It contains the OpenGL32.dll which is actually a 64 bit dll.

For 32 bit programs, Windows detects the exe as a 32 bit program and instead of using System32 files, it uses Windows\SysWOW64 which actually contains the 32 bit DLLs. WOW means W indows O n W indows which is a backwards-compatibility layer.

To find your Windows' System32 directory, go to: Start, Run. and type in %WINDIR%\System32. The system will redirect you to the default System32 directory automatically; this is also true for the 32 bits versions of Windows.

Graphics on Linux is almost exclusively implemented using the X windows system. Supporting OpenGL on Linux involves using GLX extensions to the X Server. There is a standard Application Binary Interface defined for OpenGL on Linux that gives application compatability for OpenGL for a range of drivers. In addition the Direct Rendering Infrastucture (DRI) is a driver framework that allows drivers to be written and interoperate within a standard framework to easily support hardware acceleration, the DRI is included in of XFree86 4.0 but may need a card specific driver to be configured after installation. These days, XFree86 has been rejected in favor of XOrg due to the change in the license of XFree86, so many developers left Xfree86 and joined the XOrg group. Popular Linux distros come with XOrg now. Developers

Vendors have different approaches to drivers on Linux, some support Open Source efforts using the DRI, and others support closed source frameworks but all methods support the standard ABI that will allow correctly written OpenGL applications to run on Linux.

For more information on developing OpenGL applications on Linux, see Platform specifics: Linux

Linux comes with Mesa libraries, which implements the OpenGL API as a software rasterizer. Most Linux distros don't come with hardware acceleration. Some Linux distributions may include support for hardware acceleration. Also, some GPUs have Open Source drivers developed by the community even though a close source driver may be available from the manufacturer.

All versions of Mac OS X ship with OpenGL runtime libraries pre-installed. Users who want to run OpenGL applications do not need to install or configure anything.

Unlike other platforms, where the Operating System and OpenGL implementations are often updated separately, OpenGL updates are included as part of Mac OS X system updates. To obtain the latest OpenGL on Mac OS X, users should upgrade to the latest OS release, which can be found at Apple.com.

For developers, a default installation of Mac OS X does not include any OpenGL headers, nor does it include other necessary development tools. These are installed by a separate developer tools package called Xcode. This installer includes the OpenGL headers, compilers (gcc), debuggers (gdb), Apple's Xcode IDE, and a number of performance tools useful for OpenGL application development.

For more information on developing OpenGL applications on Mac OS X, see Platform specifics: Mac OS X.

The OpenGL ABI (application binary interface) is frozen to version GL 1.1 on Windows, and GL 1.2 on Linux. This means that you can not link directly to any new function provided by newer versions or by extensions.

So how do you use newer features. The answer is to get a function pointer at runtime. The following text describes details for Windows, but it is very similar for Linux, using glXGetProcAddress instead of wglGetProcAddress.

If you will be programming for Windows, typically compilers comes with a standard OpenGL 1.1 .h and .lib.

Microsoft will never update gl.h and opengl32.lib that comes with their compiler. It hasn't been updated since 1995. Basically, the solution is to use glext.h and wglext.h (wglext.h is for Windows only) which define all the GL 1.2, 1.3, 1.4, 1.5, 2.0, 2.1 and above tokens and functions. Keep reading.

Also, for other compilers for Windows, the same applies. gl.h and opengl32.a is limited to GL 1.1.

For Linux and others, you might want to borrow the same idea (getting function pointers for the GL functions)

To access higher OpenGL functions, you would have to get the function pointers.

For example, in C or C++, this is what you would do

PS. The info here applies also to GL 3.0

Download glext.h and wglext.h from The Extensions Registry

Put it in your compiler's GL folder.

Once you create a GL context, you can use wglGetProcAddress to get a pointer to the function.

This would be tedious if you had to do this for all the functions and it is even more work if you want to detect a certain OpenGL API version, then load all the core functions. Then, detect if a certain extension is present, then load all the functions.

There exists a few libraries out there that will get the function pointers for you. All you have to do is create an OpenGL rendering context and call the library's init function. The recent version of GLee doesn't require a call to its init function.

Examples are.

GLEW is used like this :

Step 1. Just before including gl.h, include glew.h

Step 2. Just after creating your GL context and making it current, call

It includes all the new tokens and functions and the old stuff has been removed.

OpenGL 3.0 adds many features to the core of OpenGL. It also brings with it a deprecation model that previous versions of OpenGL did not have. Before OpenGL 3.0, anything that became core had to remain in the specification permanently. The deprecation model allows OpenGL versions to announce that certain features may be removed from the core in later versions.

To support backwards compatibility, that is, to not break existing programs, a new context creation model was introduced. The old context creation model can only create OpenGL versions 2.1 or lower. Thus, the only way to use 3.0 contexts is to create them with the new API.

Part of this new API is a specification of exactly what version of OpenGL you want. So if you ask for a GL 3.1 context, you are telling the system that you expect that any entrypoints version 3.1 removed from earlier versions will not be available, and that any entrypoints 3.1 added to new versions will be available. The new API can fail if the implementation simply does not implement that version of OpenGL.

The first thing to do is chose a programming language. It could be C, C++, C#, Visual Basic, Pascal, Perl, Java, Ada, x86 assembly, etc. As long as a language has an OpenGL binding for your chosen language, you may use it.

The second thing is to chose a compiler. It could be MS Visual C++, Code::Blocks, Delphi, Masm, etc. Remember that OpenGL is an API, so as long as you have the language bindings for your compiler, you can do OpenGL programming.

Typically, a compiler comes with the binding files. For example, if you have a C++ compiler, it will come with gl.h and opengl32.lib. It may even come with glu.h and glu32.lib. glut.h and glut32.lib.

If you don't have your binding files, you will need to figure out where to download them from. Microsoft releases their Windows Platform SDK which contains these files and most likely you don't need it because your compiler came with the files.

You might want to use SDL, GLUT, freeGLUT, or some other wrapper that takes care of creating a GL window for you and destroying for you. It makes it easier for someone who just wants to learn the OpenGL API syntax.

Assuming you know how to program in your language of choice, now all you need is to learn OpenGL. There are many online tutorials. Just search for opengl+tutorial in your favorite search engine or visit some of the tutorials listed here.

These are programs that you install and run, and they give you information specific to the OpenGL API your system implements, like the version offered by your system, the vendor, the renderer, the extension list, supported viewport size, line size, point size, plus many other details. Some might include a benchmark. Some are standalone benchmarks.

User contributed tutorials and getting started guides

NVidia GeForce 6100 Драйвер скачать бесплатно для Windows Vista, 7

Размер файла: 124.6Mb (130655944 bytes)

Тип архива: Microsoft CAB Self-Extracting. Просмотреть содержимое архива

Дата выхода: 05 Oct 2009

Система: Windows Vista Windows 7

Описание: International version.­

Adds support for OpenGL 3.­2 for GeForce 8,­ 9,­ 100,­ and 200-series GPUs and ION GPUs.­

Accelerates performance in several gaming applications.­ The following are examples of improvements measured with version 191.­07 drivers vs.­ version 190.­62 drivers (results will vary depending on your GPU,­ system configuration,­ and game settings):

Up to 12%­ performance increase in ARMA 2

Up to 8%­ performance increase in Batman: Arkham Asylum with GPU PhysX enabled

Up to 50%­ performance increase in Call of Juarez: Blood in Bound with SLI enabled

Up to 14%­ performance increase in Fallout 3 (indoor scenes) with antialiasing enabled

Up to 10%­ performance increase in Far Cry 2 (DX9 version) with antialiasing enabled

Up to 34%­ performance increase in Prototype with antialiasing enabled

Adds SLI support for Aion,­ Darkfall,­ Dawn of Magic 2: Time of Shadows,­ Dreamkiller,­ Fuel,­ Majesty 2: The Fantasy Kingdom Sim,­ Need for Speed: Shift and more.­

Includes numerous bug fixes,­ including the following key fix (additional bug fixes can be found in the release notes on the documentation tab): For graphics cards supporting multiple clock states,­ 3D clocks correctly return to 2D clocks after exiting a 3D application.­

Правовая информация: Все програмное обеспечение, размещённое на Driver.ru является бесплатным. Все названия и торговые марки принадлежат их владельцам.

OpenGL 3 2 Software Downloads, Reviews: GlBase, News, 3, 2-D Or! and More OpenGL 3 2 Programs

News-0.3 .2 is a fully configurable RSS READER / TICKER for Windows and Linux that displays RSS feeds as a ticker bar on you desktop. Open feed links in your favourite browser. Scrolling is really fast and ***smooth***. Highly configurable: you can link News with your favourite browser, bookmark your favorite RSS feeds, set scrolling speed, update. Free download of News 0.3.2-win32, size 4.98 Mb.

Votre sejour en Cote-dOr, au c?ur de la Bourgogne, via une application qui sajuste. toutes vos envies. A deux, entre amis ou en famille, plutot branche nature, gastronomie, vin ou patrimoine

3 ,2 ,1. Cote-d'Or, technologie issue de la recherche scientifique et du marketing touristique, combine intelligemment loffre. la demande.

Unlike many other quit smoking apps, 3 -2 -1 Quit Smoking Now! is based on proven scientific methods.

Developed by medical scientists and based on the best and most recent scientific evidence from the. Freeware download of 3-2-1 Quit Smoking Now! 1.0.4, size 9.86 Mb.

Скачать Wine 1

Wine (Wine Is Not Emulator - Wine - не эмулятор) - это набор программ, позволяющий пользователям Linux, Mac, FreeBSD, и Solaris запускать Windows-приложения без необходимости установки на компьютер самой Microsoft Windows. Wine является активно развивающимся кросс-платформенным свободным ПО, распространяемым под лицензией GNU Lesser General Public License.

Преимущества Wine

Не в последнюю очередь, Wine может предоставить преимущества по сравнению с Windows.

Wine делаем возможным пользоваться всеми сильными сторонами Unix (стабильность, гибкость, удаленное администрирование) пока вы используйте Windows программы, которые вам нужны.

Unix всегда позволяла писать мощные скрипты. Wine делает возможным вызывать Windows приложения скриптами которые также используются в Unix среде в полной красе.

Wine делает возможным доступ к Windows приложениям удаленно, даже если они за тысячи миль от вас.

Wine делает экономичным использование тонких клиентов: просто установите Wine на Linux сервер, и вуаля! У вас доступ этим приложениям с любого Х терминала.

Wine может также быть использован, чтобы сделать существующие Windows приложения доступными из Web, используя VNC или Java клиент.

Wine является ПО с открытым исходным кодом, поэтому вы можете расширить его до чего вам надо или дать одной из многих компаний сделать это за вас.

Изменения в Wine 1.8 Stable:

*** Text and fonts

- DirectWrite is implemented, and works for a number of

applications. The implemented functionality includes:

- Font file loading from system or custom font collections.

- Building font families by combining similar font faces.

- Font matching algorithm using weight/width/slope model.

- Basic text layout support.

- Bi-directional level resolution and line breaks resolution.

- GDI interoperability API, including rendering to DIB section base target.

- Rendering to arbitrary target with generic rendering interface.

- Generating black&white and grayscale alpha bitmaps.

- Bold glyphs can be synthesized for outline fonts.

- Multiple replacements can be specified for a single font by using a multi-string entry under HKCU\Software\Wine\Fonts\Replacements.

- Vertical text uses the Unicode data tables for more accurate character ranges support.

- Character tables are based on version 8.0.0 of the Unicode Standard.

- The built-in Wingdings font contains more glyphs.

- Unicode bracketing pairs are supported in Uniscribe.

- The RichEdit control uses Uniscribe for more accurate text rendering.

- Hebrew and Arabic Mac OS code pages are supported. This improves support for loading translated font names from Mac OS font files.

*** Graphics

- Direct2D is supported. Among the implemented features are:

- DXGI surface and WIC bitmap render targets.

- Geometries defined by straight lines and cubic Bézier curves.

- Drawing text.

- Bitmaps.

- Solid color brushes and bitmap brushes.

- Opacity brushes.

- PNG files can be encoded in interlaced mode.

- Gamma information can be loaded from PNG files.

- Animated GIFs are correctly supported in GdiPlus.

*** Direct3D

- Direct3D 11 is supported, to about the same level as Direct3D 10.

- Simple applications using Direct3D 10 are supported. There are still many unimplemented features. Direct3D 10 requires support for at least OpenGL 3.2 and GLSL 1.50. Some of the changes and supported features include:

- Several resource update operations are implemented.

- Many more shader model 4 opcode are recognized.

- Constant buffers are supported.

- The various resource views are implemented.

- The various state objects are implemented.

- Stateblocks are implemented.

- A number of new DXGI 1.1 interfaces are implemented. This benefits Direct3D 10 and 11 applications.

- Direct3D applications correctly minimize and restore the display mode on focus loss.

- Fixed function vertex blending is implemented. This requires GLSL support.

- Per-vertex point sizes are supported. This requires GLSL support.

- The wined3d graphics card database recognizes more graphics cards. The graphics card detection code is simplified and

improved. More reasonable fallbacks are picked for unrecognized graphics cards.

- On drivers that support it, GL_ARB_texture_mirror_clamp_to_edge or GL_EXT_texture_mirror_clamp are used to implement the "mirror once" texture addressing mode. Previously this required GL_ATI_texture_mirror_once.

- GL_ARB_depth_clamp is no longer required to correctly draw pre-transformed vertices with disabled z-buffering. This helps older graphics cards that can't correctly implement GL_ARB_depth_clamp.

- On drivers that support it, GL_ARB_blend_func_extended is used to implement the D3DBLEND_SRCALPHASAT blend factor.

- On drivers that support it, GL_ARB_sampler_objects is used to apply sampler states independently of the texture object they apply to. This helps applications that bind the same texture to multiple texture stages, but with different sampler states.

- On drivers that support it, GL_EXT_texture_snorm is used to support signed (normalized) texture formats. These are typically used for bump mapping. Previously these formats required either GL_NV_texture_shader, or fixups when loading and using them.

- On drivers that support is, GL_ARB_timer_query is used to support Direct3D 9 timestamp queries.

- Texture format restrictions are more strictly enforced. This allows applications to fall back to a different format instead of continuing with broken rendering.

- Direct3D 9 D3DTSS_CONSTANT texture stage constants are supported.

- Color keyed blits can be done by the graphics card. Previously these needed to be done by the CPU.

- NV12 surfaces are supported. This is used by some applications for playing back video.

- ATI1N textures and surfaces are supported, in addition to ATI2N textures and surfaces. This requires support for

GL_ARB_texture_compression_rgtc from the OpenGL driver.

- When GLSL is supported, lighting for Direct3D 1-3 is more correct. However, for most application the difference will only be very slight.

- The IDirect3DSwapChain9Ex interface is supported.

- OpenGL core contexts, OpenGL ES contexts, and multi-threaded OpenGL command submission (known as "CSMT") have been added, however that work is not finished yet.

*** DirectDraw

- SetCooperativeLevel() works better, affecting DirectDraw exclusive mode in particular.

- DirectDraw surface flipping is more correct. This affects applications that use more than 1 back buffer in particular.

- DirectDraw palette handling is better supported. This mostly affects older applications using 8-bpp display modes (but not exclusively.)

- "Client memory" surfaces are better supported, in particular related to the handling of pitch and texture compression.

*** Audio and video

- A Pulse Audio driver is implemented. It is selected automatically when Pulse Audio is running.

- 5.1 surround sound is supported in DirectSound. Stereo is the default, but other speaker configurations can be set through the Audio tab in Winecfg.

- XAudio2 is implemented, based on the OpenAL Soft library.

- The OpenAL library defaults to the native version.

- The Video Mixing Renderer version 7 is implemented.

- AVI file encoding and compression is implemented.

*** Kernel

- Wine can be configured to report the Windows version as 'Windows 8.1' and 'Windows 10'.

- Keyed event synchronization objects are implemented.

- The "init once" synchronization mechanism is supported.

- Condition variables are implemented.

- Slim Reader/Writer locks are implemented.

- Activation contexts are used for loading DLLs, type libraries, and COM classes, avoiding the need for explicit registration.

- Windows devices support read and write operations in addition to I/O controls. They can be remapped directly to existing Unix devices.

- Thread local storage is supported in dynamically loaded libraries.

- Process jobs are implemented.

- The Task Scheduler service is implemented.

- The UTF-7 encoding is supported.

- ATL thunk emulation supports a wider range of possible instructions.

- Process and thread affinity is supported even with a large number of processors.

- Dynamic DST (Daylight Saving Time) is supported through the registry. Timezone data is updated for a number of timezones.

- USER_SHARED_DATA access is emulated on x86-64 platforms.

- The new thread pool API is supported.

- OpenMP (parallel programming API) is implemented.

- Preliminary support for HID devices is implemented, but it's not enabled yet.

*** User interface

- There is an optional Start Menu in desktop mode, that can be enabled on a per-desktop basis by setting "EnableShell" to "Y" under HKCU\Software\Wine\Explorer\Desktops\.

- The standard Open File dialog supports a drop-down menu for file manipulations.

- The 'My Documents' folder links to the XDG or Mac OS X 'Documents' folder if it exists.

- Many more shell Known Folders are supported.

- Scrollbar theming is implemented. Theming of other controls also works better.

- The Toolbar common control can save and restore its state.

*** Mac OS X support

- The 64-bit architecture is supported on Mac OS X; however, it's not 100% compatible with Win64, because of the OS X non-standard 64-bit ABI.

- Memory size is reported accurately on Mac OS X.

- Joysticks are supported at the WinMM level on Mac OS X.

- Debugging information and stack unwinding are improved on Mac OS X.

- Trash folder enumeration is supported on Mac OS X.

- All mouse events are supported in the system tray with the Mac driver.

- Window maximization is supported in the Mac driver.

- The Cocoa-style full-screen mode is supported in the Mac driver.

- Multiple keyboard layouts are supported in the Mac driver.

*** X11 driver

- X Drag & Drop protocol version 5 is supported.

- Flashing a window caption is implemented in the X11 driver using the NET_WM_STATE_DEMANDS_ATTENTION style.

*** OLE / COM

- OLE Storage files support file locking, and sizes larger than 4 GB.

- Type libraries are registered correctly on 64-bit setups.

- 32-bit type libraries can be loaded from 64-bit programs.

- Te OLE data cache supports DIB images.

- The RP interface to control Windows services is compatible with the

native version.

- OLE Accessible Objects are implemented for better accessibility support.

*** Internet and networking

- The Gecko engine is updated to the version from Firefox 40. Many more objects and properties are implemented in MSHTML.

- Internet proxies can be configured automatically.

- RPC over HTTP supports the NTLM and Negotiate authentication schemes.

- The Web Services API is partially implemented.

- Download of Gecko and Mono add-ons can be canceled from the progress dialog.

- Conditional compilation is supported in javascript.

- Arrays, math functions, and exception unwinding are implemented in VBScript.

- Remote network shares can be configured using Samba's NetAPI library.

- The Packet Capture DLL is implemented.

- Network interface change notifications are implemented.

*** Printing

- Vertical text is supported when printing through the PostScript driver.

- The PostScript driver generates standard glyph names when possible.

- Monochrome printers are better supported, in particular when printing color images.

- Collation is supported in the PostScript driver.

*** Miscellaneous

- Windows Management Instrumentation (WMI) implements several more WBEM system classes.

- Applying installation patches is better supported in MSI.

- Hyperlink controls are supported in installers.

- More recent versions of the C/C++ runtimes are supported, including the new UCRTBASE library. The old MSVCIRT C++ runtime is also partially implemented.

- Version 9, 10, and 11 of ATL (Active Template Library) are implemented.

- The Windows Scripting Runtime supports many more classes, including file and folder collections and dictionaries.

- Writing XML files is implemented.

- The Invariant locale is supported.

*** Built-in applications

- The 'taskmgr' application displays whether processes are running under WoW64.

- The 'regedit' tool better supports import/export of registry files.

- The 'wineconsole' tool supports configuring the insert/overwrite mode in the settings dialog.

*** Platform-specific changes

- System and hardware information is properly reported on ARM platforms.

- WoW64 mode is supported for the ARM64 platform.

- The 64-bit architecture is supported on Android.

- Binaries are built as PIE on Android, for compatibility with Android version 5.

*** Build environment

- Source files can be shared across DLLs, to allow building multiple versions of a DLL from the same source. This is more compatible than forwarding calls to a single master DLL. It's used mainly for the C/C++ runtime libraries.

- #pragma directives are supported in various source files to specify dependencies, for more accurate makefile generation.

- The IDL compiler supports WinRT namespaces.

- The message compiler uses mo files instead of po files for faster processing.

- Architecture-specific compile flags like -march= are supported in Winegcc and passed along to the assembler.

*** New external dependencies

- liblcms2 is used instead of liblcms version 1.

- libnetapi from Samba is used for configuring remote network shares.

- libpcap is used to implement the Packet Capture DLL.

- libpulse is used by the Pulse Audio driver.

- The OpenAL Soft library is used to implement XAudio2.

- The prelink tool is no longer necessary as long as the linker supports the -Ttext-segment option.

*** Known issues

- Since the support for OpenGL core contexts in WineD3D is not complete enough yet, Direct3D 10 and 11 need to be supported in a legacy context / the compatibility profile, which means that they currently don't work on Mesa.

- Setting the PULSE_LATENCY_MSEC variable was sometimes necessary with the Alsa audio driver, but it can cause trouble with the Pulse driver. It is recommended to unset the variable.

Opengl 3.2 скачать бесплатно

GLFW is a small C library that lets you create and manage windows with OpenGL contexts, enumerate monitors and video modes as well as handle inputs such as keyboard, mouse, joystick, clipboard 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 having to deal with 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…

• an implementation of OpenGL or OpenGL ES. It wraps the various platform-specific context creation API.
• an OpenGL or OpenGL ES header. It includes the API headers already provided by your development environment.
• an OpenGL or OpenGL ES extension loader. There are already good extension loader libraries.
• a user interface library. It allows you to create top-level windows with OpenGL contexts. No menus, no buttons.
• a Windows-only library. Requests for features that cannot be portably implemented will be denied unless they are unobtrusive, like the Windows port looking for a GLFW_ICON resource at window creation.
• a threading library. There are already good cross-platform threading libraries and threading has been added to both the C11 and C++11 standard libraries.
• an image loading library. There are already good cross-platform image loading libraries.
• 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.
• integrated with any user interface toolkit on any platform. Good UI toolkits already provide OpenGL-capable widgets and having two libraries both talking to the vast global state of a window system is asking for trouble.
• able to play back sound.
• GLUT or SDL.

There are several other libraries available for aiding OpenGL development. The most common ones are freeglut. an Open Source implementation of GLUT, and SDL .

However, freeglut is mostly concerned with providing a stable clone of GLUT, 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, 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.

In short, all versions provided by your operating system.

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, 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 OS X.

The first version to support creation of OpenGL 3.2 contexts on OS X Lion and later was GLFW 2.7.2.

Because that is how most platforms describe OpenGL-capable pixel formats and how OpenGL describes its framebuffers. It makes GLFW more consistent with the APIs it interacts with, and more future-proof.

This doesn’t, of course, prevent you from presenting the familiar, single value color depths to the user.

You can change the resolution of a full screen window with glfwSetWindowSize. but the pixel format, i.e. the framebuffer bit depths will remain the same. Changing the pixel format requires the context to be recreated.

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

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.

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.

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 OS X, the Mach mach_absolute_time time source is used.

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 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 an EGL backend that works with the Win32 and Xlib APIs.

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 glad .

GLFW does not wrap OpenGL. No GLFW code is involved when you make an OpenGL call. Think instead of GLFW as connecting your code to OpenGL and then getting out of the way. That connection is the OpenGL context you create and make current with GLFW. 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 prevent the GLFW header from including the platform client API header (for example gl.h for OpenGL). There are two ways to do this. Either include the extension loader header before including the GLFW header:

The extension loader header will disable and replace the standard OpenGL header that the GLFW header includes. You can also disable the standard OpenGL header yourself by defining GLFW_INCLUDE_NONE before including the GLFW header. This will let you include the GLFW and extension loader headers in any order:

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 as the user pointer for the window and use it to call methods on your object.

Currently, GLFW releases are tested with MinGW, MinGW-w64 and Visual C++ 2010, 2012 and 2013, but it should work with any compiler that supports C99 (C89 on Windows). Very old development environments may require updated system headers.

The Windows binary distribution of GLFW contains pre-compiled libraries for both MinGW and the most recent versions of Visual C++.

See the Building programs that use GLFW guide for details on how to compile and link programs on various platforms.

Modern graphics drivers have settings that allow users to override an application’s request for (among other things) swap interval. If such a setting is enabled, glfwSwapInterval will have no effect.

The Windows event loop is blocked by certain actions like dragging or resizing a window, or opening the window menu. This is part of the design of Windows and cannot be changed by GLFW. If you wish to keep rendering during such actions, you should render from a secondary thread.

The only OpenGL 3.x and 4.x contexts currently supported by OS X are forward-compatible, core profile contexts. The supported versions are 3.2 on 10.7 Lion and 3.3 and 4.1 on 10.9 Mavericks. In all cases, your GPU needs to support the specified OpenGL version for context creation to succeed.

To create either an OpenGL 3.2 or later context, you should set the following hints:

This will give you a context for the highest version of OpenGL greater than or equal to 3.2 that is supported by your OS and GPU. This works because no features were deprecated between OpenGL 3.2 and 4.1, making forward-compatible OpenGL 4.1 backards-compatible with 3.2. If the requested version is not supported, window creation will fail.

If your code requires OpenGL 3.3 or 4.1, you can specify those versions instead, as well as any valid OpenGL version in between.

You are passing the window size, which is in screen coordinates, to glViewport. which works with pixels. On OS X with a Retina display, and possibly on other platforms in the future, screen coordinates and pixels do not map 1:1. Use the framebuffer size, which is in pixels, instead of the window size. See the Window handling guide for details.