framework/platform/win32/tcuWGL.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Tester Core
   3  * ----------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief WGL Utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "tcuWGL.hpp"
  25 #include "tcuWin32Window.hpp"
  26 #include "deDynamicLibrary.hpp"
  27 #include "deMemory.h"
  28 #include "deStringUtil.hpp"
  29 #include "tcuFormatUtil.hpp"
  30 #include "gluRenderConfig.hpp"
  31 #include "glwEnums.hpp"
  32
  33 #include <map>
  34 #include <sstream>
  35 #include <iterator>
  36 #include <set>
  37
  38 #include <WinGDI.h>
  39
  40 // WGL_ARB_pixel_format
  41 #define WGL_NUMBER_PIXEL_FORMATS_ARB                            0x2000
  42 #define WGL_DRAW_TO_WINDOW_ARB                                          0x2001
  43 #define WGL_DRAW_TO_BITMAP_ARB                                          0x2002
  44 #define WGL_ACCELERATION_ARB                                            0x2003
  45 #define WGL_NEED_PALETTE_ARB                                            0x2004
  46 #define WGL_NEED_SYSTEM_PALETTE_ARB                                     0x2005
  47 #define WGL_SWAP_LAYER_BUFFERS_ARB                                      0x2006
  48 #define WGL_SWAP_METHOD_ARB                                                     0x2007
  49 #define WGL_NUMBER_OVERLAYS_ARB                                         0x2008
  50 #define WGL_NUMBER_UNDERLAYS_ARB                                        0x2009
  51 #define WGL_TRANSPARENT_ARB                                                     0x200A
  52 #define WGL_TRANSPARENT_RED_VALUE_ARB                           0x2037
  53 #define WGL_TRANSPARENT_GREEN_VALUE_ARB                         0x2038
  54 #define WGL_TRANSPARENT_BLUE_VALUE_ARB                          0x2039
  55 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB                         0x203A
  56 #define WGL_TRANSPARENT_INDEX_VALUE_ARB                         0x203B
  57 #define WGL_SHARE_DEPTH_ARB                                                     0x200C
  58 #define WGL_SHARE_STENCIL_ARB                                           0x200D
  59 #define WGL_SHARE_ACCUM_ARB                                                     0x200E
  60 #define WGL_SUPPORT_GDI_ARB                                                     0x200F
  61 #define WGL_SUPPORT_OPENGL_ARB                                          0x2010
  62 #define WGL_DOUBLE_BUFFER_ARB                                           0x2011
  63 #define WGL_STEREO_ARB                                                          0x2012
  64 #define WGL_PIXEL_TYPE_ARB                                                      0x2013
  65 #define WGL_COLOR_BITS_ARB                                                      0x2014
  66 #define WGL_RED_BITS_ARB                                                        0x2015
  67 #define WGL_RED_SHIFT_ARB                                                       0x2016
  68 #define WGL_GREEN_BITS_ARB                                                      0x2017
  69 #define WGL_GREEN_SHIFT_ARB                                                     0x2018
  70 #define WGL_BLUE_BITS_ARB                                                       0x2019
  71 #define WGL_BLUE_SHIFT_ARB                                                      0x201A
  72 #define WGL_ALPHA_BITS_ARB                                                      0x201B
  73 #define WGL_ALPHA_SHIFT_ARB                                                     0x201C
  74 #define WGL_ACCUM_BITS_ARB                                                      0x201D
  75 #define WGL_ACCUM_RED_BITS_ARB                                          0x201E
  76 #define WGL_ACCUM_GREEN_BITS_ARB                                        0x201F
  77 #define WGL_ACCUM_BLUE_BITS_ARB                                         0x2020
  78 #define WGL_ACCUM_ALPHA_BITS_ARB                                        0x2021
  79 #define WGL_DEPTH_BITS_ARB                                                      0x2022
  80 #define WGL_STENCIL_BITS_ARB                                            0x2023
  81 #define WGL_AUX_BUFFERS_ARB                                                     0x2024
  82
  83 #define WGL_NO_ACCELERATION_ARB                                         0x2025
  84 #define WGL_GENERIC_ACCELERATION_ARB                            0x2026
  85 #define WGL_FULL_ACCELERATION_ARB                                       0x2027
  86
  87 #define WGL_TYPE_RGBA_ARB                                                       0x202B
  88 #define WGL_TYPE_COLORINDEX_ARB                                         0x202C
  89
  90 // WGL_ARB_color_buffer_float
  91 #define WGL_TYPE_RGBA_FLOAT_ARB                                         0x21A0
  92
  93 // WGL_EXT_pixel_type_packed_float
  94 #define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT                        0x20A8
  95
  96 // WGL_ARB_multisample
  97 #define WGL_SAMPLE_BUFFERS_ARB                                          0x2041
  98 #define WGL_SAMPLES_ARB                                                         0x2042
  99
 100 // WGL_ARB_create_context
 101 #define WGL_CONTEXT_MAJOR_VERSION_ARB                           0x2091
 102 #define WGL_CONTEXT_MINOR_VERSION_ARB                           0x2092
 103 #define WGL_CONTEXT_LAYER_PLANE_ARB                                     0x2093
 104 #define WGL_CONTEXT_FLAGS_ARB                                           0x2094
 105 #define WGL_CONTEXT_PROFILE_MASK_ARB                            0x9126
 106 #define WGL_CONTEXT_DEBUG_BIT_ARB                                       0x0001
 107 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB          0x0002
 108 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB                        0x00000001
 109 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB       0x00000002
 110 #define WGL_CONTEXT_ES_PROFILE_BIT_EXT                          0x00000004
 111
 112 // WGL_ARB_create_context_robustness
 113 #define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB                       0x0004
 114 #define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB     0x8256
 115 #define WGL_NO_RESET_NOTIFICATION_ARB                           0x8261
 116 #define WGL_LOSE_CONTEXT_ON_RESET_ARB                           0x8252
 117
 118 // WGL ARB_create_context_no_error
 119 #define WGL_CONTEXT_OPENGL_NO_ERROR_ARB                         0x31B3
 120
 121 DE_BEGIN_EXTERN_C
 122
 123 // WGL core
 124 typedef HGLRC           (WINAPI* wglCreateContextFunc)                          (HDC hdc);
 125 typedef BOOL            (WINAPI* wglDeleteContextFunc)                          (HGLRC hglrc);
 126 typedef BOOL            (WINAPI* wglMakeCurrentFunc)                            (HDC hdc, HGLRC hglrc);
 127 typedef PROC            (WINAPI* wglGetProcAddressFunc)                         (LPCSTR lpszProc);
 128 typedef BOOL            (WINAPI* wglSwapLayerBuffersFunc)                       (HDC dhc, UINT fuPlanes);
 129
 130 // WGL_ARB_pixel_format
 131 typedef BOOL            (WINAPI* wglGetPixelFormatAttribivARBFunc)      (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
 132 typedef BOOL            (WINAPI* wglGetPixelFormatAttribfvARBFunc)      (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
 133 typedef BOOL            (WINAPI* wglChoosePixelFormatARBFunc)           (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
 134
 135 // WGL_ARB_create_context
 136 typedef HGLRC           (WINAPI* wglCreateContextAttribsARBFunc)        (HDC hdc, HGLRC hshareContext, const int* attribList);
 137 typedef const char*     (WINAPI* wglGetExtensionsStringARBFunc)         (HDC hdc);
 138
 139 DE_END_EXTERN_C
 140
 141 namespace tcu
 142 {
 143 namespace wgl
 144 {
 145
 146 // Functions
 147
 148 struct Functions
 149 {
 150         // Core
 151         wglCreateContextFunc                            createContext;
 152         wglDeleteContextFunc                            deleteContext;
 153         wglMakeCurrentFunc                                      makeCurrent;
 154         wglGetProcAddressFunc                           getProcAddress;
 155         wglSwapLayerBuffersFunc                         swapLayerBuffers;
 156
 157         // WGL_ARB_pixel_format
 158         wglGetPixelFormatAttribivARBFunc        getPixelFormatAttribivARB;
 159         wglGetPixelFormatAttribfvARBFunc        getPixelFormatAttribfvARB;
 160         wglChoosePixelFormatARBFunc                     choosePixelFormatARB;
 161
 162         // WGL_ARB_create_context
 163         wglCreateContextAttribsARBFunc          createContextAttribsARB;
 164         wglGetExtensionsStringARBFunc           getExtensionsStringARB;
 165
 166         Functions (void)
 167                 : createContext                         (DE_NULL)
 168                 , deleteContext                         (DE_NULL)
 169                 , makeCurrent                           (DE_NULL)
 170                 , getProcAddress                        (DE_NULL)
 171                 , swapLayerBuffers                      (DE_NULL)
 172                 , getPixelFormatAttribivARB     (DE_NULL)
 173                 , getPixelFormatAttribfvARB     (DE_NULL)
 174                 , choosePixelFormatARB          (DE_NULL)
 175                 , createContextAttribsARB       (DE_NULL)
 176                 , getExtensionsStringARB        (DE_NULL)
 177         {
 178         }
 179 };
 180
 181 // Library
 182
 183 class Library
 184 {
 185 public:
 186                                                                 Library                 (HINSTANCE instance);
 187                                                                 ~Library                (void);
 188
 189         const Functions&                        getFunctions    (void) const    { return m_functions;   }
 190         const de::DynamicLibrary&       getGLLibrary    (void) const    { return m_library;             }
 191         bool                                            isWglExtensionSupported (const char* extName) const;
 192
 193 private:
 194         de::DynamicLibrary                      m_library;
 195         Functions                                       m_functions;
 196         std::set<std::string>           m_extensions;
 197 };
 198
 199 Library::Library (HINSTANCE instance)
 200         : m_library("opengl32.dll")
 201 {
 202         // Temporary 1x1 window for creating context
 203         win32::Window tmpWindow(instance, 1, 1);
 204
 205         // Load WGL core.
 206         m_functions.createContext               = (wglCreateContextFunc)                m_library.getFunction("wglCreateContext");
 207         m_functions.deleteContext               = (wglDeleteContextFunc)                m_library.getFunction("wglDeleteContext");
 208         m_functions.getProcAddress              = (wglGetProcAddressFunc)               m_library.getFunction("wglGetProcAddress");
 209         m_functions.makeCurrent                 = (wglMakeCurrentFunc)                  m_library.getFunction("wglMakeCurrent");
 210         m_functions.swapLayerBuffers    = (wglSwapLayerBuffersFunc)             m_library.getFunction("wglSwapLayerBuffers");
 211
 212         if (!m_functions.createContext          ||
 213                 !m_functions.deleteContext              ||
 214                 !m_functions.getProcAddress             ||
 215                 !m_functions.makeCurrent                ||
 216                 !m_functions.swapLayerBuffers)
 217                 throw ResourceError("Failed to load core WGL functions");
 218
 219         {
 220                 PIXELFORMATDESCRIPTOR pixelFormatDesc;
 221                 deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
 222
 223                 pixelFormatDesc.nSize                   = sizeof(pixelFormatDesc);
 224                 pixelFormatDesc.nVersion                = 1;
 225                 pixelFormatDesc.dwFlags                 = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
 226                 pixelFormatDesc.iPixelType              = PFD_TYPE_RGBA;
 227                 pixelFormatDesc.iLayerType              = PFD_MAIN_PLANE;
 228
 229                 int pixelFormat = ChoosePixelFormat(tmpWindow.getDeviceContext(), &pixelFormatDesc);
 230                 if (!SetPixelFormat(tmpWindow.getDeviceContext(), pixelFormat, &pixelFormatDesc))
 231                         throw ResourceError("Failed to set pixel format for temporary context creation");
 232         }
 233
 234         // Create temporary context for loading extension functions.
 235         HGLRC tmpCtx = m_functions.createContext(tmpWindow.getDeviceContext());
 236         if (!tmpCtx || !m_functions.makeCurrent(tmpWindow.getDeviceContext(), tmpCtx))
 237         {
 238                 if (tmpCtx)
 239                         m_functions.deleteContext(tmpCtx);
 240                 throw ResourceError("Failed to create temporary WGL context");
 241         }
 242
 243         // WGL_ARB_pixel_format
 244         m_functions.getPixelFormatAttribivARB   = (wglGetPixelFormatAttribivARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribivARB");
 245         m_functions.getPixelFormatAttribfvARB   = (wglGetPixelFormatAttribfvARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribfvARB");
 246         m_functions.choosePixelFormatARB                = (wglChoosePixelFormatARBFunc)m_functions.getProcAddress("wglChoosePixelFormatARB");
 247
 248         // WGL_ARB_create_context
 249         m_functions.createContextAttribsARB             = (wglCreateContextAttribsARBFunc)m_functions.getProcAddress("wglCreateContextAttribsARB");
 250         m_functions.getExtensionsStringARB              = (wglGetExtensionsStringARBFunc)m_functions.getProcAddress("wglGetExtensionsStringARB");
 251
 252         m_functions.makeCurrent(tmpWindow.getDeviceContext(), NULL);
 253         m_functions.deleteContext(tmpCtx);
 254
 255         if (!m_functions.getPixelFormatAttribivARB      ||
 256                 !m_functions.getPixelFormatAttribfvARB  ||
 257                 !m_functions.choosePixelFormatARB               ||
 258                 !m_functions.createContextAttribsARB    ||
 259                 !m_functions.getExtensionsStringARB)
 260                 throw ResourceError("Failed to load WGL extension functions");
 261
 262         const char* extensions = m_functions.getExtensionsStringARB(tmpWindow.getDeviceContext());
 263         std::istringstream extStream(extensions);
 264         m_extensions = std::set<std::string>(std::istream_iterator<std::string>(extStream),
 265                                                                                  std::istream_iterator<std::string>());
 266 }
 267
 268 Library::~Library (void)
 269 {
 270 }
 271
 272 bool Library::isWglExtensionSupported (const char* extName) const
 273 {
 274         return m_extensions.find(extName) != m_extensions.end();
 275 }
 276
 277 // Core
 278
 279 Core::Core (HINSTANCE instance)
 280         : m_library(new Library(instance))
 281 {
 282 }
 283
 284 Core::~Core (void)
 285 {
 286         delete m_library;
 287 }
 288
 289 std::vector<int> Core::getPixelFormats (HDC deviceCtx) const
 290 {
 291         const Functions& wgl = m_library->getFunctions();
 292
 293         int attribs[] = { WGL_NUMBER_PIXEL_FORMATS_ARB };
 294         int values[DE_LENGTH_OF_ARRAY(attribs)];
 295
 296         if (!wgl.getPixelFormatAttribivARB(deviceCtx, 0, 0, DE_LENGTH_OF_ARRAY(attribs), &attribs[0], &values[0]))
 297                 TCU_THROW(ResourceError, "Failed to query number of WGL pixel formats");
 298
 299         std::vector<int> pixelFormats(values[0]);
 300         for (int i = 0; i < values[0]; i++)
 301                 pixelFormats[i] = i+1;
 302
 303         return pixelFormats;
 304 }
 305
 306 static PixelFormatInfo::Acceleration translateAcceleration (int accel)
 307 {
 308         switch (accel)
 309         {
 310                 case WGL_NO_ACCELERATION_ARB:           return PixelFormatInfo::ACCELERATION_NONE;
 311                 case WGL_GENERIC_ACCELERATION_ARB:      return PixelFormatInfo::ACCELERATION_GENERIC;
 312                 case WGL_FULL_ACCELERATION_ARB:         return PixelFormatInfo::ACCELERATION_FULL;
 313                 default:                                                        return PixelFormatInfo::ACCELERATION_UNKNOWN;
 314         }
 315 }
 316
 317 static PixelFormatInfo::PixelType translatePixelType (int type)
 318 {
 319         switch (type)
 320         {
 321                 case WGL_TYPE_RGBA_ARB:                                 return PixelFormatInfo::PIXELTYPE_RGBA;
 322                 case WGL_TYPE_RGBA_FLOAT_ARB:                   return PixelFormatInfo::PIXELTYPE_RGBA_FLOAT;
 323                 case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT:  return PixelFormatInfo::PIXELTYPE_RGBA_UNSIGNED_FLOAT;
 324                 case WGL_TYPE_COLORINDEX_ARB:                   return PixelFormatInfo::PIXELTYPE_COLOR_INDEX;
 325                 default:                                                                return PixelFormatInfo::PIXELTYPE_UNKNOWN;
 326         }
 327 }
 328
 329 static void getPixelFormatAttribs (const Functions& wgl, HDC deviceCtx, int pixelFormat, int numAttribs, const int* attribs, std::map<int, int>* dst)
 330 {
 331         std::vector<int>        values  (numAttribs);
 332
 333         if (!wgl.getPixelFormatAttribivARB(deviceCtx, pixelFormat, 0, numAttribs, &attribs[0], &values[0]))
 334                 TCU_THROW(ResourceError, "Pixel format query failed");
 335
 336         for (int ndx = 0; ndx < numAttribs; ++ndx)
 337                 (*dst)[attribs[ndx]] = values[ndx];
 338 }
 339
 340 PixelFormatInfo Core::getPixelFormatInfo (HDC deviceCtx, int pixelFormat) const
 341 {
 342         static const int        s_attribsToQuery[] =
 343         {
 344                 WGL_DRAW_TO_WINDOW_ARB,
 345                 WGL_DRAW_TO_BITMAP_ARB,
 346                 WGL_ACCELERATION_ARB,
 347                 WGL_NEED_PALETTE_ARB,
 348                 WGL_NEED_SYSTEM_PALETTE_ARB,
 349                 WGL_NUMBER_OVERLAYS_ARB,
 350                 WGL_NUMBER_UNDERLAYS_ARB,
 351                 WGL_SUPPORT_OPENGL_ARB,
 352                 WGL_DOUBLE_BUFFER_ARB,
 353                 WGL_STEREO_ARB,
 354                 WGL_PIXEL_TYPE_ARB,
 355                 WGL_RED_BITS_ARB,
 356                 WGL_GREEN_BITS_ARB,
 357                 WGL_BLUE_BITS_ARB,
 358                 WGL_ALPHA_BITS_ARB,
 359                 WGL_ACCUM_BITS_ARB,
 360                 WGL_DEPTH_BITS_ARB,
 361                 WGL_STENCIL_BITS_ARB,
 362                 WGL_AUX_BUFFERS_ARB,
 363                 WGL_SAMPLE_BUFFERS_ARB,
 364                 WGL_SAMPLES_ARB,
 365         };
 366         const Functions&        wgl                     = m_library->getFunctions();
 367         std::map<int, int>      values;
 368
 369         getPixelFormatAttribs(wgl, deviceCtx, pixelFormat, DE_LENGTH_OF_ARRAY(s_attribsToQuery), &s_attribsToQuery[0], &values);
 370
 371         // Translate values.
 372         PixelFormatInfo info;
 373
 374         info.pixelFormat                = pixelFormat;
 375         info.surfaceTypes               |= (values[WGL_DRAW_TO_WINDOW_ARB] ? PixelFormatInfo::SURFACE_WINDOW : 0);
 376         info.surfaceTypes               |= (values[WGL_DRAW_TO_BITMAP_ARB] ? PixelFormatInfo::SURFACE_PIXMAP : 0);
 377         info.acceleration               = translateAcceleration(values[2]);
 378         info.needPalette                = values[WGL_NEED_PALETTE_ARB] != 0;
 379         info.needSystemPalette  = values[WGL_NEED_SYSTEM_PALETTE_ARB] != 0;
 380         info.numOverlays                = values[WGL_NUMBER_OVERLAYS_ARB] != 0;
 381         info.numUnderlays               = values[WGL_NUMBER_UNDERLAYS_ARB] != 0;
 382         info.supportOpenGL              = values[WGL_SUPPORT_OPENGL_ARB] != 0;
 383         info.doubleBuffer               = values[WGL_DOUBLE_BUFFER_ARB] != 0;
 384         info.stereo                             = values[WGL_STEREO_ARB] != 0;
 385         info.pixelType                  = translatePixelType(values[WGL_PIXEL_TYPE_ARB]);
 386         info.redBits                    = values[WGL_RED_BITS_ARB];
 387         info.greenBits                  = values[WGL_GREEN_BITS_ARB];
 388         info.blueBits                   = values[WGL_BLUE_BITS_ARB];
 389         info.alphaBits                  = values[WGL_ALPHA_BITS_ARB];
 390         info.accumBits                  = values[WGL_ACCUM_BITS_ARB];
 391         info.depthBits                  = values[WGL_DEPTH_BITS_ARB];
 392         info.stencilBits                = values[WGL_STENCIL_BITS_ARB];
 393         info.numAuxBuffers              = values[WGL_AUX_BUFFERS_ARB];
 394         info.sampleBuffers              = values[WGL_SAMPLE_BUFFERS_ARB];
 395         info.samples                    = values[WGL_SAMPLES_ARB];
 396
 397         return info;
 398 }
 399
 400 // Context
 401
 402 Context::Context (const Core*                                           core,
 403                                   HDC                                                           deviceCtx,
 404                                   glu::ContextType                                      ctxType,
 405                                   int                                                           pixelFormat,
 406                                   glu::ResetNotificationStrategy        resetNotificationStrategy)
 407         : m_core                (core)
 408         , m_deviceCtx   (deviceCtx)
 409         , m_context             (0)
 410 {
 411         const Functions&                wgl                             = core->getLibrary()->getFunctions();
 412         std::vector<int>                attribList;
 413
 414         // Context version and profile
 415         {
 416                 int     profileBit      = 0;
 417                 int minor               = ctxType.getMinorVersion();
 418                 int major               = ctxType.getMajorVersion();
 419
 420                 switch (ctxType.getProfile())
 421                 {
 422                         case glu::PROFILE_CORE:
 423                                 profileBit = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
 424                                 if (major == 3 && minor < 3)
 425                                         minor = 3;
 426                                 break;
 427
 428                         case glu::PROFILE_ES:
 429                                 profileBit = WGL_CONTEXT_ES_PROFILE_BIT_EXT;
 430                                 break;
 431
 432                         case glu::PROFILE_COMPATIBILITY:
 433                                 profileBit = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
 434                                 break;
 435
 436                         default:
 437                                 TCU_THROW(NotSupportedError, "Unsupported context type for WGL");
 438                 }
 439
 440                 attribList.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB);
 441                 attribList.push_back(major);
 442                 attribList.push_back(WGL_CONTEXT_MINOR_VERSION_ARB);
 443                 attribList.push_back(minor);
 444                 attribList.push_back(WGL_CONTEXT_PROFILE_MASK_ARB);
 445                 attribList.push_back(profileBit);
 446         }
 447
 448         // Context flags
 449         {
 450                 int             flags   = 0;
 451
 452                 if ((ctxType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
 453                 {
 454                         if (glu::isContextTypeES(ctxType))
 455                                 TCU_THROW(InternalError, "Only OpenGL core contexts can be forward-compatible");
 456
 457                         flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
 458                 }
 459
 460                 if ((ctxType.getFlags() & glu::CONTEXT_DEBUG) != 0)
 461                         flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
 462
 463                 if ((ctxType.getFlags() & glu::CONTEXT_ROBUST) != 0)
 464                         flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
 465
 466                 if ((ctxType.getFlags() & glu::CONTEXT_NO_ERROR) != 0)
 467                 {
 468                         if (core->getLibrary()->isWglExtensionSupported("WGL_ARB_create_context_no_error"))
 469                         {
 470                                 attribList.push_back(WGL_CONTEXT_OPENGL_NO_ERROR_ARB);
 471                                 attribList.push_back(1);
 472                         }
 473                         else
 474                                 TCU_THROW(NotSupportedError, "WGL_ARB_create_context_no_error is required for creating no-error contexts");
 475                 }
 476
 477                 if (flags != 0)
 478                 {
 479                         attribList.push_back(WGL_CONTEXT_FLAGS_ARB);
 480                         attribList.push_back(flags);
 481                 }
 482         }
 483
 484         if (resetNotificationStrategy != glu::RESET_NOTIFICATION_STRATEGY_NOT_SPECIFIED)
 485         {
 486                 attribList.push_back(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
 487
 488                 if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_NO_RESET_NOTIFICATION)
 489                         attribList.push_back(WGL_NO_RESET_NOTIFICATION_ARB);
 490                 else if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_LOSE_CONTEXT_ON_RESET)
 491                         attribList.push_back(WGL_LOSE_CONTEXT_ON_RESET_ARB);
 492                 else
 493                         TCU_THROW(InternalError, "Unknown reset notification strategy");
 494         }
 495
 496         // Set pixel format
 497         {
 498                 PIXELFORMATDESCRIPTOR pixelFormatDesc;
 499                 deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
 500
 501                 if (!DescribePixelFormat(deviceCtx, pixelFormat, sizeof(pixelFormatDesc), &pixelFormatDesc))
 502                         throw ResourceError("DescribePixelFormat() failed");
 503
 504                 if (!SetPixelFormat(deviceCtx, pixelFormat, &pixelFormatDesc))
 505                         throw ResourceError("Failed to set pixel format");
 506         }
 507
 508         // Terminate attribList
 509         attribList.push_back(0);
 510
 511         // Create context
 512         m_context = wgl.createContextAttribsARB(deviceCtx, (HGLRC)0, &attribList[0]);
 513
 514         if (!m_context)
 515                 TCU_THROW(ResourceError, "Failed to create WGL context");
 516
 517         if (!wgl.makeCurrent(deviceCtx, m_context))
 518         {
 519                 wgl.deleteContext(m_context);
 520                 TCU_THROW(ResourceError, "wglMakeCurrent() failed");
 521         }
 522 }
 523
 524 Context::~Context (void)
 525 {
 526         const Functions& wgl = m_core->getLibrary()->getFunctions();
 527
 528         wgl.makeCurrent(m_deviceCtx, NULL);
 529         wgl.deleteContext(m_context);
 530 }
 531
 532 FunctionPtr Context::getGLFunction (const char* name) const
 533 {
 534         FunctionPtr ptr = DE_NULL;
 535
 536         // Try first with wglGeProcAddress()
 537         ptr = (FunctionPtr)m_core->getLibrary()->getFunctions().getProcAddress(name);
 538
 539         // Fall-back to dynlib
 540         if (!ptr)
 541                 ptr = (FunctionPtr)m_core->getLibrary()->getGLLibrary().getFunction(name);
 542
 543         return ptr;
 544 }
 545
 546 void Context::makeCurrent (void)
 547 {
 548         const Functions& wgl = m_core->getLibrary()->getFunctions();
 549         if (!wgl.makeCurrent(m_deviceCtx, m_context))
 550                 TCU_THROW(ResourceError, "wglMakeCurrent() failed");
 551 }
 552
 553 void Context::swapBuffers (void) const
 554 {
 555         const Functions& wgl = m_core->getLibrary()->getFunctions();
 556         if (!wgl.swapLayerBuffers(m_deviceCtx, WGL_SWAP_MAIN_PLANE))
 557                 TCU_THROW(ResourceError, "wglSwapBuffers() failed");
 558 }
 559
 560 bool isSupportedByTests (const PixelFormatInfo& info)
 561 {
 562         if (!info.supportOpenGL)
 563                 return false;
 564
 565         if (info.pixelType != wgl::PixelFormatInfo::PIXELTYPE_RGBA)
 566                 return false;
 567
 568         if ((info.surfaceTypes & wgl::PixelFormatInfo::SURFACE_WINDOW) == 0)
 569                 return false;
 570
 571         if (info.needPalette || info.needSystemPalette)
 572                 return false;
 573
 574         if (info.numOverlays != 0 || info.numUnderlays != 0)
 575                 return false;
 576
 577         if (info.stereo)
 578                 return false;
 579
 580         return true;
 581 }
 582
 583 int choosePixelFormat (const Core& wgl, HDC deviceCtx, const glu::RenderConfig& config)
 584 {
 585         std::vector<int> pixelFormats = wgl.getPixelFormats(deviceCtx);
 586
 587         for (std::vector<int>::const_iterator fmtIter = pixelFormats.begin(); fmtIter != pixelFormats.end(); ++fmtIter)
 588         {
 589                 const PixelFormatInfo info = wgl.getPixelFormatInfo(deviceCtx, *fmtIter);
 590
 591                 // Skip formats that are fundamentally not compatible with current tests
 592                 if (!isSupportedByTests(info))
 593                         continue;
 594
 595                 if (config.redBits != glu::RenderConfig::DONT_CARE &&
 596                         config.redBits != info.redBits)
 597                         continue;
 598
 599                 if (config.greenBits != glu::RenderConfig::DONT_CARE &&
 600                         config.greenBits != info.greenBits)
 601                         continue;
 602
 603                 if (config.blueBits != glu::RenderConfig::DONT_CARE &&
 604                         config.blueBits != info.blueBits)
 605                         continue;
 606
 607                 if (config.alphaBits != glu::RenderConfig::DONT_CARE &&
 608                         config.alphaBits != info.alphaBits)
 609                         continue;
 610
 611                 if (config.depthBits != glu::RenderConfig::DONT_CARE &&
 612                         config.depthBits != info.depthBits)
 613                         continue;
 614
 615                 if (config.stencilBits != glu::RenderConfig::DONT_CARE &&
 616                         config.stencilBits != info.stencilBits)
 617                         continue;
 618
 619                 if (config.numSamples != glu::RenderConfig::DONT_CARE &&
 620                         config.numSamples != info.samples)
 621                         continue;
 622
 623                 // Passed all tests - select this.
 624                 return info.pixelFormat;
 625         }
 626
 627         return -1;
 628 }
 629
 630 } // wgl
 631 } // tcu