Project
Loading...
Searching...
No Matches
GPUDisplay.h
Go to the documentation of this file.
1// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
2// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
3// All rights not expressly granted are reserved.
4//
5// This software is distributed under the terms of the GNU General Public
6// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
7//
8// In applying this license CERN does not waive the privileges and immunities
9// granted to it by virtue of its status as an Intergovernmental Organization
10// or submit itself to any jurisdiction.
11
14
15#ifndef GPUDISPLAY_H
16#define GPUDISPLAY_H
17
20#include "GPUDisplayInterface.h"
21
22#include "../utils/vecpod.h"
23#include "../utils/qsem.h"
24
25#include <array>
26#include "HandMadeMath.h"
27
28#include "utils/timer.h"
29
30namespace o2::gpu
31{
32class GPUTPCTracker;
33struct GPUParam;
34class GPUQA;
35class GPUTRDGeometry;
36
38{
39 public:
40 GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr);
41 GPUDisplay(const GPUDisplay&) = delete;
42 ~GPUDisplay() override = default;
43
44 int32_t StartDisplay() override;
45 void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) override;
46 void WaitForNextEvent() override;
47 void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) override;
48 void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
49 void UpdateParam(const GPUParam* param) override { mParam = param; }
50
51 void HandleKey(uint8_t key);
52 int32_t DrawGLScene();
53 void HandleSendKey(int32_t key);
54 int32_t InitDisplay(bool initFailure = false);
55 void ExitDisplay();
56 void ResizeScene(int32_t width, int32_t height, bool init = false);
57
58 const GPUSettingsDisplayRenderer& cfgR() const { return mCfgR; }
59 const GPUSettingsDisplayLight& cfgL() const { return mCfgL; }
60 const GPUSettingsDisplayHeavy& cfgH() const { return mCfgH; }
61 const GPUSettingsDisplay& cfg() const { return mConfig; }
62 bool useMultiVBO() const { return mUseMultiVBO; }
63 int32_t updateDrawCommands() const { return mUpdateDrawCommands; }
64 int32_t updateRenderPipeline() const { return mUpdateRenderPipeline; }
65 GPUDisplayBackend* backend() const { return mBackend.get(); }
66 vecpod<int32_t>* vertexBufferStart() { return mVertexBufferStart; }
67 const vecpod<uint32_t>* vertexBufferCount() const { return mVertexBufferCount; }
68 struct vtx {
69 float x, y, z;
70 vtx(float a, float b, float c) : x(a), y(b), z(c) {}
71 };
72 vecpod<vtx>* vertexBuffer() { return mVertexBuffer; }
73 const GPUParam* param() { return mParam; }
74 GPUDisplayFrontend* frontend() { return mFrontend; }
75 bool drawTextInCompatMode() const { return mDrawTextInCompatMode; }
76 int32_t& drawTextFontSize() { return mDrawTextFontSize; }
77
78 private:
79 static constexpr int32_t NSECTORS = GPUCA_NSECTORS;
80 static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
81
82 static constexpr const int32_t N_POINTS_TYPE = 15;
83 static constexpr const int32_t N_POINTS_TYPE_TPC = 9;
84 static constexpr const int32_t N_POINTS_TYPE_TRD = 2;
85 static constexpr const int32_t N_POINTS_TYPE_TOF = 2;
86 static constexpr const int32_t N_POINTS_TYPE_ITS = 2;
87 static constexpr const int32_t N_LINES_TYPE = 7;
88 static constexpr const int32_t N_FINAL_TYPE = 4;
89 static constexpr int32_t TRACK_TYPE_ID_LIMIT = 100;
90 enum PointTypes { tCLUSTER = 0,
91 tINITLINK = 1,
92 tLINK = 2,
93 tSEED = 3,
94 tTRACKLET = 4,
95 tSECTORTRACK = 5,
96 tEXTRAPOLATEDTRACK = 6,
97 tFINALTRACK = 7,
98 tMARKED = 8,
99 tTRDCLUSTER = 9,
100 tTRDATTACHED = 10,
101 tTOFCLUSTER = 11,
102 tTOFATTACHED = 12,
103 tITSCLUSTER = 13,
104 tITSATTACHED = 14 };
105 enum LineTypes { RESERVED = 0 /*1 -- 6 = INITLINK to GLOBALTRACK*/ };
106
107 using vboList = GPUDisplayBackend::vboList;
108
109 struct threadVertexBuffer {
111 vecpod<int32_t> start[N_FINAL_TYPE];
112 vecpod<uint32_t> count[N_FINAL_TYPE];
113 std::pair<vecpod<int32_t>*, vecpod<uint32_t>*> vBuf[N_FINAL_TYPE];
114 threadVertexBuffer() : buffer()
115 {
116 for (int32_t i = 0; i < N_FINAL_TYPE; i++) {
117 vBuf[i].first = start + i;
118 vBuf[i].second = count + i;
119 }
120 }
121 void clear()
122 {
123 for (int32_t i = 0; i < N_FINAL_TYPE; i++) {
124 start[i].clear();
125 count[i].clear();
126 }
127 }
128 };
129
130 class opengl_spline
131 {
132 public:
133 opengl_spline() : ma(), mb(), mc(), md(), mx() {}
134 void create(const vecpod<float>& x, const vecpod<float>& y);
135 float evaluate(float x);
136 void setVerbose() { mVerbose = true; }
137
138 private:
139 vecpod<float> ma, mb, mc, md, mx;
140 bool mVerbose = false;
141 };
142
143 void DrawGLScene_internal(float animateTime = -1.f, bool renderToMixBuffer = false);
144 void DrawGLScene_updateEventData();
145 void DrawGLScene_cameraAndAnimation(float animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
146 size_t DrawGLScene_updateVertexList();
147 void DrawGLScene_drawCommands();
148 int32_t InitDisplay_internal();
149 int32_t getNumThreads();
150 void updateOptions();
151 void disableUnsupportedOptions();
152 int32_t buildTrackFilter();
153 const GPUTPCTracker& sectorTracker(int32_t iSector);
154 const GPUTRDGeometry* trdGeometry();
155 const GPUTrackingInOutPointers* mIOPtrs = nullptr;
156 void insertVertexList(std::pair<vecpod<int32_t>*, vecpod<uint32_t>*>& vBuf, size_t first, size_t last);
157 void insertVertexList(int32_t iSector, size_t first, size_t last);
158 template <typename... Args>
159 void SetInfo(Args... args);
160 void PrintGLHelpText(float colorValue);
161 void calcXYZ(const float*);
162 void mAnimationCloseAngle(float& newangle, float lastAngle);
163 void mAnimateCloseQuaternion(float* v, float lastx, float lasty, float lastz, float lastw);
164 void setAnimationPoint();
165 void resetAnimation();
166 void removeAnimationPoint();
167 void startAnimation();
168 int32_t animateCamera(float& animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
169 void showInfo(const char* info);
170 void ActivateColor();
171 void SetColorTRD();
172 void SetColorTOF();
173 void SetColorITS();
174 void SetColorClusters();
175 void SetColorInitLinks();
176 void SetColorLinks();
177 void SetColorSeeds();
178 void SetColorTracklets();
179 void SetColorTracks();
180 void SetColorExtrapolatedTracks();
181 void SetColorFinal();
182 void SetColorGrid();
183 void SetColorGridTRD();
184 void SetColorMarked();
185 void SetCollisionColor(int32_t col);
186 void updateConfig();
187 void drawPointLinestrip(int32_t iSector, int32_t cid, int32_t id, int32_t id_limit = TRACK_TYPE_ID_LIMIT);
188 vboList DrawClusters(int32_t iSector, int32_t select, uint32_t iCol);
189 vboList DrawSpacePointsTRD(int32_t iSector, int32_t select, int32_t iCol);
190 vboList DrawSpacePointsTOF(int32_t iSector, int32_t select, int32_t iCol);
191 vboList DrawSpacePointsITS(int32_t iSector, int32_t select, int32_t iCol);
192 vboList DrawLinks(const GPUTPCTracker& tracker, int32_t id, bool dodown = false);
193 vboList DrawSeeds(const GPUTPCTracker& tracker);
194 vboList DrawTracklets(const GPUTPCTracker& tracker);
195 vboList DrawTracks(const GPUTPCTracker& tracker, int32_t global);
196 void DrawTrackITS(int32_t trackId, int32_t iSector);
197 GPUDisplay::vboList DrawFinalITS();
198 template <class T>
199 void DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMPropagator* prop, std::array<vecpod<int32_t>, 2>& trackList, threadVertexBuffer& threadBuffer);
200 vboList DrawGrid(const GPUTPCTracker& tracker);
201 vboList DrawGridTRD(int32_t sector);
202 void DoScreenshot(const char* filename, std::vector<char>& pixels, float animateTime = -1.f);
203 void PrintHelp();
204 void createQuaternionFromMatrix(float* v, const float* mat);
205 void drawVertices(const vboList& v, const GPUDisplayBackend::drawType t);
206 void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true);
207
208 GPUDisplayFrontend* mFrontend = nullptr;
209 std::unique_ptr<GPUDisplayBackend> mBackend;
210 GPUChainTracking* mChain = nullptr;
211 const GPUParam* mParam = nullptr;
212 const GPUCalibObjectsConst* mCalib = nullptr;
213 const GPUSettingsDisplay& mConfig;
214 GPUSettingsDisplayLight mCfgL;
215 GPUSettingsDisplayHeavy mCfgH;
216 GPUSettingsDisplayRenderer mCfgR;
217 GPUQA* mQA;
218 qSem mSemLockDisplay;
219
220 bool mDrawTextInCompatMode = false;
221 int32_t mDrawTextFontSize = 0;
222
223 int32_t mNDrawCalls = 0;
224
225 bool mUseMultiVBO = false;
226
227 std::array<float, 4> mDrawColor = {1.f, 1.f, 1.f, 1.f};
228
229 int32_t mTestSetting = 0;
230
231 float mAngleRollOrigin = -1e9;
232 float mMaxClusterZ = -1;
233
234 hmm_mat4 mViewMatrix, mModelMatrix;
235 float* const mViewMatrixP = &mViewMatrix.Elements[0][0];
236 float mXYZ[3];
237 float mAngle[3];
238 float mRPhiTheta[3];
239 float mQuat[4];
240
241 vecpod<std::array<int32_t, 37>> mOverlayTFClusters;
242 int32_t mNCollissions = 1;
243
244 vecpod<vtx> mVertexBuffer[NSECTORS];
245 vecpod<int32_t> mVertexBufferStart[NSECTORS];
246 vecpod<uint32_t> mVertexBufferCount[NSECTORS];
247
248 std::unique_ptr<float4[]> mGlobalPosPtr;
249 std::unique_ptr<float4[]> mGlobalPosPtrTRD;
250 std::unique_ptr<float4[]> mGlobalPosPtrTRD2;
251 std::unique_ptr<float4[]> mGlobalPosPtrITS;
252 std::unique_ptr<float4[]> mGlobalPosPtrTOF;
253 float4* mGlobalPos;
254 float4* mGlobalPosTRD;
255 float4* mGlobalPosTRD2;
256 float4* mGlobalPosITS;
257 float4* mGlobalPosTOF;
258 int32_t mNMaxClusters = 0;
259 int32_t mNMaxSpacePointsTRD = 0;
260 int32_t mNMaxClustersITS = 0;
261 int32_t mNMaxClustersTOF = 0;
262 int32_t mCurrentClusters = 0;
263 int32_t mCurrentSpacePointsTRD = 0;
264 int32_t mCurrentClustersITS = 0;
265 int32_t mCurrentClustersTOF = 0;
266 vecpod<int32_t> mTRDTrackIds;
267 vecpod<bool> mITSStandaloneTracks;
268 std::vector<bool> mTrackFilter;
269 bool mUpdateTrackFilter = false;
270
271 int32_t mUpdateVertexLists = 1;
272 int32_t mUpdateEventData = 0;
273 int32_t mUpdateDrawCommands = 1;
274 int32_t mUpdateRenderPipeline = 0;
275 volatile int32_t mResetScene = 0;
276
277 int32_t mAnimate = 0;
278 HighResTimer mAnimationTimer;
279 int32_t mAnimationFrame = 0;
280 int32_t mAnimationLastBase = 0;
281 int32_t mAnimateScreenshot = 0;
282 int32_t mAnimationExport = 0;
283 bool mAnimationChangeConfig = true;
284 float mAnimationDelay = 2.f;
285 vecpod<float> mAnimateVectors[9];
286 vecpod<GPUSettingsDisplayLight> mAnimateConfig;
287 opengl_spline mAnimationSplines[8];
288
289 int32_t mPrintInfoText = 1;
290 bool mPrintInfoTextAlways = 0;
291 char mInfoText2[1024];
292 HighResTimer mInfoText2Timer, mInfoHelpTimer;
293
294 std::vector<threadVertexBuffer> mThreadBuffers;
295 std::vector<std::vector<std::array<std::array<vecpod<int32_t>, 2>, NSECTORS>>> mThreadTracks;
296 volatile int32_t mInitResult = 0;
297
298 float mFPSScale = 1, mFPSScaleadjust = 0;
299 int32_t mFramesDone = 0, mFramesDoneFPS = 0;
300 HighResTimer mTimerFPS, mTimerDisplay, mTimerDraw;
301 vboList mGlDLLines[NSECTORS][N_LINES_TYPE];
302 vecpod<std::array<vboList, N_FINAL_TYPE>> mGlDLFinal[NSECTORS];
303 vboList mGlDLFinalITS;
304 vecpod<vboList> mGlDLPoints[NSECTORS][N_POINTS_TYPE];
305 vboList mGlDLGrid[NSECTORS];
306 vboList mGlDLGridTRD[NSECTORS / 2];
307
308 bool mRequestScreenshot = false;
309 std::string mScreenshotFile;
310
311 float mYFactor = 1.0f;
312};
313} // namespace o2::gpu
314
315#endif
int32_t i
GPUChain * chain
#define GPUCA_NSECTORS
uint32_t col
Definition RawData.h:4
uint32_t c
Definition RawData.h:2
StringRef key
std::tuple< uint32_t, uint32_t, int32_t > vboList
const GPUSettingsDisplayLight & cfgL() const
Definition GPUDisplay.h:59
void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) override
void HandleKey(uint8_t key)
const GPUParam * param()
Definition GPUDisplay.h:73
const GPUSettingsDisplayHeavy & cfgH() const
Definition GPUDisplay.h:60
~GPUDisplay() override=default
int32_t updateRenderPipeline() const
Definition GPUDisplay.h:64
void HandleSendKey(int32_t key)
void UpdateCalib(const GPUCalibObjectsConst *calib) override
Definition GPUDisplay.h:48
const GPUSettingsDisplayRenderer & cfgR() const
Definition GPUDisplay.h:58
void WaitForNextEvent() override
vecpod< vtx > * vertexBuffer()
Definition GPUDisplay.h:72
GPUDisplay(const GPUDisplay &)=delete
int32_t StartDisplay() override
bool drawTextInCompatMode() const
Definition GPUDisplay.h:75
int32_t & drawTextFontSize()
Definition GPUDisplay.h:76
void UpdateParam(const GPUParam *param) override
Definition GPUDisplay.h:49
int32_t updateDrawCommands() const
Definition GPUDisplay.h:63
GPUDisplayFrontend * frontend()
Definition GPUDisplay.h:74
const vecpod< uint32_t > * vertexBufferCount() const
Definition GPUDisplay.h:67
const GPUSettingsDisplay & cfg() const
Definition GPUDisplay.h:61
int32_t InitDisplay(bool initFailure=false)
bool useMultiVBO() const
Definition GPUDisplay.h:62
void ShowNextEvent(const GPUTrackingInOutPointers *ptrs=nullptr) override
vecpod< int32_t > * vertexBufferStart()
Definition GPUDisplay.h:66
GPUDisplayBackend * backend() const
Definition GPUDisplay.h:65
void ResizeScene(int32_t width, int32_t height, bool init=false)
Definition qsem.h:25
GLint GLenum GLint x
Definition glcorearb.h:403
GLint GLsizei count
Definition glcorearb.h:399
GLuint buffer
Definition glcorearb.h:655
const GLdouble * v
Definition glcorearb.h:832
GLint GLsizei GLsizei height
Definition glcorearb.h:270
GLint GLsizei width
Definition glcorearb.h:270
GLboolean GLboolean GLboolean b
Definition glcorearb.h:1233
GLboolean GLboolean g
Definition glcorearb.h:1233
GLint GLint GLsizei GLint GLenum GLenum const void * pixels
Definition glcorearb.h:275
GLboolean r
Definition glcorearb.h:1233
GLuint start
Definition glcorearb.h:469
GLenum GLfloat param
Definition glcorearb.h:271
GLboolean GLboolean GLboolean GLboolean a
Definition glcorearb.h:1233
GLdouble GLdouble GLdouble z
Definition glcorearb.h:843
ConcreteParserVariants< PageSize, BOUNDS_CHECKS > create(T const *buffer, size_t size)
create a raw parser depending on version of RAWDataHeader found at beginning of data
Definition RawParser.h:378
std::vector< InputSpec > select(char const *matcher="")
GPUCalibObjectsTemplate< ConstPtr > GPUCalibObjectsConst
std::string filename()
vtx(float a, float b, float c)
Definition GPUDisplay.h:70
vec clear()
float Elements[4][4]
typename std::vector< T, vecpod_allocator< T > > vecpod
Definition vecpod.h:31