GPU Display: Wrap lines of help text if they do not fit on screen

Author: davidrohr

GPU/GPUTracking/display/GPUDisplay.h

@@ -233,7 +233,7 @@ class GPUDisplay : public GPUDisplayInterface
   void PrintHelp();
   void createQuaternionFromMatrix(float* v, const float* mat);
   void drawVertices(const vboList& v, const GPUDisplayBackend::drawType t);
-  void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true);
+  void GLPrintText(const char* s, float x, float y, float r, float g, float b, float a, uint32_t nCharacters = 0, bool fromBotton = true); // nCharacters > 0: print at most that many characters
 
   GPUDisplayFrontend* mFrontend = nullptr;
   std::unique_ptr<GPUDisplayBackend> mBackend;

GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx

@@ -140,6 +140,9 @@ void GPUDisplayBackend::loadFont()
       return;
     }
     const auto& glyph = face->glyph;
+    if (i == 'M') {
+      mFontCharWidth = (glyph->advance.x >> 6) * (smoothFont() ? 0.25f : 1.f) / mFontRasterScale; // As in GLPrintText of the backends
+    }
     addFontSymbol(i, glyph->bitmap.width, glyph->bitmap.rows, glyph->bitmap_left, glyph->bitmap_top, glyph->advance.x, glyph->bitmap.buffer);
   }
   initializeTextDrawing();

GPU/GPUTracking/display/backend/GPUDisplayBackend.h

@@ -99,7 +99,7 @@ class GPUDisplayBackend
   const char* backendName() const { return mBackendName; }
   virtual void resizeScene(uint32_t width, uint32_t height) {}
   virtual size_t needMultiVBO() { return 0; }
-  virtual void OpenGLPrint(const char* s, float x, float y, float* color, float scale) = 0;
+  virtual void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) = 0; // nCharacters > 0: at most that many characters, otherwise until the terminating 0
   static GPUDisplayBackend* getBackend(const char* type);
   std::vector<char> getPixels();
   virtual float getYFactor() const { return 1.0f; }
@@ -120,6 +120,7 @@ class GPUDisplayBackend
   vecpod<DrawArraysIndirectCommand> mCmdBuffer;
   bool mFreetypeInitialized = false;
   float mFontRasterScale = 1.f; // Display scale the font was rasterized for
+  float mFontCharWidth = 0.f;   // Advance of a character of the (monospace) font in logical pixels, 0 without Freetype font
   std::vector<char> mScreenshotPixels;
 
   static constexpr float SMOOTH_POINT_EXTRA_SIZE = 0.6f;

GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h

@@ -39,7 +39,7 @@ class GPUDisplayBackendNone : public GPUDisplayBackend
   void finishText() override {}
   void pointSizeFactor(float factor) override {}
   void lineWidthFactor(float factor) override {}
-  void OpenGLPrint(const char* s, float x, float y, float* color, float scale) override {}
+  void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) override {}
   void addFontSymbol(int32_t symbol, int32_t sizex, int32_t sizey, int32_t offsetx, int32_t offsety, int32_t advance, void* data) override {}
   void initializeTextDrawing() override {}
 };

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx

@@ -668,7 +668,7 @@ void GPUDisplayBackendOpenGL::initializeTextDrawing()
   CHKERR(glBindVertexArray(0));
 }
 
-void GPUDisplayBackendOpenGL::OpenGLPrint(const char* s, float x, float y, float* color, float scale)
+void GPUDisplayBackendOpenGL::GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters)
 {
   if (!mFreetypeInitialized) {
     return;
@@ -678,7 +678,7 @@ void GPUDisplayBackendOpenGL::OpenGLPrint(const char* s, float x, float y, float
   if (smoothFont()) {
     scale *= 0.25f; // Font size is 48 to have nice bitmap, scale to size 12
   }
-  for (const unsigned char* c = (const unsigned char*)s; *c; c++) {
+  for (const unsigned char* c = (const unsigned char*)s; *c && (nCharacters == 0 || c < (const unsigned char*)s + nCharacters); c++) {
     if ((int32_t)*c >= (int32_t)mFontSymbols.size()) {
       GPUError("Trying to draw unsupported symbol: %d > %d\n", (int32_t)*c, (int32_t)mFontSymbols.size());
       continue;

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.h

@@ -79,7 +79,7 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   void addFontSymbol(int32_t symbol, int32_t sizex, int32_t sizey, int32_t offsetx, int32_t offsety, int32_t advance, void* data) override;
   void initializeTextDrawing() override;
   void clearFontSymbols() override;
-  void OpenGLPrint(const char* s, float x, float y, float* color, float scale) override;
+  void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) override;
 
   struct FontSymbolOpenGL : public FontSymbol {
     uint32_t texId;

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx

@@ -1888,7 +1888,7 @@ void GPUDisplayBackendVulkan::clearFontSymbols()
   mFontSymbols.clear();
 }
 
-void GPUDisplayBackendVulkan::OpenGLPrint(const char* s, float x, float y, float* color, float scale)
+void GPUDisplayBackendVulkan::GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters)
 {
   if (!mFreetypeInitialized) {
     return;
@@ -1899,7 +1899,7 @@ void GPUDisplayBackendVulkan::OpenGLPrint(const char* s, float x, float y, float
     scale *= 0.25f; // Font size is 48 to have nice bitmap, scale to size 12
   }
 
-  for (const unsigned char* c = (const unsigned char*)s; *c; c++) {
+  for (const unsigned char* c = (const unsigned char*)s; *c && (nCharacters == 0 || c < (const unsigned char*)s + nCharacters); c++) {
     if ((int32_t)*c >= (int32_t)mFontSymbols.size()) {
       GPUError("Trying to draw unsupported symbol: %d > %d\n", (int32_t)*c, (int32_t)mFontSymbols.size());
       continue;

GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.h

@@ -136,7 +136,7 @@ class GPUDisplayBackendVulkan : public GPUDisplayBackend
   void addFontSymbol(int32_t symbol, int32_t sizex, int32_t sizey, int32_t offsetx, int32_t offsety, int32_t advance, void* data) override;
   void initializeTextDrawing() override;
   void clearFontSymbols() override;
-  void OpenGLPrint(const char* s, float x, float y, float* color, float scale) override;
+  void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) override;
 
   uint32_t mGraphicsFamily;
   SwapChainSupportDetails mSwapChainDetails;

GPU/GPUTracking/display/frontend/GPUDisplayHelp.cxx

@@ -15,6 +15,8 @@
 #include "GPUDisplay.h"
 #include "GPULogging.h"
 
+#include <string>
+
 using namespace o2::gpu;
 
 void GPUDisplay::PrintHelp()
@@ -28,7 +30,29 @@ void GPUDisplay::PrintHelp()
 void GPUDisplay::PrintGLHelpText(float colorValue)
 {
   const auto& lines = mFrontend->getHelpText();
-  for (uint32_t i = 0; i < lines.size(); i++) {
-    OpenGLPrint(lines[i].c_str(), 40.f, 35 + std::max(20, mDrawTextFontSize + 4) * (1 + i), colorValue, colorValue, colorValue, mInfoHelpTimer.GetCurrentElapsedTime() >= 5 ? (6 - mInfoHelpTimer.GetCurrentElapsedTime()) : 1, false);
+  const int32_t maxChars = mBackend->mFontCharWidth > 0.f ? (mBackend->mScreenWidth / mFrontend->getDisplayScale() - 80.f) / mBackend->mFontCharWidth : 0; // Characters fitting between the margins, 0 = unknown (no Freetype font), no wrapping
+  uint32_t row = 0;
+  auto print = [&](const char* s, uint32_t nCharacters, uint32_t indent) { GLPrintText(s, 40.f + indent * mBackend->mFontCharWidth, 35 + std::max(20, mDrawTextFontSize + 4) * (1 + row++), colorValue, colorValue, colorValue, mInfoHelpTimer.GetCurrentElapsedTime() >= 5 ? (6 - mInfoHelpTimer.GetCurrentElapsedTime()) : 1, nCharacters, false); };
+  for (const auto& line : lines) {
+    if (maxChars <= 0 || line.size() <= (size_t)maxChars) {
+      print(line.c_str(), 0, 0);
+      continue;
+    }
+    const size_t textStart = line.find(": ");
+    const size_t indent = textStart != std::string::npos && textStart + 2 < (size_t)maxChars / 2 ? textStart + 2 : 0; // Continuation lines aligned with the text after the keys, if that leaves enough space
+    size_t pos = 0;                                                                                                   // Start of the part not yet printed
+    for (bool first = true;; first = false) {                                                                         // Wrap at the last space that fits, or hard if there is none (also if it is only in the keys)
+      const size_t lineIndent = first ? 0 : indent, available = maxChars - lineIndent;
+      if (line.size() - pos <= available) {
+        print(line.c_str() + pos, line.size() - pos, lineIndent);
+        break;
+      }
+      size_t cut = line.rfind(' ', pos + available);
+      if (cut == std::string::npos || cut <= pos + (first ? indent : 0)) {
+        cut = pos + available;
+      }
+      print(line.c_str() + pos, cut - pos, lineIndent);
+      pos = line[cut] == ' ' ? cut + 1 : cut;
+    }
   }
 }

GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx

@@ -102,12 +102,12 @@ void GPUDisplay::showInfo(const char* info)
   mBackend->updateFontScale(mFrontend->getDisplayScale());
   mBackend->prepareText();
   float colorValue = mCfgL.invertColors ? 0.f : 1.f;
-  OpenGLPrint(info, 40.f, 20.f + std::max(20, mDrawTextFontSize + 4), colorValue, colorValue, colorValue, 1);
+  GLPrintText(info, 40.f, 20.f + std::max(20, mDrawTextFontSize + 4), colorValue, colorValue, colorValue, 1);
   if (mInfoText2Timer.IsRunning()) {
     if (mInfoText2Timer.GetCurrentElapsedTime() >= 6) {
       mInfoText2Timer.Reset();
     } else {
-      OpenGLPrint(mInfoText2, 40.f, 20.f, colorValue, colorValue, colorValue, 6 - mInfoText2Timer.GetCurrentElapsedTime());
+      GLPrintText(mInfoText2, 40.f, 20.f, colorValue, colorValue, colorValue, 6 - mInfoText2Timer.GetCurrentElapsedTime());
     }
   }
   if (mInfoHelpTimer.IsRunning() || mCfgC.mPrintInfoTextAlways) {
@@ -120,7 +120,7 @@ void GPUDisplay::showInfo(const char* info)
   mBackend->finishText();
 }
 
-void GPUDisplay::OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton)
+void GPUDisplay::GLPrintText(const char* s, float x, float y, float r, float g, float b, float a, uint32_t nCharacters, bool fromBotton)
 {
   if (mBackend->mFreetypeInitialized) {
     const float scale = mFrontend->getDisplayScale();
@@ -130,6 +130,6 @@ void GPUDisplay::OpenGLPrint(const char* s, float x, float y, float r, float g,
       y = mBackend->mScreenHeight - y;
     }
     float color[4] = {r, g, b, a};
-    mBackend->OpenGLPrint(s, x, y, color, scale / mBackend->mFontRasterScale);
+    mBackend->GLPrintText(s, x, y, color, scale / mBackend->mFontRasterScale, nCharacters);
   }
 }