WGLContext.cpp

#ifdef _WIN32
 
#include "GLFuncPointers.h"
#include "GLContext.h"
 
#include "../IGraphicsDevice.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/WindowData.h"
 
#include <cstring>
 
namespace {
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("WGLContext");
 
  PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = nullptr;
  PFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB = nullptr;
  PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = nullptr;
  PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = nullptr;
  PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB = nullptr;
 
  struct LibFunc {
    void** ptr;
    const char* name;
  };
  LibFunc WGLFuncs[] = {
    { (void**)&wglChoosePixelFormatARB, "wglChoosePixelFormatARB"},
    { (void**)&wglGetPixelFormatAttribivARB, "wglGetPixelFormatAttribivARB"},
    { (void**)&wglSwapIntervalEXT, "wglSwapIntervalEXT"},
    { (void**)&wglGetExtensionsStringARB, "wglGetExtensionsStringARB"},
    { (void**)&wglCreateContextAttribsARB, "wglCreateContextAttribsARB"},
  };
 
  bool getWGLFuncPointers()
  {
    for (const LibFunc& libFunc : WGLFuncs) {
      *libFunc.ptr = wglGetProcAddress(libFunc.name);
      if (*libFunc.ptr == nullptr) {  // GetProcAddress signals failure by returning null
        LOG_FATAL(logger, "Failed to look up %s (GetLastError()=%d).", libFunc.name, GetLastError());
        return false;
      }
    }
    return true;
  }
 
  LRESULT CALLBACK dummyWindowWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  {
    if (message == WM_NCCREATE) {
      HWND* hwndPtr = reinterpret_cast<HWND*>(((LPCREATESTRUCT)lParam)->lpCreateParams);
      *hwndPtr = hWnd;
    }
    return ::DefWindowProc(hWnd, message, wParam, lParam);
  }
 
 
  bool dummyWindowCreate(HWND& hWnd, LPCWSTR windowName)
  {
    static ATOM classAtom = 0;
    if (classAtom == 0) {
      WNDCLASSEX wcex = { 0 };
      wcex.cbSize = sizeof(WNDCLASSEX);
      wcex.style = CS_OWNDC;
      wcex.lpfnWndProc = dummyWindowWndProc;
      wcex.hInstance = GetModuleHandle(NULL);
      wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 2);
      wcex.lpszClassName = TEXT("CogsRenderingWGLDummyWindow");
      classAtom = RegisterClassEx(&wcex);
      if (classAtom == 0) {
        LOG_ERROR(logger, "RegisterClass failed for dummy window(GetLastError()=%x).", GetLastError());
        return false;
      }
    }
 
    CreateWindow((LPCTSTR)classAtom, windowName,
                 WS_OVERLAPPEDWINDOW,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 CW_USEDEFAULT,
                 NULL,
                 NULL,
                 GetModuleHandle(NULL),
                 &hWnd);
 
    if (hWnd == nullptr) {
      return false;
    }
    return true;
  }
 
  void dummyWindowDestroy(HWND& hwnd)
  {
    if (hwnd) {
      DestroyWindow(hwnd);
      hwnd = nullptr;
    }
  }
 
  struct DummyContext
  {
    ~DummyContext() { destroy(); }
 
    bool create()
    {
      if (!dummyWindowCreate(dummyWindow, TEXT("DummyContextWindow"))) return false;
 
      PIXELFORMATDESCRIPTOR dummy_pfd = { 0 };
      dummy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
      dummy_pfd.nVersion = 1;
      dummy_pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
      dummy_pfd.iPixelType = PFD_TYPE_RGBA;
      dummy_pfd.cColorBits = 32;
      dummy_pfd.cDepthBits = 24;
      dummy_pfd.cStencilBits = 8;
      dummy_pfd.iLayerType = PFD_MAIN_PLANE;
 
      hdc = GetDC(dummyWindow);
      int dummy_pf = ChoosePixelFormat(hdc, &dummy_pfd);
      if (!dummy_pf) {
        LOG_FATAL(logger, "Failed to choose pixel format (GetLastError()=%d).", GetLastError());
        return false;
      }
      if (!SetPixelFormat(hdc, dummy_pf, &dummy_pfd)) {
        LOG_FATAL(logger, "Failed to set pixel format (GetLastError()=%d).", GetLastError());
        return false;
      }
      context = wglCreateContext(hdc);
      if (!context) {
        LOG_FATAL(logger, "Failed to create dummy context (GetLastError()=%d).", GetLastError());
        return false;
      }
 
      if (!wglMakeCurrent(hdc, context)) {
        LOG_FATAL(logger, "Failed to make dummy context current (GetLastError()=%d).", GetLastError());
        return false;
      }
 
      return true;
    }
 
    void destroy()
    {
      if (context) {
        wglMakeCurrent(hdc, nullptr);
        wglDeleteContext(context);
      }
      dummyWindowDestroy(dummyWindow);
    }
 
    HWND dummyWindow = nullptr;
    HGLRC context = nullptr;
    HDC hdc = nullptr;
  };
 
  bool chooseAndSetPixelFormat(HDC hdc, int requestedSampleCount, bool sRGB)
  {
    PIXELFORMATDESCRIPTOR pfd = { 0 };
    std::vector<int> pfAttribs = {
      WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
      WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
      WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
      WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
      WGL_COLOR_BITS_ARB, 24,
      WGL_ALPHA_BITS_ARB, 8,
      WGL_DEPTH_BITS_ARB, 24,
      WGL_STENCIL_BITS_ARB, 8,
    };
 
    if (sRGB) {
      pfAttribs.push_back(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB);
      pfAttribs.push_back(GL_TRUE);
    }
    pfAttribs.push_back(0);
 
    const int maxPixelFormats = 1024;
    std::vector<int> pixelFormats(maxPixelFormats);
    UINT numFormats;
    if (!wglChoosePixelFormatARB(hdc, pfAttribs.data(), nullptr, maxPixelFormats, pixelFormats.data(), &numFormats))
    {
      LOG_FATAL(logger, "wglChoosePixelFormatARB failed (GetLastError()=%d).", GetLastError());
      return false;
    }
 
    size_t bestFormat = 0;
    int bestSampleCount = 0;
    if (requestedSampleCount) {
 
      static const int attributeNames[2] = { WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB };
      for (size_t i = 0; i < numFormats; i++) {
        int attributeValues[2] = {};
        if (!wglGetPixelFormatAttribivARB(hdc, pixelFormats[i], 0, 2, attributeNames, attributeValues)) {
          LOG_FATAL(logger, "wglGetPixelFormatAttribivARB failed (GetLastError()=%d).", GetLastError());
          return false;
        }
        int sampleBuffers = attributeValues[0];
        int sampleCount = attributeValues[1];
        if (sampleBuffers && (bestSampleCount < sampleCount) && (sampleCount <= requestedSampleCount)) {
          bestFormat = i;
          bestSampleCount = sampleCount;
        }
        LOG_DEBUG(logger, "%zu: format=0x%x sampleBufs=%d sampleCount=%d", i, pixelFormats[i], attributeValues[0], attributeValues[1]);
      }
    }
    LOG_DEBUG(logger, "Requested %d samples, chose pixel format %zu: 0x%x", requestedSampleCount, bestFormat, pixelFormats[bestFormat]);
 
    if (!SetPixelFormat(hdc, pixelFormats[bestFormat], &pfd)) {
      LOG_FATAL(logger, "Failed to set pixel format (GetLastError()=%d).", GetLastError());
      return false;
    }
    return true;
  }
 
 
  bool finalizeContext(Cogs::GLContextBase::Platform platform, bool debug, bool sRGB)
  {
    if (debug) {
      Cogs::setUpGLDebugging(nullptr, platform);
    }
 
    if (sRGB) {
      glEnable(GL_FRAMEBUFFER_SRGB_EXT);
    }
 
    return true;
  }
 
}
 
bool Cogs::GLContext::create(NativeDisplay /*display*/, WindowData* windowData, GLContext* shareContext, const GraphicsDeviceSettings* settings, Platform desiredPlatform, bool debug)
{
  assert(hdc == nullptr);
  assert(context == nullptr);
  platform = Platform::GL;
 
  DummyContext dummyContext;
  if (!dummyContext.create()) {
    return false;
  }
  if (!getWGLFuncPointers()) {
    LOG_FATAL(logger, "Failed to get required WGL function pointers");
    return false;
  }
 
 
  if (windowData == nullptr) {
    LOG_DEBUG(logger, "Creating headless dummy window");
    if (!dummyWindowCreate(headlessHwnd, TEXT("HeadlessContextWindow"))) {
      LOG_FATAL(logger, "Failed to create context sharing dummy window");
      return false;
    }
    hdc = GetDC(headlessHwnd);
  }
  else {
    hdc = GetDC(windowData->windowHandle);
  }
 
  const char* wglExtensions = wglGetExtensionsStringARB(hdc);
  bool sRGB = std::strstr(wglExtensions, "WGL_EXT_framebuffer_sRGB") != nullptr;
  int numSamples = settings && (std::strstr(wglExtensions, "WGL_ARB_multisample") != nullptr) ? settings->numSamples : 0;
  if (!chooseAndSetPixelFormat(hdc, numSamples, sRGB)) {
    return false;
  }
 
  std::vector<int> cxAttribs;
  if (debug) {
    cxAttribs.push_back(WGL_CONTEXT_FLAGS_ARB); cxAttribs.push_back(WGL_CONTEXT_DEBUG_BIT_ARB);
  }
 
  // OpenGL ES3 - try to get ES context
  if (desiredPlatform == Platform::ES3) {
    if (std::strstr(wglExtensions, "WGL_EXT_create_context_es2_profile") != nullptr) {
      LOG_DEBUG(logger, "WGL_EXT_create_context_es2_profile present, creating real ES3 context");
      cxAttribs.push_back(WGL_CONTEXT_PROFILE_MASK_ARB);  cxAttribs.push_back(WGL_CONTEXT_ES2_PROFILE_BIT_EXT);
      cxAttribs.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB); cxAttribs.push_back(3);
      cxAttribs.push_back(WGL_CONTEXT_MINOR_VERSION_ARB); cxAttribs.push_back(0);
      platform = Platform::ES3;
    }
    else {
      platform = Platform::GL;
    }
  }
 
  // OpenGL Desktop
  else {
    // Note: 3.0 will give you most recent version with compatibility
    // From 3.1 it will in practice give you that specific version
    cxAttribs.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB); cxAttribs.push_back(3);
    cxAttribs.push_back(WGL_CONTEXT_MINOR_VERSION_ARB); cxAttribs.push_back(0);
    platform = Platform::GL;
  }
  cxAttribs.push_back(0);
 
  context = wglCreateContextAttribsARB(hdc, shareContext ? shareContext->context : nullptr, cxAttribs.data());
  if (!context) {
    LOG_ERROR(logger, "wglCreateContextAttribsARB failed (GetLastError()=%d).", GetLastError());
    return false;
  }
 
 
  dummyContext.destroy();
 
  if (!makeCurrent()) {
    LOG_ERROR(logger, "Failed to make context current (GetLastError()=%d).", GetLastError());
    return false;
  }
 
  // OpenGL ES3
  if (desiredPlatform == Platform::ES3) {
    if (!getGLES3FuncPointers(platform)) {
      destroy();
      return false;
    }
    if (platform == Platform::GL && (std::strstr((const char*)glGetString(GL_EXTENSIONS), "ARB_ES3_compatibility") == nullptr)) {
      LOG_FATAL(logger, "Neither WGL_EXT_create_context_es2_profile nor ARB_ES3_compatibility extensions are present");
      destroy();
      return false;
    }
  }
 
  // OpenGL Desktop
  else {
    if (!getGLFuncPointers()) {
      destroy();
      return false;
    }
  }
 
  finalizeContext(platform, debug, sRGB);
  return true;
}
 
bool Cogs::GLContext::makeCurrent()
{
  return wglMakeCurrent(hdc, context);
}
 
void Cogs::GLContext::swapBuffers(uint32_t syncInterval, uint32_t presentFlags)
{
 
  if (context == 0) return;
 
  if ((presentFlags & PresentFlags::NoSwap) == 0) {
    if (wglSwapIntervalEXT) {
      wglSwapIntervalEXT(syncInterval != 0 ? 1 : 0);
    }
    ::SwapBuffers(hdc);
  }
 
}
 
 
void Cogs::GLContext::destroy()
{
  if (context) {
    wglMakeCurrent(hdc, nullptr);
    wglDeleteContext(context);
    context = nullptr;
  }
  hdc = nullptr;
}
 
#endif