GPUDisplayFrontendGlfw.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#include "GPUDisplayFrontendGlfw.h"
#include "backend/GPUDisplayBackend.h"
#include "GPUDisplayGUIWrapper.h"
#include "GPULogging.h"
 
#ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
#define GLFW_INCLUDE_VULKAN
#endif
#include <GLFW/glfw3.h>
 
#include <cstdio>
#include <cstring>
#include <unistd.h>
 
using namespace o2::gpu;
 
GPUDisplayFrontendGlfw::GPUDisplayFrontendGlfw()
{
  mFrontendType = TYPE_GLFW;
  mFrontendName = "GLFW";
}
 
static GPUDisplayFrontendGlfw* me = nullptr;
 
int32_t GPUDisplayFrontendGlfw::GetKey(int32_t key)
{
  if (key == GLFW_KEY_KP_SUBTRACT) {
    return ('-');
  }
  if (key == GLFW_KEY_KP_ADD) {
    return ('+');
  }
  if (key == GLFW_KEY_LEFT_SHIFT || key == GLFW_KEY_RIGHT_SHIFT) {
    return (KEY_SHIFT);
  }
  if (key == GLFW_KEY_LEFT_ALT) {
    return (KEY_ALT);
  }
  if (key == GLFW_KEY_RIGHT_ALT) {
    return (KEY_RALT);
  }
  if (key == GLFW_KEY_LEFT_CONTROL) {
    return (KEY_CTRL);
  }
  if (key == GLFW_KEY_RIGHT_CONTROL) {
    return (KEY_RCTRL);
  }
  if (key == GLFW_KEY_UP) {
    return (KEY_UP);
  }
  if (key == GLFW_KEY_DOWN) {
    return (KEY_DOWN);
  }
  if (key == GLFW_KEY_LEFT) {
    return (KEY_LEFT);
  }
  if (key == GLFW_KEY_RIGHT) {
    return (KEY_RIGHT);
  }
  if (key == GLFW_KEY_PAGE_UP) {
    return (KEY_PAGEUP);
  }
  if (key == GLFW_KEY_PAGE_DOWN) {
    return (KEY_PAGEDOWN);
  }
  if (key == GLFW_KEY_ESCAPE) {
    return (KEY_ESCAPE);
  }
  if (key == GLFW_KEY_SPACE) {
    return (KEY_SPACE);
  }
  if (key == GLFW_KEY_HOME) {
    return (KEY_HOME);
  }
  if (key == GLFW_KEY_END) {
    return (KEY_END);
  }
  if (key == GLFW_KEY_INSERT) {
    return (KEY_INSERT);
  }
  if (key == GLFW_KEY_ENTER) {
    return (KEY_ENTER);
  }
  if (key == GLFW_KEY_F1) {
    return (KEY_F1);
  }
  if (key == GLFW_KEY_F2) {
    return (KEY_F2);
  }
  if (key == GLFW_KEY_F3) {
    return (KEY_F3);
  }
  if (key == GLFW_KEY_F4) {
    return (KEY_F4);
  }
  if (key == GLFW_KEY_F5) {
    return (KEY_F5);
  }
  if (key == GLFW_KEY_F6) {
    return (KEY_F6);
  }
  if (key == GLFW_KEY_F7) {
    return (KEY_F7);
  }
  if (key == GLFW_KEY_F8) {
    return (KEY_F8);
  }
  if (key == GLFW_KEY_F9) {
    return (KEY_F9);
  }
  if (key == GLFW_KEY_F10) {
    return (KEY_F10);
  }
  if (key == GLFW_KEY_F11) {
    return (KEY_F11);
  }
  if (key == GLFW_KEY_F12) {
    return (KEY_F12);
  }
  return (0);
}
 
void GPUDisplayFrontendGlfw::GetKey(int32_t key, int32_t scancode, int32_t mods, int32_t& keyOut, int32_t& keyPressOut)
{
  int32_t specialKey = GetKey(key);
  const char* str = glfwGetKeyName(key, scancode);
  char localeKey = str ? str[0] : 0;
  if ((mods & GLFW_MOD_SHIFT) && localeKey >= 'a' && localeKey <= 'z') {
    localeKey += 'A' - 'a';
  }
  // GPUInfo("Key: key %d (%c) scancode %d -> %d (%c) special %d (%c)", key, (char)key, scancode, (int32_t)localeKey, localeKey, specialKey, (char)specialKey);
 
  if (specialKey) {
    keyOut = keyPressOut = specialKey;
  } else {
    keyOut = keyPressOut = (uint8_t)localeKey;
    if (keyPressOut >= 'a' && keyPressOut <= 'z') {
      keyPressOut += 'A' - 'a';
    }
  }
}
 
void GPUDisplayFrontendGlfw::error_callback(int32_t error, const char* description) { fprintf(stderr, "Error: %s\n", description); }
 
void GPUDisplayFrontendGlfw::key_callback(GLFWwindow* window, int32_t key, int32_t scancode, int32_t action, int32_t mods)
{
  int32_t handleKey = 0, keyPress = 0;
  GetKey(key, scancode, mods, handleKey, keyPress);
  if (handleKey < 32) {
    if (action == GLFW_PRESS) {
      me->mKeys[keyPress] = true;
      me->mKeysShift[keyPress] = mods & GLFW_MOD_SHIFT;
      me->HandleKey(handleKey);
    } else if (action == GLFW_RELEASE) {
      me->mKeys[keyPress] = false;
      me->mKeysShift[keyPress] = false;
    }
  } else if (handleKey < 256) {
    if (action == GLFW_PRESS) {
      me->mLastKeyDown = handleKey;
    } else if (action == GLFW_RELEASE) {
      keyPress = (uint8_t)me->mKeyDownMap[handleKey];
      me->mKeys[keyPress] = false;
      me->mKeysShift[keyPress] = false;
    }
  }
}
 
void GPUDisplayFrontendGlfw::char_callback(GLFWwindow* window, uint32_t codepoint)
{
  // GPUInfo("Key (char callback): %d %c - key: %d", codepoint, (char)codepoint, (int32_t)me->mLastKeyDown);
  if (codepoint < 256) {
    uint8_t keyPress = codepoint;
    if (keyPress >= 'a' && keyPress <= 'z') {
      keyPress += 'A' - 'a';
    }
    me->mKeyDownMap[me->mLastKeyDown] = keyPress;
    me->mKeys[keyPress] = true;
    me->mKeysShift[keyPress] = me->mKeys[KEY_SHIFT];
    me->HandleKey(codepoint);
  }
}
 
void GPUDisplayFrontendGlfw::mouseButton_callback(GLFWwindow* window, int32_t button, int32_t action, int32_t mods)
{
  if (action == GLFW_PRESS) {
    if (button == 0) {
      me->mMouseDn = true;
    } else if (button == 1) {
      me->mMouseDnR = true;
    } else if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
      me->mMouseDnM = true;
    }
    me->mMouseDnX = me->mMouseMvX;
    me->mMouseDnY = me->mMouseMvY;
  } else if (action == GLFW_RELEASE) {
    if (button == 0) {
      me->mMouseDn = false;
    } else if (button == 1) {
      me->mMouseDnR = false;
    } else if (button == GLFW_MOUSE_BUTTON_MIDDLE) {
      me->mMouseDnM = false;
    }
  }
}
 
void GPUDisplayFrontendGlfw::scroll_callback(GLFWwindow* window, double x, double y) { me->mMouseWheel += y * 100; }
 
void GPUDisplayFrontendGlfw::cursorPos_callback(GLFWwindow* window, double x, double y)
{
  me->mMouseMvX = x * me->mPixelRatio; // Window coordinates to framebuffer pixels
  me->mMouseMvY = y * me->mPixelRatio;
}
 
void GPUDisplayFrontendGlfw::resize_callback(GLFWwindow* window, int32_t width, int32_t height) // Framebuffer size in pixels
{
  int32_t windowWidth, windowHeight;
  glfwGetWindowSize(window, &windowWidth, &windowHeight);
  me->mPixelRatio = windowWidth ? (double)width / windowWidth : 1.;
  me->ResizeScene(width, height);
}
 
void GPUDisplayFrontendGlfw::focus_callback(GLFWwindow* window, int32_t focused)
{
  if (!focused) {
    me->focusLost();
  }
}
 
void GPUDisplayFrontendGlfw::contentScale_callback(GLFWwindow* window, float xscale, float yscale)
{
  me->mScale = xscale;
}
 
void GPUDisplayFrontendGlfw::maximize_callback(GLFWwindow* window, int32_t maximized)
{
  me->setWindowState(glfwGetWindowMonitor(window) != nullptr, maximized);
  if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND) { // Called before the resize. GLFW keeps the maximized size if the compositor leaves the size to the client when unmaximizing, so restore the last windowed size
    if (maximized) {
      glfwGetWindowSize(window, &me->mWindowedWidth, &me->mWindowedHeight);
    } else {
      me->mRestoreWindowedSize = true; // Must be applied after GLFW has processed the configure event, otherwise GLFW resizes to the pending maximized size again
    }
  }
}
 
int32_t GPUDisplayFrontendGlfw::FrontendMain()
{
  me = this;
 
  if (!glfwInit()) {
    fprintf(stderr, "Error initializing glfw\n");
    return (-1);
  }
  glfwSetErrorCallback(error_callback);
 
  if (backend()->backendType() == GPUDisplayBackend::TYPE_VULKAN) {
    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
  }
  if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, GL_MIN_VERSION_MAJOR);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_MIN_VERSION_MINOR);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 0);
    glfwWindowHint(GLFW_OPENGL_PROFILE, mBackend->CoreProfile() ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
  }
  glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Initial size scaled by the content scale on X11 / Win32
  mWindow = glfwCreateWindow(INIT_WIDTH, INIT_HEIGHT, DISPLAY_WINDOW_NAME, nullptr, nullptr);
  if (!mWindow) {
    fprintf(stderr, "Error creating glfw window\n");
    glfwTerminate();
    return (-1);
  }
  if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
    glfwMakeContextCurrent(mWindow);
  }
 
  glfwSetKeyCallback(mWindow, key_callback);
  glfwSetCharCallback(mWindow, char_callback);
  glfwSetMouseButtonCallback(mWindow, mouseButton_callback);
  glfwSetScrollCallback(mWindow, scroll_callback);
  glfwSetCursorPosCallback(mWindow, cursorPos_callback);
  glfwSetFramebufferSizeCallback(mWindow, resize_callback);
  glfwSetWindowMaximizeCallback(mWindow, maximize_callback);
  glfwSetWindowFocusCallback(mWindow, focus_callback);
  float xscale, yscale;
  glfwGetWindowContentScale(mWindow, &xscale, &yscale);
  contentScale_callback(mWindow, xscale, yscale);
  glfwSetWindowContentScaleCallback(mWindow, contentScale_callback);
  const float limitScale = (glfwGetPlatform() == GLFW_PLATFORM_X11 || glfwGetPlatform() == GLFW_PLATFORM_WIN32) ? mScale : 1.f; // Window coordinates are pixels on X11 / Win32, logical on Wayland / macOS
  glfwSetWindowSizeLimits(mWindow, MIN_WIDTH * limitScale, MIN_HEIGHT * limitScale, GLFW_DONT_CARE, GLFW_DONT_CARE);
  int32_t fbWidth, fbHeight, windowWidth, windowHeight;
  glfwGetFramebufferSize(mWindow, &fbWidth, &fbHeight);
  glfwGetWindowSize(mWindow, &windowWidth, &windowHeight);
  mPixelRatio = windowWidth ? (double)fbWidth / windowWidth : 1.; // Updated in resize_callback, which must not be called before InitDisplay
  applyInitialWindowState();
  SetVSync(vsyncEnabled());
 
  if (mBackend->ExtInit()) {
    fprintf(stderr, "Error initializing GL extension wrapper\n");
    return (-1);
  }
 
  if (InitDisplay()) {
    fprintf(stderr, "Error in GLFW display initialization\n");
    return (1);
  }
 
  {
    std::lock_guard lock(mExitStateMutex);
    mDisplayRunning = true; // Only after successful initialization, StopDisplay waits for it to become false again
  }
 
  int32_t retVal = 0;
  while (!glfwWindowShouldClose(mWindow)) {
    HandleExternalGUISignals();
    if (DrawGLScene()) {
      fprintf(stderr, "Error drawing GL scene\n");
      retVal = 1;
      break; // Cleanup below
    }
    if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
      glfwSwapBuffers(mWindow);
    }
    waitForFPSLimit();
    glfwPollEvents();
    if (mRestoreWindowedSize) {
      mRestoreWindowedSize = false;
      if (mWindowedWidth > 0 && mWindowedHeight > 0 && !glfwGetWindowAttrib(mWindow, GLFW_MAXIMIZED)) {
        glfwSetWindowSize(mWindow, mWindowedWidth, mWindowedHeight);
      }
    }
  }
 
  ExitDisplay();
  {
    std::lock_guard lock(mExitStateMutex);
    mDisplayControl = 2;
    glfwDestroyWindow(mWindow);
    glfwTerminate();
    mDisplayRunning = false;
  }
 
  return retVal;
}
 
void GPUDisplayFrontendGlfw::StopDisplayA()
{
  glfwSetWindowShouldClose(mWindow, true);
}
 
void GPUDisplayFrontendGlfw::OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton)
{
}
 
void GPUDisplayFrontendGlfw::SwitchFullscreen(bool set)
{
  GPUInfo("Setting Full Screen %d", (int32_t)set);
  if (set) {
    glfwGetWindowPos(mWindow, &mWindowX, &mWindowY);
    glfwGetWindowSize(mWindow, &mWindowWidth, &mWindowHeight);
    GLFWmonitor* primary = glfwGetPrimaryMonitor();
    const GLFWvidmode* mode = glfwGetVideoMode(primary);
    glfwSetWindowMonitor(mWindow, primary, 0, 0, mode->width, mode->height, mode->refreshRate);
  } else {
    glfwSetWindowMonitor(mWindow, nullptr, mWindowX, mWindowY, mWindowWidth, mWindowHeight, GLFW_DONT_CARE);
  }
}
 
void GPUDisplayFrontendGlfw::ToggleMaximized(bool set)
{
  if (set) {
    glfwMaximizeWindow(mWindow);
  } else {
    glfwRestoreWindow(mWindow);
  }
}
 
void GPUDisplayFrontendGlfw::SetVSync(bool enable)
{
  if (canSetVSync()) { // No GL context with Vulkan
    glfwSwapInterval(enable);
  }
}
 
bool GPUDisplayFrontendGlfw::canSetVSync() { return backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL; }
 
float GPUDisplayFrontendGlfw::getRefreshRate()
{
  GLFWmonitor* monitor = glfwGetWindowMonitor(mWindow) ? glfwGetWindowMonitor(mWindow) : glfwGetPrimaryMonitor(); // Monitor of a windowed window is not known, use the primary one
  const GLFWvidmode* mode = monitor ? glfwGetVideoMode(monitor) : nullptr;
  return mode ? mode->refreshRate : 0.f;
}
 
void GPUDisplayFrontendGlfw::getSize(int32_t& width, int32_t& height)
{
  glfwGetFramebufferSize(mWindow, &width, &height);
}
 
int32_t GPUDisplayFrontendGlfw::getVulkanSurface(void* instance, void* surface)
{
#ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
  return glfwCreateWindowSurface(*(VkInstance*)instance, mWindow, nullptr, (VkSurfaceKHR*)surface) != VK_SUCCESS;
#else
  return 1;
#endif
}
 
uint32_t GPUDisplayFrontendGlfw::getReqVulkanExtensions(const char**& p)
{
  uint32_t glfwExtensionCount = 0;
#ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
  p = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
#endif
  return glfwExtensionCount;
}