GPU Display: Add an integrated console for manipulating the configuration and steering the display

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -526,6 +526,10 @@ AddOptionVec(filterMacros, std::string, "", 0, "ROOT macros used as track filter
 AddOption(guiReplyTimeout, uint32_t, 100, "", 0, "Time in ms the Qt GUI waits at most for the display to process its update")
 AddOption(guiMaxUpdatesAhead, uint32_t, 3, "", 0, "Number of updates the Qt GUI may send ahead of the last one the display has processed, before it waits for the display")
 AddOption(listFrontendOptionHandling, bool, false, "", 0, "List all assigned keys in frontend, Configurable settings in Qt GUI, and missing configuration options")
+AddOption(consoleDelay, float, 0.5f, "", 0, "Time in seconds to open / close the console (^ key)")
+AddOption(consoleAlpha, float, 0.8f, "", 0, "Opacity of the console background")
+AddOption(consoleVertical, float, 0.5f, "", 0, "Fraction of the window height covered by the fully opened console")
+AddOption(consoleHistorySize, uint32_t, 1000000, "", 0, "Number of console lines kept, the history is shortened to this when it reaches twice the size")
 AddSubConfig(GPUSettingsDisplayLight, light)
 AddSubConfig(GPUSettingsDisplayHeavy, heavy)
 AddSubConfig(GPUSettingsDisplayRenderer, renderer)

GPU/GPUTracking/display/CMakeLists.txt

@@ -117,6 +117,7 @@ set(SRCS ../utils/qsem.cxx
          GPUDisplay.cxx
          helpers/GPUDisplayMagneticField.cxx
          frontend/GPUDisplayFrontend.cxx
+         frontend/GPUDisplayConsole.cxx
          frontend/GPUDisplayFrontendNone.cxx
          backend/GPUDisplayBackend.cxx
          backend/GPUDisplayBackendNone.cxx)

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -727,9 +727,23 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
       mFramesDoneFPS = 0;
     }
 
+    const float consoleFraction = consoleVerticalFraction();
+    const bool drawText = (mCfgC.mPrintInfoText & 1) || consoleFraction > 0.f;
+    if (drawText) {
+      mBackend->updateFontScale(mFrontend->getDisplayScale());
+      mBackend->prepareText();
+    }
     if (mCfgC.mPrintInfoText & 1 || mCfgC.mPrintInfoTextGUI) {
       showInfo(info);
     }
+    if (consoleFraction > 0.f) {
+      const bool cursor = mCfgC.showConsole && std::fmod(mConsoleTimer.GetCurrentElapsedTime(), 1.0) < 0.5; // Blinking, the timer runs while the console is open
+      mBackend->GLDrawConsole(consoleFraction, mFrontend->mConsole->mConsoleHistory, mFrontend->mConsole->shownText(), cursor ? (int32_t)mFrontend->mConsole->mConsoleTextPos : -1);
+    }
+    if (drawText) {
+      mBackend->finishText();
+    }
+    mFrontend->mConsole->consoleLimitHistory(mConfig.consoleHistorySize);
   }
 
   mBackend->finishFrame(doScreenshot, renderToMixBuffer, mixSlaveImage);

GPU/GPUTracking/display/GPUDisplay.h

@@ -61,7 +61,7 @@ class GPUDisplay : public GPUDisplayInterface
   void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
   void UpdateParam(const GPUParam* param) override { mParam = param; }
 
-  void HandleKey(uint8_t key);
+  void HandleKey(uint8_t key, bool external = false); // external: from the Qt GUI or the console, not typed into the event display console
   int32_t DrawGLScene(bool suspended = false);
   void HandleExternalGUIKey(int32_t key);
   int32_t InitDisplay(bool initFailure = false);
@@ -198,6 +198,7 @@ class GPUDisplay : public GPUDisplayInterface
   void startAnimation();
   int32_t animateCamera(bool suspended, float& animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
   void showInfo(const char* info);
+  float consoleVerticalFraction(); // Fraction of the window covered by the console (animated), 0 if hidden
   void ActivateColor();
   void SetColorTRD();
   void SetColorTOF();
@@ -321,10 +322,11 @@ class GPUDisplay : public GPUDisplayInterface
   opengl_spline mAnimationSplines[8];
 
   char mInfoText2[1024];
-  std::string mGUIInfoStatus;       // Latest status line (FPS etc.) for the Qt GUI
-  std::string mGUIInfoText;         // Latest info message (SetInfo) for the Qt GUI
-  uint64_t mGUIInfoTextCounter = 0; // Number of info messages, the GUI shows a new one for some seconds
-  HighResTimer mInfoText2Timer, mInfoHelpTimer;
+  std::string mGUIInfoStatus;                                  // Latest status line (FPS etc.) for the Qt GUI
+  std::string mGUIInfoText;                                    // Latest info message (SetInfo) for the Qt GUI
+  uint64_t mGUIInfoTextCounter = 0;                            // Number of info messages, the GUI shows a new one for some seconds
+  HighResTimer mInfoText2Timer, mInfoHelpTimer, mConsoleTimer; // mConsoleTimer: opening / closing animation of the console
+  bool mConsoleShown = false;                                  // showConsole of the last checkAndApplyConfigChanges
 
   std::vector<threadVertexBuffer> mThreadBuffers;
   std::vector<std::vector<std::array<std::array<vecpod<int32_t>, 2>, NSECTORS>>> mThreadTracks;

GPU/GPUTracking/display/GPUDisplayControl.h

@@ -40,6 +40,7 @@ BeginHiddenConfig(GPUDisplayControl, control)
   AddVariable(mGLAnimationFile, std::string, "glanimation.tmp")  // File for saving / loading the animation path
   AddVariable(mGuiDarkMode, int8_t, -1)                          // Dark mode of the Qt GUI, -1 = not yet set: the GUI reports the system scheme when it starts
   AddVariable(mGuiScale, float, 1.f)                             // Scale factor of text and elements of the Qt GUI (on top of the system scaling), Ctrl + mouse wheel / Ctrl + 0 in the GUI
+  AddVariable(showConsole, bool, false)                          // Console shown (^ key): all other keys go to the console
   AddVariable(dummy, bool, false)                                // dummy value to reference for keys that do not change variables
 EndConfig()
 EndNamespace() // o2::gpu

GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx

@@ -132,7 +132,7 @@ void GPUDisplayBackend::loadFont()
   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++) {
+  for (uint32_t i = 0; i < SOLID_GLYPH; i++) {
     if (FT_Load_Char(face, i, FT_LOAD_RENDER)) {
       GPUError("Error loading freetype symbol");
       FT_Done_Face(face);
@@ -145,6 +145,8 @@ void GPUDisplayBackend::loadFont()
     }
     addFontSymbol(i, glyph->bitmap.width, glyph->bitmap.rows, glyph->bitmap_left, glyph->bitmap_top, glyph->advance.x, glyph->bitmap.buffer);
   }
+  std::vector<uint8_t> solid(8 * 8, 255);
+  addFontSymbol(SOLID_GLYPH, 8, 8, 0, 0, 0, solid.data());
   initializeTextDrawing();
   FT_Done_Face(face);
   FT_Done_FreeType(ft);
@@ -207,3 +209,42 @@ bool GPUDisplayBackend::smoothFont()
 {
   return mDisplay->cfg().smoothFont < 0 ? (mDisplay->cfg().fontSize > 12) : mDisplay->cfg().smoothFont;
 }
+
+void GPUDisplayBackend::GLDrawLine(float x0, float y0, float x1, float y1, float width, const float* color)
+{
+  const float dx = x1 - x0, dy = y1 - y0, length = std::sqrt(dx * dx + dy * dy);
+  if (length == 0.f) {
+    return;
+  }
+  const float nx = -dy / length * width * 0.5f, ny = dx / length * width * 0.5f; // Perpendicular, half the width
+  GLDrawQuad({{x0 + nx, y0 + ny}, {x0 - nx, y0 - ny}, {x1 - nx, y1 - ny}, {x1 + nx, y1 + ny}}, color);
+}
+
+void GPUDisplayBackend::GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos)
+{
+  if (!mFreetypeInitialized) {
+    return;
+  }
+  const float scale = mDisplay->frontend()->getDisplayScale();
+  const float colorValue = mDisplay->cfgL().invertColors ? 0.f : 1.f;
+  float textColor[4] = {colorValue, colorValue, colorValue, 1.f};
+  const float backgroundColor[4] = {1.f - colorValue, 1.f - colorValue, 1.f - colorValue, mDisplay->cfg().consoleAlpha};
+  const float width = mScreenWidth, top = mScreenHeight, bottom = top * (1.f - verticalFraction);
+  GLDrawQuad({{0.f, bottom}, {width, bottom}, {width, top}, {0.f, top}}, backgroundColor);
+  GLDrawLine(0.f, bottom, width, bottom, scale, textColor);
+
+  static constexpr float MARGIN = 6.f;                                                                                    // Logical pixels from the text to the left border and to the line
+  const float lineHeight = std::max(20, mDisplay->drawTextFontSize() + 4) * scale;                                        // As the info text of GPUDisplay
+  const float descent = 0.25f * mDisplay->drawTextFontSize() * scale;                                                     // Below the baseline, approximately
+  const size_t maxChars = mFontCharWidth > 0.f ? std::max(0.f, (width / scale - 2 * MARGIN) / mFontCharWidth) : SIZE_MAX; // Longer lines are cut
+  float y = bottom + (0.5f + MARGIN) * scale + descent;                                                                   // Baseline of the lowest line, MARGIN above the line (half its width)
+  if (cursorPos >= 0 && (size_t)cursorPos < maxChars && mFontCharWidth > 0.f) {                                           // Monospace font: position from the character width
+    GLPrintText("_", (MARGIN + cursorPos * mFontCharWidth) * scale, y, textColor, scale / mFontRasterScale, 0);
+  }
+  for (size_t i = 0; i <= previous.size() && y + lineHeight - descent <= top; i++, y += lineHeight) {
+    const std::string& text = i == 0 ? current : previous[previous.size() - i];
+    if (!text.empty() && maxChars) {
+      GLPrintText(text.c_str(), MARGIN * scale, y, textColor, scale / mFontRasterScale, std::min(text.size(), maxChars));
+    }
+  }
+}

GPU/GPUTracking/display/backend/GPUDisplayBackend.h

@@ -17,6 +17,8 @@
 
 #include "GPUCommonDef.h"
 #include "../utils/vecpod.h"
+#include <span>
+#include <string>
 #include <array>
 #include <cstddef>
 #include <memory>
@@ -99,7 +101,10 @@ 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 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
+  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
+  virtual void GLDrawQuad(const float (&corners)[4][2], const float* color) = 0;                                                    // Filled quad with the corners counterclockwise, in pixels with y from the bottom, drawn with the text (SOLID_GLYPH)
+  void GLDrawLine(float x0, float y0, float x1, float y1, float width, const float* color);                                         // As GLDrawQuad
+  void GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos); // Console over the top verticalFraction of the window: current text in the lowest line, previous ones above (last one lowest), cursor _ at cursorPos (< 0: none)
   static GPUDisplayBackend* getBackend(const char* type);
   std::vector<char> getPixels();
   virtual float getYFactor() const { return 1.0f; }
@@ -119,8 +124,9 @@ class GPUDisplayBackend
   std::vector<int32_t> mIndirectSectorOffset;
   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
+  float mFontRasterScale = 1.f;               // Display scale the font was rasterized for
+  static constexpr int32_t SOLID_GLYPH = 128; // Fully opaque glyph after the characters (0 - 127), for quads drawn with the text
+  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

@@ -40,6 +40,7 @@ class GPUDisplayBackendNone : public GPUDisplayBackend
   void pointSizeFactor(float factor) override {}
   void lineWidthFactor(float factor) override {}
   void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) override {}
+  void GLDrawQuad(const float (&corners)[4][2], const float* color) 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

@@ -684,8 +684,8 @@ void GPUDisplayBackendOpenGL::GLPrintText(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 && (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());
+    if (*c < 32 || *c >= SOLID_GLYPH) { // Printable ASCII only, SOLID_GLYPH is not a character
+      GPUError("Trying to draw unsupported symbol: %d", (int32_t)*c);
       continue;
     }
     FontSymbolOpenGL sym = mFontSymbols[*c];
@@ -701,11 +701,7 @@ void GPUDisplayBackendOpenGL::GLPrintText(const char* s, float x, float y, float
         {xpos, ypos + h, 0.0f, 0.0f},
         {xpos + w, ypos, 1.0f, 1.0f},
         {xpos + w, ypos + h, 1.0f, 0.0f}};
-      CHKERR(glBindTexture(GL_TEXTURE_2D, sym.texId));
-      CHKERR(glBindBuffer(GL_ARRAY_BUFFER, VBO_text));
-      CHKERR(glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices));
-      CHKERR(glBindBuffer(GL_ARRAY_BUFFER, 0));
-      CHKERR(glDrawArrays(GL_TRIANGLES, 0, 6));
+      drawTextVertices(vertices, sym.texId);
     }
     x += (sym.advance >> 6) * scale; // shift is in 1/64th of a pixel
   }
@@ -714,6 +710,34 @@ void GPUDisplayBackendOpenGL::GLPrintText(const char* s, float x, float y, float
   }
 }
 
+void GPUDisplayBackendOpenGL::drawTextVertices(const float (&vertices)[6][4], uint32_t texId)
+{
+  CHKERR(glBindTexture(GL_TEXTURE_2D, texId));
+  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, VBO_text));
+  CHKERR(glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices));
+  CHKERR(glBindBuffer(GL_ARRAY_BUFFER, 0));
+  CHKERR(glDrawArrays(GL_TRIANGLES, 0, 6));
+}
+
+void GPUDisplayBackendOpenGL::GLDrawQuad(const float (&corners)[4][2], const float* color)
+{
+  if (!mFreetypeInitialized) {
+    return;
+  }
+  CHKERR(glUniform4fv(UNIFORM_LOCATION_COLOR, 1, color));
+  static constexpr int32_t order[6] = {0, 1, 2, 0, 2, 3};
+  float vertices[6][4];
+  for (int32_t i = 0; i < 6; i++) {
+    vertices[i][0] = corners[order[i]][0];
+    vertices[i][1] = corners[order[i]][1];
+    vertices[i][2] = vertices[i][3] = 0.5f; // Center of the opaque glyph
+  }
+  drawTextVertices(vertices, mFontSymbols[SOLID_GLYPH].texId);
+  if (!mDisplay->useMultiVBO()) {
+    CHKERR(glBindBuffer(GL_ARRAY_BUFFER, mVBOId[0])); // As in GLPrintText
+  }
+}
+
 void GPUDisplayBackendOpenGL::ClearOffscreenBuffers()
 {
   if (mMixBuffer.created) {

GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.h

@@ -80,6 +80,8 @@ class GPUDisplayBackendOpenGL : public GPUDisplayBackend
   void initializeTextDrawing() override;
   void clearFontSymbols() override;
   void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) override;
+  void GLDrawQuad(const float (&corners)[4][2], const float* color) override;
+  void drawTextVertices(const float (&vertices)[6][4], uint32_t texId); // One quad with the text shader, after GLPrintText / GLDrawQuad set the color
 
   struct FontSymbolOpenGL : public FontSymbol {
     uint32_t texId;