GPUDisplayBackend.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 "GPUDisplayBackend.h"
#include "helpers/GPUDisplayMagneticField.h"
 
#include "GPUDisplayBackendNone.h"
#ifdef GPUCA_BUILD_EVENT_DISPLAY_OPENGL
#include "GPUDisplayBackendOpenGL.h"
#endif
#ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
#include "GPUDisplayBackendVulkan.h"
#endif
 
#ifdef GPUCA_BUILD_EVENT_DISPLAY_FREETYPE
#include <ft2build.h>
#include FT_FREETYPE_H
#ifdef GPUCA_BUILD_EVENT_DISPLAY_FONTCONFIG
#if !__has_include(<fontconfig/fontconfig.h>)
#undef GPUCA_BUILD_EVENT_DISPLAY_FONTCONFIG
#else
#include <fontconfig/fontconfig.h>
#endif
#endif
#endif
 
#include "GPUDisplay.h"
#include "GPULogging.h"
#include "GPUTPCGeometry.h"
#include <string>
 
using namespace o2::gpu;
 
GPUDisplayBackend::GPUDisplayBackend() = default;
GPUDisplayBackend::~GPUDisplayBackend() = default;
 
GPUDisplayBackend* GPUDisplayBackend::getBackend(const char* type)
{
#ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
  if (strcmp(type, "vulkan") == 0 || strcmp(type, "auto") == 0) {
    return new GPUDisplayBackendVulkan;
  } else
#endif
#ifdef GPUCA_BUILD_EVENT_DISPLAY_OPENGL
    if (strcmp(type, "opengl") == 0 || strcmp(type, "auto") == 0) {
    return new GPUDisplayBackendOpenGL;
  } else
#endif
    if (strcmp(type, "none") == 0) {
    return new GPUDisplayBackendNone;
  } else {
    GPUError("Requested renderer not available");
  }
  return nullptr;
}
 
int32_t GPUDisplayBackend::InitBackend()
{
  int32_t retVal = InitBackendA();
  if (retVal) {
    return retVal;
  }
  if (!mDisplay->cfg().noFreetype) {
    loadFont();
  }
  return retVal;
}
 
void GPUDisplayBackend::updateFontScale(float scale)
{
  if (mFreetypeInitialized && scale != mFontRasterScale) {
    clearFontSymbols();
    mFreetypeInitialized = false;
    loadFont();
  }
}
 
void GPUDisplayBackend::loadFont()
{
  std::string fontName = mDisplay->cfg().font;
#ifdef GPUCA_BUILD_EVENT_DISPLAY_FONTCONFIG
  FcInit();
  FcConfig* config = FcInitLoadConfigAndFonts();
  FcPattern* pat = FcNameParse((const FcChar8*)fontName.c_str());
  FcConfigSubstitute(config, pat, FcMatchPattern);
  FcDefaultSubstitute(pat);
  FcResult result;
  FcPattern* font = FcFontMatch(config, pat, &result);
  if (font && result == 0) {
    FcChar8* file = nullptr;
    if (FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {
      fontName = (char*)file;
    }
  } else {
    GPUError("Coult not find font for pattern %s", fontName.c_str());
  }
  FcPatternDestroy(font);
  FcPatternDestroy(pat);
  FcConfigDestroy(config);
  FcFini();
#endif // GPUCA_BUILD_EVENT_DISPLAY_FONTCONFIG
 
#ifdef GPUCA_BUILD_EVENT_DISPLAY_FREETYPE
  FT_Library ft;
  FT_Face face;
  if (FT_Init_FreeType(&ft)) {
    GPUError("Error initializing freetype");
    return;
  }
  if (FT_New_Face(ft, fontName.c_str(), 0, &face)) {
    GPUError("Error loading freetype font");
    FT_Done_FreeType(ft);
    return;
  }
 
  int32_t fontSize = mDisplay->cfg().fontSize;
  mDisplay->drawTextFontSize() = fontSize;
  if (smoothFont()) {
    fontSize *= 4; // Font size scaled by 4, can be downsampled
  }
  mFontRasterScale = mDisplay->frontend()->getDisplayScale();
  FT_Set_Pixel_Sizes(face, 0, (uint32_t)(fontSize * mFontRasterScale + 0.5f)); // Rasterize at physical pixel size for HiDPI
 
  for (uint32_t i = 0; i < 128; i++) {
    if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
      GPUError("Error loading freetype symbol");
      FT_Done_Face(face);
      FT_Done_FreeType(ft);
      return;
    }
    const auto& glyph = face->glyph;
    addFontSymbol(i, glyph->bitmap.width, glyph->bitmap.rows, glyph->bitmap_left, glyph->bitmap_top, glyph->advance.x, glyph->bitmap.buffer);
  }
  initializeTextDrawing();
  FT_Done_Face(face);
  FT_Done_FreeType(ft);
  mFreetypeInitialized = true;
#endif // GPUCA_BUILD_EVENT_DISPLAY_FREETYPE
}
 
void GPUDisplayBackend::ExitBackend()
{
  ExitBackendA();
}
 
std::vector<char> GPUDisplayBackend::getPixels()
{
  auto retVal = std::move(mScreenshotPixels);
  mScreenshotPixels = std::vector<char>();
  return retVal;
}
 
void GPUDisplayBackend::fillIndirectCmdBuffer()
{
  mCmdBuffer.clear();
  mIndirectSectorOffset.resize(GPUTPCGeometry::NSECTORS);
  // TODO: Check if this can be parallelized
  for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
    mIndirectSectorOffset[iSector] = mCmdBuffer.size();
    for (uint32_t k = 0; k < mDisplay->vertexBufferStart()[iSector].size(); k++) {
      mCmdBuffer.emplace_back(mDisplay->vertexBufferCount()[iSector][k], 1, mDisplay->vertexBufferStart()[iSector][k], 0);
    }
  }
}
 
int32_t GPUDisplayBackend::fpsLimitMode() const
{
  const auto& cfg = mDisplay->cfgR();
  if (cfg.fpsLimit == FPS_LIMIT_VSYNC) {
    return !cfg.drawQualityVSync ? FPS_LIMIT_NONE : (canLimitToVSync() ? FPS_LIMIT_VSYNC : FPS_LIMIT_RATE);
  }
  return cfg.fpsLimit;
}
 
float GPUDisplayBackend::getDownsampleFactor(bool screenshot)
{
  float factor = 1.0f;
  int32_t fsaa = mDisplay->cfgR().drawQualityDownsampleFSAA;
  int32_t screenshotScale = mDisplay->cfgR().screenshotScaleFactor;
  if (fsaa) {
    factor *= fsaa;
  }
  if (screenshotScale && screenshot) {
    factor *= screenshotScale;
  }
  return factor;
}
 
bool GPUDisplayBackend::smoothFont()
{
  return mDisplay->cfg().smoothFont < 0 ? (mDisplay->cfg().fontSize > 12) : mDisplay->cfg().smoothFont;
}