1 | // Copyright (C) 2016 The Qt Company Ltd. |
2 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only |
3 | |
4 | #undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses |
5 | |
6 | #include "surface3drenderer_p.h" |
7 | #include "q3dcamera_p.h" |
8 | #include "shaderhelper_p.h" |
9 | #include "texturehelper_p.h" |
10 | #include "utils_p.h" |
11 | |
12 | #include <QtCore/qmath.h> |
13 | |
14 | static const int ID_TO_RGBA_MASK = 0xff; |
15 | |
16 | QT_BEGIN_NAMESPACE |
17 | |
18 | //#define SHOW_DEPTH_TEXTURE_SCENE |
19 | |
20 | const GLfloat sliceZScale = 0.1f; |
21 | const GLfloat sliceUnits = 2.5f; |
22 | const uint greenMultiplier = 256; |
23 | const uint blueMultiplier = 65536; |
24 | const uint alphaMultiplier = 16777216; |
25 | |
26 | Surface3DRenderer::Surface3DRenderer(Surface3DController *controller) |
27 | : Abstract3DRenderer(controller), |
28 | m_cachedIsSlicingActivated(false), |
29 | m_depthShader(0), |
30 | m_backgroundShader(0), |
31 | m_surfaceFlatShader(0), |
32 | m_surfaceSmoothShader(0), |
33 | m_surfaceTexturedSmoothShader(0), |
34 | m_surfaceTexturedFlatShader(0), |
35 | m_surfaceGridShader(0), |
36 | m_surfaceSliceFlatShader(0), |
37 | m_surfaceSliceSmoothShader(0), |
38 | m_selectionShader(0), |
39 | m_heightNormalizer(0.0f), |
40 | m_scaleX(0.0f), |
41 | m_scaleY(0.0f), |
42 | m_scaleZ(0.0f), |
43 | m_depthFrameBuffer(0), |
44 | m_selectionFrameBuffer(0), |
45 | m_selectionDepthBuffer(0), |
46 | m_selectionResultTexture(0), |
47 | m_shadowQualityToShader(33.3f), |
48 | m_flatSupported(true), |
49 | m_selectionActive(false), |
50 | m_shadowQualityMultiplier(3), |
51 | m_selectedPoint(Surface3DController::invalidSelectionPosition()), |
52 | m_selectedSeries(0), |
53 | m_clickedPosition(Surface3DController::invalidSelectionPosition()), |
54 | m_selectionTexturesDirty(false), |
55 | m_noShadowTexture(0) |
56 | { |
57 | // Check if flat feature is supported |
58 | ShaderHelper tester(this, QStringLiteral(":/shaders/vertexSurfaceFlat" ), |
59 | QStringLiteral(":/shaders/fragmentSurfaceFlat" )); |
60 | if (!tester.testCompile()) { |
61 | m_flatSupported = false; |
62 | connect(sender: this, signal: &Surface3DRenderer::flatShadingSupportedChanged, |
63 | context: controller, slot: &Surface3DController::handleFlatShadingSupportedChange); |
64 | emit flatShadingSupportedChanged(supported: m_flatSupported); |
65 | qWarning() << "Warning: Flat qualifier not supported on your platform's GLSL language." |
66 | " Requires at least GLSL version 1.2 with GL_EXT_gpu_shader4 extension." ; |
67 | } |
68 | |
69 | initializeOpenGL(); |
70 | } |
71 | |
72 | Surface3DRenderer::~Surface3DRenderer() |
73 | { |
74 | contextCleanup(); |
75 | delete m_depthShader; |
76 | delete m_backgroundShader; |
77 | delete m_selectionShader; |
78 | delete m_surfaceFlatShader; |
79 | delete m_surfaceSmoothShader; |
80 | delete m_surfaceTexturedSmoothShader; |
81 | delete m_surfaceTexturedFlatShader; |
82 | delete m_surfaceGridShader; |
83 | delete m_surfaceSliceFlatShader; |
84 | delete m_surfaceSliceSmoothShader; |
85 | } |
86 | |
87 | void Surface3DRenderer::contextCleanup() |
88 | { |
89 | if (QOpenGLContext::currentContext()) { |
90 | m_textureHelper->glDeleteFramebuffers(n: 1, framebuffers: &m_depthFrameBuffer); |
91 | m_textureHelper->glDeleteRenderbuffers(n: 1, renderbuffers: &m_selectionDepthBuffer); |
92 | m_textureHelper->glDeleteFramebuffers(n: 1, framebuffers: &m_selectionFrameBuffer); |
93 | |
94 | m_textureHelper->deleteTexture(texture: &m_noShadowTexture); |
95 | m_textureHelper->deleteTexture(texture: &m_depthTexture); |
96 | m_textureHelper->deleteTexture(texture: &m_selectionResultTexture); |
97 | } |
98 | } |
99 | |
100 | void Surface3DRenderer::initializeOpenGL() |
101 | { |
102 | Abstract3DRenderer::initializeOpenGL(); |
103 | |
104 | // Initialize shaders |
105 | initSurfaceShaders(); |
106 | |
107 | if (!m_isOpenGLES) { |
108 | initDepthShader(); // For shadows |
109 | loadGridLineMesh(); |
110 | } |
111 | |
112 | // Init selection shader |
113 | initSelectionShaders(); |
114 | |
115 | // Resize in case we've missed resize events |
116 | // Resize calls initSelectionBuffer and initDepthBuffer, so they don't need to be called here |
117 | handleResize(); |
118 | |
119 | // Load background mesh (we need to be initialized first) |
120 | loadBackgroundMesh(); |
121 | |
122 | // Create texture for no shadows |
123 | QImage image(2, 2, QImage::Format_RGB32); |
124 | image.fill(color: Qt::white); |
125 | m_noShadowTexture = m_textureHelper->create2DTexture(image, useTrilinearFiltering: false, convert: true, smoothScale: false, clampY: true); |
126 | } |
127 | |
128 | void Surface3DRenderer::fixCameraTarget(QVector3D &target) |
129 | { |
130 | target.setX(target.x() * m_scaleX); |
131 | target.setY(target.y() * m_scaleY); |
132 | target.setZ(target.z() * -m_scaleZ); |
133 | } |
134 | |
135 | void Surface3DRenderer::getVisibleItemBounds(QVector3D &minBounds, QVector3D &maxBounds) |
136 | { |
137 | // The inputs are the item bounds in OpenGL coordinates. |
138 | // The outputs limit these bounds to visible ranges, normalized to range [-1, 1] |
139 | // Volume shader flips the Y and Z axes, so we need to set negatives of actual values to those |
140 | float itemRangeX = (maxBounds.x() - minBounds.x()); |
141 | float itemRangeY = (maxBounds.y() - minBounds.y()); |
142 | float itemRangeZ = (maxBounds.z() - minBounds.z()); |
143 | |
144 | if (minBounds.x() < -m_scaleX) |
145 | minBounds.setX(-1.0f + (2.0f * qAbs(t: minBounds.x() + m_scaleX) / itemRangeX)); |
146 | else |
147 | minBounds.setX(-1.0f); |
148 | |
149 | if (minBounds.y() < -m_scaleY) |
150 | minBounds.setY(-(-1.0f + (2.0f * qAbs(t: minBounds.y() + m_scaleY) / itemRangeY))); |
151 | else |
152 | minBounds.setY(1.0f); |
153 | |
154 | if (minBounds.z() < -m_scaleZ) |
155 | minBounds.setZ(-(-1.0f + (2.0f * qAbs(t: minBounds.z() + m_scaleZ) / itemRangeZ))); |
156 | else |
157 | minBounds.setZ(1.0f); |
158 | |
159 | if (maxBounds.x() > m_scaleX) |
160 | maxBounds.setX(1.0f - (2.0f * qAbs(t: maxBounds.x() - m_scaleX) / itemRangeX)); |
161 | else |
162 | maxBounds.setX(1.0f); |
163 | |
164 | if (maxBounds.y() > m_scaleY) |
165 | maxBounds.setY(-(1.0f - (2.0f * qAbs(t: maxBounds.y() - m_scaleY) / itemRangeY))); |
166 | else |
167 | maxBounds.setY(-1.0f); |
168 | |
169 | if (maxBounds.z() > m_scaleZ) |
170 | maxBounds.setZ(-(1.0f - (2.0f * qAbs(t: maxBounds.z() - m_scaleZ) / itemRangeZ))); |
171 | else |
172 | maxBounds.setZ(-1.0f); |
173 | } |
174 | |
175 | void Surface3DRenderer::updateData() |
176 | { |
177 | calculateSceneScalingFactors(); |
178 | |
179 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
180 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
181 | if (cache->isVisible() && cache->dataDirty()) { |
182 | const QSurface3DSeries *currentSeries = cache->series(); |
183 | QSurfaceDataProxy *dataProxy = currentSeries->dataProxy(); |
184 | const QSurfaceDataArray &array = *dataProxy->array(); |
185 | QSurfaceDataArray &dataArray = cache->dataArray(); |
186 | QRect sampleSpace; |
187 | |
188 | // Need minimum of 2x2 array to draw a surface |
189 | if (array.size() >= 2 && array.at(i: 0)->size() >= 2) |
190 | sampleSpace = calculateSampleRect(array); |
191 | |
192 | bool dimensionsChanged = false; |
193 | if (cache->sampleSpace() != sampleSpace) { |
194 | if (sampleSpace.width() >= 2) |
195 | m_selectionTexturesDirty = true; |
196 | |
197 | dimensionsChanged = true; |
198 | cache->setSampleSpace(sampleSpace); |
199 | |
200 | for (int i = 0; i < dataArray.size(); i++) |
201 | delete dataArray.at(i); |
202 | dataArray.clear(); |
203 | } |
204 | |
205 | if (sampleSpace.width() >= 2 && sampleSpace.height() >= 2) { |
206 | if (dimensionsChanged) { |
207 | dataArray.reserve(asize: sampleSpace.height()); |
208 | for (int i = 0; i < sampleSpace.height(); i++) |
209 | dataArray << new QSurfaceDataRow(sampleSpace.width()); |
210 | } |
211 | for (int i = 0; i < sampleSpace.height(); i++) { |
212 | for (int j = 0; j < sampleSpace.width(); j++) { |
213 | (*(dataArray.at(i)))[j] = array.at(i: i + sampleSpace.y())->at( |
214 | i: j + sampleSpace.x()); |
215 | } |
216 | } |
217 | |
218 | checkFlatSupport(cache); |
219 | updateObjects(cache, dimensionChanged: dimensionsChanged); |
220 | cache->setFlatStatusDirty(false); |
221 | } else { |
222 | cache->surfaceObject()->clear(); |
223 | } |
224 | cache->setDataDirty(false); |
225 | } |
226 | } |
227 | |
228 | if (m_selectionTexturesDirty && m_cachedSelectionMode > QAbstract3DGraph::SelectionNone) |
229 | updateSelectionTextures(); |
230 | |
231 | updateSelectedPoint(position: m_selectedPoint, series: m_selectedSeries); |
232 | } |
233 | |
234 | void Surface3DRenderer::updateSeries(const QList<QAbstract3DSeries *> &seriesList) |
235 | { |
236 | Abstract3DRenderer::updateSeries(seriesList); |
237 | |
238 | bool noSelection = true; |
239 | foreach (QAbstract3DSeries *series, seriesList) { |
240 | QSurface3DSeries *surfaceSeries = static_cast<QSurface3DSeries *>(series); |
241 | SurfaceSeriesRenderCache *cache = |
242 | static_cast<SurfaceSeriesRenderCache *>( m_renderCacheList.value(key: series)); |
243 | if (noSelection |
244 | && surfaceSeries->selectedPoint() != QSurface3DSeries::invalidSelectionPosition()) { |
245 | if (selectionLabel() != cache->itemLabel()) |
246 | m_selectionLabelDirty = true; |
247 | noSelection = false; |
248 | } |
249 | |
250 | if (cache->isFlatStatusDirty() && cache->sampleSpace().width()) { |
251 | checkFlatSupport(cache); |
252 | updateObjects(cache, dimensionChanged: true); |
253 | cache->setFlatStatusDirty(false); |
254 | } |
255 | } |
256 | |
257 | if (noSelection && !selectionLabel().isEmpty()) { |
258 | m_selectionLabelDirty = true; |
259 | updateSelectedPoint(position: Surface3DController::invalidSelectionPosition(), series: 0); |
260 | } |
261 | |
262 | // Selection pointer issues |
263 | if (m_selectedSeries) { |
264 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
265 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
266 | QVector4D highlightColor = |
267 | Utils::vectorFromColor(color: cache->series()->singleHighlightColor()); |
268 | SelectionPointer *slicePointer = cache->sliceSelectionPointer(); |
269 | if (slicePointer) { |
270 | slicePointer->setHighlightColor(highlightColor); |
271 | slicePointer->setPointerObject(cache->object()); |
272 | slicePointer->setRotation(cache->meshRotation()); |
273 | } |
274 | SelectionPointer *mainPointer = cache->mainSelectionPointer(); |
275 | if (mainPointer) { |
276 | mainPointer->setHighlightColor(highlightColor); |
277 | mainPointer->setPointerObject(cache->object()); |
278 | mainPointer->setRotation(cache->meshRotation()); |
279 | } |
280 | } |
281 | } |
282 | } |
283 | |
284 | void Surface3DRenderer::updateSurfaceTextures(QList<QSurface3DSeries *> seriesList) |
285 | { |
286 | foreach (QSurface3DSeries *series, seriesList) { |
287 | SurfaceSeriesRenderCache *cache = |
288 | static_cast<SurfaceSeriesRenderCache *>(m_renderCacheList.value(key: series)); |
289 | if (cache) { |
290 | GLuint oldTexture = cache->surfaceTexture(); |
291 | m_textureHelper->deleteTexture(texture: &oldTexture); |
292 | cache->setSurfaceTexture(0); |
293 | |
294 | const QSurface3DSeries *currentSeries = cache->series(); |
295 | QSurfaceDataProxy *dataProxy = currentSeries->dataProxy(); |
296 | const QSurfaceDataArray &array = *dataProxy->array(); |
297 | |
298 | if (!series->texture().isNull()) { |
299 | GLuint texId = m_textureHelper->create2DTexture(image: series->texture(), |
300 | useTrilinearFiltering: true, convert: true, smoothScale: true, clampY: true); |
301 | glBindTexture(GL_TEXTURE_2D, texture: texId); |
302 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
303 | glBindTexture(GL_TEXTURE_2D, texture: 0); |
304 | cache->setSurfaceTexture(texId); |
305 | |
306 | if (cache->isFlatShadingEnabled()) |
307 | cache->surfaceObject()->coarseUVs(dataArray: array, modelArray: cache->dataArray()); |
308 | else |
309 | cache->surfaceObject()->smoothUVs(dataArray: array, modelArray: cache->dataArray()); |
310 | } |
311 | } |
312 | } |
313 | } |
314 | |
315 | SeriesRenderCache *Surface3DRenderer::createNewCache(QAbstract3DSeries *series) |
316 | { |
317 | m_selectionTexturesDirty = true; |
318 | return new SurfaceSeriesRenderCache(series, this); |
319 | } |
320 | |
321 | void Surface3DRenderer::cleanCache(SeriesRenderCache *cache) |
322 | { |
323 | Abstract3DRenderer::cleanCache(cache); |
324 | m_selectionTexturesDirty = true; |
325 | } |
326 | |
327 | void Surface3DRenderer::updateRows(const QList<Surface3DController::ChangeRow> &rows) |
328 | { |
329 | foreach (Surface3DController::ChangeRow item, rows) { |
330 | SurfaceSeriesRenderCache *cache = |
331 | static_cast<SurfaceSeriesRenderCache *>(m_renderCacheList.value(key: item.series)); |
332 | QSurfaceDataArray &dstArray = cache->dataArray(); |
333 | const QRect &sampleSpace = cache->sampleSpace(); |
334 | |
335 | const QSurfaceDataArray *srcArray = 0; |
336 | QSurfaceDataProxy *dataProxy = item.series->dataProxy(); |
337 | if (dataProxy) |
338 | srcArray = dataProxy->array(); |
339 | |
340 | if (cache && srcArray->size() >= 2 && srcArray->at(i: 0)->size() >= 2 && |
341 | sampleSpace.width() >= 2 && sampleSpace.height() >= 2) { |
342 | bool updateBuffers = false; |
343 | int sampleSpaceTop = sampleSpace.y() + sampleSpace.height(); |
344 | int row = item.row; |
345 | if (row >= sampleSpace.y() && row <= sampleSpaceTop) { |
346 | updateBuffers = true; |
347 | for (int j = 0; j < sampleSpace.width(); j++) { |
348 | (*(dstArray.at(i: row - sampleSpace.y())))[j] = |
349 | srcArray->at(i: row)->at(i: j + sampleSpace.x()); |
350 | } |
351 | |
352 | if (cache->isFlatShadingEnabled()) { |
353 | cache->surfaceObject()->updateCoarseRow(dataArray: dstArray, rowIndex: row - sampleSpace.y(), |
354 | polar: m_polarGraph); |
355 | } else { |
356 | cache->surfaceObject()->updateSmoothRow(dataArray: dstArray, startRow: row - sampleSpace.y(), |
357 | polar: m_polarGraph); |
358 | } |
359 | } |
360 | if (updateBuffers) |
361 | cache->surfaceObject()->uploadBuffers(); |
362 | } |
363 | } |
364 | |
365 | updateSelectedPoint(position: m_selectedPoint, series: m_selectedSeries); |
366 | } |
367 | |
368 | void Surface3DRenderer::updateItems(const QList<Surface3DController::ChangeItem> &points) |
369 | { |
370 | foreach (Surface3DController::ChangeItem item, points) { |
371 | SurfaceSeriesRenderCache *cache = |
372 | static_cast<SurfaceSeriesRenderCache *>(m_renderCacheList.value(key: item.series)); |
373 | QSurfaceDataArray &dstArray = cache->dataArray(); |
374 | const QRect &sampleSpace = cache->sampleSpace(); |
375 | |
376 | const QSurfaceDataArray *srcArray = 0; |
377 | QSurfaceDataProxy *dataProxy = item.series->dataProxy(); |
378 | if (dataProxy) |
379 | srcArray = dataProxy->array(); |
380 | |
381 | if (cache && srcArray->size() >= 2 && srcArray->at(i: 0)->size() >= 2 && |
382 | sampleSpace.width() >= 2 && sampleSpace.height() >= 2) { |
383 | int sampleSpaceTop = sampleSpace.y() + sampleSpace.height(); |
384 | int sampleSpaceRight = sampleSpace.x() + sampleSpace.width(); |
385 | bool updateBuffers = false; |
386 | // Note: Point is (row, column), samplespace is (columns x rows) |
387 | QPoint point = item.point; |
388 | |
389 | if (point.x() <= sampleSpaceTop && point.x() >= sampleSpace.y() && |
390 | point.y() <= sampleSpaceRight && point.y() >= sampleSpace.x()) { |
391 | updateBuffers = true; |
392 | int x = point.y() - sampleSpace.x(); |
393 | int y = point.x() - sampleSpace.y(); |
394 | (*(dstArray.at(i: y)))[x] = srcArray->at(i: point.x())->at(i: point.y()); |
395 | |
396 | if (cache->isFlatShadingEnabled()) |
397 | cache->surfaceObject()->updateCoarseItem(dataArray: dstArray, row: y, column: x, polar: m_polarGraph); |
398 | else |
399 | cache->surfaceObject()->updateSmoothItem(dataArray: dstArray, row: y, column: x, polar: m_polarGraph); |
400 | } |
401 | if (updateBuffers) |
402 | cache->surfaceObject()->uploadBuffers(); |
403 | } |
404 | |
405 | } |
406 | |
407 | updateSelectedPoint(position: m_selectedPoint, series: m_selectedSeries); |
408 | } |
409 | |
410 | void Surface3DRenderer::updateSliceDataModel(const QPoint &point) |
411 | { |
412 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) |
413 | static_cast<SurfaceSeriesRenderCache *>(baseCache)->sliceSurfaceObject()->clear(); |
414 | |
415 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionMultiSeries)) { |
416 | // Find axis coordinates for the selected point |
417 | SeriesRenderCache *selectedCache = |
418 | m_renderCacheList.value(key: const_cast<QSurface3DSeries *>(m_selectedSeries)); |
419 | QSurfaceDataArray &dataArray = |
420 | static_cast<SurfaceSeriesRenderCache *>(selectedCache)->dataArray(); |
421 | QSurfaceDataItem item = dataArray.at(i: point.x())->at(i: point.y()); |
422 | QPointF coords(item.x(), item.z()); |
423 | |
424 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
425 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
426 | if (cache->series() != m_selectedSeries) { |
427 | QPoint mappedPoint = mapCoordsToSampleSpace(cache, coords); |
428 | updateSliceObject(cache, point: mappedPoint); |
429 | } else { |
430 | updateSliceObject(cache, point); |
431 | } |
432 | } |
433 | } else { |
434 | if (m_selectedSeries) { |
435 | SurfaceSeriesRenderCache *cache = |
436 | static_cast<SurfaceSeriesRenderCache *>( |
437 | m_renderCacheList.value(key: m_selectedSeries)); |
438 | if (cache) |
439 | updateSliceObject(cache: static_cast<SurfaceSeriesRenderCache *>(cache), point); |
440 | } |
441 | } |
442 | } |
443 | |
444 | QPoint Surface3DRenderer::mapCoordsToSampleSpace(SurfaceSeriesRenderCache *cache, |
445 | const QPointF &coords) |
446 | { |
447 | QPoint point(-1, -1); |
448 | |
449 | QSurfaceDataArray &dataArray = cache->dataArray(); |
450 | int top = dataArray.size() - 1; |
451 | int right = dataArray.at(i: top)->size() - 1; |
452 | QSurfaceDataItem itemBottomLeft = dataArray.at(i: 0)->at(i: 0); |
453 | QSurfaceDataItem itemTopRight = dataArray.at(i: top)->at(i: right); |
454 | |
455 | if (itemBottomLeft.x() <= coords.x() && itemTopRight.x() >= coords.x()) { |
456 | float modelX = coords.x() - itemBottomLeft.x(); |
457 | float spanX = itemTopRight.x() - itemBottomLeft.x(); |
458 | float stepX = spanX / float(right); |
459 | int sampleX = int((modelX + (stepX / 2.0f)) / stepX); |
460 | |
461 | QSurfaceDataItem item = dataArray.at(i: 0)->at(i: sampleX); |
462 | if (!::qFuzzyCompare(p1: float(coords.x()), p2: item.x())) { |
463 | int direction = 1; |
464 | if (item.x() > coords.x()) |
465 | direction = -1; |
466 | |
467 | findMatchingColumn(x: coords.x(), sample&: sampleX, direction, dataArray); |
468 | } |
469 | |
470 | if (sampleX >= 0 && sampleX <= right) |
471 | point.setY(sampleX); |
472 | } |
473 | |
474 | if (itemBottomLeft.z() <= coords.y() && itemTopRight.z() >= coords.y()) { |
475 | float modelY = coords.y() - itemBottomLeft.z(); |
476 | float spanY = itemTopRight.z() - itemBottomLeft.z(); |
477 | float stepY = spanY / float(top); |
478 | int sampleY = int((modelY + (stepY / 2.0f)) / stepY); |
479 | |
480 | QSurfaceDataItem item = dataArray.at(i: sampleY)->at(i: 0); |
481 | if (!::qFuzzyCompare(p1: float(coords.y()), p2: item.z())) { |
482 | int direction = 1; |
483 | if (item.z() > coords.y()) |
484 | direction = -1; |
485 | |
486 | findMatchingRow(z: coords.y(), sample&: sampleY, direction, dataArray); |
487 | } |
488 | |
489 | if (sampleY >= 0 && sampleY <= top) |
490 | point.setX(sampleY); |
491 | } |
492 | |
493 | return point; |
494 | } |
495 | |
496 | void Surface3DRenderer::findMatchingRow(float z, int &sample, int direction, |
497 | QSurfaceDataArray &dataArray) |
498 | { |
499 | int maxZ = dataArray.size() - 1; |
500 | QSurfaceDataItem item = dataArray.at(i: sample)->at(i: 0); |
501 | float distance = qAbs(t: z - item.z()); |
502 | int newSample = sample + direction; |
503 | while (newSample >= 0 && newSample <= maxZ) { |
504 | item = dataArray.at(i: newSample)->at(i: 0); |
505 | float newDist = qAbs(t: z - item.z()); |
506 | if (newDist < distance) { |
507 | sample = newSample; |
508 | distance = newDist; |
509 | } else { |
510 | break; |
511 | } |
512 | newSample = sample + direction; |
513 | } |
514 | } |
515 | |
516 | void Surface3DRenderer::findMatchingColumn(float x, int &sample, int direction, |
517 | QSurfaceDataArray &dataArray) |
518 | { |
519 | int maxX = dataArray.at(i: 0)->size() - 1; |
520 | QSurfaceDataItem item = dataArray.at(i: 0)->at(i: sample); |
521 | float distance = qAbs(t: x - item.x()); |
522 | int newSample = sample + direction; |
523 | while (newSample >= 0 && newSample <= maxX) { |
524 | item = dataArray.at(i: 0)->at(i: newSample); |
525 | float newDist = qAbs(t: x - item.x()); |
526 | if (newDist < distance) { |
527 | sample = newSample; |
528 | distance = newDist; |
529 | } else { |
530 | break; |
531 | } |
532 | newSample = sample + direction; |
533 | } |
534 | } |
535 | |
536 | void Surface3DRenderer::updateSliceObject(SurfaceSeriesRenderCache *cache, const QPoint &point) |
537 | { |
538 | int column = point.y(); |
539 | int row = point.x(); |
540 | |
541 | if ((m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionRow) && row == -1) || |
542 | (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionColumn) && column == -1)) { |
543 | cache->sliceSurfaceObject()->clear(); |
544 | return; |
545 | } |
546 | |
547 | QSurfaceDataArray &sliceDataArray = cache->sliceDataArray(); |
548 | for (int i = 0; i < sliceDataArray.size(); i++) |
549 | delete sliceDataArray.at(i); |
550 | sliceDataArray.clear(); |
551 | sliceDataArray.reserve(asize: 2); |
552 | |
553 | QSurfaceDataRow *sliceRow; |
554 | QSurfaceDataArray &dataArray = cache->dataArray(); |
555 | float adjust = (0.025f * m_heightNormalizer) / 2.0f; |
556 | float doubleAdjust = 2.0f * adjust; |
557 | bool flipZX = false; |
558 | float zBack; |
559 | float zFront; |
560 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionRow)) { |
561 | QSurfaceDataRow *src = dataArray.at(i: row); |
562 | sliceRow = new QSurfaceDataRow(src->size()); |
563 | zBack = m_axisCacheZ.min(); |
564 | zFront = m_axisCacheZ.max(); |
565 | for (int i = 0; i < sliceRow->size(); i++) |
566 | (*sliceRow)[i].setPosition(QVector3D(src->at(i).x(), src->at(i).y() + adjust, zFront)); |
567 | } else { |
568 | flipZX = true; |
569 | const QRect &sampleSpace = cache->sampleSpace(); |
570 | sliceRow = new QSurfaceDataRow(sampleSpace.height()); |
571 | zBack = m_axisCacheX.min(); |
572 | zFront = m_axisCacheX.max(); |
573 | for (int i = 0; i < sampleSpace.height(); i++) { |
574 | (*sliceRow)[i].setPosition(QVector3D(dataArray.at(i)->at(i: column).z(), |
575 | dataArray.at(i)->at(i: column).y() + adjust, |
576 | zFront)); |
577 | } |
578 | } |
579 | sliceDataArray << sliceRow; |
580 | |
581 | // Make a duplicate, so that we get a little bit depth |
582 | QSurfaceDataRow *duplicateRow = new QSurfaceDataRow(*sliceRow); |
583 | for (int i = 0; i < sliceRow->size(); i++) { |
584 | (*sliceRow)[i].setPosition(QVector3D(sliceRow->at(i).x(), |
585 | sliceRow->at(i).y() - doubleAdjust, |
586 | zBack)); |
587 | } |
588 | sliceDataArray << duplicateRow; |
589 | |
590 | QRect sliceRect(0, 0, sliceRow->size(), 2); |
591 | if (sliceRow->size() > 0) { |
592 | if (cache->isFlatShadingEnabled()) { |
593 | cache->sliceSurfaceObject()->setUpData(dataArray: sliceDataArray, space: sliceRect, changeGeometry: true, polar: false, flipXZ: flipZX); |
594 | } else { |
595 | cache->sliceSurfaceObject()->setUpSmoothData(dataArray: sliceDataArray, space: sliceRect, changeGeometry: true, polar: false, |
596 | flipXZ: flipZX); |
597 | } |
598 | } |
599 | } |
600 | |
601 | inline static float getDataValue(const QSurfaceDataArray &array, bool searchRow, int index) |
602 | { |
603 | if (searchRow) |
604 | return array.at(i: 0)->at(i: index).x(); |
605 | else |
606 | return array.at(i: index)->at(i: 0).z(); |
607 | } |
608 | |
609 | inline static int binarySearchArray(const QSurfaceDataArray &array, int maxIdx, float limitValue, |
610 | bool searchRow, bool lowBound, bool ascending) |
611 | { |
612 | int min = 0; |
613 | int max = maxIdx; |
614 | int mid = 0; |
615 | int retVal; |
616 | while (max >= min) { |
617 | mid = (min + max) / 2; |
618 | float arrayValue = getDataValue(array, searchRow, index: mid); |
619 | if (arrayValue == limitValue) |
620 | return mid; |
621 | if (ascending) { |
622 | if (arrayValue < limitValue) |
623 | min = mid + 1; |
624 | else |
625 | max = mid - 1; |
626 | } else { |
627 | if (arrayValue > limitValue) |
628 | min = mid + 1; |
629 | else |
630 | max = mid - 1; |
631 | } |
632 | } |
633 | |
634 | // Exact match not found, return closest depending on bound. |
635 | // The boundary is between last mid and min/max. |
636 | if (lowBound == ascending) { |
637 | if (mid > max) |
638 | retVal = mid; |
639 | else |
640 | retVal = min; |
641 | } else { |
642 | if (mid > max) |
643 | retVal = max; |
644 | else |
645 | retVal = mid; |
646 | } |
647 | if (retVal < 0 || retVal > maxIdx) { |
648 | retVal = -1; |
649 | } else if (lowBound) { |
650 | if (getDataValue(array, searchRow, index: retVal) < limitValue) |
651 | retVal = -1; |
652 | } else { |
653 | if (getDataValue(array, searchRow, index: retVal) > limitValue) |
654 | retVal = -1; |
655 | } |
656 | return retVal; |
657 | } |
658 | |
659 | QRect Surface3DRenderer::calculateSampleRect(const QSurfaceDataArray &array) |
660 | { |
661 | QRect sampleSpace; |
662 | |
663 | const int maxRow = array.size() - 1; |
664 | const int maxColumn = array.at(i: 0)->size() - 1; |
665 | |
666 | // We assume data is ordered sequentially in rows for X-value and in columns for Z-value. |
667 | // Determine if data is ascending or descending in each case. |
668 | const bool ascendingX = array.at(i: 0)->at(i: 0).x() < array.at(i: 0)->at(i: maxColumn).x(); |
669 | const bool ascendingZ = array.at(i: 0)->at(i: 0).z() < array.at(i: maxRow)->at(i: 0).z(); |
670 | |
671 | int idx = binarySearchArray(array, maxIdx: maxColumn, limitValue: m_axisCacheX.min(), searchRow: true, lowBound: true, ascending: ascendingX); |
672 | if (idx != -1) { |
673 | if (ascendingX) |
674 | sampleSpace.setLeft(idx); |
675 | else |
676 | sampleSpace.setRight(idx); |
677 | } else { |
678 | sampleSpace.setWidth(-1); // to indicate nothing needs to be shown |
679 | return sampleSpace; |
680 | } |
681 | |
682 | idx = binarySearchArray(array, maxIdx: maxColumn, limitValue: m_axisCacheX.max(), searchRow: true, lowBound: false, ascending: ascendingX); |
683 | if (idx != -1) { |
684 | if (ascendingX) |
685 | sampleSpace.setRight(idx); |
686 | else |
687 | sampleSpace.setLeft(idx); |
688 | } else { |
689 | sampleSpace.setWidth(-1); // to indicate nothing needs to be shown |
690 | return sampleSpace; |
691 | } |
692 | |
693 | idx = binarySearchArray(array, maxIdx: maxRow, limitValue: m_axisCacheZ.min(), searchRow: false, lowBound: true, ascending: ascendingZ); |
694 | if (idx != -1) { |
695 | if (ascendingZ) |
696 | sampleSpace.setTop(idx); |
697 | else |
698 | sampleSpace.setBottom(idx); |
699 | } else { |
700 | sampleSpace.setWidth(-1); // to indicate nothing needs to be shown |
701 | return sampleSpace; |
702 | } |
703 | |
704 | idx = binarySearchArray(array, maxIdx: maxRow, limitValue: m_axisCacheZ.max(), searchRow: false, lowBound: false, ascending: ascendingZ); |
705 | if (idx != -1) { |
706 | if (ascendingZ) |
707 | sampleSpace.setBottom(idx); |
708 | else |
709 | sampleSpace.setTop(idx); |
710 | } else { |
711 | sampleSpace.setWidth(-1); // to indicate nothing needs to be shown |
712 | return sampleSpace; |
713 | } |
714 | |
715 | return sampleSpace; |
716 | } |
717 | |
718 | void Surface3DRenderer::updateScene(Q3DScene *scene) |
719 | { |
720 | Abstract3DRenderer::updateScene(scene); |
721 | |
722 | if (m_selectionActive |
723 | && m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionItem)) { |
724 | m_selectionDirty = true; // Ball may need repositioning if scene changes |
725 | } |
726 | |
727 | updateSlicingActive(isSlicing: scene->isSlicingActive()); |
728 | } |
729 | |
730 | void Surface3DRenderer::render(GLuint defaultFboHandle) |
731 | { |
732 | // Handle GL state setup for FBO buffers and clearing of the render surface |
733 | Abstract3DRenderer::render(defaultFboHandle); |
734 | |
735 | if (m_axisCacheX.positionsDirty()) |
736 | m_axisCacheX.updateAllPositions(); |
737 | if (m_axisCacheY.positionsDirty()) |
738 | m_axisCacheY.updateAllPositions(); |
739 | if (m_axisCacheZ.positionsDirty()) |
740 | m_axisCacheZ.updateAllPositions(); |
741 | |
742 | drawScene(defaultFboHandle); |
743 | if (m_cachedIsSlicingActivated) |
744 | drawSlicedScene(); |
745 | |
746 | // Render selection label |
747 | if (m_selectionActive |
748 | && m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionItem)) { |
749 | for (SeriesRenderCache *baseCache: m_renderCacheList) { |
750 | const SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
751 | if (cache->slicePointerActive() && cache->renderable() && |
752 | m_cachedIsSlicingActivated ) { |
753 | cache->sliceSelectionPointer()->renderSelectionLabel(defaultFboHandle); |
754 | } |
755 | if (cache->mainPointerActive() && cache->renderable()) { |
756 | cache->mainSelectionPointer()->renderSelectionLabel(defaultFboHandle, |
757 | useOrtho: m_useOrthoProjection); |
758 | } |
759 | } |
760 | } |
761 | } |
762 | |
763 | void Surface3DRenderer::drawSlicedScene() |
764 | { |
765 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionRow) |
766 | == m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionColumn)) { |
767 | qWarning(msg: "Invalid selection mode. Either QAbstract3DGraph::SelectionRow or" |
768 | " QAbstract3DGraph::SelectionColumn must be set before calling" |
769 | " setSlicingActive(true)." ); |
770 | return; |
771 | } |
772 | |
773 | QVector3D lightPos; |
774 | |
775 | QVector4D lightColor = Utils::vectorFromColor(color: m_cachedTheme->lightColor()); |
776 | |
777 | // Specify viewport |
778 | glViewport(x: m_secondarySubViewport.x(), |
779 | y: m_secondarySubViewport.y(), |
780 | width: m_secondarySubViewport.width(), |
781 | height: m_secondarySubViewport.height()); |
782 | |
783 | // Set up projection matrix |
784 | QMatrix4x4 projectionMatrix; |
785 | |
786 | GLfloat aspect = (GLfloat)m_secondarySubViewport.width() |
787 | / (GLfloat)m_secondarySubViewport.height(); |
788 | GLfloat sliceUnitsScaled = sliceUnits / m_autoScaleAdjustment; |
789 | projectionMatrix.ortho(left: -sliceUnitsScaled * aspect, right: sliceUnitsScaled * aspect, |
790 | bottom: -sliceUnitsScaled, top: sliceUnitsScaled, |
791 | nearPlane: -1.0f, farPlane: 4.0f); |
792 | |
793 | // Set view matrix |
794 | QMatrix4x4 viewMatrix; |
795 | viewMatrix.lookAt(eye: QVector3D(0.0f, 0.0f, 1.0f), center: zeroVector, up: upVector); |
796 | |
797 | // Set light position |
798 | lightPos = QVector3D(0.0f, 0.0f, 2.0f); |
799 | |
800 | QMatrix4x4 projectionViewMatrix = projectionMatrix * viewMatrix; |
801 | |
802 | const Q3DCamera *activeCamera = m_cachedScene->activeCamera(); |
803 | |
804 | bool rowMode = m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionRow); |
805 | AxisRenderCache &sliceCache = rowMode ? m_axisCacheX : m_axisCacheZ; |
806 | |
807 | GLfloat scaleXBackground = 0.0f; |
808 | if (rowMode) { |
809 | // Don't use the regular margin for polar, as the graph is not going to be to scale anyway, |
810 | // and polar graphs often have quite a bit of margin, resulting in ugly slices. |
811 | if (m_polarGraph) |
812 | scaleXBackground = m_scaleX + 0.1f; |
813 | else |
814 | scaleXBackground = m_scaleXWithBackground; |
815 | } else { |
816 | if (m_polarGraph) |
817 | scaleXBackground = m_scaleZ + 0.1f; |
818 | else |
819 | scaleXBackground = m_scaleZWithBackground; |
820 | } |
821 | |
822 | // Disable culling to avoid ugly conditionals with reversed axes and data |
823 | glDisable(GL_CULL_FACE); |
824 | |
825 | if (!m_renderCacheList.isEmpty()) { |
826 | bool drawGrid = false; |
827 | |
828 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
829 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
830 | if (cache->sliceSurfaceObject()->indexCount() && cache->renderable()) { |
831 | if (!drawGrid && cache->surfaceGridVisible()) { |
832 | glEnable(GL_POLYGON_OFFSET_FILL); |
833 | glPolygonOffset(factor: 0.5f, units: 1.0f); |
834 | drawGrid = true; |
835 | } |
836 | |
837 | QMatrix4x4 MVPMatrix; |
838 | QMatrix4x4 modelMatrix; |
839 | QMatrix4x4 itModelMatrix; |
840 | |
841 | QVector3D scaling(1.0f, 1.0f, sliceZScale); |
842 | modelMatrix.scale(vector: scaling); |
843 | itModelMatrix.scale(vector: scaling); |
844 | |
845 | MVPMatrix = projectionViewMatrix * modelMatrix; |
846 | cache->setMVPMatrix(MVPMatrix); |
847 | |
848 | if (cache->surfaceVisible()) { |
849 | ShaderHelper *surfaceShader = m_surfaceSliceSmoothShader; |
850 | if (cache->isFlatShadingEnabled()) |
851 | surfaceShader = m_surfaceSliceFlatShader; |
852 | |
853 | surfaceShader->bind(); |
854 | |
855 | GLuint colorTexture = cache->baseUniformTexture(); |
856 | if (cache->colorStyle() == Q3DTheme::ColorStyleUniform) { |
857 | colorTexture = cache->baseUniformTexture(); |
858 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientMin(), value: 0.0f); |
859 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientHeight(), value: 0.0f); |
860 | } else { |
861 | colorTexture = cache->baseGradientTexture(); |
862 | if (cache->colorStyle() == Q3DTheme::ColorStyleObjectGradient) { |
863 | float objMin = cache->surfaceObject()->minYValue(); |
864 | float objMax = cache->surfaceObject()->maxYValue(); |
865 | float objRange = objMax - objMin; |
866 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientMin(), |
867 | value: -(objMin / objRange)); |
868 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientHeight(), |
869 | value: 1.0f / objRange); |
870 | } else { |
871 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientMin(), value: 0.5f); |
872 | surfaceShader->setUniformValue(uniform: surfaceShader->gradientHeight(), |
873 | value: 1.0f / (m_scaleY * 2.0f)); |
874 | } |
875 | } |
876 | |
877 | // Set shader bindings |
878 | surfaceShader->setUniformValue(uniform: surfaceShader->lightP(), value: lightPos); |
879 | surfaceShader->setUniformValue(uniform: surfaceShader->view(), value: viewMatrix); |
880 | surfaceShader->setUniformValue(uniform: surfaceShader->model(), value: modelMatrix); |
881 | surfaceShader->setUniformValue(uniform: surfaceShader->nModel(), |
882 | value: itModelMatrix.inverted().transposed()); |
883 | surfaceShader->setUniformValue(uniform: surfaceShader->MVP(), value: MVPMatrix); |
884 | surfaceShader->setUniformValue(uniform: surfaceShader->lightS(), value: 0.0f); |
885 | surfaceShader->setUniformValue(uniform: surfaceShader->ambientS(), |
886 | value: m_cachedTheme->ambientLightStrength() |
887 | + m_cachedTheme->lightStrength() / 10.0f); |
888 | surfaceShader->setUniformValue(uniform: surfaceShader->lightColor(), value: lightColor); |
889 | |
890 | m_drawer->drawObject(shader: surfaceShader, object: cache->sliceSurfaceObject(), textureId: colorTexture); |
891 | } |
892 | } |
893 | } |
894 | |
895 | // Draw surface grid |
896 | if (drawGrid) { |
897 | glDisable(GL_POLYGON_OFFSET_FILL); |
898 | m_surfaceGridShader->bind(); |
899 | m_surfaceGridShader->setUniformValue(uniform: m_surfaceGridShader->color(), |
900 | value: Utils::vectorFromColor(color: m_cachedTheme->gridLineColor())); |
901 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
902 | SurfaceSeriesRenderCache *cache = |
903 | static_cast<SurfaceSeriesRenderCache *>(baseCache); |
904 | if (cache->sliceSurfaceObject()->indexCount() && cache->isVisible() && |
905 | cache->surfaceGridVisible()) { |
906 | m_surfaceGridShader->setUniformValue(uniform: m_surfaceGridShader->MVP(), |
907 | value: cache->MVPMatrix()); |
908 | m_drawer->drawSurfaceGrid(shader: m_surfaceGridShader, object: cache->sliceSurfaceObject()); |
909 | } |
910 | } |
911 | } |
912 | } |
913 | |
914 | glEnable(GL_CULL_FACE); |
915 | glCullFace(GL_BACK); |
916 | |
917 | // Grid lines |
918 | if (m_cachedTheme->isGridEnabled()) { |
919 | ShaderHelper *lineShader; |
920 | if (m_isOpenGLES) |
921 | lineShader = m_selectionShader; // Plain color shader for GL_LINES |
922 | else |
923 | lineShader = m_backgroundShader; |
924 | |
925 | // Bind line shader |
926 | lineShader->bind(); |
927 | |
928 | // Set unchanging shader bindings |
929 | QVector4D lineColor = Utils::vectorFromColor(color: m_cachedTheme->gridLineColor()); |
930 | lineShader->setUniformValue(uniform: lineShader->lightP(), value: lightPos); |
931 | lineShader->setUniformValue(uniform: lineShader->view(), value: viewMatrix); |
932 | lineShader->setUniformValue(uniform: lineShader->color(), value: lineColor); |
933 | lineShader->setUniformValue(uniform: lineShader->ambientS(), |
934 | value: m_cachedTheme->ambientLightStrength() |
935 | + m_cachedTheme->lightStrength() / 10.0f); |
936 | lineShader->setUniformValue(uniform: lineShader->lightS(), value: 0.0f); |
937 | lineShader->setUniformValue(uniform: lineShader->lightColor(), value: lightColor); |
938 | |
939 | // Horizontal lines |
940 | int gridLineCount = m_axisCacheY.gridLineCount(); |
941 | if (m_axisCacheY.segmentCount() > 0) { |
942 | QVector3D gridLineScaleX(scaleXBackground, gridLineWidth, gridLineWidth); |
943 | |
944 | for (int line = 0; line < gridLineCount; line++) { |
945 | QMatrix4x4 modelMatrix; |
946 | QMatrix4x4 MVPMatrix; |
947 | QMatrix4x4 itModelMatrix; |
948 | |
949 | modelMatrix.translate(x: 0.0f, y: m_axisCacheY.gridLinePosition(index: line), z: -1.0f); |
950 | |
951 | modelMatrix.scale(vector: gridLineScaleX); |
952 | itModelMatrix.scale(vector: gridLineScaleX); |
953 | |
954 | MVPMatrix = projectionViewMatrix * modelMatrix; |
955 | |
956 | // Set the rest of the shader bindings |
957 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
958 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
959 | value: itModelMatrix.inverted().transposed()); |
960 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
961 | |
962 | // Draw the object |
963 | if (m_isOpenGLES) |
964 | m_drawer->drawLine(shader: lineShader); |
965 | else |
966 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
967 | } |
968 | } |
969 | |
970 | // Vertical lines |
971 | QVector3D gridLineScaleY(gridLineWidth, m_scaleYWithBackground, gridLineWidth); |
972 | |
973 | gridLineCount = sliceCache.gridLineCount(); |
974 | for (int line = 0; line < gridLineCount; line++) { |
975 | QMatrix4x4 modelMatrix; |
976 | QMatrix4x4 MVPMatrix; |
977 | QMatrix4x4 itModelMatrix; |
978 | |
979 | modelMatrix.translate(x: sliceCache.gridLinePosition(index: line), y: 0.0f, z: -1.0f); |
980 | modelMatrix.scale(vector: gridLineScaleY); |
981 | itModelMatrix.scale(vector: gridLineScaleY); |
982 | |
983 | if (m_isOpenGLES) { |
984 | modelMatrix.rotate(quaternion: m_zRightAngleRotation); |
985 | itModelMatrix.rotate(quaternion: m_zRightAngleRotation); |
986 | } |
987 | |
988 | MVPMatrix = projectionViewMatrix * modelMatrix; |
989 | |
990 | // Set the rest of the shader bindings |
991 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
992 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
993 | value: itModelMatrix.inverted().transposed()); |
994 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
995 | |
996 | // Draw the object |
997 | if (m_isOpenGLES) |
998 | m_drawer->drawLine(shader: lineShader); |
999 | else |
1000 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1001 | } |
1002 | } |
1003 | |
1004 | // Draw labels |
1005 | m_labelShader->bind(); |
1006 | glDisable(GL_DEPTH_TEST); |
1007 | glEnable(GL_BLEND); |
1008 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
1009 | |
1010 | // Y Labels to back wall |
1011 | int labelNbr = 0; |
1012 | |
1013 | QVector3D positionComp(0.0f, 0.0f, 0.0f); |
1014 | QVector3D labelTrans = QVector3D(scaleXBackground + labelMargin, 0.0f, 0.0f); |
1015 | int labelCount = m_axisCacheY.labelCount(); |
1016 | for (int label = 0; label < labelCount; label++) { |
1017 | if (m_axisCacheY.labelItems().size() > labelNbr) { |
1018 | labelTrans.setY(m_axisCacheY.labelPosition(index: label)); |
1019 | const LabelItem &axisLabelItem = *m_axisCacheY.labelItems().at(i: labelNbr); |
1020 | |
1021 | // Draw the label here |
1022 | m_dummyRenderItem.setTranslation(labelTrans); |
1023 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
1024 | positionComp, rotation: identityQuaternion, itemHeight: 0, mode: m_cachedSelectionMode, |
1025 | shader: m_labelShader, object: m_labelObj, camera: activeCamera, useDepth: true, rotateAlong: true, |
1026 | position: Drawer::LabelMid, alignment: Qt::AlignLeft, isSlicing: true); |
1027 | } |
1028 | labelNbr++; |
1029 | } |
1030 | |
1031 | // X Labels to ground |
1032 | int countLabelItems = sliceCache.labelItems().size(); |
1033 | |
1034 | QVector3D rotation(0.0f, 0.0f, -45.0f); |
1035 | QQuaternion totalRotation = Utils::calculateRotation(xyzRotations: rotation); |
1036 | |
1037 | labelNbr = 0; |
1038 | positionComp.setY(-0.1f); |
1039 | labelTrans.setY(-m_scaleYWithBackground); |
1040 | labelCount = sliceCache.labelCount(); |
1041 | for (int label = 0; label < labelCount; label++) { |
1042 | if (countLabelItems > labelNbr) { |
1043 | // Draw the label here |
1044 | if (rowMode) |
1045 | labelTrans.setX(sliceCache.labelPosition(index: label)); |
1046 | else |
1047 | labelTrans.setX(-sliceCache.labelPosition(index: label)); |
1048 | |
1049 | m_dummyRenderItem.setTranslation(labelTrans); |
1050 | |
1051 | LabelItem *axisLabelItem; |
1052 | axisLabelItem = sliceCache.labelItems().at(i: labelNbr); |
1053 | |
1054 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: *axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
1055 | positionComp, rotation: totalRotation, itemHeight: 0, mode: QAbstract3DGraph::SelectionRow, |
1056 | shader: m_labelShader, object: m_labelObj, camera: activeCamera, |
1057 | useDepth: false, rotateAlong: false, position: Drawer::LabelBelow, |
1058 | alignment: Qt::AlignLeft | Qt::AlignTop, isSlicing: true); |
1059 | } |
1060 | labelNbr++; |
1061 | } |
1062 | |
1063 | // Draw labels for axes |
1064 | AbstractRenderItem *dummyItem(0); |
1065 | positionComp.setY(m_autoScaleAdjustment); |
1066 | m_drawer->drawLabel(item: *dummyItem, labelItem: sliceCache.titleItem(), viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
1067 | positionComp, rotation: identityQuaternion, itemHeight: 0, mode: m_cachedSelectionMode, shader: m_labelShader, |
1068 | object: m_labelObj, camera: activeCamera, useDepth: false, rotateAlong: false, position: Drawer::LabelBottom, |
1069 | alignment: Qt::AlignCenter, isSlicing: true); |
1070 | |
1071 | // Y-axis label |
1072 | rotation = QVector3D(0.0f, 0.0f, 90.0f); |
1073 | totalRotation = Utils::calculateRotation(xyzRotations: rotation); |
1074 | labelTrans = QVector3D(-scaleXBackground - labelMargin, 0.0f, 0.0f); |
1075 | m_dummyRenderItem.setTranslation(labelTrans); |
1076 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: m_axisCacheY.titleItem(), viewmatrix: viewMatrix, |
1077 | projectionmatrix: projectionMatrix, positionComp: zeroVector, rotation: totalRotation, itemHeight: 0, |
1078 | mode: m_cachedSelectionMode, shader: m_labelShader, object: m_labelObj, camera: activeCamera, |
1079 | useDepth: false, rotateAlong: false, position: Drawer::LabelMid, alignment: Qt::AlignBottom); |
1080 | |
1081 | glEnable(GL_DEPTH_TEST); |
1082 | glDisable(GL_BLEND); |
1083 | |
1084 | // Release shader |
1085 | glUseProgram(program: 0); |
1086 | } |
1087 | |
1088 | void Surface3DRenderer::drawScene(GLuint defaultFboHandle) |
1089 | { |
1090 | bool noShadows = true; |
1091 | |
1092 | GLfloat backgroundRotation = 0; |
1093 | QVector4D lightColor = Utils::vectorFromColor(color: m_cachedTheme->lightColor()); |
1094 | |
1095 | glViewport(x: m_primarySubViewport.x(), |
1096 | y: m_primarySubViewport.y(), |
1097 | width: m_primarySubViewport.width(), |
1098 | height: m_primarySubViewport.height()); |
1099 | |
1100 | // Set up projection matrix |
1101 | QMatrix4x4 projectionMatrix; |
1102 | GLfloat viewPortRatio = (GLfloat)m_primarySubViewport.width() |
1103 | / (GLfloat)m_primarySubViewport.height(); |
1104 | if (m_useOrthoProjection) { |
1105 | GLfloat orthoRatio = 2.0f; |
1106 | projectionMatrix.ortho(left: -viewPortRatio * orthoRatio, right: viewPortRatio * orthoRatio, |
1107 | bottom: -orthoRatio, top: orthoRatio, |
1108 | nearPlane: 0.0f, farPlane: 100.0f); |
1109 | } else { |
1110 | projectionMatrix.perspective(verticalAngle: 45.0f, aspectRatio: viewPortRatio, nearPlane: 0.1f, farPlane: 100.0f); |
1111 | } |
1112 | |
1113 | const Q3DCamera *activeCamera = m_cachedScene->activeCamera(); |
1114 | |
1115 | // Calculate view matrix |
1116 | QMatrix4x4 viewMatrix = activeCamera->d_ptr->viewMatrix(); |
1117 | |
1118 | QMatrix4x4 projectionViewMatrix = projectionMatrix * viewMatrix; |
1119 | |
1120 | // Calculate flipping indicators |
1121 | if (viewMatrix.row(index: 0).x() > 0) |
1122 | m_zFlipped = false; |
1123 | else |
1124 | m_zFlipped = true; |
1125 | if (viewMatrix.row(index: 0).z() <= 0) |
1126 | m_xFlipped = false; |
1127 | else |
1128 | m_xFlipped = true; |
1129 | |
1130 | m_yFlippedForGrid = m_yFlipped; |
1131 | if (m_flipHorizontalGrid) { |
1132 | if (!m_useOrthoProjection) { |
1133 | // Need to determine if camera is below graph top |
1134 | float distanceToCenter = activeCamera->position().length() |
1135 | / activeCamera->zoomLevel() / m_autoScaleAdjustment * 100.0f; |
1136 | qreal cameraAngle = qDegreesToRadians(degrees: qreal(activeCamera->yRotation())); |
1137 | float cameraYPos = float(qSin(v: cameraAngle)) * distanceToCenter; |
1138 | m_yFlippedForGrid = cameraYPos < (m_scaleYWithBackground - m_oldCameraTarget.y()); |
1139 | } else if (m_useOrthoProjection && activeCamera->yRotation() == 0.0f) { |
1140 | // With ortho we only need to flip at angle zero, to fix label autorotation angles |
1141 | m_yFlippedForGrid = !m_yFlipped; |
1142 | } |
1143 | } |
1144 | |
1145 | // calculate background rotation based on view matrix rotation |
1146 | if (viewMatrix.row(index: 0).x() > 0 && viewMatrix.row(index: 0).z() <= 0) |
1147 | backgroundRotation = 270.0f; |
1148 | else if (viewMatrix.row(index: 0).x() > 0 && viewMatrix.row(index: 0).z() > 0) |
1149 | backgroundRotation = 180.0f; |
1150 | else if (viewMatrix.row(index: 0).x() <= 0 && viewMatrix.row(index: 0).z() > 0) |
1151 | backgroundRotation = 90.0f; |
1152 | else if (viewMatrix.row(index: 0).x() <= 0 && viewMatrix.row(index: 0).z() <= 0) |
1153 | backgroundRotation = 0.0f; |
1154 | |
1155 | QVector3D lightPos = m_cachedScene->activeLight()->position(); |
1156 | |
1157 | QMatrix4x4 depthViewMatrix; |
1158 | QMatrix4x4 depthProjectionMatrix; |
1159 | QMatrix4x4 depthProjectionViewMatrix; |
1160 | |
1161 | // Draw depth buffer |
1162 | GLfloat adjustedLightStrength = m_cachedTheme->lightStrength() / 10.0f; |
1163 | if (!m_isOpenGLES && m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone && |
1164 | (!m_renderCacheList.isEmpty() || !m_customRenderCache.isEmpty())) { |
1165 | // Render scene into a depth texture for using with shadow mapping |
1166 | // Enable drawing to depth framebuffer |
1167 | glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: m_depthFrameBuffer); |
1168 | |
1169 | // Attach texture to depth attachment |
1170 | glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, |
1171 | texture: m_depthTexture, level: 0); |
1172 | glClear(GL_DEPTH_BUFFER_BIT); |
1173 | |
1174 | // Bind depth shader |
1175 | m_depthShader->bind(); |
1176 | |
1177 | // Set viewport for depth map rendering. Must match texture size. Larger values give smoother shadows. |
1178 | glViewport(x: 0, y: 0, |
1179 | width: m_primarySubViewport.width() * m_shadowQualityMultiplier, |
1180 | height: m_primarySubViewport.height() * m_shadowQualityMultiplier); |
1181 | |
1182 | // Get the depth view matrix |
1183 | // It may be possible to hack lightPos here if we want to make some tweaks to shadow |
1184 | QVector3D depthLightPos = activeCamera->d_ptr->calculatePositionRelativeToCamera( |
1185 | relativePosition: zeroVector, fixedRotation: 0.0f, distanceModifier: 4.0f / m_autoScaleAdjustment); |
1186 | depthViewMatrix.lookAt(eye: depthLightPos, center: zeroVector, up: upVector); |
1187 | |
1188 | // Set the depth projection matrix |
1189 | depthProjectionMatrix.perspective(verticalAngle: 10.0f, aspectRatio: (GLfloat)m_primarySubViewport.width() |
1190 | / (GLfloat)m_primarySubViewport.height(), nearPlane: 3.0f, farPlane: 100.0f); |
1191 | depthProjectionViewMatrix = depthProjectionMatrix * depthViewMatrix; |
1192 | |
1193 | // Surface is not closed, so don't cull anything |
1194 | glDisable(GL_CULL_FACE); |
1195 | |
1196 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
1197 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
1198 | SurfaceObject *object = cache->surfaceObject(); |
1199 | if (object->indexCount() && cache->surfaceVisible() && cache->isVisible() |
1200 | && cache->sampleSpace().width() >= 2 && cache->sampleSpace().height() >= 2) { |
1201 | // No translation nor scaling for surfaces, therefore no modelMatrix |
1202 | // Use directly projectionViewMatrix |
1203 | m_depthShader->setUniformValue(uniform: m_depthShader->MVP(), value: depthProjectionViewMatrix); |
1204 | |
1205 | // 1st attribute buffer : vertices |
1206 | glEnableVertexAttribArray(index: m_depthShader->posAtt()); |
1207 | glBindBuffer(GL_ARRAY_BUFFER, buffer: object->vertexBuf()); |
1208 | glVertexAttribPointer(indx: m_depthShader->posAtt(), size: 3, GL_FLOAT, GL_FALSE, stride: 0, |
1209 | ptr: (void *)0); |
1210 | |
1211 | // Index buffer |
1212 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer: object->elementBuf()); |
1213 | |
1214 | // Draw the triangles |
1215 | glDrawElements(GL_TRIANGLES, count: object->indexCount(), GL_UNSIGNED_INT, indices: (void *)0); |
1216 | } |
1217 | } |
1218 | |
1219 | // Free buffers |
1220 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer: 0); |
1221 | glBindBuffer(GL_ARRAY_BUFFER, buffer: 0); |
1222 | |
1223 | glDisableVertexAttribArray(index: m_depthShader->posAtt()); |
1224 | |
1225 | glEnable(GL_CULL_FACE); |
1226 | glCullFace(GL_FRONT); |
1227 | |
1228 | Abstract3DRenderer::drawCustomItems(state: RenderingDepth, regularShader: m_depthShader, viewMatrix, |
1229 | projectionViewMatrix, |
1230 | depthProjectionViewMatrix, depthTexture: m_depthTexture, |
1231 | shadowQuality: m_shadowQualityToShader); |
1232 | |
1233 | // Disable drawing to depth framebuffer (= enable drawing to screen) |
1234 | glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: defaultFboHandle); |
1235 | |
1236 | // Revert to original viewport |
1237 | glViewport(x: m_primarySubViewport.x(), |
1238 | y: m_primarySubViewport.y(), |
1239 | width: m_primarySubViewport.width(), |
1240 | height: m_primarySubViewport.height()); |
1241 | |
1242 | // Reset culling to normal |
1243 | glEnable(GL_CULL_FACE); |
1244 | glCullFace(GL_BACK); |
1245 | } |
1246 | |
1247 | // Do position mapping when necessary |
1248 | if (m_graphPositionQueryPending) { |
1249 | QVector3D graphDimensions(m_scaleX, m_scaleY, m_scaleZ); |
1250 | queriedGraphPosition(projectionViewMatrix, scaling: graphDimensions, defaultFboHandle); |
1251 | emit needRender(); |
1252 | } |
1253 | |
1254 | // Draw selection buffer |
1255 | if (!m_cachedIsSlicingActivated && (!m_renderCacheList.isEmpty() |
1256 | || !m_customRenderCache.isEmpty()) |
1257 | && m_selectionState == SelectOnScene |
1258 | && m_cachedSelectionMode > QAbstract3DGraph::SelectionNone |
1259 | && m_selectionResultTexture) { |
1260 | m_selectionShader->bind(); |
1261 | glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: m_selectionFrameBuffer); |
1262 | glViewport(x: 0, |
1263 | y: 0, |
1264 | width: m_primarySubViewport.width(), |
1265 | height: m_primarySubViewport.height()); |
1266 | |
1267 | glEnable(GL_DEPTH_TEST); // Needed, otherwise the depth render buffer is not used |
1268 | glClearColor(red: 0.0f, green: 0.0f, blue: 0.0f, alpha: 0.0f); |
1269 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Needed for clearing the frame buffer |
1270 | glDisable(GL_DITHER); // disable dithering, it may affect colors if enabled |
1271 | |
1272 | glDisable(GL_CULL_FACE); |
1273 | |
1274 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
1275 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
1276 | if (cache->surfaceObject()->indexCount() && cache->renderable()) { |
1277 | m_selectionShader->setUniformValue(uniform: m_selectionShader->MVP(), value: projectionViewMatrix); |
1278 | |
1279 | cache->surfaceObject()->activateSurfaceTexture(value: false); |
1280 | |
1281 | m_drawer->drawObject(shader: m_selectionShader, object: cache->surfaceObject(), |
1282 | textureId: cache->selectionTexture()); |
1283 | } |
1284 | } |
1285 | m_surfaceGridShader->bind(); |
1286 | Abstract3DRenderer::drawCustomItems(state: RenderingSelection, regularShader: m_surfaceGridShader, |
1287 | viewMatrix, |
1288 | projectionViewMatrix, depthProjectionViewMatrix, |
1289 | depthTexture: m_depthTexture, shadowQuality: m_shadowQualityToShader); |
1290 | drawLabels(drawSelection: true, activeCamera, viewMatrix, projectionMatrix); |
1291 | |
1292 | glEnable(GL_DITHER); |
1293 | |
1294 | QVector4D clickedColor = Utils::getSelection(mousepos: m_inputPosition, height: m_viewport.height()); |
1295 | |
1296 | glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: defaultFboHandle); |
1297 | |
1298 | // Put the RGBA value back to uint |
1299 | uint selectionId = uint(clickedColor.x()) |
1300 | + uint(clickedColor.y()) * greenMultiplier |
1301 | + uint(clickedColor.z()) * blueMultiplier |
1302 | + uint(clickedColor.w()) * alphaMultiplier; |
1303 | |
1304 | m_clickedPosition = selectionIdToSurfacePoint(id: selectionId); |
1305 | m_clickResolved = true; |
1306 | |
1307 | emit needRender(); |
1308 | |
1309 | // Revert to original viewport |
1310 | glViewport(x: m_primarySubViewport.x(), |
1311 | y: m_primarySubViewport.y(), |
1312 | width: m_primarySubViewport.width(), |
1313 | height: m_primarySubViewport.height()); |
1314 | } |
1315 | |
1316 | // Selection handling |
1317 | if (m_selectionDirty || m_selectionLabelDirty) { |
1318 | QPoint visiblePoint = Surface3DController::invalidSelectionPosition(); |
1319 | if (m_selectedSeries) { |
1320 | SurfaceSeriesRenderCache *cache = |
1321 | static_cast<SurfaceSeriesRenderCache *>( |
1322 | m_renderCacheList.value(key: const_cast<QSurface3DSeries *>(m_selectedSeries))); |
1323 | if (cache && m_selectedPoint != Surface3DController::invalidSelectionPosition()) { |
1324 | const QRect &sampleSpace = cache->sampleSpace(); |
1325 | int x = m_selectedPoint.x() - sampleSpace.y(); |
1326 | int y = m_selectedPoint.y() - sampleSpace.x(); |
1327 | if (x >= 0 && y >= 0 && x < sampleSpace.height() && y < sampleSpace.width() |
1328 | && cache->dataArray().size()) { |
1329 | visiblePoint = QPoint(x, y); |
1330 | } |
1331 | } |
1332 | } |
1333 | |
1334 | if (m_cachedSelectionMode == QAbstract3DGraph::SelectionNone |
1335 | || visiblePoint == Surface3DController::invalidSelectionPosition()) { |
1336 | m_selectionActive = false; |
1337 | } else { |
1338 | if (m_cachedIsSlicingActivated) |
1339 | updateSliceDataModel(point: visiblePoint); |
1340 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionItem)) |
1341 | surfacePointSelected(point: visiblePoint); |
1342 | m_selectionActive = true; |
1343 | } |
1344 | |
1345 | m_selectionDirty = false; |
1346 | } |
1347 | |
1348 | // Draw the surface |
1349 | if (!m_renderCacheList.isEmpty()) { |
1350 | // For surface we can see glimpses from underneath |
1351 | glDisable(GL_CULL_FACE); |
1352 | |
1353 | bool drawGrid = false; |
1354 | |
1355 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
1356 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
1357 | QMatrix4x4 modelMatrix; |
1358 | QMatrix4x4 MVPMatrix; |
1359 | QMatrix4x4 itModelMatrix; |
1360 | |
1361 | #ifdef SHOW_DEPTH_TEXTURE_SCENE |
1362 | MVPMatrix = depthProjectionViewMatrix; |
1363 | #else |
1364 | MVPMatrix = projectionViewMatrix; |
1365 | #endif |
1366 | cache->setMVPMatrix(MVPMatrix); |
1367 | |
1368 | const QRect &sampleSpace = cache->sampleSpace(); |
1369 | if (cache->surfaceObject()->indexCount() && cache->isVisible() && |
1370 | sampleSpace.width() >= 2 && sampleSpace.height() >= 2) { |
1371 | noShadows = false; |
1372 | if (!drawGrid && cache->surfaceGridVisible()) { |
1373 | glEnable(GL_POLYGON_OFFSET_FILL); |
1374 | glPolygonOffset(factor: 0.5f, units: 1.0f); |
1375 | drawGrid = true; |
1376 | } |
1377 | |
1378 | if (cache->surfaceVisible()) { |
1379 | ShaderHelper *shader = m_surfaceFlatShader; |
1380 | if (cache->surfaceTexture()) |
1381 | shader = m_surfaceTexturedFlatShader; |
1382 | if (!cache->isFlatShadingEnabled()) { |
1383 | shader = m_surfaceSmoothShader; |
1384 | if (cache->surfaceTexture()) |
1385 | shader = m_surfaceTexturedSmoothShader; |
1386 | } |
1387 | shader->bind(); |
1388 | |
1389 | // Set shader bindings |
1390 | shader->setUniformValue(uniform: shader->lightP(), value: lightPos); |
1391 | shader->setUniformValue(uniform: shader->view(), value: viewMatrix); |
1392 | shader->setUniformValue(uniform: shader->model(), value: modelMatrix); |
1393 | shader->setUniformValue(uniform: shader->nModel(), |
1394 | value: itModelMatrix.inverted().transposed()); |
1395 | shader->setUniformValue(uniform: shader->MVP(), value: MVPMatrix); |
1396 | shader->setUniformValue(uniform: shader->ambientS(), |
1397 | value: m_cachedTheme->ambientLightStrength()); |
1398 | shader->setUniformValue(uniform: shader->lightColor(), value: lightColor); |
1399 | |
1400 | // Set the surface texturing |
1401 | cache->surfaceObject()->activateSurfaceTexture(value: false); |
1402 | GLuint texture; |
1403 | if (cache->surfaceTexture()) { |
1404 | texture = cache->surfaceTexture(); |
1405 | cache->surfaceObject()->activateSurfaceTexture(value: true); |
1406 | } else { |
1407 | if (cache->colorStyle() == Q3DTheme::ColorStyleUniform) { |
1408 | texture = cache->baseUniformTexture(); |
1409 | shader->setUniformValue(uniform: shader->gradientMin(), value: 0.0f); |
1410 | shader->setUniformValue(uniform: shader->gradientHeight(), value: 0.0f); |
1411 | } else { |
1412 | texture = cache->baseGradientTexture(); |
1413 | if (cache->colorStyle() == Q3DTheme::ColorStyleObjectGradient) { |
1414 | float objMin = cache->surfaceObject()->minYValue(); |
1415 | float objMax = cache->surfaceObject()->maxYValue(); |
1416 | float objRange = objMax - objMin; |
1417 | shader->setUniformValue(uniform: shader->gradientMin(), value: -(objMin / objRange)); |
1418 | shader->setUniformValue(uniform: shader->gradientHeight(), value: 1.0f / objRange); |
1419 | } else { |
1420 | shader->setUniformValue(uniform: shader->gradientMin(), value: 0.5f); |
1421 | shader->setUniformValue(uniform: shader->gradientHeight(), |
1422 | value: 1.0f / (m_scaleY * 2.0f)); |
1423 | } |
1424 | } |
1425 | } |
1426 | |
1427 | if (!m_isOpenGLES && |
1428 | m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1429 | // Set shadow shader bindings |
1430 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1431 | shader->setUniformValue(uniform: shader->shadowQ(), value: m_shadowQualityToShader); |
1432 | shader->setUniformValue(uniform: shader->depth(), value: depthMVPMatrix); |
1433 | shader->setUniformValue(uniform: shader->lightS(), value: adjustedLightStrength); |
1434 | |
1435 | // Draw the objects |
1436 | m_drawer->drawObject(shader, object: cache->surfaceObject(), textureId: texture, |
1437 | depthTextureId: m_depthTexture); |
1438 | } else { |
1439 | // Set shadowless shader bindings |
1440 | shader->setUniformValue(uniform: shader->lightS(), value: m_cachedTheme->lightStrength()); |
1441 | // Draw the objects |
1442 | m_drawer->drawObject(shader, object: cache->surfaceObject(), textureId: texture); |
1443 | } |
1444 | } |
1445 | } |
1446 | } |
1447 | glEnable(GL_CULL_FACE); |
1448 | |
1449 | // Draw surface grid |
1450 | if (drawGrid) { |
1451 | glDisable(GL_POLYGON_OFFSET_FILL); |
1452 | m_surfaceGridShader->bind(); |
1453 | m_surfaceGridShader->setUniformValue(uniform: m_surfaceGridShader->color(), |
1454 | value: Utils::vectorFromColor( |
1455 | color: m_cachedTheme->gridLineColor())); |
1456 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
1457 | SurfaceSeriesRenderCache *cache = |
1458 | static_cast<SurfaceSeriesRenderCache *>(baseCache); |
1459 | m_surfaceGridShader->setUniformValue(uniform: m_surfaceGridShader->MVP(), |
1460 | value: cache->MVPMatrix()); |
1461 | |
1462 | const QRect &sampleSpace = cache->sampleSpace(); |
1463 | if (cache->surfaceObject()->indexCount() && cache->surfaceGridVisible() |
1464 | && cache->isVisible() && sampleSpace.width() >= 2 |
1465 | && sampleSpace.height() >= 2) { |
1466 | m_drawer->drawSurfaceGrid(shader: m_surfaceGridShader, object: cache->surfaceObject()); |
1467 | } |
1468 | } |
1469 | } |
1470 | } |
1471 | |
1472 | // Render selection ball |
1473 | if (m_selectionActive |
1474 | && m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionItem)) { |
1475 | for (SeriesRenderCache *baseCache: m_renderCacheList) { |
1476 | const SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
1477 | if (cache->slicePointerActive() && cache->renderable() && |
1478 | m_cachedIsSlicingActivated ) { |
1479 | cache->sliceSelectionPointer()->renderSelectionPointer(defaultFboHandle); |
1480 | } |
1481 | if (cache->mainPointerActive() && cache->renderable()) { |
1482 | cache->mainSelectionPointer()->renderSelectionPointer(defaultFboHandle, |
1483 | useOrtho: m_useOrthoProjection); |
1484 | } |
1485 | } |
1486 | } |
1487 | |
1488 | // Bind background shader |
1489 | m_backgroundShader->bind(); |
1490 | glCullFace(GL_BACK); |
1491 | |
1492 | // Draw background |
1493 | if (m_cachedTheme->isBackgroundEnabled() && m_backgroundObj) { |
1494 | QMatrix4x4 modelMatrix; |
1495 | QMatrix4x4 MVPMatrix; |
1496 | QMatrix4x4 itModelMatrix; |
1497 | |
1498 | QVector3D bgScale(m_scaleXWithBackground, m_scaleYWithBackground, m_scaleZWithBackground); |
1499 | modelMatrix.scale(vector: bgScale); |
1500 | |
1501 | // If we're viewing from below, background object must be flipped |
1502 | if (m_yFlipped) { |
1503 | modelMatrix.rotate(quaternion: m_xFlipRotation); |
1504 | modelMatrix.rotate(angle: 270.0f - backgroundRotation, x: 0.0f, y: 1.0f, z: 0.0f); |
1505 | } else { |
1506 | modelMatrix.rotate(angle: backgroundRotation, x: 0.0f, y: 1.0f, z: 0.0f); |
1507 | } |
1508 | |
1509 | itModelMatrix = modelMatrix; // Only scaling and rotations, can be used directly |
1510 | |
1511 | #ifdef SHOW_DEPTH_TEXTURE_SCENE |
1512 | MVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1513 | #else |
1514 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1515 | #endif |
1516 | |
1517 | bool blendEnabled = false; |
1518 | QVector4D backgroundColor = Utils::vectorFromColor(color: m_cachedTheme->backgroundColor()); |
1519 | if (backgroundColor.w() < 1.0f) { |
1520 | blendEnabled = true; |
1521 | glEnable(GL_BLEND); |
1522 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
1523 | } |
1524 | |
1525 | // Set shader bindings |
1526 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->lightP(), value: lightPos); |
1527 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->view(), value: viewMatrix); |
1528 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->model(), value: modelMatrix); |
1529 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->nModel(), |
1530 | value: itModelMatrix.inverted().transposed()); |
1531 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->MVP(), value: MVPMatrix); |
1532 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->color(), value: backgroundColor); |
1533 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->ambientS(), |
1534 | value: m_cachedTheme->ambientLightStrength() * 2.0f); |
1535 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->lightColor(), value: lightColor); |
1536 | |
1537 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone && !m_isOpenGLES) { |
1538 | // Set shadow shader bindings |
1539 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1540 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->shadowQ(), |
1541 | value: m_shadowQualityToShader); |
1542 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->depth(), value: depthMVPMatrix); |
1543 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->lightS(), |
1544 | value: adjustedLightStrength); |
1545 | // Draw the object |
1546 | if (noShadows && m_customRenderCache.isEmpty()) |
1547 | m_drawer->drawObject(shader: m_backgroundShader, object: m_backgroundObj, textureId: 0, depthTextureId: m_noShadowTexture); |
1548 | else |
1549 | m_drawer->drawObject(shader: m_backgroundShader, object: m_backgroundObj, textureId: 0, depthTextureId: m_depthTexture); |
1550 | } else { |
1551 | // Set shadowless shader bindings |
1552 | m_backgroundShader->setUniformValue(uniform: m_backgroundShader->lightS(), |
1553 | value: m_cachedTheme->lightStrength()); |
1554 | |
1555 | // Draw the object |
1556 | m_drawer->drawObject(shader: m_backgroundShader, object: m_backgroundObj); |
1557 | } |
1558 | |
1559 | if (blendEnabled) |
1560 | glDisable(GL_BLEND); |
1561 | } |
1562 | |
1563 | // Draw grid lines |
1564 | QVector3D gridLineScaleX(m_scaleXWithBackground, gridLineWidth, gridLineWidth); |
1565 | QVector3D gridLineScaleZ(gridLineWidth, gridLineWidth, m_scaleZWithBackground); |
1566 | QVector3D gridLineScaleY(gridLineWidth, m_scaleYWithBackground, gridLineWidth); |
1567 | |
1568 | if (m_cachedTheme->isGridEnabled()) { |
1569 | ShaderHelper *lineShader; |
1570 | if (m_isOpenGLES) |
1571 | lineShader = m_surfaceGridShader; // Plain color shader for GL_LINES |
1572 | else |
1573 | lineShader = m_backgroundShader; |
1574 | |
1575 | // Bind line shader |
1576 | lineShader->bind(); |
1577 | |
1578 | // Set unchanging shader bindings |
1579 | QVector4D lineColor = Utils::vectorFromColor(color: m_cachedTheme->gridLineColor()); |
1580 | lineShader->setUniformValue(uniform: lineShader->lightP(), value: lightPos); |
1581 | lineShader->setUniformValue(uniform: lineShader->view(), value: viewMatrix); |
1582 | lineShader->setUniformValue(uniform: lineShader->color(), value: lineColor); |
1583 | lineShader->setUniformValue(uniform: lineShader->ambientS(), value: m_cachedTheme->ambientLightStrength()); |
1584 | lineShader->setUniformValue(uniform: lineShader->lightColor(), value: lightColor); |
1585 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone && !m_isOpenGLES) { |
1586 | // Set shadowed shader bindings |
1587 | lineShader->setUniformValue(uniform: lineShader->shadowQ(), value: m_shadowQualityToShader); |
1588 | lineShader->setUniformValue(uniform: lineShader->lightS(), |
1589 | value: m_cachedTheme->lightStrength() / 20.0f); |
1590 | } else { |
1591 | // Set shadowless shader bindings |
1592 | lineShader->setUniformValue(uniform: lineShader->lightS(), |
1593 | value: m_cachedTheme->lightStrength() / 2.5f); |
1594 | } |
1595 | |
1596 | QQuaternion lineYRotation; |
1597 | QQuaternion lineXRotation; |
1598 | |
1599 | if (m_xFlipped) |
1600 | lineYRotation = m_yRightAngleRotationNeg; |
1601 | else |
1602 | lineYRotation = m_yRightAngleRotation; |
1603 | |
1604 | if (m_yFlippedForGrid) |
1605 | lineXRotation = m_xRightAngleRotation; |
1606 | else |
1607 | lineXRotation = m_xRightAngleRotationNeg; |
1608 | |
1609 | float yFloorLinePosition = -m_scaleYWithBackground + gridLineOffset; |
1610 | if (m_yFlipped != m_flipHorizontalGrid) |
1611 | yFloorLinePosition = -yFloorLinePosition; |
1612 | |
1613 | // Rows (= Z) |
1614 | if (m_axisCacheZ.segmentCount() > 0) { |
1615 | int gridLineCount = m_axisCacheZ.gridLineCount(); |
1616 | // Floor lines |
1617 | if (m_polarGraph) { |
1618 | drawRadialGrid(shader: lineShader, yFloorLinePos: yFloorLinePosition, projectionViewMatrix, |
1619 | depthMatrix: depthProjectionViewMatrix); |
1620 | } else { |
1621 | for (int line = 0; line < gridLineCount; line++) { |
1622 | QMatrix4x4 modelMatrix; |
1623 | QMatrix4x4 MVPMatrix; |
1624 | QMatrix4x4 itModelMatrix; |
1625 | |
1626 | modelMatrix.translate(x: 0.0f, y: yFloorLinePosition, |
1627 | z: m_axisCacheZ.gridLinePosition(index: line)); |
1628 | |
1629 | modelMatrix.scale(vector: gridLineScaleX); |
1630 | itModelMatrix.scale(vector: gridLineScaleX); |
1631 | |
1632 | modelMatrix.rotate(quaternion: lineXRotation); |
1633 | itModelMatrix.rotate(quaternion: lineXRotation); |
1634 | |
1635 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1636 | |
1637 | // Set the rest of the shader bindings |
1638 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1639 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1640 | value: itModelMatrix.inverted().transposed()); |
1641 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1642 | |
1643 | if (!m_isOpenGLES) { |
1644 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1645 | // Set shadow shader bindings |
1646 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1647 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1648 | // Draw the object |
1649 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1650 | } else { |
1651 | // Draw the object |
1652 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1653 | } |
1654 | } else { |
1655 | m_drawer->drawLine(shader: lineShader); |
1656 | } |
1657 | } |
1658 | // Side wall lines |
1659 | GLfloat = m_scaleXWithBackground - gridLineOffset; |
1660 | |
1661 | if (!m_xFlipped) |
1662 | lineXTrans = -lineXTrans; |
1663 | |
1664 | for (int line = 0; line < gridLineCount; line++) { |
1665 | QMatrix4x4 modelMatrix; |
1666 | QMatrix4x4 MVPMatrix; |
1667 | QMatrix4x4 itModelMatrix; |
1668 | |
1669 | modelMatrix.translate(x: lineXTrans, y: 0.0f, z: m_axisCacheZ.gridLinePosition(index: line)); |
1670 | |
1671 | modelMatrix.scale(vector: gridLineScaleY); |
1672 | itModelMatrix.scale(vector: gridLineScaleY); |
1673 | |
1674 | if (m_isOpenGLES) { |
1675 | modelMatrix.rotate(quaternion: m_zRightAngleRotation); |
1676 | itModelMatrix.rotate(quaternion: m_zRightAngleRotation); |
1677 | } else { |
1678 | modelMatrix.rotate(quaternion: lineYRotation); |
1679 | itModelMatrix.rotate(quaternion: lineYRotation); |
1680 | } |
1681 | |
1682 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1683 | |
1684 | // Set the rest of the shader bindings |
1685 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1686 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1687 | value: itModelMatrix.inverted().transposed()); |
1688 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1689 | |
1690 | if (!m_isOpenGLES) { |
1691 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1692 | // Set shadow shader bindings |
1693 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1694 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1695 | // Draw the object |
1696 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1697 | } else { |
1698 | // Draw the object |
1699 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1700 | } |
1701 | } else { |
1702 | m_drawer->drawLine(shader: lineShader); |
1703 | } |
1704 | } |
1705 | } |
1706 | } |
1707 | |
1708 | // Columns (= X) |
1709 | if (m_axisCacheX.segmentCount() > 0) { |
1710 | if (m_isOpenGLES) |
1711 | lineXRotation = m_yRightAngleRotation; |
1712 | |
1713 | // Floor lines |
1714 | int gridLineCount = m_axisCacheX.gridLineCount(); |
1715 | |
1716 | if (m_polarGraph) { |
1717 | drawAngularGrid(shader: lineShader, yFloorLinePos: yFloorLinePosition, projectionViewMatrix, |
1718 | depthMatrix: depthProjectionViewMatrix); |
1719 | } else { |
1720 | for (int line = 0; line < gridLineCount; line++) { |
1721 | QMatrix4x4 modelMatrix; |
1722 | QMatrix4x4 MVPMatrix; |
1723 | QMatrix4x4 itModelMatrix; |
1724 | |
1725 | modelMatrix.translate(x: m_axisCacheX.gridLinePosition(index: line), y: yFloorLinePosition, |
1726 | z: 0.0f); |
1727 | |
1728 | modelMatrix.scale(vector: gridLineScaleZ); |
1729 | itModelMatrix.scale(vector: gridLineScaleZ); |
1730 | |
1731 | modelMatrix.rotate(quaternion: lineXRotation); |
1732 | itModelMatrix.rotate(quaternion: lineXRotation); |
1733 | |
1734 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1735 | |
1736 | // Set the rest of the shader bindings |
1737 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1738 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1739 | value: itModelMatrix.inverted().transposed()); |
1740 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1741 | |
1742 | if (!m_isOpenGLES) { |
1743 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1744 | // Set shadow shader bindings |
1745 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1746 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1747 | // Draw the object |
1748 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1749 | } else { |
1750 | // Draw the object |
1751 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1752 | } |
1753 | } else { |
1754 | m_drawer->drawLine(shader: lineShader); |
1755 | } |
1756 | } |
1757 | |
1758 | // Back wall lines |
1759 | GLfloat lineZTrans = m_scaleZWithBackground - gridLineOffset; |
1760 | |
1761 | if (!m_zFlipped) |
1762 | lineZTrans = -lineZTrans; |
1763 | |
1764 | for (int line = 0; line < gridLineCount; line++) { |
1765 | QMatrix4x4 modelMatrix; |
1766 | QMatrix4x4 MVPMatrix; |
1767 | QMatrix4x4 itModelMatrix; |
1768 | |
1769 | modelMatrix.translate(x: m_axisCacheX.gridLinePosition(index: line), y: 0.0f, z: lineZTrans); |
1770 | |
1771 | modelMatrix.scale(vector: gridLineScaleY); |
1772 | itModelMatrix.scale(vector: gridLineScaleY); |
1773 | |
1774 | if (m_isOpenGLES) { |
1775 | modelMatrix.rotate(quaternion: m_zRightAngleRotation); |
1776 | itModelMatrix.rotate(quaternion: m_zRightAngleRotation); |
1777 | } else if (m_zFlipped) { |
1778 | modelMatrix.rotate(quaternion: m_xFlipRotation); |
1779 | itModelMatrix.rotate(quaternion: m_xFlipRotation); |
1780 | } |
1781 | |
1782 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1783 | |
1784 | // Set the rest of the shader bindings |
1785 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1786 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1787 | value: itModelMatrix.inverted().transposed()); |
1788 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1789 | |
1790 | if (!m_isOpenGLES) { |
1791 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1792 | // Set shadow shader bindings |
1793 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1794 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1795 | // Draw the object |
1796 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1797 | } else { |
1798 | // Draw the object |
1799 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1800 | } |
1801 | } else { |
1802 | m_drawer->drawLine(shader: lineShader); |
1803 | } |
1804 | } |
1805 | } |
1806 | } |
1807 | |
1808 | // Horizontal wall lines |
1809 | if (m_axisCacheY.segmentCount() > 0) { |
1810 | // Back wall |
1811 | int gridLineCount = m_axisCacheY.gridLineCount(); |
1812 | |
1813 | GLfloat lineZTrans = m_scaleZWithBackground - gridLineOffset; |
1814 | |
1815 | if (!m_zFlipped) |
1816 | lineZTrans = -lineZTrans; |
1817 | |
1818 | for (int line = 0; line < gridLineCount; line++) { |
1819 | QMatrix4x4 modelMatrix; |
1820 | QMatrix4x4 MVPMatrix; |
1821 | QMatrix4x4 itModelMatrix; |
1822 | |
1823 | modelMatrix.translate(x: 0.0f, y: m_axisCacheY.gridLinePosition(index: line), z: lineZTrans); |
1824 | |
1825 | modelMatrix.scale(vector: gridLineScaleX); |
1826 | itModelMatrix.scale(vector: gridLineScaleX); |
1827 | |
1828 | if (m_zFlipped) { |
1829 | modelMatrix.rotate(quaternion: m_xFlipRotation); |
1830 | itModelMatrix.rotate(quaternion: m_xFlipRotation); |
1831 | } |
1832 | |
1833 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1834 | |
1835 | // Set the rest of the shader bindings |
1836 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1837 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1838 | value: itModelMatrix.inverted().transposed()); |
1839 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1840 | |
1841 | if (!m_isOpenGLES) { |
1842 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1843 | // Set shadow shader bindings |
1844 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1845 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1846 | // Draw the object |
1847 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1848 | } else { |
1849 | // Draw the object |
1850 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1851 | } |
1852 | } else { |
1853 | m_drawer->drawLine(shader: lineShader); |
1854 | } |
1855 | } |
1856 | |
1857 | // Side wall |
1858 | GLfloat = m_scaleXWithBackground - gridLineOffset; |
1859 | |
1860 | if (!m_xFlipped) |
1861 | lineXTrans = -lineXTrans; |
1862 | |
1863 | for (int line = 0; line < gridLineCount; line++) { |
1864 | QMatrix4x4 modelMatrix; |
1865 | QMatrix4x4 MVPMatrix; |
1866 | QMatrix4x4 itModelMatrix; |
1867 | |
1868 | modelMatrix.translate(x: lineXTrans, y: m_axisCacheY.gridLinePosition(index: line), z: 0.0f); |
1869 | |
1870 | modelMatrix.scale(vector: gridLineScaleZ); |
1871 | itModelMatrix.scale(vector: gridLineScaleZ); |
1872 | |
1873 | modelMatrix.rotate(quaternion: lineYRotation); |
1874 | itModelMatrix.rotate(quaternion: lineYRotation); |
1875 | |
1876 | MVPMatrix = projectionViewMatrix * modelMatrix; |
1877 | |
1878 | // Set the rest of the shader bindings |
1879 | lineShader->setUniformValue(uniform: lineShader->model(), value: modelMatrix); |
1880 | lineShader->setUniformValue(uniform: lineShader->nModel(), |
1881 | value: itModelMatrix.inverted().transposed()); |
1882 | lineShader->setUniformValue(uniform: lineShader->MVP(), value: MVPMatrix); |
1883 | |
1884 | if (!m_isOpenGLES) { |
1885 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
1886 | // Set shadow shader bindings |
1887 | QMatrix4x4 depthMVPMatrix = depthProjectionViewMatrix * modelMatrix; |
1888 | lineShader->setUniformValue(uniform: lineShader->depth(), value: depthMVPMatrix); |
1889 | // Draw the object |
1890 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture); |
1891 | } else { |
1892 | // Draw the object |
1893 | m_drawer->drawObject(shader: lineShader, object: m_gridLineObj); |
1894 | } |
1895 | } else { |
1896 | m_drawer->drawLine(shader: lineShader); |
1897 | } |
1898 | } |
1899 | } |
1900 | } |
1901 | |
1902 | Abstract3DRenderer::drawCustomItems(state: RenderingNormal, regularShader: m_customItemShader, viewMatrix, |
1903 | projectionViewMatrix, depthProjectionViewMatrix, |
1904 | depthTexture: m_depthTexture, shadowQuality: m_shadowQualityToShader); |
1905 | |
1906 | drawLabels(drawSelection: false, activeCamera, viewMatrix, projectionMatrix); |
1907 | |
1908 | // Release shader |
1909 | glUseProgram(program: 0); |
1910 | } |
1911 | |
1912 | void Surface3DRenderer::drawLabels(bool drawSelection, const Q3DCamera *activeCamera, |
1913 | const QMatrix4x4 &viewMatrix, |
1914 | const QMatrix4x4 &projectionMatrix) |
1915 | { |
1916 | ShaderHelper *shader = 0; |
1917 | GLfloat alphaForValueSelection = labelValueAlpha / 255.0f; |
1918 | GLfloat alphaForRowSelection = labelRowAlpha / 255.0f; |
1919 | GLfloat alphaForColumnSelection = labelColumnAlpha / 255.0f; |
1920 | if (drawSelection) { |
1921 | shader = m_surfaceGridShader; |
1922 | } else { |
1923 | shader = m_labelShader; |
1924 | shader->bind(); |
1925 | |
1926 | glEnable(GL_BLEND); |
1927 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); |
1928 | } |
1929 | |
1930 | glEnable(GL_POLYGON_OFFSET_FILL); |
1931 | |
1932 | float labelAutoAngle = m_axisCacheZ.labelAutoRotation(); |
1933 | float labelAngleFraction = labelAutoAngle / 90.0f; |
1934 | float fractionCamY = activeCamera->yRotation() * labelAngleFraction; |
1935 | float fractionCamX = activeCamera->xRotation() * labelAngleFraction; |
1936 | float labelsMaxWidth = 0.0f; |
1937 | |
1938 | int startIndex; |
1939 | int endIndex; |
1940 | int indexStep; |
1941 | |
1942 | // Z Labels |
1943 | QVector3D positionZComp(0.0f, 0.0f, 0.0f); |
1944 | if (m_axisCacheZ.segmentCount() > 0) { |
1945 | int labelCount = m_axisCacheZ.labelCount(); |
1946 | float labelXTrans = m_scaleXWithBackground + labelMargin; |
1947 | float labelYTrans = m_flipHorizontalGrid ? m_scaleYWithBackground : -m_scaleYWithBackground; |
1948 | if (m_polarGraph) { |
1949 | labelXTrans *= m_radialLabelOffset; |
1950 | // YTrans up only if over background |
1951 | if (m_radialLabelOffset < 1.0f) |
1952 | labelYTrans += gridLineOffset + gridLineWidth; |
1953 | } |
1954 | Qt::Alignment alignment = (m_xFlipped == m_zFlipped) ? Qt::AlignLeft : Qt::AlignRight; |
1955 | QVector3D labelRotation; |
1956 | if (m_xFlipped) |
1957 | labelXTrans = -labelXTrans; |
1958 | if (m_yFlipped) |
1959 | labelYTrans = -labelYTrans; |
1960 | if (labelAutoAngle == 0.0f) { |
1961 | if (m_zFlipped) |
1962 | labelRotation.setY(180.0f); |
1963 | if (m_yFlippedForGrid) { |
1964 | if (m_zFlipped) |
1965 | labelRotation.setY(180.0f); |
1966 | else |
1967 | labelRotation.setY(0.0f); |
1968 | labelRotation.setX(90.0f); |
1969 | } else { |
1970 | labelRotation.setX(-90.0f); |
1971 | } |
1972 | } else { |
1973 | if (m_zFlipped) |
1974 | labelRotation.setY(180.0f); |
1975 | if (m_yFlippedForGrid) { |
1976 | if (m_zFlipped) { |
1977 | if (m_xFlipped) { |
1978 | labelRotation.setX(90.0f - (labelAutoAngle - fractionCamX) |
1979 | * (-labelAutoAngle - fractionCamY) / labelAutoAngle); |
1980 | labelRotation.setZ(labelAutoAngle + fractionCamY); |
1981 | } else { |
1982 | labelRotation.setX(90.0f + (labelAutoAngle + fractionCamX) |
1983 | * (labelAutoAngle + fractionCamY) / labelAutoAngle); |
1984 | labelRotation.setZ(-labelAutoAngle - fractionCamY); |
1985 | } |
1986 | } else { |
1987 | if (m_xFlipped) { |
1988 | labelRotation.setX(90.0f + (labelAutoAngle - fractionCamX) |
1989 | * -(labelAutoAngle + fractionCamY) / labelAutoAngle); |
1990 | labelRotation.setZ(-labelAutoAngle - fractionCamY); |
1991 | } else { |
1992 | labelRotation.setX(90.0f - (labelAutoAngle + fractionCamX) |
1993 | * (labelAutoAngle + fractionCamY) / labelAutoAngle); |
1994 | labelRotation.setZ(labelAutoAngle + fractionCamY); |
1995 | } |
1996 | } |
1997 | } else { |
1998 | if (m_zFlipped) { |
1999 | if (m_xFlipped) { |
2000 | labelRotation.setX(-90.0f + (labelAutoAngle - fractionCamX) |
2001 | * (-labelAutoAngle + fractionCamY) / labelAutoAngle); |
2002 | labelRotation.setZ(-labelAutoAngle + fractionCamY); |
2003 | } else { |
2004 | labelRotation.setX(-90.0f - (labelAutoAngle + fractionCamX) |
2005 | * (labelAutoAngle - fractionCamY) / labelAutoAngle); |
2006 | labelRotation.setZ(labelAutoAngle - fractionCamY); |
2007 | } |
2008 | } else { |
2009 | if (m_xFlipped) { |
2010 | labelRotation.setX(-90.0f - (labelAutoAngle - fractionCamX) |
2011 | * (-labelAutoAngle + fractionCamY) / labelAutoAngle); |
2012 | labelRotation.setZ(labelAutoAngle - fractionCamY); |
2013 | } else { |
2014 | labelRotation.setX(-90.0f + (labelAutoAngle + fractionCamX) |
2015 | * (labelAutoAngle - fractionCamY) / labelAutoAngle); |
2016 | labelRotation.setZ(-labelAutoAngle + fractionCamY); |
2017 | } |
2018 | } |
2019 | } |
2020 | } |
2021 | |
2022 | QQuaternion totalRotation = Utils::calculateRotation(xyzRotations: labelRotation); |
2023 | |
2024 | QVector3D labelTrans = QVector3D(labelXTrans, |
2025 | labelYTrans, |
2026 | 0.0f); |
2027 | |
2028 | if (m_zFlipped) { |
2029 | startIndex = 0; |
2030 | endIndex = labelCount; |
2031 | indexStep = 1; |
2032 | } else { |
2033 | startIndex = labelCount - 1; |
2034 | endIndex = -1; |
2035 | indexStep = -1; |
2036 | } |
2037 | float offsetValue = 0.0f; |
2038 | for (int label = startIndex; label != endIndex; label = label + indexStep) { |
2039 | glPolygonOffset(factor: offsetValue++ / -10.0f, units: 1.0f); |
2040 | const LabelItem &axisLabelItem = *m_axisCacheZ.labelItems().at(i: label); |
2041 | // Draw the label here |
2042 | if (m_polarGraph) { |
2043 | float direction = m_zFlipped ? -1.0f : 1.0f; |
2044 | labelTrans.setZ((m_axisCacheZ.formatter()->labelPositions().at(i: label) |
2045 | * -m_polarRadius |
2046 | + m_drawer->scaledFontSize() + gridLineWidth) * direction); |
2047 | } else { |
2048 | labelTrans.setZ(m_axisCacheZ.labelPosition(index: label)); |
2049 | } |
2050 | if (label == 0 || label == (labelCount - 1)) { |
2051 | // If the margin is small, adjust the position of the edge labels to avoid overlapping |
2052 | // with labels of the other axes. |
2053 | float scaleFactor = m_drawer->scaledFontSize() / axisLabelItem.size().height(); |
2054 | float labelOverlap = qAbs(t: labelTrans.z()) |
2055 | + (scaleFactor * axisLabelItem.size().height() / 2.0f) |
2056 | - m_scaleZWithBackground + labelMargin; |
2057 | // No need to adjust quite as much on the front edges |
2058 | if (label != startIndex) |
2059 | labelOverlap /= 2.0f; |
2060 | if (labelOverlap > 0.0f) { |
2061 | if (label == 0) |
2062 | labelTrans.setZ(labelTrans.z() - labelOverlap); |
2063 | else |
2064 | labelTrans.setZ(labelTrans.z() + labelOverlap); |
2065 | } |
2066 | } |
2067 | m_dummyRenderItem.setTranslation(labelTrans); |
2068 | |
2069 | if (drawSelection) { |
2070 | QVector4D labelColor = QVector4D(label / 255.0f, 0.0f, 0.0f, |
2071 | alphaForRowSelection); |
2072 | shader->setUniformValue(uniform: shader->color(), value: labelColor); |
2073 | } |
2074 | |
2075 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
2076 | positionComp: positionZComp, rotation: totalRotation, itemHeight: 0, mode: m_cachedSelectionMode, |
2077 | shader, object: m_labelObj, camera: activeCamera, |
2078 | useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment, isSlicing: false, isSelecting: drawSelection); |
2079 | labelsMaxWidth = qMax(a: labelsMaxWidth, b: float(axisLabelItem.size().width())); |
2080 | } |
2081 | if (!drawSelection && m_axisCacheZ.isTitleVisible()) { |
2082 | if (m_polarGraph) { |
2083 | float titleZ = -m_polarRadius / 2.0f; |
2084 | if (m_zFlipped) |
2085 | titleZ = -titleZ; |
2086 | labelTrans.setZ(titleZ); |
2087 | } else { |
2088 | labelTrans.setZ(0.0f); |
2089 | } |
2090 | drawAxisTitleZ(labelRotation, labelTrans, totalRotation, dummyItem&: m_dummyRenderItem, |
2091 | activeCamera, labelsMaxWidth, viewMatrix, projectionMatrix, shader); |
2092 | } |
2093 | } |
2094 | // X Labels |
2095 | if (m_axisCacheX.segmentCount() > 0) { |
2096 | labelsMaxWidth = 0.0f; |
2097 | labelAutoAngle = m_axisCacheX.labelAutoRotation(); |
2098 | labelAngleFraction = labelAutoAngle / 90.0f; |
2099 | fractionCamY = activeCamera->yRotation() * labelAngleFraction; |
2100 | fractionCamX = activeCamera->xRotation() * labelAngleFraction; |
2101 | int labelCount = m_axisCacheX.labelCount(); |
2102 | |
2103 | float labelZTrans = 0.0f; |
2104 | float labelYTrans = m_flipHorizontalGrid ? m_scaleYWithBackground : -m_scaleYWithBackground; |
2105 | if (m_polarGraph) |
2106 | labelYTrans += gridLineOffset + gridLineWidth; |
2107 | else |
2108 | labelZTrans = m_scaleZWithBackground + labelMargin; |
2109 | |
2110 | Qt::Alignment alignment = (m_xFlipped != m_zFlipped) ? Qt::AlignLeft : Qt::AlignRight; |
2111 | QVector3D labelRotation; |
2112 | if (m_zFlipped) |
2113 | labelZTrans = -labelZTrans; |
2114 | if (m_yFlipped) |
2115 | labelYTrans = -labelYTrans; |
2116 | if (labelAutoAngle == 0.0f) { |
2117 | labelRotation = QVector3D(-90.0f, 90.0f, 0.0f); |
2118 | if (m_xFlipped) |
2119 | labelRotation.setY(-90.0f); |
2120 | if (m_yFlippedForGrid) { |
2121 | if (m_xFlipped) |
2122 | labelRotation.setY(-90.0f); |
2123 | else |
2124 | labelRotation.setY(90.0f); |
2125 | labelRotation.setX(90.0f); |
2126 | } |
2127 | } else { |
2128 | if (m_xFlipped) |
2129 | labelRotation.setY(-90.0f); |
2130 | else |
2131 | labelRotation.setY(90.0f); |
2132 | if (m_yFlippedForGrid) { |
2133 | if (m_zFlipped) { |
2134 | if (m_xFlipped) { |
2135 | labelRotation.setX(90.0f - (2.0f * labelAutoAngle - fractionCamX) |
2136 | * (labelAutoAngle + fractionCamY) / labelAutoAngle); |
2137 | labelRotation.setZ(-labelAutoAngle - fractionCamY); |
2138 | } else { |
2139 | labelRotation.setX(90.0f - (2.0f * labelAutoAngle + fractionCamX) |
2140 | * (labelAutoAngle + fractionCamY) / labelAutoAngle); |
2141 | labelRotation.setZ(labelAutoAngle + fractionCamY); |
2142 | } |
2143 | } else { |
2144 | if (m_xFlipped) { |
2145 | labelRotation.setX(90.0f + fractionCamX |
2146 | * -(labelAutoAngle + fractionCamY) / labelAutoAngle); |
2147 | labelRotation.setZ(labelAutoAngle + fractionCamY); |
2148 | } else { |
2149 | labelRotation.setX(90.0f - fractionCamX |
2150 | * (-labelAutoAngle - fractionCamY) / labelAutoAngle); |
2151 | labelRotation.setZ(-labelAutoAngle - fractionCamY); |
2152 | } |
2153 | } |
2154 | } else { |
2155 | if (m_zFlipped) { |
2156 | if (m_xFlipped) { |
2157 | labelRotation.setX(-90.0f + (2.0f * labelAutoAngle - fractionCamX) |
2158 | * (labelAutoAngle - fractionCamY) / labelAutoAngle); |
2159 | labelRotation.setZ(labelAutoAngle - fractionCamY); |
2160 | } else { |
2161 | labelRotation.setX(-90.0f + (2.0f * labelAutoAngle + fractionCamX) |
2162 | * (labelAutoAngle - fractionCamY) / labelAutoAngle); |
2163 | labelRotation.setZ(-labelAutoAngle + fractionCamY); |
2164 | } |
2165 | } else { |
2166 | if (m_xFlipped) { |
2167 | labelRotation.setX(-90.0f - fractionCamX |
2168 | * (-labelAutoAngle + fractionCamY) / labelAutoAngle); |
2169 | labelRotation.setZ(-labelAutoAngle + fractionCamY); |
2170 | } else { |
2171 | labelRotation.setX(-90.0f + fractionCamX |
2172 | * -(labelAutoAngle - fractionCamY) / labelAutoAngle); |
2173 | labelRotation.setZ(labelAutoAngle - fractionCamY); |
2174 | } |
2175 | } |
2176 | } |
2177 | } |
2178 | |
2179 | QQuaternion totalRotation = Utils::calculateRotation(xyzRotations: labelRotation); |
2180 | if (m_polarGraph) { |
2181 | if ((!m_yFlippedForGrid && (m_zFlipped != m_xFlipped)) |
2182 | || (m_yFlippedForGrid && (m_zFlipped == m_xFlipped))) { |
2183 | totalRotation *= m_zRightAngleRotation; |
2184 | } else { |
2185 | totalRotation *= m_zRightAngleRotationNeg; |
2186 | } |
2187 | } |
2188 | |
2189 | QVector3D labelTrans = QVector3D(0.0f, |
2190 | labelYTrans, |
2191 | labelZTrans); |
2192 | |
2193 | if (m_xFlipped) { |
2194 | startIndex = labelCount - 1; |
2195 | endIndex = -1; |
2196 | indexStep = -1; |
2197 | } else { |
2198 | startIndex = 0; |
2199 | endIndex = labelCount; |
2200 | indexStep = 1; |
2201 | } |
2202 | float offsetValue = 0.0f; |
2203 | bool showLastLabel = false; |
2204 | QList<float> &labelPositions = m_axisCacheX.formatter()->labelPositions(); |
2205 | int lastLabelPosIndex = labelPositions.size() - 1; |
2206 | if (labelPositions.size() |
2207 | && (labelPositions.at(i: lastLabelPosIndex) != 1.0f || labelPositions.at(i: 0) != 0.0f)) { |
2208 | // Avoid overlapping first and last label if they would get on same position |
2209 | showLastLabel = true; |
2210 | } |
2211 | |
2212 | for (int label = startIndex; label != endIndex; label = label + indexStep) { |
2213 | glPolygonOffset(factor: offsetValue++ / -10.0f, units: 1.0f); |
2214 | // Draw the label here |
2215 | if (m_polarGraph) { |
2216 | // Calculate angular position |
2217 | if (label == lastLabelPosIndex && !showLastLabel) |
2218 | continue; |
2219 | float labelPosition = labelPositions.at(i: label); |
2220 | qreal angle = labelPosition * M_PI * 2.0; |
2221 | labelTrans.setX((m_polarRadius + labelMargin) * float(qSin(v: angle))); |
2222 | labelTrans.setZ(-(m_polarRadius + labelMargin) * float(qCos(v: angle))); |
2223 | // Alignment depends on label angular position, as well as flips |
2224 | Qt::AlignmentFlag vAlignment = Qt::AlignCenter; |
2225 | Qt::AlignmentFlag hAlignment = Qt::AlignCenter; |
2226 | const float centerMargin = 0.005f; |
2227 | if (labelPosition < 0.25f - centerMargin || labelPosition > 0.75f + centerMargin) |
2228 | vAlignment = m_zFlipped ? Qt::AlignTop : Qt::AlignBottom; |
2229 | else if (labelPosition > 0.25f + centerMargin && labelPosition < 0.75f - centerMargin) |
2230 | vAlignment = m_zFlipped ? Qt::AlignBottom : Qt::AlignTop; |
2231 | |
2232 | if (labelPosition < 0.50f - centerMargin && labelPosition > centerMargin) |
2233 | hAlignment = m_zFlipped ? Qt::AlignRight : Qt::AlignLeft; |
2234 | else if (labelPosition < 1.0f - centerMargin && labelPosition > 0.5f + centerMargin) |
2235 | hAlignment = m_zFlipped ? Qt::AlignLeft : Qt::AlignRight; |
2236 | if (m_yFlippedForGrid && vAlignment != Qt::AlignCenter) |
2237 | vAlignment = (vAlignment == Qt::AlignTop) ? Qt::AlignBottom : Qt::AlignTop; |
2238 | alignment = vAlignment | hAlignment; |
2239 | } else { |
2240 | labelTrans.setX(m_axisCacheX.labelPosition(index: label)); |
2241 | } |
2242 | const LabelItem &axisLabelItem = *m_axisCacheX.labelItems().at(i: label); |
2243 | if (label == 0 || label == (labelCount - 1)) { |
2244 | // If the margin is small, adjust the position of the edge labels to avoid overlapping |
2245 | // with labels of the other axes. |
2246 | float scaleFactor = m_drawer->scaledFontSize() / axisLabelItem.size().height(); |
2247 | float labelOverlap = qAbs(t: labelTrans.x()) |
2248 | + (scaleFactor * axisLabelItem.size().height() / 2.0f) |
2249 | - m_scaleXWithBackground + labelMargin; |
2250 | // No need to adjust quite as much on the front edges |
2251 | if (label != startIndex) |
2252 | labelOverlap /= 2.0f; |
2253 | if (labelOverlap > 0.0f) { |
2254 | if (label == 0) |
2255 | labelTrans.setX(labelTrans.x() + labelOverlap); |
2256 | else |
2257 | labelTrans.setX(labelTrans.x() - labelOverlap); |
2258 | } |
2259 | } |
2260 | m_dummyRenderItem.setTranslation(labelTrans); |
2261 | |
2262 | if (drawSelection) { |
2263 | QVector4D labelColor = QVector4D(0.0f, label / 255.0f, 0.0f, |
2264 | alphaForColumnSelection); |
2265 | shader->setUniformValue(uniform: shader->color(), value: labelColor); |
2266 | } |
2267 | |
2268 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
2269 | positionComp: positionZComp, rotation: totalRotation, itemHeight: 0, mode: m_cachedSelectionMode, |
2270 | shader, object: m_labelObj, camera: activeCamera, |
2271 | useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment, isSlicing: false, isSelecting: drawSelection); |
2272 | labelsMaxWidth = qMax(a: labelsMaxWidth, b: float(axisLabelItem.size().width())); |
2273 | } |
2274 | if (!drawSelection && m_axisCacheX.isTitleVisible()) { |
2275 | labelTrans.setX(0.0f); |
2276 | bool radial = false; |
2277 | if (m_polarGraph) { |
2278 | if (m_xFlipped == m_zFlipped) |
2279 | totalRotation *= m_zRightAngleRotation; |
2280 | else |
2281 | totalRotation *= m_zRightAngleRotationNeg; |
2282 | if (m_yFlippedForGrid) |
2283 | totalRotation *= QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: -180.0f); |
2284 | labelTrans.setZ(-m_polarRadius); |
2285 | radial = true; |
2286 | } |
2287 | drawAxisTitleX(labelRotation, labelTrans, totalRotation, dummyItem&: m_dummyRenderItem, |
2288 | activeCamera, labelsMaxWidth, viewMatrix, projectionMatrix, shader, |
2289 | radial); |
2290 | } |
2291 | } |
2292 | // Y Labels |
2293 | if (m_axisCacheY.segmentCount() > 0) { |
2294 | labelsMaxWidth = 0.0f; |
2295 | labelAutoAngle = m_axisCacheY.labelAutoRotation(); |
2296 | labelAngleFraction = labelAutoAngle / 90.0f; |
2297 | fractionCamY = activeCamera->yRotation() * labelAngleFraction; |
2298 | fractionCamX = activeCamera->xRotation() * labelAngleFraction; |
2299 | int labelCount = m_axisCacheY.labelCount(); |
2300 | |
2301 | float labelXTrans = m_scaleXWithBackground; |
2302 | float labelZTrans = m_scaleZWithBackground; |
2303 | |
2304 | // Back & side wall |
2305 | float labelMarginXTrans = labelMargin; |
2306 | float labelMarginZTrans = labelMargin; |
2307 | QVector3D backLabelRotation(0.0f, -90.0f, 0.0f); |
2308 | QVector3D sideLabelRotation(0.0f, 0.0f, 0.0f); |
2309 | Qt::AlignmentFlag backAlignment = |
2310 | (m_xFlipped != m_zFlipped) ? Qt::AlignLeft : Qt::AlignRight; |
2311 | Qt::AlignmentFlag sideAlignment = |
2312 | (m_xFlipped == m_zFlipped) ? Qt::AlignLeft : Qt::AlignRight; |
2313 | if (!m_xFlipped) { |
2314 | labelXTrans = -labelXTrans; |
2315 | labelMarginXTrans = -labelMargin; |
2316 | } |
2317 | if (m_zFlipped) { |
2318 | labelZTrans = -labelZTrans; |
2319 | labelMarginZTrans = -labelMargin; |
2320 | } |
2321 | if (labelAutoAngle == 0.0f) { |
2322 | if (!m_xFlipped) |
2323 | backLabelRotation.setY(90.0f); |
2324 | if (m_zFlipped) |
2325 | sideLabelRotation.setY(180.f); |
2326 | } else { |
2327 | // Orient side labels somewhat towards the camera |
2328 | if (m_xFlipped) { |
2329 | if (m_zFlipped) |
2330 | sideLabelRotation.setY(180.0f + (2.0f * labelAutoAngle) - fractionCamX); |
2331 | else |
2332 | sideLabelRotation.setY(-fractionCamX); |
2333 | backLabelRotation.setY(-90.0f + labelAutoAngle - fractionCamX); |
2334 | } else { |
2335 | if (m_zFlipped) |
2336 | sideLabelRotation.setY(180.0f - (2.0f * labelAutoAngle) - fractionCamX); |
2337 | else |
2338 | sideLabelRotation.setY(-fractionCamX); |
2339 | backLabelRotation.setY(90.0f - labelAutoAngle - fractionCamX); |
2340 | } |
2341 | } |
2342 | sideLabelRotation.setX(-fractionCamY); |
2343 | backLabelRotation.setX(-fractionCamY); |
2344 | |
2345 | QQuaternion totalSideRotation = Utils::calculateRotation(xyzRotations: sideLabelRotation); |
2346 | QQuaternion totalBackRotation = Utils::calculateRotation(xyzRotations: backLabelRotation); |
2347 | |
2348 | QVector3D labelTransBack = QVector3D(labelXTrans, 0.0f, labelZTrans + labelMarginZTrans); |
2349 | QVector3D labelTransSide(-labelXTrans - labelMarginXTrans, 0.0f, -labelZTrans); |
2350 | |
2351 | if (m_yFlipped) { |
2352 | startIndex = labelCount - 1; |
2353 | endIndex = -1; |
2354 | indexStep = -1; |
2355 | } else { |
2356 | startIndex = 0; |
2357 | endIndex = labelCount; |
2358 | indexStep = 1; |
2359 | } |
2360 | float offsetValue = 0.0f; |
2361 | for (int label = startIndex; label != endIndex; label = label + indexStep) { |
2362 | const LabelItem &axisLabelItem = *m_axisCacheY.labelItems().at(i: label); |
2363 | float labelYTrans = m_axisCacheY.labelPosition(index: label); |
2364 | |
2365 | glPolygonOffset(factor: offsetValue++ / -10.0f, units: 1.0f); |
2366 | |
2367 | if (drawSelection) { |
2368 | QVector4D labelColor = QVector4D(0.0f, 0.0f, label / 255.0f, |
2369 | alphaForValueSelection); |
2370 | shader->setUniformValue(uniform: shader->color(), value: labelColor); |
2371 | } |
2372 | |
2373 | if (label == startIndex) { |
2374 | // If the margin is small, adjust the position of the edge label to avoid |
2375 | // overlapping with labels of the other axes. |
2376 | float scaleFactor = m_drawer->scaledFontSize() / axisLabelItem.size().height(); |
2377 | float labelOverlap = qAbs(t: labelYTrans) |
2378 | + (scaleFactor * axisLabelItem.size().height() / 2.0f) |
2379 | - m_scaleYWithBackground + labelMargin; |
2380 | if (labelOverlap > 0.0f) { |
2381 | if (label == 0) |
2382 | labelYTrans += labelOverlap; |
2383 | else |
2384 | labelYTrans -= labelOverlap; |
2385 | } |
2386 | } |
2387 | |
2388 | // Back wall |
2389 | labelTransBack.setY(labelYTrans); |
2390 | m_dummyRenderItem.setTranslation(labelTransBack); |
2391 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
2392 | positionComp: positionZComp, rotation: totalBackRotation, itemHeight: 0, mode: m_cachedSelectionMode, |
2393 | shader, object: m_labelObj, camera: activeCamera, |
2394 | useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment: backAlignment, isSlicing: false, |
2395 | isSelecting: drawSelection); |
2396 | |
2397 | // Side wall |
2398 | labelTransSide.setY(labelYTrans); |
2399 | m_dummyRenderItem.setTranslation(labelTransSide); |
2400 | m_drawer->drawLabel(item: m_dummyRenderItem, labelItem: axisLabelItem, viewmatrix: viewMatrix, projectionmatrix: projectionMatrix, |
2401 | positionComp: positionZComp, rotation: totalSideRotation, itemHeight: 0, mode: m_cachedSelectionMode, |
2402 | shader, object: m_labelObj, camera: activeCamera, |
2403 | useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment: sideAlignment, isSlicing: false, |
2404 | isSelecting: drawSelection); |
2405 | labelsMaxWidth = qMax(a: labelsMaxWidth, b: float(axisLabelItem.size().width())); |
2406 | } |
2407 | if (!drawSelection && m_axisCacheY.isTitleVisible()) { |
2408 | labelTransSide.setY(0.0f); |
2409 | labelTransBack.setY(0.0f); |
2410 | drawAxisTitleY(sideLabelRotation, backLabelRotation, sideLabelTrans: labelTransSide, backLabelTrans: labelTransBack, |
2411 | totalSideRotation, totalBackRotation, dummyItem&: m_dummyRenderItem, activeCamera, |
2412 | labelsMaxWidth, viewMatrix, projectionMatrix, |
2413 | shader); |
2414 | } |
2415 | } |
2416 | glDisable(GL_POLYGON_OFFSET_FILL); |
2417 | |
2418 | if (!drawSelection) |
2419 | glDisable(GL_BLEND); |
2420 | } |
2421 | |
2422 | void Surface3DRenderer::updateSelectionMode(QAbstract3DGraph::SelectionFlags mode) |
2423 | { |
2424 | Abstract3DRenderer::updateSelectionMode(newMode: mode); |
2425 | |
2426 | if (m_cachedSelectionMode > QAbstract3DGraph::SelectionNone) |
2427 | updateSelectionTextures(); |
2428 | } |
2429 | |
2430 | void Surface3DRenderer::updateSelectionTextures() |
2431 | { |
2432 | uint lastSelectionId = 1; |
2433 | |
2434 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
2435 | SurfaceSeriesRenderCache *cache = |
2436 | static_cast<SurfaceSeriesRenderCache *>(baseCache); |
2437 | GLuint texture = cache->selectionTexture(); |
2438 | m_textureHelper->deleteTexture(texture: &texture); |
2439 | createSelectionTexture(cache, lastSelectionId); |
2440 | } |
2441 | m_selectionTexturesDirty = false; |
2442 | } |
2443 | |
2444 | void Surface3DRenderer::createSelectionTexture(SurfaceSeriesRenderCache *cache, |
2445 | uint &lastSelectionId) |
2446 | { |
2447 | // Create the selection ID image. Each grid corner gets 1 pixel area of |
2448 | // ID color so that each vertex (data point) has 2x2 pixel area of ID color, |
2449 | // except the vertices on the edges. |
2450 | const QRect &sampleSpace = cache->sampleSpace(); |
2451 | int idImageWidth = (sampleSpace.width() - 1) * 2; |
2452 | int idImageHeight = (sampleSpace.height() - 1) * 2; |
2453 | |
2454 | if (idImageHeight <= 0 || idImageWidth <= 0) { |
2455 | cache->setSelectionIdRange(start: ~0U, end: ~0U); |
2456 | cache->setSelectionTexture(0); |
2457 | return; |
2458 | } |
2459 | |
2460 | int stride = idImageWidth * 4 * sizeof(uchar); // 4 = number of color components (rgba) |
2461 | |
2462 | uint idStart = lastSelectionId; |
2463 | uchar *bits = new uchar[idImageWidth * idImageHeight * 4 * sizeof(uchar)]; |
2464 | for (int i = 0; i < idImageHeight; i += 2) { |
2465 | for (int j = 0; j < idImageWidth; j += 2) { |
2466 | int p = (i * idImageWidth + j) * 4; |
2467 | uchar r, g, b, a; |
2468 | idToRGBA(id: lastSelectionId, r: &r, g: &g, b: &b, a: &a); |
2469 | fillIdCorner(p: &bits[p], r, g, b, a); |
2470 | |
2471 | idToRGBA(id: lastSelectionId + 1, r: &r, g: &g, b: &b, a: &a); |
2472 | fillIdCorner(p: &bits[p + 4], r, g, b, a); |
2473 | |
2474 | idToRGBA(id: lastSelectionId + sampleSpace.width(), r: &r, g: &g, b: &b, a: &a); |
2475 | fillIdCorner(p: &bits[p + stride], r, g, b, a); |
2476 | |
2477 | idToRGBA(id: lastSelectionId + sampleSpace.width() + 1, r: &r, g: &g, b: &b, a: &a); |
2478 | fillIdCorner(p: &bits[p + stride + 4], r, g, b, a); |
2479 | |
2480 | lastSelectionId++; |
2481 | } |
2482 | lastSelectionId++; |
2483 | } |
2484 | lastSelectionId += sampleSpace.width(); |
2485 | cache->setSelectionIdRange(start: idStart, end: lastSelectionId - 1); |
2486 | |
2487 | // Move the ID image (bits) to the texture |
2488 | QImage image = QImage(bits, idImageWidth, idImageHeight, QImage::Format_RGB32); |
2489 | GLuint selectionTexture = m_textureHelper->create2DTexture(image, useTrilinearFiltering: false, convert: false, smoothScale: false); |
2490 | cache->setSelectionTexture(selectionTexture); |
2491 | |
2492 | // Release the temp bits allocation |
2493 | delete[] bits; |
2494 | } |
2495 | |
2496 | void Surface3DRenderer::initSelectionBuffer() |
2497 | { |
2498 | // Create the result selection texture and buffers |
2499 | m_textureHelper->deleteTexture(texture: &m_selectionResultTexture); |
2500 | |
2501 | m_selectionResultTexture = m_textureHelper->createSelectionTexture(size: m_primarySubViewport.size(), |
2502 | frameBuffer&: m_selectionFrameBuffer, |
2503 | depthBuffer&: m_selectionDepthBuffer); |
2504 | } |
2505 | |
2506 | void Surface3DRenderer::fillIdCorner(uchar *p, uchar r, uchar g, uchar b, uchar a) |
2507 | { |
2508 | p[0] = r; |
2509 | p[1] = g; |
2510 | p[2] = b; |
2511 | p[3] = a; |
2512 | } |
2513 | |
2514 | void Surface3DRenderer::idToRGBA(uint id, uchar *r, uchar *g, uchar *b, uchar *a) |
2515 | { |
2516 | *r = id & ID_TO_RGBA_MASK; |
2517 | *g = (id >> 8) & ID_TO_RGBA_MASK; |
2518 | *b = (id >> 16) & ID_TO_RGBA_MASK; |
2519 | *a = (id >> 24) & ID_TO_RGBA_MASK; |
2520 | } |
2521 | |
2522 | void Surface3DRenderer::calculateSceneScalingFactors() |
2523 | { |
2524 | // Margin for background (the default 0.10 makes it 10% larger to avoid |
2525 | // selection ball being drawn inside background) |
2526 | if (m_requestedMargin < 0.0f) { |
2527 | m_hBackgroundMargin = 0.1f; |
2528 | m_vBackgroundMargin = 0.1f; |
2529 | } else { |
2530 | m_hBackgroundMargin = m_requestedMargin; |
2531 | m_vBackgroundMargin = m_requestedMargin; |
2532 | } |
2533 | if (m_polarGraph) { |
2534 | float polarMargin = calculatePolarBackgroundMargin(); |
2535 | m_hBackgroundMargin = qMax(a: m_hBackgroundMargin, b: polarMargin); |
2536 | } |
2537 | |
2538 | // Calculate scene scaling and translation factors |
2539 | m_heightNormalizer = GLfloat(m_axisCacheY.max() - m_axisCacheY.min()); |
2540 | |
2541 | float horizontalAspectRatio; |
2542 | if (m_polarGraph) |
2543 | horizontalAspectRatio = 1.0f; |
2544 | else |
2545 | horizontalAspectRatio = m_graphHorizontalAspectRatio; |
2546 | |
2547 | QSizeF areaSize; |
2548 | if (horizontalAspectRatio == 0.0f) { |
2549 | areaSize.setHeight(m_axisCacheZ.max() - m_axisCacheZ.min()); |
2550 | areaSize.setWidth(m_axisCacheX.max() - m_axisCacheX.min()); |
2551 | } else { |
2552 | areaSize.setHeight(1.0f); |
2553 | areaSize.setWidth(horizontalAspectRatio); |
2554 | } |
2555 | |
2556 | float horizontalMaxDimension; |
2557 | if (m_graphAspectRatio > 2.0f) { |
2558 | horizontalMaxDimension = 2.0f; |
2559 | m_scaleY = 2.0f / m_graphAspectRatio; |
2560 | } else { |
2561 | horizontalMaxDimension = m_graphAspectRatio; |
2562 | m_scaleY = 1.0f; |
2563 | } |
2564 | if (m_polarGraph) |
2565 | m_polarRadius = horizontalMaxDimension; |
2566 | |
2567 | float scaleFactor = qMax(a: areaSize.width(), b: areaSize.height()); |
2568 | m_scaleX = horizontalMaxDimension * areaSize.width() / scaleFactor; |
2569 | m_scaleZ = horizontalMaxDimension * areaSize.height() / scaleFactor; |
2570 | |
2571 | m_scaleXWithBackground = m_scaleX + m_hBackgroundMargin; |
2572 | m_scaleYWithBackground = m_scaleY + m_vBackgroundMargin; |
2573 | m_scaleZWithBackground = m_scaleZ + m_hBackgroundMargin; |
2574 | |
2575 | m_axisCacheX.setScale(m_scaleX * 2.0f); |
2576 | m_axisCacheY.setScale(m_scaleY * 2.0f); |
2577 | m_axisCacheZ.setScale(-m_scaleZ * 2.0f); |
2578 | m_axisCacheX.setTranslate(-m_scaleX); |
2579 | m_axisCacheY.setTranslate(-m_scaleY); |
2580 | m_axisCacheZ.setTranslate(m_scaleZ); |
2581 | |
2582 | updateCameraViewport(); |
2583 | updateCustomItemPositions(); |
2584 | } |
2585 | |
2586 | void Surface3DRenderer::checkFlatSupport(SurfaceSeriesRenderCache *cache) |
2587 | { |
2588 | bool flatEnable = cache->isFlatShadingEnabled(); |
2589 | if (flatEnable && !m_flatSupported) { |
2590 | qWarning() << "Warning: Flat qualifier not supported on your platform's GLSL language." |
2591 | " Requires at least GLSL version 1.2 with GL_EXT_gpu_shader4 extension." ; |
2592 | cache->setFlatShadingEnabled(false); |
2593 | cache->setFlatChangeAllowed(false); |
2594 | } |
2595 | } |
2596 | |
2597 | void Surface3DRenderer::updateObjects(SurfaceSeriesRenderCache *cache, bool dimensionChanged) |
2598 | { |
2599 | QSurfaceDataArray &dataArray = cache->dataArray(); |
2600 | const QRect &sampleSpace = cache->sampleSpace(); |
2601 | |
2602 | const QSurface3DSeries *currentSeries = cache->series(); |
2603 | QSurfaceDataProxy *dataProxy = currentSeries->dataProxy(); |
2604 | const QSurfaceDataArray &array = *dataProxy->array(); |
2605 | |
2606 | if (cache->isFlatShadingEnabled()) { |
2607 | cache->surfaceObject()->setUpData(dataArray, space: sampleSpace, changeGeometry: dimensionChanged, polar: m_polarGraph); |
2608 | if (cache->surfaceTexture()) |
2609 | cache->surfaceObject()->coarseUVs(dataArray: array, modelArray: dataArray); |
2610 | } else { |
2611 | cache->surfaceObject()->setUpSmoothData(dataArray, space: sampleSpace, changeGeometry: dimensionChanged, |
2612 | polar: m_polarGraph); |
2613 | if (cache->surfaceTexture()) |
2614 | cache->surfaceObject()->smoothUVs(dataArray: array, modelArray: dataArray); |
2615 | } |
2616 | } |
2617 | |
2618 | void Surface3DRenderer::updateSelectedPoint(const QPoint &position, QSurface3DSeries *series) |
2619 | { |
2620 | m_selectedPoint = position; |
2621 | m_selectedSeries = series; |
2622 | m_selectionDirty = true; |
2623 | } |
2624 | |
2625 | void Surface3DRenderer::updateFlipHorizontalGrid(bool flip) |
2626 | { |
2627 | m_flipHorizontalGrid = flip; |
2628 | } |
2629 | |
2630 | void Surface3DRenderer::resetClickedStatus() |
2631 | { |
2632 | m_clickedPosition = Surface3DController::invalidSelectionPosition(); |
2633 | m_clickedSeries = 0; |
2634 | } |
2635 | |
2636 | void Surface3DRenderer::loadBackgroundMesh() |
2637 | { |
2638 | ObjectHelper::resetObjectHelper(cacheId: this, obj&: m_backgroundObj, |
2639 | QStringLiteral(":/defaultMeshes/background" )); |
2640 | } |
2641 | |
2642 | void Surface3DRenderer::surfacePointSelected(const QPoint &point) |
2643 | { |
2644 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
2645 | SurfaceSeriesRenderCache *cache = |
2646 | static_cast<SurfaceSeriesRenderCache *>(baseCache); |
2647 | cache->setSlicePointerActivity(false); |
2648 | cache->setMainPointerActivity(false); |
2649 | } |
2650 | |
2651 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionMultiSeries)) { |
2652 | // Find axis coordinates for the selected point |
2653 | SurfaceSeriesRenderCache *selectedCache = |
2654 | static_cast<SurfaceSeriesRenderCache *>( |
2655 | m_renderCacheList.value(key: const_cast<QSurface3DSeries *>(m_selectedSeries))); |
2656 | QSurfaceDataArray &dataArray = selectedCache->dataArray(); |
2657 | QSurfaceDataItem item = dataArray.at(i: point.x())->at(i: point.y()); |
2658 | QPointF coords(item.x(), item.z()); |
2659 | |
2660 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
2661 | SurfaceSeriesRenderCache *cache = |
2662 | static_cast<SurfaceSeriesRenderCache *>(baseCache); |
2663 | if (cache->series() != m_selectedSeries) { |
2664 | QPoint mappedPoint = mapCoordsToSampleSpace(cache, coords); |
2665 | updateSelectionPoint(cache, point: mappedPoint, label: false); |
2666 | } else { |
2667 | updateSelectionPoint(cache, point, label: true); |
2668 | } |
2669 | } |
2670 | } else { |
2671 | if (m_selectedSeries) { |
2672 | SurfaceSeriesRenderCache *cache = |
2673 | static_cast<SurfaceSeriesRenderCache *>( |
2674 | m_renderCacheList.value(key: const_cast<QSurface3DSeries *>(m_selectedSeries))); |
2675 | if (cache) |
2676 | updateSelectionPoint(cache, point, label: true); |
2677 | } |
2678 | } |
2679 | } |
2680 | |
2681 | void Surface3DRenderer::updateSelectionPoint(SurfaceSeriesRenderCache *cache, const QPoint &point, |
2682 | bool label) |
2683 | { |
2684 | int row = point.x(); |
2685 | int column = point.y(); |
2686 | |
2687 | if (column < 0 || row < 0) |
2688 | return; |
2689 | |
2690 | SelectionPointer *slicePointer = cache->sliceSelectionPointer(); |
2691 | if (!slicePointer && m_cachedIsSlicingActivated) { |
2692 | slicePointer = new SelectionPointer(m_drawer); |
2693 | cache->setSliceSelectionPointer(slicePointer); |
2694 | } |
2695 | SelectionPointer *mainPointer = cache->mainSelectionPointer(); |
2696 | if (!mainPointer) { |
2697 | mainPointer = new SelectionPointer(m_drawer); |
2698 | cache->setMainSelectionPointer(mainPointer); |
2699 | } |
2700 | |
2701 | QString selectionLabel; |
2702 | if (label) { |
2703 | m_selectionLabelDirty = false; |
2704 | selectionLabel = cache->itemLabel(); |
2705 | } |
2706 | |
2707 | if (m_cachedIsSlicingActivated) { |
2708 | QVector3D subPosFront; |
2709 | QVector3D subPosBack; |
2710 | if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionRow)) { |
2711 | subPosFront = cache->sliceSurfaceObject()->vertexAt(column, row: 0); |
2712 | subPosBack = cache->sliceSurfaceObject()->vertexAt(column, row: 1); |
2713 | } else if (m_cachedSelectionMode.testFlag(flag: QAbstract3DGraph::SelectionColumn)) { |
2714 | subPosFront = cache->sliceSurfaceObject()->vertexAt(column: row, row: 0); |
2715 | subPosBack = cache->sliceSurfaceObject()->vertexAt(column: row, row: 1); |
2716 | } |
2717 | slicePointer->updateBoundingRect(rect: m_secondarySubViewport); |
2718 | slicePointer->updateSliceData(sliceActivated: true, autoScaleAdjustment: m_autoScaleAdjustment); |
2719 | slicePointer->setPosition((subPosFront + subPosBack) / 2.0f); |
2720 | slicePointer->setLabel(label: selectionLabel); |
2721 | slicePointer->setPointerObject(cache->object()); |
2722 | slicePointer->setLabelObject(m_labelObj); |
2723 | slicePointer->setHighlightColor(cache->singleHighlightColor()); |
2724 | slicePointer->updateScene(scene: m_cachedScene); |
2725 | slicePointer->setRotation(cache->meshRotation()); |
2726 | cache->setSlicePointerActivity(true); |
2727 | } |
2728 | |
2729 | QVector3D mainPos; |
2730 | mainPos = cache->surfaceObject()->vertexAt(column, row); |
2731 | mainPointer->updateBoundingRect(rect: m_primarySubViewport); |
2732 | mainPointer->updateSliceData(sliceActivated: false, autoScaleAdjustment: m_autoScaleAdjustment); |
2733 | mainPointer->setPosition(mainPos); |
2734 | mainPointer->setLabel(label: selectionLabel); |
2735 | mainPointer->setPointerObject(cache->object()); |
2736 | mainPointer->setLabelObject(m_labelObj); |
2737 | mainPointer->setHighlightColor(cache->singleHighlightColor()); |
2738 | mainPointer->updateScene(scene: m_cachedScene); |
2739 | mainPointer->setRotation(cache->meshRotation()); |
2740 | cache->setMainPointerActivity(true); |
2741 | } |
2742 | |
2743 | // Maps selection Id to surface point in data array |
2744 | QPoint Surface3DRenderer::selectionIdToSurfacePoint(uint id) |
2745 | { |
2746 | m_clickedType = QAbstract3DGraph::ElementNone; |
2747 | m_selectedLabelIndex = -1; |
2748 | m_selectedCustomItemIndex = -1; |
2749 | // Check for label and custom item selection |
2750 | if (id / alphaMultiplier == labelRowAlpha) { |
2751 | m_selectedLabelIndex = id - (alphaMultiplier * uint(labelRowAlpha)); |
2752 | m_clickedType = QAbstract3DGraph::ElementAxisZLabel; |
2753 | return Surface3DController::invalidSelectionPosition(); |
2754 | } else if (id / alphaMultiplier == labelColumnAlpha) { |
2755 | m_selectedLabelIndex = (id - (alphaMultiplier * uint(labelColumnAlpha))) / greenMultiplier; |
2756 | m_clickedType = QAbstract3DGraph::ElementAxisXLabel; |
2757 | return Surface3DController::invalidSelectionPosition(); |
2758 | } else if (id / alphaMultiplier == labelValueAlpha) { |
2759 | m_selectedLabelIndex = (id - (alphaMultiplier * uint(labelValueAlpha))) / blueMultiplier; |
2760 | m_clickedType = QAbstract3DGraph::ElementAxisYLabel; |
2761 | return Surface3DController::invalidSelectionPosition(); |
2762 | } else if (id / alphaMultiplier == customItemAlpha) { |
2763 | // Custom item selection |
2764 | m_clickedType = QAbstract3DGraph::ElementCustomItem; |
2765 | m_selectedCustomItemIndex = id - (alphaMultiplier * uint(customItemAlpha)); |
2766 | return Surface3DController::invalidSelectionPosition(); |
2767 | } |
2768 | |
2769 | // Not a label selection |
2770 | SurfaceSeriesRenderCache *selectedCache = 0; |
2771 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
2772 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
2773 | if (cache->isWithinIdRange(selection: id)) { |
2774 | selectedCache = cache; |
2775 | break; |
2776 | } |
2777 | } |
2778 | if (!selectedCache) { |
2779 | m_clickedSeries = 0; |
2780 | return Surface3DController::invalidSelectionPosition(); |
2781 | } |
2782 | |
2783 | uint idInSeries = id - selectedCache->selectionIdStart() + 1; |
2784 | const QRect &sampleSpace = selectedCache->sampleSpace(); |
2785 | int column = ((idInSeries - 1) % sampleSpace.width()) + sampleSpace.x(); |
2786 | int row = ((idInSeries - 1) / sampleSpace.width()) + sampleSpace.y(); |
2787 | |
2788 | m_clickedSeries = selectedCache->series(); |
2789 | m_clickedType = QAbstract3DGraph::ElementSeries; |
2790 | return QPoint(row, column); |
2791 | } |
2792 | |
2793 | void Surface3DRenderer::updateShadowQuality(QAbstract3DGraph::ShadowQuality quality) |
2794 | { |
2795 | m_cachedShadowQuality = quality; |
2796 | |
2797 | switch (quality) { |
2798 | case QAbstract3DGraph::ShadowQualityLow: |
2799 | m_shadowQualityToShader = 33.3f; |
2800 | m_shadowQualityMultiplier = 1; |
2801 | break; |
2802 | case QAbstract3DGraph::ShadowQualityMedium: |
2803 | m_shadowQualityToShader = 100.0f; |
2804 | m_shadowQualityMultiplier = 3; |
2805 | break; |
2806 | case QAbstract3DGraph::ShadowQualityHigh: |
2807 | m_shadowQualityToShader = 200.0f; |
2808 | m_shadowQualityMultiplier = 5; |
2809 | break; |
2810 | case QAbstract3DGraph::ShadowQualitySoftLow: |
2811 | m_shadowQualityToShader = 5.0f; |
2812 | m_shadowQualityMultiplier = 1; |
2813 | break; |
2814 | case QAbstract3DGraph::ShadowQualitySoftMedium: |
2815 | m_shadowQualityToShader = 10.0f; |
2816 | m_shadowQualityMultiplier = 3; |
2817 | break; |
2818 | case QAbstract3DGraph::ShadowQualitySoftHigh: |
2819 | m_shadowQualityToShader = 15.0f; |
2820 | m_shadowQualityMultiplier = 4; |
2821 | break; |
2822 | default: |
2823 | m_shadowQualityToShader = 0.0f; |
2824 | m_shadowQualityMultiplier = 1; |
2825 | break; |
2826 | } |
2827 | |
2828 | handleShadowQualityChange(); |
2829 | |
2830 | updateDepthBuffer(); |
2831 | } |
2832 | |
2833 | void Surface3DRenderer::updateTextures() |
2834 | { |
2835 | Abstract3DRenderer::updateTextures(); |
2836 | |
2837 | if (m_polarGraph) |
2838 | calculateSceneScalingFactors(); |
2839 | } |
2840 | |
2841 | void Surface3DRenderer::updateSlicingActive(bool isSlicing) |
2842 | { |
2843 | if (m_cachedIsSlicingActivated == isSlicing) |
2844 | return; |
2845 | |
2846 | m_cachedIsSlicingActivated = isSlicing; |
2847 | |
2848 | if (!m_cachedIsSlicingActivated) { |
2849 | // We need to re-init selection buffer in case there has been a resize |
2850 | initSelectionBuffer(); |
2851 | initCursorPositionBuffer(); |
2852 | } |
2853 | |
2854 | updateDepthBuffer(); // Re-init depth buffer as well |
2855 | |
2856 | m_selectionDirty = true; |
2857 | |
2858 | foreach (SeriesRenderCache *baseCache, m_renderCacheList) { |
2859 | SurfaceSeriesRenderCache *cache = static_cast<SurfaceSeriesRenderCache *>(baseCache); |
2860 | if (cache->mainSelectionPointer()) |
2861 | cache->mainSelectionPointer()->updateBoundingRect(rect: m_primarySubViewport); |
2862 | } |
2863 | } |
2864 | |
2865 | void Surface3DRenderer::initShaders(const QString &vertexShader, const QString &fragmentShader) |
2866 | { |
2867 | Q_UNUSED(vertexShader); |
2868 | Q_UNUSED(fragmentShader); |
2869 | |
2870 | delete m_surfaceFlatShader; |
2871 | delete m_surfaceSmoothShader; |
2872 | delete m_surfaceTexturedSmoothShader; |
2873 | delete m_surfaceTexturedFlatShader; |
2874 | delete m_surfaceSliceFlatShader; |
2875 | delete m_surfaceSliceSmoothShader; |
2876 | |
2877 | if (!m_isOpenGLES) { |
2878 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
2879 | m_surfaceSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexShadow" ), |
2880 | QStringLiteral(":/shaders/fragmentSurfaceShadowNoTex" )); |
2881 | m_surfaceTexturedSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexShadow" ), |
2882 | QStringLiteral(":/shaders/fragmentTexturedSurfaceShadow" )); |
2883 | } else { |
2884 | m_surfaceSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2885 | QStringLiteral(":/shaders/fragmentSurface" )); |
2886 | m_surfaceTexturedSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexTexture" ), |
2887 | QStringLiteral(":/shaders/fragmentTexture" )); |
2888 | } |
2889 | m_surfaceSliceSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2890 | QStringLiteral(":/shaders/fragmentSurface" )); |
2891 | if (m_flatSupported) { |
2892 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
2893 | m_surfaceFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexSurfaceShadowFlat" ), |
2894 | QStringLiteral(":/shaders/fragmentSurfaceShadowFlat" )); |
2895 | m_surfaceTexturedFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexSurfaceShadowFlat" ), |
2896 | QStringLiteral(":/shaders/fragmentTexturedSurfaceShadowFlat" )); |
2897 | } else { |
2898 | m_surfaceFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexSurfaceFlat" ), |
2899 | QStringLiteral(":/shaders/fragmentSurfaceFlat" )); |
2900 | m_surfaceTexturedFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexSurfaceFlat" ), |
2901 | QStringLiteral(":/shaders/fragmentSurfaceTexturedFlat" )); |
2902 | } |
2903 | m_surfaceSliceFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexSurfaceFlat" ), |
2904 | QStringLiteral(":/shaders/fragmentSurfaceFlat" )); |
2905 | } else { |
2906 | m_surfaceFlatShader = 0; |
2907 | m_surfaceSliceFlatShader = 0; |
2908 | m_surfaceTexturedFlatShader = 0; |
2909 | } |
2910 | } else { |
2911 | m_surfaceSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2912 | QStringLiteral(":/shaders/fragmentSurfaceES2" )); |
2913 | m_surfaceFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2914 | QStringLiteral(":/shaders/fragmentSurfaceES2" )); |
2915 | m_surfaceTexturedSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexTexture" ), |
2916 | QStringLiteral(":/shaders/fragmentTextureES2" )); |
2917 | m_surfaceTexturedFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexTexture" ), |
2918 | QStringLiteral(":/shaders/fragmentTextureES2" )); |
2919 | m_surfaceSliceSmoothShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2920 | QStringLiteral(":/shaders/fragmentSurfaceES2" )); |
2921 | m_surfaceSliceFlatShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertex" ), |
2922 | QStringLiteral(":/shaders/fragmentSurfaceES2" )); |
2923 | } |
2924 | |
2925 | m_surfaceSmoothShader->initialize(); |
2926 | m_surfaceSliceSmoothShader->initialize(); |
2927 | m_surfaceTexturedSmoothShader->initialize(); |
2928 | if (m_flatSupported) { |
2929 | m_surfaceFlatShader->initialize(); |
2930 | m_surfaceSliceFlatShader->initialize(); |
2931 | m_surfaceTexturedFlatShader->initialize(); |
2932 | } |
2933 | } |
2934 | |
2935 | void Surface3DRenderer::initBackgroundShaders(const QString &vertexShader, |
2936 | const QString &fragmentShader) |
2937 | { |
2938 | if (m_backgroundShader) |
2939 | delete m_backgroundShader; |
2940 | m_backgroundShader = new ShaderHelper(this, vertexShader, fragmentShader); |
2941 | m_backgroundShader->initialize(); |
2942 | } |
2943 | |
2944 | void Surface3DRenderer::initSelectionShaders() |
2945 | { |
2946 | if (m_selectionShader) |
2947 | delete m_selectionShader; |
2948 | m_selectionShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexLabel" ), |
2949 | QStringLiteral(":/shaders/fragmentLabel" )); |
2950 | m_selectionShader->initialize(); |
2951 | } |
2952 | |
2953 | void Surface3DRenderer::initSurfaceShaders() |
2954 | { |
2955 | // Gridline shader |
2956 | if (m_surfaceGridShader) |
2957 | delete m_surfaceGridShader; |
2958 | m_surfaceGridShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexPlainColor" ), |
2959 | QStringLiteral(":/shaders/fragmentPlainColor" )); |
2960 | m_surfaceGridShader->initialize(); |
2961 | |
2962 | // Triggers surface shader selection by shadow setting |
2963 | handleShadowQualityChange(); |
2964 | } |
2965 | |
2966 | void Surface3DRenderer::initDepthShader() |
2967 | { |
2968 | if (!m_isOpenGLES) { |
2969 | delete m_depthShader; |
2970 | m_depthShader = new ShaderHelper(this, QStringLiteral(":/shaders/vertexDepth" ), |
2971 | QStringLiteral(":/shaders/fragmentDepth" )); |
2972 | m_depthShader->initialize(); |
2973 | } |
2974 | } |
2975 | |
2976 | void Surface3DRenderer::updateDepthBuffer() |
2977 | { |
2978 | if (!m_isOpenGLES) { |
2979 | m_textureHelper->deleteTexture(texture: &m_depthTexture); |
2980 | |
2981 | if (m_primarySubViewport.size().isEmpty()) |
2982 | return; |
2983 | |
2984 | if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) { |
2985 | m_depthTexture = m_textureHelper->createDepthTextureFrameBuffer(size: m_primarySubViewport.size(), |
2986 | frameBuffer&: m_depthFrameBuffer, |
2987 | textureSize: m_shadowQualityMultiplier); |
2988 | if (!m_depthTexture) |
2989 | lowerShadowQuality(); |
2990 | } |
2991 | } |
2992 | } |
2993 | |
2994 | QVector3D Surface3DRenderer::convertPositionToTranslation(const QVector3D &position, |
2995 | bool isAbsolute) |
2996 | { |
2997 | float xTrans = 0.0f; |
2998 | float yTrans = 0.0f; |
2999 | float zTrans = 0.0f; |
3000 | if (!isAbsolute) { |
3001 | if (m_polarGraph) { |
3002 | calculatePolarXZ(dataPos: position, x&: xTrans, z&: zTrans); |
3003 | } else { |
3004 | xTrans = m_axisCacheX.positionAt(value: position.x()); |
3005 | zTrans = m_axisCacheZ.positionAt(value: position.z()); |
3006 | } |
3007 | yTrans = m_axisCacheY.positionAt(value: position.y()); |
3008 | } else { |
3009 | xTrans = position.x() * m_scaleX; |
3010 | yTrans = position.y() * m_scaleY; |
3011 | zTrans = position.z() * -m_scaleZ; |
3012 | } |
3013 | return QVector3D(xTrans, yTrans, zTrans); |
3014 | } |
3015 | |
3016 | void Surface3DRenderer::updateAxisLabels(QAbstract3DAxis::AxisOrientation orientation, |
3017 | const QStringList &labels) |
3018 | { |
3019 | Abstract3DRenderer::updateAxisLabels(orientation, labels); |
3020 | |
3021 | // Angular axis label dimensions affect the chart dimensions |
3022 | if (m_polarGraph && orientation == QAbstract3DAxis::AxisOrientationX) |
3023 | calculateSceneScalingFactors(); |
3024 | } |
3025 | |
3026 | void Surface3DRenderer::updateAxisTitleVisibility(QAbstract3DAxis::AxisOrientation orientation, bool visible) |
3027 | { |
3028 | Abstract3DRenderer::updateAxisTitleVisibility(orientation, visible); |
3029 | |
3030 | // Angular axis title existence affects the chart dimensions |
3031 | if (m_polarGraph && orientation == QAbstract3DAxis::AxisOrientationX) |
3032 | calculateSceneScalingFactors(); |
3033 | } |
3034 | |
3035 | void Surface3DRenderer::updateMargin(float margin) |
3036 | { |
3037 | Abstract3DRenderer::updateMargin(margin); |
3038 | calculateSceneScalingFactors(); |
3039 | } |
3040 | |
3041 | QT_END_NAMESPACE |
3042 | |