GPUDisplay.h

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.
 
 
#ifndef GPUDISPLAY_H
#define GPUDISPLAY_H
 
#define GPUSETTINGS_DISPLAY
#define GPUSETTINGS_DISPLAYCONTROL
#include "GPUSettings.h"
#include "frontend/GPUDisplayFrontend.h"
#include "backend/GPUDisplayBackend.h"
#include "GPUDisplayInterface.h"
#include "DataFormatsTPC/Constants.h"
 
#include <atomic>
#include <array>
#include <tuple>
#include <mutex>
#include <condition_variable>
 
union hmm_mat4; // From HandMadeMath
 
#include "utils/timer.h"
#include "utils/vecpod.h"
#include "utils/qsem.h"
 
namespace o2::gpu
{
class GPUTPCTracker;
struct GPUParam;
class GPUQA;
class GPUTRDGeometry;
class GPUTPCGMPropagator;
 
class GPUDisplay : public GPUDisplayInterface
{
  friend class GPUDisplayFrontend;
 
 public:
  GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr, const GPUSettingsProcessing* proc = nullptr);
  GPUDisplay(const GPUDisplay&) = delete;
  ~GPUDisplay() override = default;
 
  int32_t StartDisplay() override;
  void ExitDisplay();
  void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) override;
  void BlockTillNextEvent() override;
  void UnblockDisplay();
  void WaitTillEventShown() override;
  void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) override;
  void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
  void UpdateParam(const GPUParam* param) override { mParam = param; }
 
  void HandleKey(uint8_t key, bool external = false, bool bypassConsole = false); // external: from the Qt GUI or the console, not typed into the event display console; bypassConsole: handled as key also while the console is shown (injectKey)
  int32_t DrawGLScene(bool suspended = false);
  void HandleExternalGUIKey(int32_t key, bool bypassConsole = false); // key >= 256: special key with SHIFT
  int32_t InitDisplay(bool initFailure = false);
  void ResizeScene(int32_t width, int32_t height, bool init = false);
  void checkAndApplyConfigChanges(); // Set update flags / apply the settings that changed compared to mOldCfg
 
  const GPUSettingsDisplayRenderer& cfgR() const { return mCfgR; }
  const GPUSettingsDisplayLight& cfgL() const { return mCfgL; }
  const GPUSettingsDisplayHeavy& cfgH() const { return mCfgH; }
  const GPUSettingsDisplay& cfg() const { return mConfig; }
  bool useMultiVBO() const { return mUseMultiVBO; }
  int32_t updateDrawCommands() const { return mUpdateDrawCommands; }
  int32_t updateRenderPipeline() const { return mUpdateRenderPipeline; }
  GPUDisplayBackend* backend() const { return mBackend.get(); }
  vecpod<int32_t>* vertexBufferStart() { return mVertexBufferStart; }
  const vecpod<uint32_t>* vertexBufferCount() const { return mVertexBufferCount; }
  struct vtx {
    float x, y, z;
    vtx(float a, float b, float c) : x(a), y(b), z(c) {}
  };
  vecpod<vtx>* vertexBuffer() { return mVertexBuffer; }
  const GPUParam* param() { return mParam; }
  const GPUSettingsProcessing& GetProcessingSettings() const { return mProcessingSettings; }
  GPUDisplayFrontend* frontend() { return mFrontend; }
  int32_t& drawTextFontSize() { return mDrawTextFontSize; }
 
  GPUDisplayOptions mCfgO;
  GPUDisplayControl mCfgC;
 
 private:
  void buildConfig();
  void buildConfigKeys();
  void buildConfigInfo();
  void buildConfigQtGUI();
 
  static constexpr int32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
  static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
 
  static constexpr const int32_t N_POINTS_TYPE = 15;
  static constexpr const int32_t N_POINTS_TYPE_TPC = 9;
  static constexpr const int32_t N_POINTS_TYPE_TRD = 2;
  static constexpr const int32_t N_POINTS_TYPE_TOF = 2;
  static constexpr const int32_t N_POINTS_TYPE_ITS = 2;
  static constexpr const int32_t N_LINES_TYPE = 7;
  static constexpr const int32_t N_FINAL_TYPE = 4;
  static constexpr int32_t TRACK_TYPE_ID_LIMIT = 100;
  static const std::array<std::string, 7> ANIMATION_MODE_NAMES_SHORT, ANIMATION_MODE_NAMES_LONG; // By mCfgL.animationMode
  enum PointTypes { tCLUSTER = 0,
                    tINITLINK = 1,
                    tLINK = 2,
                    tSEED = 3,
                    tTRACKLET = 4,
                    tSECTORTRACK = 5,
                    tEXTRAPOLATEDTRACK = 6,
                    tFINALTRACK = 7,
                    tMARKED = 8,
                    tTRDCLUSTER = 9,
                    tTRDATTACHED = 10,
                    tTOFCLUSTER = 11,
                    tTOFATTACHED = 12,
                    tITSCLUSTER = 13,
                    tITSATTACHED = 14 };
  enum LineTypes { RESERVED = 0 /*1 -- 6 = INITLINK to GLOBALTRACK*/ };
 
  using vboList = GPUDisplayBackend::vboList;
 
  struct threadVertexBuffer {
    vecpod<vtx> buffer;
    vecpod<int32_t> start[N_FINAL_TYPE];
    vecpod<uint32_t> count[N_FINAL_TYPE];
    std::pair<vecpod<int32_t>*, vecpod<uint32_t>*> vBuf[N_FINAL_TYPE];
    threadVertexBuffer() : buffer()
    {
      for (int32_t i = 0; i < N_FINAL_TYPE; i++) {
        vBuf[i].first = start + i;
        vBuf[i].second = count + i;
      }
    }
    void clear()
    {
      for (int32_t i = 0; i < N_FINAL_TYPE; i++) {
        start[i].clear();
        count[i].clear();
      }
    }
  };
 
  struct animationVector {        // Animation point, its time is in mCfgC.animationPoints.values
    float v[6];                   // Camera: x, y, z, pitch, yaw, roll (as mXYZ, mAngle), independent of the animation mode
    GPUSettingsDisplayLight cfgL; // Settings at the point
  };
 
  class opengl_spline
  {
   public:
    opengl_spline() : ma(), mb(), mc(), md(), mx() {}
    void create(const vecpod<float>& x, const vecpod<float>& y);
    float evaluate(float x);
    void setVerbose() { mVerbose = true; }
 
   private:
    vecpod<float> ma, mb, mc, md, mx;
    bool mVerbose = false;
  };
 
  static const GPUSettingsDisplay& GetConfig(GPUChainTracking* chain);
  static const GPUSettingsProcessing& GetProcessingConfig(GPUChainTracking* chain);
 
  void DrawGLScene_internal(bool suspended, float animateTime = -1.f, bool renderToMixBuffer = false); // suspended: return before drawing
  void DrawGLScene_updateEventData();
  void DrawGLScene_cameraAndAnimation(bool suspended, float animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
  size_t DrawGLScene_updateVertexList();
  void DrawGLScene_drawCommands();
  int32_t InitDisplay_internal();
  int32_t getNumThreads();
  void updateOptions();
  void disableUnsupportedOptions();
  int32_t buildTrackFilter();
  std::string trackFilterName() const; // Selected track filter: macro file from filterMacros, or "Custom Macro"
  const GPUTPCTracker& sectorTracker(int32_t iSector);
  const GPUTRDGeometry* trdGeometry();
  const GPUTrackingInOutPointers* mIOPtrs = nullptr;
  void insertVertexList(std::pair<vecpod<int32_t>*, vecpod<uint32_t>*>& vBuf, size_t first, size_t last);
  void insertVertexList(int32_t iSector, size_t first, size_t last);
  template <typename... Args>
  void SetInfo(Args... args);
  void PrintGLHelpText(float colorValue);
  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 mCfgO.glPosFile
  void LoadGLPos();
  void SaveGLAnimation(); // Animation path to mCfgO.glAnimationFile
  void LoadGLAnimation();
  void takeScreenshot();
  void runAnimation(); // Starts the animation if it has enough points
  void setAnimationPoint();
  void setCamera(const float (&xyz)[3], const float (&angles)[3]);         // Position and angles (radians, as mAngle: pitch, yaw, roll)
  void addAnimationPoint(const float (&xyz)[3], const float (&angles)[3]); // Animation point for this camera, the current camera is kept
  bool lookAt(const float (&target)[3]);                                   // Turn the camera to the point, false if it is the camera position
  void rotateCamera(const float (&angles)[3]);                             // Yaw, pitch, roll in degrees relative to the view, as the keyboard
  hmm_mat4 cameraRotation(const float (&angles)[3]) const;                 // Rotation of rotateCamera, applied to the view matrix also for keyboard / mouse
  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 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 (vals of animationPointValues), as animateCamera
  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();
  void SetColorITS();
  void SetColorClusters();
  void SetColorInitLinks();
  void SetColorLinks();
  void SetColorSeeds();
  void SetColorTracklets();
  void SetColorTracks();
  void SetColorExtrapolatedTracks();
  void SetColorFinal();
  void SetColorGrid();
  void SetColorGridTRD();
  void SetColorMarked();
  void SetCollisionColor(int32_t col);
  void updateConfig();
  void drawPointLinestrip(int32_t iSector, int32_t cid, int32_t id, int32_t id_limit = TRACK_TYPE_ID_LIMIT);
  void DrawClusters(int32_t iSector);
  vboList DrawSpacePointsTRD(int32_t iSector, int32_t select, int32_t iCol);
  vboList DrawSpacePointsTOF(int32_t iSector, int32_t select, int32_t iCol);
  vboList DrawSpacePointsITS(int32_t iSector, int32_t select, int32_t iCol);
  vboList DrawLinks(const GPUTPCTracker& tracker, int32_t id, bool dodown = false);
  vboList DrawSeeds(const GPUTPCTracker& tracker);
  vboList DrawTracklets(const GPUTPCTracker& tracker);
  vboList DrawTracks(const GPUTPCTracker& tracker, int32_t global);
  void DrawTrackITS(int32_t trackId, int32_t iSector);
  GPUDisplay::vboList DrawFinalITS();
  template <class T>
  void DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMPropagator* prop, std::array<vecpod<int32_t>, 2>& trackList, threadVertexBuffer& threadBuffer);
  vboList DrawGrid(const GPUTPCTracker& tracker);
  vboList DrawGridTRD(int32_t sector);
  void DoScreenshot(const char* filename, std::vector<char>& pixels, float animateTime = -1.f);
  void PrintHelp();
  void createQuaternionFromMatrix(float* v, const float* mat);
  void drawVertices(const vboList& v, const GPUDisplayBackend::drawType t);
  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;
  GPUChainTracking* mChain = nullptr;
  const GPUParam* mParam = nullptr;
  const GPUCalibObjectsConst* mCalib = nullptr;
  const GPUSettingsDisplay& mConfig;
  GPUSettingsDisplayLight mCfgL;
  GPUSettingsDisplayHeavy mCfgH;
  GPUSettingsDisplayRenderer mCfgR;
  std::tuple<GPUSettingsDisplayHeavy, GPUSettingsDisplayLight, GPUSettingsDisplayRenderer> mOldCfg; // Settings after the last draw, for checkAndApplyConfigChanges
  const GPUSettingsProcessing& mProcessingSettings;
  GPUQA* mQA;
 
  qSem mSemLockDisplay;
  std::mutex mMutexLoadAndShowEvent;
  std::condition_variable mCVLoadAndShowEvent;
 
  int32_t mDrawTextFontSize = 0;
 
  int32_t mNDrawCalls = 0;
 
  bool mUseMultiVBO = false;
 
  std::array<float, 4> mDrawColor = {1.f, 1.f, 1.f, 1.f};
 
  float mAngleRollOrigin = -1e9;
  float mMaxClusterZ = -1;
 
  std::unique_ptr<hmm_mat4> mViewMatrix, mModelMatrix;
  float mXYZ[3];
  float mAngle[3];
  float mRPhiTheta[3];
  float mQuat[4];
 
  vecpod<std::array<int32_t, 37>> mOverlayTFClusters;
  int32_t mNCollissions = 1;
 
  vecpod<vtx> mVertexBuffer[NSECTORS];
  vecpod<int32_t> mVertexBufferStart[NSECTORS];
  vecpod<uint32_t> mVertexBufferCount[NSECTORS];
  std::vector<std::array<uint32_t, N_POINTS_TYPE_TPC>> mClusterBufferSizeCache[NSECTORS];
 
  std::unique_ptr<float4[]> mGlobalPosPtr;
  std::unique_ptr<float4[]> mGlobalPosPtrTRD;
  std::unique_ptr<float4[]> mGlobalPosPtrTRD2;
  std::unique_ptr<float4[]> mGlobalPosPtrITS;
  std::unique_ptr<float4[]> mGlobalPosPtrTOF;
  float4* mGlobalPos;
  float4* mGlobalPosTRD;
  float4* mGlobalPosTRD2;
  float4* mGlobalPosITS;
  float4* mGlobalPosTOF;
  int32_t mNMaxClusters = 0;
  int32_t mNMaxSpacePointsTRD = 0;
  int32_t mNMaxClustersITS = 0;
  int32_t mNMaxClustersTOF = 0;
  int32_t mCurrentClusters = 0;
  int32_t mCurrentSpacePointsTRD = 0;
  int32_t mCurrentClustersITS = 0;
  int32_t mCurrentClustersTOF = 0;
  vecpod<int32_t> mTRDTrackIds;
  vecpod<bool> mITSStandaloneTracks;
  std::vector<bool> mTrackFilter;
 
  volatile bool mUpdateTrackFilter = false;
  std::string mTrackFilterMacroLoaded; // Track filter macro file loaded into ROOT, unloaded before loading another one (same function name)
  bool mUpdateGUIOptions = false;      // The Qt GUI must call the dynamic option lambdas of its elements again (new event, GUI started)
  volatile bool mUpdateVertexLists = true;
  volatile bool mUpdateEventData = false;
  volatile bool mUpdateDrawCommands = true;
  volatile bool mUpdateRenderPipeline = false;
  volatile bool mLoadAndShowEvent = false;
  uint32_t mNEventsShown = 0; // Events loaded and drawn, in the frontend thread
  bool mTracksArePropagated = false;
 
  int32_t mAnimate = 0;
  HighResTimer mAnimationTimer;
  int32_t mAnimationFrame = 0;
  int32_t mAnimationLastBase = 0;
  int32_t mAnimationMixBase = -1; // Target keyframe of the current config blend (mixing), -1 = none
  int32_t mAnimationExport = 0;
  vecpod<animationVector> mAnimationVectors;
  std::vector<std::array<opengl_spline, 8>> mAnimationSplines; // By animation mode: the 8 values of animationPointValues
 
  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, mConsoleTimer; // mConsoleTimer: opening / closing animation of the console
  HighResTimer mConsoleCursorTimer;                            // Blinking of the console cursor, started when the console is fully open, restarted when the cursor moves
  uint32_t mConsoleCursorPos = 0;                              // Cursor position at the last restart of mConsoleCursorTimer
  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;
  int32_t mInitResult = 0; // 1 success, -1 failure, protected by mFrontend->mExitStateMutex
 
  float mFPSScale = 1, mFPSScaleadjust = 0;
  int32_t mFramesDone = 0, mFramesDoneFPS = 0;
  HighResTimer mTimerFPS;
  vboList mGlDLLines[NSECTORS][N_LINES_TYPE];
  vecpod<std::array<vboList, N_FINAL_TYPE>> mGlDLFinal[NSECTORS];
  vboList mGlDLFinalITS;
  vecpod<vboList> mGlDLPoints[NSECTORS][N_POINTS_TYPE];
  vboList mGlDLGrid[NSECTORS];
  vboList mGlDLGridTRD[NSECTORS / 2];
 
  std::string mScreenshotFile;
 
  float mYFactor = 1.0f;
};
} // namespace o2::gpu
 
#endif