GPU Display: Cleanup: remove dummy variale and string comparisons for transient check

Author: davidrohr

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -263,8 +263,8 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
   mFrontend->mMouseWheel = 0;
   bool lookOrigin = mCfgR.camLookOrigin ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIGIN]];
   bool yUp = mCfgR.camYUp ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIENT_UP]] ^ lookOrigin;
-  bool rotateModelTPC = mCfgC.rotateAroundZ || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
-  bool rotateModel = rotateModelTPC || mCfgC.rotateModel || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]];
+  bool rotateModelTPC = mCfgO.rotateAroundZ || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
+  bool rotateModel = rotateModelTPC || mCfgO.rotateModel || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]];
 
   // Calculate rotation / translation scaling factors
   float scalefactor = mFrontend->mKeys[mFrontend->KEY_SHIFT] ? 0.2f : 1.0f;
@@ -324,15 +324,15 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     }
 
     if (mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_CHANGE_ANIMATION_INTERVAL]]) {
-      mCfgC.animationDelay += moveX;
-      if (mCfgC.animationDelay < 0.05f) {
-        mCfgC.animationDelay = 0.05f;
-      } else if (mCfgC.animationDelay > 20.f) {
-        mCfgC.animationDelay = 20.f;
+      mCfgO.animationDelay += moveX;
+      if (mCfgO.animationDelay < 0.05f) {
+        mCfgO.animationDelay = 0.05f;
+      } else if (mCfgO.animationDelay > 20.f) {
+        mCfgO.animationDelay = 20.f;
       }
       moveX = 0.f;
       moveY = 0.f;
-      SetInfo("Animation delay set to %1.2f", mCfgC.animationDelay);
+      SetInfo("Animation delay set to %1.2f", mCfgO.animationDelay);
     }
 
     if (yUp) {
@@ -641,15 +641,15 @@ void GPUDisplay::DrawGLScene_drawCommands()
 
 void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool renderToMixBuffer) // negative time = no mixing
 {
-  if (mCfgC.requestScreenshot || mCfgC.animateScreenshot) {
+  if (mCfgC.requestScreenshot || mCfgO.animateScreenshot) {
     const uint32_t factor = std::max(1, mCfgR.drawQualityDownsampleFSAA) * std::max(1, mCfgR.screenshotScaleFactor);
     if (std::max(mBackend->mScreenWidth, mBackend->mScreenHeight) * factor > mBackend->mMaxRenderSize) {
       GPUError("Screenshot not taken: requested render size %u x %u (window x FSAA x screenshot scale) exceeds the maximum size %u x %u", mBackend->mScreenWidth * factor, mBackend->mScreenHeight * factor, mBackend->mMaxRenderSize, mBackend->mMaxRenderSize);
       mCfgC.requestScreenshot = false;
-      mCfgC.animateScreenshot = 0;
+      mCfgO.animateScreenshot = 0;
     }
   }
-  const bool animateScreenshot = mCfgC.animateScreenshot && mAnimate;        // Copy, the animation resets animateScreenshot in its last frame
+  const bool animateScreenshot = mCfgO.animateScreenshot && mAnimate;        // Copy, the animation resets animateScreenshot in its last frame
   const bool screenshotFrame = mCfgC.requestScreenshot || animateScreenshot; // Also for the mix pass (animateTime >= 0), which must use the same render size
   const bool doScreenshot = screenshotFrame && animateTime < 0;
 
@@ -724,7 +724,7 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
              fps, mCfgL.drawSector, mCfgL.drawClusters, mCfgL.drawInitLinks, mCfgL.drawLinks, mCfgL.drawSeeds, mCfgL.drawTracklets, mCfgL.drawTracks, mCfgL.drawExtrapolatedTracks, mCfgL.drawFinal, mFramesDone, mNDrawCalls, mXYZ[0], mXYZ[1], mXYZ[2], mRPhiTheta[0], mRPhiTheta[1] * 180 / CAMath::Pi(),
              mRPhiTheta[2] * 180 / CAMath::Pi(), mAngle[1] * 180 / CAMath::Pi(), mAngle[0] * 180 / CAMath::Pi(), mAngle[2] * 180 / CAMath::Pi(), mBackend->mScreenWidth, mBackend->mScreenHeight);
     if (fpstime > 1.) {
-      if (mCfgC.printInfoText & 2) {
+      if (mCfgO.printInfoText & 2) {
         GPUInfo("%s", info);
       }
       if (mFPSScaleadjust++) {
@@ -735,12 +735,12 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
     }
 
     const float consoleFraction = consoleVerticalFraction();
-    const bool drawText = (mCfgC.printInfoText & 1) || consoleFraction > 0.f;
+    const bool drawText = (mCfgO.printInfoText & 1) || consoleFraction > 0.f;
     if (drawText) {
       mBackend->updateFontScale(mFrontend->getDisplayScale());
       mBackend->prepareText();
     }
-    if (mCfgC.printInfoText & 1 || mCfgC.printInfoTextGUI) {
+    if (mCfgO.printInfoText & 1 || mCfgO.printInfoTextGUI) {
       showInfo(info);
     }
     if (consoleFraction > 0.f) {
@@ -769,7 +769,7 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
     if (animateScreenshot) {
       snprintf(tmpFileName, 48, "%d_%05d.bmp", mAnimationExport, mAnimationFrame);
     }
-    DoScreenshot(animateScreenshot ? (mCfgC.mscreenShotName + tmpFileName).c_str() : mScreenshotFile.c_str(), pixels);
+    DoScreenshot(animateScreenshot ? (mCfgO.mscreenShotName + tmpFileName).c_str() : mScreenshotFile.c_str(), pixels);
   }
 }
 

GPU/GPUTracking/display/GPUDisplay.h

@@ -89,6 +89,7 @@ class GPUDisplay : public GPUDisplayInterface
   GPUDisplayFrontend* frontend() { return mFrontend; }
   int32_t& drawTextFontSize() { return mDrawTextFontSize; }
 
+  GPUDisplayOptions mCfgO;
   GPUDisplayControl mCfgC;
 
  private:
@@ -192,9 +193,9 @@ class GPUDisplay : public GPUDisplayInterface
   void calcXYZ(const float*);
   void mAnimationCloseAngle(float& newangle, float lastAngle);
   void mAnimateCloseQuaternion(float* v, float lastx, float lasty, float lastz, float lastw);
-  void SaveGLPos(); // Camera position to mCfgC.glPosFile
+  void SaveGLPos(); // Camera position to mCfgO.glPosFile
   void LoadGLPos();
-  void SaveGLAnimation(); // Animation path to mCfgC.glAnimationFile
+  void SaveGLAnimation(); // Animation path to mCfgO.glAnimationFile
   void LoadGLAnimation();
   void takeScreenshot();
   void runAnimation(); // Starts the animation if it has enough points
@@ -207,12 +208,11 @@ class GPUDisplay : public GPUDisplayInterface
   void resetAnimation();
   void removeAnimationPoint(int32_t i = -1);                                                              // -1: the selected one, the last one if none is selected
   void StopAnimation();                                                                                   // Ends a running animation, camera and settings stay as they are; for changed settings (checkAndApplyConfigChanges), scene reset, changes of the animation points
-  void setCameraFromAnimationPoint(const animationVector& p);                                             // Camera stored in the point, as the animation shows it there
   void selectAnimationPoint(int32_t i);                                                                   // -1: none, otherwise also loads its light settings and camera
   void setAnimationPointsFromGUI(const GPUDisplayMultiSliderValue& points);                               // New times from the Qt GUI: reorders the points, selection
   void updateAnimationPointsGUI();                                                                        // Range end of the GUI multi slider: last time + animationDelay, progress 0 without animation
   void animationPointValues(const animationVector& p, int32_t mode, const float* last, float (&vals)[8]); // The 8 interpolated values of the point in this animation mode, angles / quaternion continuous to the values of the previous point (last, nullptr if none)
-  void animationViewMatrix(float (&vals)[8], int32_t mode, hmm_mat4& viewMatrix) const;                   // Camera of interpolated / stored animation values (v[1..8]), as animateCamera
+  void animationViewMatrix(float (&vals)[8], int32_t mode, hmm_mat4& viewMatrix) const;                   // Camera of interpolated / stored animation values (vals of animationPointValues), as animateCamera
   void startAnimation();
   int32_t animateCamera(bool suspended, float& animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
   void showInfo(const char* info);

GPU/GPUTracking/display/GPUDisplayControl.h

@@ -21,12 +21,9 @@
 
 // clang-format off
 BeginNamespace(o2::gpu)
-BeginHiddenConfig(GPUDisplayControl, control)
-  AddVariable(displayControl, GPUDisplayCopyableAtomic<int32_t>, 0) // Control for next event (=1) or quit (=2)
-  AddVariable(resetScene, GPUDisplayCopyableAtomic<bool>, false)
+BeginHiddenConfig(GPUDisplayOptions, options) // Display options without command line option, saved and reset with the other settings (console saveSettings / reset)
   AddVariable(printInfoText, int32_t, 1)
   AddVariable(printInfoTextAlways, bool, false)
-  AddVariable(requestScreenshot, bool, false)
   AddVariable(animateScreenshot, int32_t, 0)
   AddVariable(animationChangeConfig, bool, true)
   AddVariable(animationDelay, float, 2.f)
@@ -35,14 +32,19 @@ BeginHiddenConfig(GPUDisplayControl, control)
   AddVariable(rotateModel, bool, false)                         // Rotate the model instead of the camera, like holding RCTRL (set in the Qt GUI)
   AddVariable(rotateAroundZ, bool, false)                       // Rotate the TPC around the beamline, like holding RALT (set in the Qt GUI)
   AddVariable(filterMacroCustom, std::string, "")               // Code of the custom track filter ROOT macro (trackFilter = filterMacros.size() + 1), set in the Qt GUI
-  AddVariable(mscreenShotName, std::string, "screenshot")        // Name of screenshot and animation frame files, followed by numbers
+  AddVariable(mscreenShotName, std::string, "screenshot")       // Name of screenshot and animation frame files, followed by numbers
   AddVariable(glPosFile, std::string, "glpos.tmp")              // File for saving / loading the camera position
   AddVariable(glAnimationFile, std::string, "glanimation.tmp")  // File for saving / loading the animation path
   AddVariable(guiDarkMode, int8_t, -1)                          // Dark mode of the Qt GUI, -1 = not yet set: the GUI reports the system scheme when it starts
   AddVariable(guiScale, 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(applyToAllPoints, bool, false) // A change of the animation mode is applied to all animation points
+  AddVariable(applyToAllPoints, bool, false)                    // A change of the animation mode is applied to all animation points
+EndConfig()
+
+BeginHiddenConfig(GPUDisplayControl, control) // Transient control state and actions: not saved, not reset with the other settings
+  AddVariable(displayControl, GPUDisplayCopyableAtomic<int32_t>, 0) // Control for next event (=1) or quit (=2)
+  AddVariable(resetScene, GPUDisplayCopyableAtomic<bool>, false)
+  AddVariable(requestScreenshot, bool, false)
+  AddVariable(showConsole, bool, false)                         // Console shown (^ key): all other keys go to the console
   AddVariable(animationPoints, GPUDisplayMultiSliderValue, GPUDisplayMultiSliderValue()) // Times of the animation points (GPUDisplay::mAnimationVectors) and the selected one, shown in the Qt GUI
-  AddVariable(dummy, bool, false)                                // dummy value to reference for keys that do not change variables
 EndConfig()
 EndNamespace() // o2::gpu

GPU/GPUTracking/display/GPUDisplayTypes.h

@@ -16,6 +16,7 @@
 #define GPUDISPLAYTYPES_H
 
 #include "utils/vecpod.h"
+#include <atomic>
 #include <cstdint>
 #include <ostream>
 

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx

@@ -135,20 +135,20 @@ void GPUDisplayFrontend::HandleExternalGUISignals()
     }
     applyGUIValues(*update);
     if (update->guiScale) {
-      mDisplay->mCfgC.guiScale = *update->guiScale;
+      mDisplay->mCfgO.guiScale = *update->guiScale;
     }
     if (update->guiDarkMode) {
-      mDisplay->mCfgC.guiDarkMode = *update->guiDarkMode;
+      mDisplay->mCfgO.guiDarkMode = *update->guiDarkMode;
     }
   }
 
   if (gui) {
-    GPUDisplayGUIChannel::Settings cfg{mDisplay->mCfgH, mDisplay->mCfgL, mDisplay->mCfgR, mDisplay->mCfgC};
+    GPUDisplayGUIChannel::Settings cfg{mDisplay->mCfgH, mDisplay->mCfgL, mDisplay->mCfgR, mDisplay->mCfgO, mDisplay->mCfgC};
     {
       std::lock_guard lock(mGUIChannel->mutex);
       mGUIChannel->state.cfg = std::move(cfg);
-      mGUIChannel->state.infoStatus = mDisplay->mCfgC.printInfoTextGUI ? mDisplay->mGUIInfoStatus : "";
-      mGUIChannel->state.infoText = mDisplay->mCfgC.printInfoTextGUI ? mDisplay->mGUIInfoText : "";
+      mGUIChannel->state.infoStatus = mDisplay->mCfgO.printInfoTextGUI ? mDisplay->mGUIInfoStatus : "";
+      mGUIChannel->state.infoText = mDisplay->mCfgO.printInfoTextGUI ? mDisplay->mGUIInfoText : "";
       mGUIChannel->state.infoTextCounter = mDisplay->mGUIInfoTextCounter;
       if (mDisplay->mUpdateGUIOptions) {
         mGUIChannel->state.optionsRevision++;

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -61,7 +61,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
   static constexpr int32_t GL_MIN_VERSION_MAJOR = 4;
   static constexpr int32_t GL_MIN_VERSION_MINOR = 6;
 
-  int32_t StartDisplay();                      // Start the display. This function returns, and should spawn a thread that runs the display, and calls InitDisplay
+  int32_t StartDisplay();                      // Start the display: spawns the frontend thread (FrontendThreadWrapper, calls InitDisplay), returns after both threads are initialized
   void StopDisplay() override;                 // Stop the display. Display thread should call ExitDisplay. Functions waits for display thread to terminate
   virtual void SwitchFullscreen(bool set) = 0; // Toggle full-screen mode
   virtual void ToggleMaximized(bool set) = 0;  // Maximize window
@@ -141,7 +141,6 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
   void HandleKey(uint8_t key);                     // Callback for handling key presses
   bool consoleShown() const;                       // Key presses go to the console, frontends do not set mKeys
   void HandleExternalGUISignals();                 // Callback to handle signals from external GUIs
-  bool HasExternalGUISignals() const;              // Returns whether there are currently pending signals from external GUIs to be handled
   bool processKeyLambda(uint32_t key);             // Process key lambda callback
   void showConfigInfo(uint32_t index);             // Info for a changed option (index in the config RTTI): its info callback, or "struct.option changed to value"
   void ResizeScene(int32_t width, int32_t height); // Callback when GL window is resized