title: Why don't I have WGL_ARB_create_context extension?
body: <p>I'm executing the following code to create a core-profile OpenGL context.</p>
  
  <p>Specifically, I am:</p>
  
  <ol>
  <li>Creating a dummy window</li>
  <li>Using this dummy window to request an OpenGL context (I assume it would be hardware accelerated, but I'm not sure that would even matter)</li>
  <li>Using this OpenGL context to load OpenGL function pointers</li>
  <li>With these function pointers, I then attempt to use <code>wglCreateContextAttribsARB</code> to create second context specifically with a core profile in a second window.</li>
  </ol>
  
  <p>Code:</p>
  
  <pre><code>WNDCLASSW wcDummy = {0};
  wcDummy.lpfnWndProc     = +[](HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){return DefWindowProcW(hWnd, message, wParam, lParam);};
  wcDummy.hInstance       = GetModuleHandle(0);
  wcDummy.hbrBackground   = (HBRUSH)(COLOR_BACKGROUND);
  wcDummy.lpszClassName   = L"Dummy";
  wcDummy.style           = CS_OWNDC;
  
  if(!RegisterClassW(&amp;wcDummy))
  {
      get_and_print_error();
      return false;
  }
  
  HWND windowDummy = CreateWindowW(wcDummy.lpszClassName, title.c_str(), WS_DISABLED, 0, 0, 640, 480, 0, 0, wcDummy.hInstance, NULL);
  if(windowDummy == NULL)
  {
      get_and_print_error();
      return false;
  }
  
  PIXELFORMATDESCRIPTOR pfdDummy =
  {
      sizeof(PIXELFORMATDESCRIPTOR),
      1,
      PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
      PFD_TYPE_RGBA,
      32,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      24,
      8,
      0, 0, 0, 0, 0, 0
  };
  
  HDC dummyDrawingContext = GetDC(windowDummy);
  
  INT pixelFormatDummy = ChoosePixelFormat(dummyDrawingContext, &amp;pfdDummy);
  SetPixelFormat(dummyDrawingContext, pixelFormatDummy, &amp;pfdDummy);
  
  HGLRC dummyContext = wglCreateContext(dummyDrawingContext);
  wglMakeCurrent(dummyDrawingContext, dummyContext);
  
  if(wglGetCurrentContext() != NULL)
  {
      load_gl_functions();
  }
  else
      return false;
  
  PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = nullptr;
  
  GLint64 numExtensions;
  glGetInteger64v(GL_NUM_EXTENSIONS, &amp;numExtensions);
  std::cout &lt;&lt; "Available Extensions:\n";
  for(GLint64 i = 0; i &lt; numExtensions; ++i)
  {
      const GLubyte* extensionName = glGetStringi(GL_EXTENSIONS, i);
  
      std::cout &lt;&lt; "\n\t" &lt;&lt; (const char*)extensionName;
  
      if(std::strcmp((const char*)extensionName, "WGL_ARB_create_context") == 0)
      {
          wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");
      }
  }
  std::cout &lt;&lt; std::endl;
  
  wglDeleteContext(dummyContext);
  DestroyWindow(windowDummy);
  
  WNDCLASSW wc = {0};
  wc.lpfnWndProc      = Window::WndProc;
  wc.hInstance        = GetModuleHandle(0);
  wc.hbrBackground    = (HBRUSH)(COLOR_BACKGROUND);
  wc.lpszClassName    = title.c_str();
  wc.style = CS_OWNDC;
  
  if(!RegisterClassW(&amp;wc))
  {
      get_and_print_error();
      return false;
  }
  
  HWND window = CreateWindowW(wc.lpszClassName, title.c_str(), WS_OVERLAPPED|WS_VISIBLE|WS_SYSMENU ,0,0,640,480,0,0,wc.hInstance,this);
  if(window == NULL)
  {
      get_and_print_error();
      return false;
  }
  
  PIXELFORMATDESCRIPTOR pfd =
  {
      sizeof(PIXELFORMATDESCRIPTOR),
      1,
      PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
      PFD_TYPE_RGBA,
      32,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      24,
      8,
      0, 0, 0, 0, 0, 0
  };
  
  HDC m_drawingContext = GetDC(window);
  
  INT pixelFormat = ChoosePixelFormat(m_drawingContext, &amp;pfd);
  SetPixelFormat(m_drawingContext, pixelFormat, &amp;pfd);
  
  const GLint attribList[] =
  {
      WGL_CONTEXT_MAJOR_VERSION_ARB, 4,
      WGL_CONTEXT_MINOR_VERSION_ARB, 4,
      WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
      0
  };
  
  m_glRenderContext = wglCreateContextAttribsARB(m_drawingContext, 0, attribList);
  
  wglMakeCurrent(m_drawingContext, m_glRenderContext);
  
  if(wglGetCurrentContext() != NULL)
  {
      load_gl_functions();
  }
  else
      return false;
  
  const GLubyte* driver = glGetString(GL_RENDERER);
  const GLubyte* version = glGetString(GL_VERSION);
  const GLubyte* glslVersion = glGetString(GL_SHADING_LANGUAGE_VERSION);
  
  std::wcout &lt;&lt; "Device:       " &lt;&lt; std::wstring(convert_gl_string_to_win32_string(driver)) &lt;&lt; std::endl;
  std::wcout &lt;&lt; "GL Version:   " &lt;&lt; std::wstring(convert_gl_string_to_win32_string(version)) &lt;&lt; std::endl;
  std::wcout &lt;&lt; "GLSL Version: " &lt;&lt; std::wstring(convert_gl_string_to_win32_string(glslVersion)) &lt;&lt; std::endl;
  std::wcout &lt;&lt; std::endl;
  </code></pre>
  
  <p>The problem is that the <code>WGL_ARB_create_context</code> extension does not exist.</p>
  
  <p>However, if I forget about checking the list of extensions, i.e. forgo the loop and simply:</p>
  
  <pre><code>wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");
  </code></pre>
  
  <p>I end up with a function pointer and everything works correctly.</p>
  
  <p>Why does my list of available extensions not provide the <code>WGL_ARB_create_context</code> string, even though the extension exists?</p>
  
  <p><strong>EDIT</strong> I have an AMD Radeon HD 7900 seriesY</p>