DSCF

.co.uk

PC32

A ColorForth compiler and editor for x86-64
git clone https://dscf.co.uk/clone/PC32.git
Log | Files | Refs | README

wgl_context.c (26959B)


      1 //========================================================================
      2 // GLFW 3.3 WGL - www.glfw.org
      3 //------------------------------------------------------------------------
      4 // Copyright (c) 2002-2006 Marcus Geelnard
      5 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org>
      6 //
      7 // This software is provided 'as-is', without any express or implied
      8 // warranty. In no event will the authors be held liable for any damages
      9 // arising from the use of this software.
     10 //
     11 // Permission is granted to anyone to use this software for any purpose,
     12 // including commercial applications, and to alter it and redistribute it
     13 // freely, subject to the following restrictions:
     14 //
     15 // 1. The origin of this software must not be misrepresented; you must not
     16 //    claim that you wrote the original software. If you use this software
     17 //    in a product, an acknowledgment in the product documentation would
     18 //    be appreciated but is not required.
     19 //
     20 // 2. Altered source versions must be plainly marked as such, and must not
     21 //    be misrepresented as being the original software.
     22 //
     23 // 3. This notice may not be removed or altered from any source
     24 //    distribution.
     25 //
     26 //========================================================================
     27 // Please use C89 style variable declarations in this file because VS 2010
     28 //========================================================================
     29 
     30 #include "internal.h"
     31 
     32 #include <stdlib.h>
     33 #include <malloc.h>
     34 #include <assert.h>
     35 
     36 // Return the value corresponding to the specified attribute
     37 //
     38 static int findPixelFormatAttribValue(const int* attribs,
     39                                       int attribCount,
     40                                       const int* values,
     41                                       int attrib)
     42 {
     43     int i;
     44 
     45     for (i = 0;  i < attribCount;  i++)
     46     {
     47         if (attribs[i] == attrib)
     48             return values[i];
     49     }
     50 
     51     _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
     52                          "WGL: Unknown pixel format attribute requested");
     53     return 0;
     54 }
     55 
     56 #define addAttrib(a) \
     57 { \
     58     assert((size_t) attribCount < sizeof(attribs) / sizeof(attribs[0])); \
     59     attribs[attribCount++] = a; \
     60 }
     61 #define findAttribValue(a) \
     62     findPixelFormatAttribValue(attribs, attribCount, values, a)
     63 
     64 // Return a list of available and usable framebuffer configs
     65 //
     66 static int choosePixelFormat(_GLFWwindow* window,
     67                              const _GLFWctxconfig* ctxconfig,
     68                              const _GLFWfbconfig* fbconfig)
     69 {
     70     _GLFWfbconfig* usableConfigs;
     71     const _GLFWfbconfig* closest;
     72     int i, pixelFormat, nativeCount, usableCount = 0, attribCount = 0;
     73     int attribs[40];
     74     int values[sizeof(attribs) / sizeof(attribs[0])];
     75 
     76     if (_glfw.wgl.ARB_pixel_format)
     77     {
     78         const int attrib = WGL_NUMBER_PIXEL_FORMATS_ARB;
     79 
     80         if (!wglGetPixelFormatAttribivARB(window->context.wgl.dc,
     81                                           1, 0, 1, &attrib, &nativeCount))
     82         {
     83             _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
     84                                  "WGL: Failed to retrieve pixel format attribute");
     85             return 0;
     86         }
     87 
     88         addAttrib(WGL_SUPPORT_OPENGL_ARB);
     89         addAttrib(WGL_DRAW_TO_WINDOW_ARB);
     90         addAttrib(WGL_PIXEL_TYPE_ARB);
     91         addAttrib(WGL_ACCELERATION_ARB);
     92         addAttrib(WGL_RED_BITS_ARB);
     93         addAttrib(WGL_RED_SHIFT_ARB);
     94         addAttrib(WGL_GREEN_BITS_ARB);
     95         addAttrib(WGL_GREEN_SHIFT_ARB);
     96         addAttrib(WGL_BLUE_BITS_ARB);
     97         addAttrib(WGL_BLUE_SHIFT_ARB);
     98         addAttrib(WGL_ALPHA_BITS_ARB);
     99         addAttrib(WGL_ALPHA_SHIFT_ARB);
    100         addAttrib(WGL_DEPTH_BITS_ARB);
    101         addAttrib(WGL_STENCIL_BITS_ARB);
    102         addAttrib(WGL_ACCUM_BITS_ARB);
    103         addAttrib(WGL_ACCUM_RED_BITS_ARB);
    104         addAttrib(WGL_ACCUM_GREEN_BITS_ARB);
    105         addAttrib(WGL_ACCUM_BLUE_BITS_ARB);
    106         addAttrib(WGL_ACCUM_ALPHA_BITS_ARB);
    107         addAttrib(WGL_AUX_BUFFERS_ARB);
    108         addAttrib(WGL_STEREO_ARB);
    109         addAttrib(WGL_DOUBLE_BUFFER_ARB);
    110 
    111         if (_glfw.wgl.ARB_multisample)
    112             addAttrib(WGL_SAMPLES_ARB);
    113 
    114         if (ctxconfig->client == GLFW_OPENGL_API)
    115         {
    116             if (_glfw.wgl.ARB_framebuffer_sRGB || _glfw.wgl.EXT_framebuffer_sRGB)
    117                 addAttrib(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
    118         }
    119         else
    120         {
    121             if (_glfw.wgl.EXT_colorspace)
    122                 addAttrib(WGL_COLORSPACE_EXT);
    123         }
    124     }
    125     else
    126     {
    127         nativeCount = DescribePixelFormat(window->context.wgl.dc,
    128                                           1,
    129                                           sizeof(PIXELFORMATDESCRIPTOR),
    130                                           NULL);
    131     }
    132 
    133     usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
    134 
    135     for (i = 0;  i < nativeCount;  i++)
    136     {
    137         _GLFWfbconfig* u = usableConfigs + usableCount;
    138         pixelFormat = i + 1;
    139 
    140         if (_glfw.wgl.ARB_pixel_format)
    141         {
    142             // Get pixel format attributes through "modern" extension
    143 
    144             if (!wglGetPixelFormatAttribivARB(window->context.wgl.dc,
    145                                               pixelFormat, 0,
    146                                               attribCount,
    147                                               attribs, values))
    148             {
    149                 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    150                                     "WGL: Failed to retrieve pixel format attributes");
    151 
    152                 free(usableConfigs);
    153                 return 0;
    154             }
    155 
    156             if (!findAttribValue(WGL_SUPPORT_OPENGL_ARB) ||
    157                 !findAttribValue(WGL_DRAW_TO_WINDOW_ARB))
    158             {
    159                 continue;
    160             }
    161 
    162             if (findAttribValue(WGL_PIXEL_TYPE_ARB) != WGL_TYPE_RGBA_ARB)
    163                 continue;
    164 
    165             if (findAttribValue(WGL_ACCELERATION_ARB) == WGL_NO_ACCELERATION_ARB)
    166                 continue;
    167 
    168             if (findAttribValue(WGL_DOUBLE_BUFFER_ARB) != fbconfig->doublebuffer)
    169                 continue;
    170 
    171             u->redBits = findAttribValue(WGL_RED_BITS_ARB);
    172             u->greenBits = findAttribValue(WGL_GREEN_BITS_ARB);
    173             u->blueBits = findAttribValue(WGL_BLUE_BITS_ARB);
    174             u->alphaBits = findAttribValue(WGL_ALPHA_BITS_ARB);
    175 
    176             u->depthBits = findAttribValue(WGL_DEPTH_BITS_ARB);
    177             u->stencilBits = findAttribValue(WGL_STENCIL_BITS_ARB);
    178 
    179             u->accumRedBits = findAttribValue(WGL_ACCUM_RED_BITS_ARB);
    180             u->accumGreenBits = findAttribValue(WGL_ACCUM_GREEN_BITS_ARB);
    181             u->accumBlueBits = findAttribValue(WGL_ACCUM_BLUE_BITS_ARB);
    182             u->accumAlphaBits = findAttribValue(WGL_ACCUM_ALPHA_BITS_ARB);
    183 
    184             u->auxBuffers = findAttribValue(WGL_AUX_BUFFERS_ARB);
    185 
    186             if (findAttribValue(WGL_STEREO_ARB))
    187                 u->stereo = GLFW_TRUE;
    188 
    189             if (_glfw.wgl.ARB_multisample)
    190                 u->samples = findAttribValue(WGL_SAMPLES_ARB);
    191 
    192             if (ctxconfig->client == GLFW_OPENGL_API)
    193             {
    194                 if (_glfw.wgl.ARB_framebuffer_sRGB ||
    195                     _glfw.wgl.EXT_framebuffer_sRGB)
    196                 {
    197                     if (findAttribValue(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB))
    198                         u->sRGB = GLFW_TRUE;
    199                 }
    200             }
    201             else
    202             {
    203                 if (_glfw.wgl.EXT_colorspace)
    204                 {
    205                     if (findAttribValue(WGL_COLORSPACE_EXT) == WGL_COLORSPACE_SRGB_EXT)
    206                         u->sRGB = GLFW_TRUE;
    207                 }
    208             }
    209         }
    210         else
    211         {
    212             // Get pixel format attributes through legacy PFDs
    213 
    214             PIXELFORMATDESCRIPTOR pfd;
    215 
    216             if (!DescribePixelFormat(window->context.wgl.dc,
    217                                      pixelFormat,
    218                                      sizeof(PIXELFORMATDESCRIPTOR),
    219                                      &pfd))
    220             {
    221                 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    222                                     "WGL: Failed to describe pixel format");
    223 
    224                 free(usableConfigs);
    225                 return 0;
    226             }
    227 
    228             if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW) ||
    229                 !(pfd.dwFlags & PFD_SUPPORT_OPENGL))
    230             {
    231                 continue;
    232             }
    233 
    234             if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) &&
    235                 (pfd.dwFlags & PFD_GENERIC_FORMAT))
    236             {
    237                 continue;
    238             }
    239 
    240             if (pfd.iPixelType != PFD_TYPE_RGBA)
    241                 continue;
    242 
    243             if (!!(pfd.dwFlags & PFD_DOUBLEBUFFER) != fbconfig->doublebuffer)
    244                 continue;
    245 
    246             u->redBits = pfd.cRedBits;
    247             u->greenBits = pfd.cGreenBits;
    248             u->blueBits = pfd.cBlueBits;
    249             u->alphaBits = pfd.cAlphaBits;
    250 
    251             u->depthBits = pfd.cDepthBits;
    252             u->stencilBits = pfd.cStencilBits;
    253 
    254             u->accumRedBits = pfd.cAccumRedBits;
    255             u->accumGreenBits = pfd.cAccumGreenBits;
    256             u->accumBlueBits = pfd.cAccumBlueBits;
    257             u->accumAlphaBits = pfd.cAccumAlphaBits;
    258 
    259             u->auxBuffers = pfd.cAuxBuffers;
    260 
    261             if (pfd.dwFlags & PFD_STEREO)
    262                 u->stereo = GLFW_TRUE;
    263         }
    264 
    265         u->handle = pixelFormat;
    266         usableCount++;
    267     }
    268 
    269     if (!usableCount)
    270     {
    271         _glfwInputError(GLFW_API_UNAVAILABLE,
    272                         "WGL: The driver does not appear to support OpenGL");
    273 
    274         free(usableConfigs);
    275         return 0;
    276     }
    277 
    278     closest = _glfwChooseFBConfig(fbconfig, usableConfigs, usableCount);
    279     if (!closest)
    280     {
    281         _glfwInputError(GLFW_FORMAT_UNAVAILABLE,
    282                         "WGL: Failed to find a suitable pixel format");
    283 
    284         free(usableConfigs);
    285         return 0;
    286     }
    287 
    288     pixelFormat = (int) closest->handle;
    289     free(usableConfigs);
    290 
    291     return pixelFormat;
    292 }
    293 
    294 #undef addAttrib
    295 #undef findAttribValue
    296 
    297 static void makeContextCurrentWGL(_GLFWwindow* window)
    298 {
    299     if (window)
    300     {
    301         if (wglMakeCurrent(window->context.wgl.dc, window->context.wgl.handle))
    302             _glfwPlatformSetTls(&_glfw.contextSlot, window);
    303         else
    304         {
    305             _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    306                                  "WGL: Failed to make context current");
    307             _glfwPlatformSetTls(&_glfw.contextSlot, NULL);
    308         }
    309     }
    310     else
    311     {
    312         if (!wglMakeCurrent(NULL, NULL))
    313         {
    314             _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    315                                  "WGL: Failed to clear current context");
    316         }
    317 
    318         _glfwPlatformSetTls(&_glfw.contextSlot, NULL);
    319     }
    320 }
    321 
    322 static void swapBuffersWGL(_GLFWwindow* window)
    323 {
    324     if (!window->monitor)
    325     {
    326         if (IsWindowsVistaOrGreater())
    327         {
    328             // DWM Composition is always enabled on Win8+
    329             BOOL enabled = IsWindows8OrGreater();
    330 
    331             // HACK: Use DwmFlush when desktop composition is enabled
    332             if (enabled ||
    333                 (SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled))
    334             {
    335                 int count = abs(window->context.wgl.interval);
    336                 while (count--)
    337                     DwmFlush();
    338             }
    339         }
    340     }
    341 
    342     SwapBuffers(window->context.wgl.dc);
    343 }
    344 
    345 static void swapIntervalWGL(int interval)
    346 {
    347     _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
    348 
    349     window->context.wgl.interval = interval;
    350 
    351     if (!window->monitor)
    352     {
    353         if (IsWindowsVistaOrGreater())
    354         {
    355             // DWM Composition is always enabled on Win8+
    356             BOOL enabled = IsWindows8OrGreater();
    357 
    358             // HACK: Disable WGL swap interval when desktop composition is enabled to
    359             //       avoid interfering with DWM vsync
    360             if (enabled ||
    361                 (SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled))
    362                 interval = 0;
    363         }
    364     }
    365 
    366     if (_glfw.wgl.EXT_swap_control)
    367         wglSwapIntervalEXT(interval);
    368 }
    369 
    370 static int extensionSupportedWGL(const char* extension)
    371 {
    372     const char* extensions = NULL;
    373 
    374     if (_glfw.wgl.GetExtensionsStringARB)
    375         extensions = wglGetExtensionsStringARB(wglGetCurrentDC());
    376     else if (_glfw.wgl.GetExtensionsStringEXT)
    377         extensions = wglGetExtensionsStringEXT();
    378 
    379     if (!extensions)
    380         return GLFW_FALSE;
    381 
    382     return _glfwStringInExtensionString(extension, extensions);
    383 }
    384 
    385 static GLFWglproc getProcAddressWGL(const char* procname)
    386 {
    387     const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname);
    388     if (proc)
    389         return proc;
    390 
    391     return (GLFWglproc) GetProcAddress(_glfw.wgl.instance, procname);
    392 }
    393 
    394 static void destroyContextWGL(_GLFWwindow* window)
    395 {
    396     if (window->context.wgl.handle)
    397     {
    398         wglDeleteContext(window->context.wgl.handle);
    399         window->context.wgl.handle = NULL;
    400     }
    401 }
    402 
    403 
    404 //////////////////////////////////////////////////////////////////////////
    405 //////                       GLFW internal API                      //////
    406 //////////////////////////////////////////////////////////////////////////
    407 
    408 // Initialize WGL
    409 //
    410 GLFWbool _glfwInitWGL(void)
    411 {
    412     PIXELFORMATDESCRIPTOR pfd;
    413     HGLRC prc, rc;
    414     HDC pdc, dc;
    415 
    416     if (_glfw.wgl.instance)
    417         return GLFW_TRUE;
    418 
    419     _glfw.wgl.instance = LoadLibraryA("opengl32.dll");
    420     if (!_glfw.wgl.instance)
    421     {
    422         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    423                              "WGL: Failed to load opengl32.dll");
    424         return GLFW_FALSE;
    425     }
    426 
    427     _glfw.wgl.CreateContext = (PFN_wglCreateContext)
    428         GetProcAddress(_glfw.wgl.instance, "wglCreateContext");
    429     _glfw.wgl.DeleteContext = (PFN_wglDeleteContext)
    430         GetProcAddress(_glfw.wgl.instance, "wglDeleteContext");
    431     _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress)
    432         GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress");
    433     _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC)
    434         GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC");
    435     _glfw.wgl.GetCurrentContext = (PFN_wglGetCurrentContext)
    436         GetProcAddress(_glfw.wgl.instance, "wglGetCurrentContext");
    437     _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent)
    438         GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent");
    439     _glfw.wgl.ShareLists = (PFN_wglShareLists)
    440         GetProcAddress(_glfw.wgl.instance, "wglShareLists");
    441 
    442     // NOTE: A dummy context has to be created for opengl32.dll to load the
    443     //       OpenGL ICD, from which we can then query WGL extensions
    444     // NOTE: This code will accept the Microsoft GDI ICD; accelerated context
    445     //       creation failure occurs during manual pixel format enumeration
    446 
    447     dc = GetDC(_glfw.win32.helperWindowHandle);
    448 
    449     ZeroMemory(&pfd, sizeof(pfd));
    450     pfd.nSize = sizeof(pfd);
    451     pfd.nVersion = 1;
    452     pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    453     pfd.iPixelType = PFD_TYPE_RGBA;
    454     pfd.cColorBits = 24;
    455 
    456     if (!SetPixelFormat(dc, ChoosePixelFormat(dc, &pfd), &pfd))
    457     {
    458         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    459                              "WGL: Failed to set pixel format for dummy context");
    460         return GLFW_FALSE;
    461     }
    462 
    463     rc = wglCreateContext(dc);
    464     if (!rc)
    465     {
    466         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    467                              "WGL: Failed to create dummy context");
    468         return GLFW_FALSE;
    469     }
    470 
    471     pdc = wglGetCurrentDC();
    472     prc = wglGetCurrentContext();
    473 
    474     if (!wglMakeCurrent(dc, rc))
    475     {
    476         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    477                              "WGL: Failed to make dummy context current");
    478         wglMakeCurrent(pdc, prc);
    479         wglDeleteContext(rc);
    480         return GLFW_FALSE;
    481     }
    482 
    483     // NOTE: Functions must be loaded first as they're needed to retrieve the
    484     //       extension string that tells us whether the functions are supported
    485     _glfw.wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)
    486         wglGetProcAddress("wglGetExtensionsStringEXT");
    487     _glfw.wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
    488         wglGetProcAddress("wglGetExtensionsStringARB");
    489     _glfw.wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
    490         wglGetProcAddress("wglCreateContextAttribsARB");
    491     _glfw.wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)
    492         wglGetProcAddress("wglSwapIntervalEXT");
    493     _glfw.wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)
    494         wglGetProcAddress("wglGetPixelFormatAttribivARB");
    495 
    496     // NOTE: WGL_ARB_extensions_string and WGL_EXT_extensions_string are not
    497     //       checked below as we are already using them
    498     _glfw.wgl.ARB_multisample =
    499         extensionSupportedWGL("WGL_ARB_multisample");
    500     _glfw.wgl.ARB_framebuffer_sRGB =
    501         extensionSupportedWGL("WGL_ARB_framebuffer_sRGB");
    502     _glfw.wgl.EXT_framebuffer_sRGB =
    503         extensionSupportedWGL("WGL_EXT_framebuffer_sRGB");
    504     _glfw.wgl.ARB_create_context =
    505         extensionSupportedWGL("WGL_ARB_create_context");
    506     _glfw.wgl.ARB_create_context_profile =
    507         extensionSupportedWGL("WGL_ARB_create_context_profile");
    508     _glfw.wgl.EXT_create_context_es2_profile =
    509         extensionSupportedWGL("WGL_EXT_create_context_es2_profile");
    510     _glfw.wgl.ARB_create_context_robustness =
    511         extensionSupportedWGL("WGL_ARB_create_context_robustness");
    512     _glfw.wgl.ARB_create_context_no_error =
    513         extensionSupportedWGL("WGL_ARB_create_context_no_error");
    514     _glfw.wgl.EXT_swap_control =
    515         extensionSupportedWGL("WGL_EXT_swap_control");
    516     _glfw.wgl.EXT_colorspace =
    517         extensionSupportedWGL("WGL_EXT_colorspace");
    518     _glfw.wgl.ARB_pixel_format =
    519         extensionSupportedWGL("WGL_ARB_pixel_format");
    520     _glfw.wgl.ARB_context_flush_control =
    521         extensionSupportedWGL("WGL_ARB_context_flush_control");
    522 
    523     wglMakeCurrent(pdc, prc);
    524     wglDeleteContext(rc);
    525     return GLFW_TRUE;
    526 }
    527 
    528 // Terminate WGL
    529 //
    530 void _glfwTerminateWGL(void)
    531 {
    532     if (_glfw.wgl.instance)
    533         FreeLibrary(_glfw.wgl.instance);
    534 }
    535 
    536 #define setAttrib(a, v) \
    537 { \
    538     assert(((size_t) index + 1) < sizeof(attribs) / sizeof(attribs[0])); \
    539     attribs[index++] = a; \
    540     attribs[index++] = v; \
    541 }
    542 
    543 // Create the OpenGL or OpenGL ES context
    544 //
    545 GLFWbool _glfwCreateContextWGL(_GLFWwindow* window,
    546                                const _GLFWctxconfig* ctxconfig,
    547                                const _GLFWfbconfig* fbconfig)
    548 {
    549     int attribs[40];
    550     int pixelFormat;
    551     PIXELFORMATDESCRIPTOR pfd;
    552     HGLRC share = NULL;
    553 
    554     if (ctxconfig->share)
    555         share = ctxconfig->share->context.wgl.handle;
    556 
    557     window->context.wgl.dc = GetDC(window->win32.handle);
    558     if (!window->context.wgl.dc)
    559     {
    560         _glfwInputError(GLFW_PLATFORM_ERROR,
    561                         "WGL: Failed to retrieve DC for window");
    562         return GLFW_FALSE;
    563     }
    564 
    565     pixelFormat = choosePixelFormat(window, ctxconfig, fbconfig);
    566     if (!pixelFormat)
    567         return GLFW_FALSE;
    568 
    569     if (!DescribePixelFormat(window->context.wgl.dc,
    570                              pixelFormat, sizeof(pfd), &pfd))
    571     {
    572         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    573                              "WGL: Failed to retrieve PFD for selected pixel format");
    574         return GLFW_FALSE;
    575     }
    576 
    577     if (!SetPixelFormat(window->context.wgl.dc, pixelFormat, &pfd))
    578     {
    579         _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    580                              "WGL: Failed to set selected pixel format");
    581         return GLFW_FALSE;
    582     }
    583 
    584     if (ctxconfig->client == GLFW_OPENGL_API)
    585     {
    586         if (ctxconfig->forward)
    587         {
    588             if (!_glfw.wgl.ARB_create_context)
    589             {
    590                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    591                                 "WGL: A forward compatible OpenGL context requested but WGL_ARB_create_context is unavailable");
    592                 return GLFW_FALSE;
    593             }
    594         }
    595 
    596         if (ctxconfig->profile)
    597         {
    598             if (!_glfw.wgl.ARB_create_context_profile)
    599             {
    600                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    601                                 "WGL: OpenGL profile requested but WGL_ARB_create_context_profile is unavailable");
    602                 return GLFW_FALSE;
    603             }
    604         }
    605     }
    606     else
    607     {
    608         if (!_glfw.wgl.ARB_create_context ||
    609             !_glfw.wgl.ARB_create_context_profile ||
    610             !_glfw.wgl.EXT_create_context_es2_profile)
    611         {
    612             _glfwInputError(GLFW_API_UNAVAILABLE,
    613                             "WGL: OpenGL ES requested but WGL_ARB_create_context_es2_profile is unavailable");
    614             return GLFW_FALSE;
    615         }
    616     }
    617 
    618     if (_glfw.wgl.ARB_create_context)
    619     {
    620         int index = 0, mask = 0, flags = 0;
    621 
    622         if (ctxconfig->client == GLFW_OPENGL_API)
    623         {
    624             if (ctxconfig->forward)
    625                 flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
    626 
    627             if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
    628                 mask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
    629             else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
    630                 mask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
    631         }
    632         else
    633             mask |= WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
    634 
    635         if (ctxconfig->debug)
    636             flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
    637 
    638         if (ctxconfig->robustness)
    639         {
    640             if (_glfw.wgl.ARB_create_context_robustness)
    641             {
    642                 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION)
    643                 {
    644                     setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
    645                               WGL_NO_RESET_NOTIFICATION_ARB);
    646                 }
    647                 else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET)
    648                 {
    649                     setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
    650                               WGL_LOSE_CONTEXT_ON_RESET_ARB);
    651                 }
    652 
    653                 flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
    654             }
    655         }
    656 
    657         if (ctxconfig->release)
    658         {
    659             if (_glfw.wgl.ARB_context_flush_control)
    660             {
    661                 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE)
    662                 {
    663                     setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
    664                               WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB);
    665                 }
    666                 else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH)
    667                 {
    668                     setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB,
    669                               WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB);
    670                 }
    671             }
    672         }
    673 
    674         if (ctxconfig->noerror)
    675         {
    676             if (_glfw.wgl.ARB_create_context_no_error)
    677                 setAttrib(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE);
    678         }
    679 
    680         // NOTE: Only request an explicitly versioned context when necessary, as
    681         //       explicitly requesting version 1.0 does not always return the
    682         //       highest version supported by the driver
    683         if (ctxconfig->major != 1 || ctxconfig->minor != 0)
    684         {
    685             setAttrib(WGL_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major);
    686             setAttrib(WGL_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor);
    687         }
    688 
    689         if (flags)
    690             setAttrib(WGL_CONTEXT_FLAGS_ARB, flags);
    691 
    692         if (mask)
    693             setAttrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask);
    694 
    695         setAttrib(0, 0);
    696 
    697         window->context.wgl.handle =
    698             wglCreateContextAttribsARB(window->context.wgl.dc, share, attribs);
    699         if (!window->context.wgl.handle)
    700         {
    701             const DWORD error = GetLastError();
    702 
    703             if (error == (0xc0070000 | ERROR_INVALID_VERSION_ARB))
    704             {
    705                 if (ctxconfig->client == GLFW_OPENGL_API)
    706                 {
    707                     _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    708                                     "WGL: Driver does not support OpenGL version %i.%i",
    709                                     ctxconfig->major,
    710                                     ctxconfig->minor);
    711                 }
    712                 else
    713                 {
    714                     _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    715                                     "WGL: Driver does not support OpenGL ES version %i.%i",
    716                                     ctxconfig->major,
    717                                     ctxconfig->minor);
    718                 }
    719             }
    720             else if (error == (0xc0070000 | ERROR_INVALID_PROFILE_ARB))
    721             {
    722                 _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    723                                 "WGL: Driver does not support the requested OpenGL profile");
    724             }
    725             else if (error == (0xc0070000 | ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB))
    726             {
    727                 _glfwInputError(GLFW_INVALID_VALUE,
    728                                 "WGL: The share context is not compatible with the requested context");
    729             }
    730             else
    731             {
    732                 if (ctxconfig->client == GLFW_OPENGL_API)
    733                 {
    734                     _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    735                                     "WGL: Failed to create OpenGL context");
    736                 }
    737                 else
    738                 {
    739                     _glfwInputError(GLFW_VERSION_UNAVAILABLE,
    740                                     "WGL: Failed to create OpenGL ES context");
    741                 }
    742             }
    743 
    744             return GLFW_FALSE;
    745         }
    746     }
    747     else
    748     {
    749         window->context.wgl.handle = wglCreateContext(window->context.wgl.dc);
    750         if (!window->context.wgl.handle)
    751         {
    752             _glfwInputErrorWin32(GLFW_VERSION_UNAVAILABLE,
    753                                  "WGL: Failed to create OpenGL context");
    754             return GLFW_FALSE;
    755         }
    756 
    757         if (share)
    758         {
    759             if (!wglShareLists(share, window->context.wgl.handle))
    760             {
    761                 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR,
    762                                      "WGL: Failed to enable sharing with specified OpenGL context");
    763                 return GLFW_FALSE;
    764             }
    765         }
    766     }
    767 
    768     window->context.makeCurrent = makeContextCurrentWGL;
    769     window->context.swapBuffers = swapBuffersWGL;
    770     window->context.swapInterval = swapIntervalWGL;
    771     window->context.extensionSupported = extensionSupportedWGL;
    772     window->context.getProcAddress = getProcAddressWGL;
    773     window->context.destroy = destroyContextWGL;
    774 
    775     return GLFW_TRUE;
    776 }
    777 
    778 #undef setAttrib
    779 
    780 
    781 //////////////////////////////////////////////////////////////////////////
    782 //////                        GLFW native API                       //////
    783 //////////////////////////////////////////////////////////////////////////
    784 
    785 GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle)
    786 {
    787     _GLFWwindow* window = (_GLFWwindow*) handle;
    788     _GLFW_REQUIRE_INIT_OR_RETURN(NULL);
    789 
    790     if (window->context.source != GLFW_NATIVE_CONTEXT_API)
    791     {
    792         _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
    793         return NULL;
    794     }
    795 
    796     return window->context.wgl.handle;
    797 }
    798