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 "abstract3drenderer_p.h"
7	#include "texturehelper_p.h"
8	#include "q3dcamera_p.h"
9	#include "q3dtheme_p.h"
10	#include "qvalue3daxisformatter_p.h"
11	#include "shaderhelper_p.h"
12	#include "qcustom3ditem_p.h"
13	#include "qcustom3dlabel_p.h"
14	#include "qcustom3dvolume_p.h"
15	#include "scatter3drenderer_p.h"
16
17	#include <QtCore/qmath.h>
18	#include <QtGui/QOffscreenSurface>
19	#include <QtCore/QThread>
20
21	QT_BEGIN_NAMESPACE
22
23	// Defined in shaderhelper.cpp
24	extern void discardDebugMsgs(QtMsgType type, const QMessageLogContext &context, const QString &msg);
25
26	const qreal doublePi(M_PI * 2.0);
27	const int polarGridRoundness(64);
28	const qreal polarGridAngle(doublePi / qreal(polarGridRoundness));
29	const float polarGridAngleDegrees(float(360.0 / qreal(polarGridRoundness)));
30	const qreal polarGridHalfAngle(polarGridAngle / 2.0);
31
32	Abstract3DRenderer::Abstract3DRenderer(Abstract3DController *controller)
33	: QObject(0),
34	m_hasNegativeValues(false),
35	m_cachedTheme(new Q3DTheme()),
36	m_drawer(new Drawer(m_cachedTheme)),
37	m_cachedShadowQuality(QAbstract3DGraph::ShadowQualityMedium),
38	m_autoScaleAdjustment(1.0f),
39	m_cachedSelectionMode(QAbstract3DGraph::SelectionNone),
40	m_cachedOptimizationHint(QAbstract3DGraph::OptimizationDefault),
41	m_textureHelper(0),
42	m_depthTexture(0),
43	m_cachedScene(new Q3DScene()),
44	m_selectionDirty(true),
45	m_selectionState(SelectNone),
46	m_devicePixelRatio(1.0f),
47	m_selectionLabelDirty(true),
48	m_clickResolved(false),
49	m_graphPositionQueryPending(false),
50	m_graphPositionQueryResolved(false),
51	m_clickedSeries(0),
52	m_clickedType(QAbstract3DGraph::ElementNone),
53	m_selectedLabelIndex(-1),
54	m_selectedCustomItemIndex(-1),
55	m_selectionLabelItem(0),
56	m_visibleSeriesCount(0),
57	m_customItemShader(0),
58	m_volumeTextureShader(0),
59	m_volumeTextureLowDefShader(0),
60	m_volumeTextureSliceShader(0),
61	m_volumeSliceFrameShader(0),
62	m_labelShader(0),
63	m_cursorPositionShader(0),
64	m_cursorPositionFrameBuffer(0),
65	m_cursorPositionTexture(0),
66	m_useOrthoProjection(false),
67	m_xFlipped(false),
68	m_yFlipped(false),
69	m_zFlipped(false),
70	m_yFlippedForGrid(false),
71	m_backgroundObj(0),
72	m_gridLineObj(0),
73	m_labelObj(0),
74	m_positionMapperObj(0),
75	m_graphAspectRatio(2.0f),
76	m_graphHorizontalAspectRatio(0.0f),
77	m_polarGraph(false),
78	m_radialLabelOffset(1.0f),
79	m_polarRadius(2.0f),
80	m_xRightAngleRotation(QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: 90.0f)),
81	m_yRightAngleRotation(QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: 90.0f)),
82	m_zRightAngleRotation(QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: 90.0f)),
83	m_xRightAngleRotationNeg(QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: -90.0f)),
84	m_yRightAngleRotationNeg(QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: -90.0f)),
85	m_zRightAngleRotationNeg(QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: -90.0f)),
86	m_xFlipRotation(QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: -180.0f)),
87	m_zFlipRotation(QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: -180.0f)),
88	m_requestedMargin(-1.0f),
89	m_vBackgroundMargin(0.1f),
90	m_hBackgroundMargin(0.1f),
91	m_scaleXWithBackground(0.0f),
92	m_scaleYWithBackground(0.0f),
93	m_scaleZWithBackground(0.0f),
94	m_oldCameraTarget(QVector3D(2000.0f, 2000.0f, 2000.0f)), // Just random invalid target
95	m_reflectionEnabled(false),
96	m_reflectivity(0.5),
97	#if !QT_CONFIG(opengles2)
98	m_funcs_2_1(0),
99	#endif
100	m_context(0),
101	m_isOpenGLES(true)
102
103	{
104	initializeOpenGLFunctions();
105	m_isOpenGLES = Utils::isOpenGLES();
106	#if !QT_CONFIG(opengles2)
107	if (!m_isOpenGLES) {
108	// Discard warnings about deprecated functions
109	QtMessageHandler handler = qInstallMessageHandler(discardDebugMsgs);
110
111	m_funcs_2_1 = new QOpenGLFunctions_2_1;
112	if (m_funcs_2_1)
113	m_funcs_2_1->initializeOpenGLFunctions();
114
115	// Restore original message handler
116	qInstallMessageHandler(handler);
117
118	if (!m_funcs_2_1)
119	qFatal(msg: "OpenGL version is too low, at least 2.1 is required");
120	}
121	#endif
122	QObject::connect(sender: m_drawer, signal: &Drawer::drawerChanged, context: this, slot: &Abstract3DRenderer::updateTextures);
123	QObject::connect(sender: this, signal: &Abstract3DRenderer::needRender, context: controller,
124	slot: &Abstract3DController::needRender, type: Qt::QueuedConnection);
125	QObject::connect(sender: this, signal: &Abstract3DRenderer::requestShadowQuality, context: controller,
126	slot: &Abstract3DController::handleRequestShadowQuality, type: Qt::QueuedConnection);
127	}
128
129	Abstract3DRenderer::~Abstract3DRenderer()
130	{
131	contextCleanup();
132	delete m_drawer;
133	delete m_cachedScene;
134	delete m_cachedTheme;
135	delete m_selectionLabelItem;
136	delete m_customItemShader;
137	delete m_volumeTextureShader;
138	delete m_volumeTextureLowDefShader;
139	delete m_volumeSliceFrameShader;
140	delete m_volumeTextureSliceShader;
141	delete m_labelShader;
142	delete m_cursorPositionShader;
143
144	foreach (SeriesRenderCache *cache, m_renderCacheList) {
145	cache->cleanup(texHelper: m_textureHelper);
146	delete cache;
147	}
148	m_renderCacheList.clear();
149
150	foreach (CustomRenderItem *item, m_customRenderCache) {
151	GLuint texture = item->texture();
152	m_textureHelper->deleteTexture(texture: &texture);
153	delete item;
154	}
155	m_customRenderCache.clear();
156
157	ObjectHelper::releaseObjectHelper(cacheId: this, obj&: m_backgroundObj);
158	ObjectHelper::releaseObjectHelper(cacheId: this, obj&: m_gridLineObj);
159	ObjectHelper::releaseObjectHelper(cacheId: this, obj&: m_labelObj);
160	ObjectHelper::releaseObjectHelper(cacheId: this, obj&: m_positionMapperObj);
161
162	if (m_textureHelper) {
163	m_textureHelper->deleteTexture(texture: &m_depthTexture);
164	m_textureHelper->deleteTexture(texture: &m_cursorPositionTexture);
165	delete m_textureHelper;
166	}
167
168	m_axisCacheX.clearLabels();
169	m_axisCacheY.clearLabels();
170	m_axisCacheZ.clearLabels();
171
172	#if !QT_CONFIG(opengles2)
173	delete m_funcs_2_1;
174	#endif
175	}
176
177	void Abstract3DRenderer::contextCleanup()
178	{
179	if (QOpenGLContext::currentContext())
180	m_textureHelper->glDeleteFramebuffers(n: 1, framebuffers: &m_cursorPositionFrameBuffer);
181	}
182
183	void Abstract3DRenderer::initializeOpenGL()
184	{
185	m_context = QOpenGLContext::currentContext();
186
187	// Set OpenGL features
188	glEnable(GL_DEPTH_TEST);
189	glDepthFunc(GL_LESS);
190	glEnable(GL_CULL_FACE);
191	glCullFace(GL_BACK);
192
193	#if !QT_CONFIG(opengles2)
194	if (!m_isOpenGLES) {
195	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
196	glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
197	glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
198	}
199	#endif
200
201	m_textureHelper = new TextureHelper();
202	m_drawer->initializeOpenGL();
203
204	axisCacheForOrientation(orientation: QAbstract3DAxis::AxisOrientationX).setDrawer(m_drawer);
205	axisCacheForOrientation(orientation: QAbstract3DAxis::AxisOrientationY).setDrawer(m_drawer);
206	axisCacheForOrientation(orientation: QAbstract3DAxis::AxisOrientationZ).setDrawer(m_drawer);
207
208	initLabelShaders(QStringLiteral(":/shaders/vertexLabel"),
209	QStringLiteral(":/shaders/fragmentLabel"));
210
211	initCursorPositionShaders(QStringLiteral(":/shaders/vertexPosition"),
212	QStringLiteral(":/shaders/fragmentPositionMap"));
213
214	loadLabelMesh();
215	loadPositionMapperMesh();
216
217	QObject::connect(sender: m_context.data(), signal: &QOpenGLContext::aboutToBeDestroyed,
218	context: this, slot: &Abstract3DRenderer::contextCleanup);
219	}
220
221	void Abstract3DRenderer::render(const GLuint defaultFboHandle)
222	{
223	if (defaultFboHandle) {
224	glDepthMask(flag: true);
225	glEnable(GL_DEPTH_TEST);
226	glDepthFunc(GL_LESS);
227	glEnable(GL_CULL_FACE);
228	glCullFace(GL_BACK);
229	glDisable(GL_BLEND); // For QtQuick2 blending is enabled by default, but we don't want it to be
230	}
231
232	// Clear the graph background to the theme color
233	glViewport(x: m_viewport.x(),
234	y: m_viewport.y(),
235	width: m_viewport.width(),
236	height: m_viewport.height());
237	glScissor(x: m_viewport.x(),
238	y: m_viewport.y(),
239	width: m_viewport.width(),
240	height: m_viewport.height());
241	glEnable(GL_SCISSOR_TEST);
242	QVector4D clearColor = Utils::vectorFromColor(color: m_cachedTheme->windowColor());
243	glClearColor(red: clearColor.x(), green: clearColor.y(), blue: clearColor.z(), alpha: 1.0f);
244	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
245	glDisable(GL_SCISSOR_TEST);
246	}
247
248	void Abstract3DRenderer::updateSelectionState(SelectionState state)
249	{
250	m_selectionState = state;
251	}
252
253	void Abstract3DRenderer::initGradientShaders(const QString &vertexShader,
254	const QString &fragmentShader)
255	{
256	// Do nothing by default
257	Q_UNUSED(vertexShader);
258	Q_UNUSED(fragmentShader);
259	}
260
261	void Abstract3DRenderer::initStaticSelectedItemShaders(const QString &vertexShader,
262	const QString &fragmentShader,
263	const QString &gradientVertexShader,
264	const QString &gradientFragmentShader)
265	{
266	// Do nothing by default
267	Q_UNUSED(vertexShader);
268	Q_UNUSED(fragmentShader);
269	Q_UNUSED(gradientVertexShader);
270	Q_UNUSED(gradientFragmentShader);
271	}
272
273	void Abstract3DRenderer::initCustomItemShaders(const QString &vertexShader,
274	const QString &fragmentShader)
275	{
276	delete m_customItemShader;
277	m_customItemShader = new ShaderHelper(this, vertexShader, fragmentShader);
278	m_customItemShader->initialize();
279	}
280
281	void Abstract3DRenderer::initVolumeTextureShaders(const QString &vertexShader,
282	const QString &fragmentShader,
283	const QString &fragmentLowDefShader,
284	const QString &sliceShader,
285	const QString &sliceFrameVertexShader,
286	const QString &sliceFrameShader)
287	{
288
289	delete m_volumeTextureShader;
290	m_volumeTextureShader = new ShaderHelper(this, vertexShader, fragmentShader);
291	m_volumeTextureShader->initialize();
292
293	delete m_volumeTextureLowDefShader;
294	m_volumeTextureLowDefShader = new ShaderHelper(this, vertexShader, fragmentLowDefShader);
295	m_volumeTextureLowDefShader->initialize();
296
297	delete m_volumeTextureSliceShader;
298	m_volumeTextureSliceShader = new ShaderHelper(this, vertexShader, sliceShader);
299	m_volumeTextureSliceShader->initialize();
300
301	delete m_volumeSliceFrameShader;
302	m_volumeSliceFrameShader = new ShaderHelper(this, sliceFrameVertexShader, sliceFrameShader);
303	m_volumeSliceFrameShader->initialize();
304	}
305
306	void Abstract3DRenderer::initLabelShaders(const QString &vertexShader, const QString &fragmentShader)
307	{
308	delete m_labelShader;
309	m_labelShader = new ShaderHelper(this, vertexShader, fragmentShader);
310	m_labelShader->initialize();
311	}
312
313	void Abstract3DRenderer::initCursorPositionShaders(const QString &vertexShader,
314	const QString &fragmentShader)
315	{
316	// Init the shader
317	delete m_cursorPositionShader;
318	m_cursorPositionShader = new ShaderHelper(this, vertexShader, fragmentShader);
319	m_cursorPositionShader->initialize();
320	}
321
322	void Abstract3DRenderer::initCursorPositionBuffer()
323	{
324	m_textureHelper->deleteTexture(texture: &m_cursorPositionTexture);
325	m_textureHelper->glDeleteFramebuffers(n: 1, framebuffers: &m_cursorPositionFrameBuffer);
326	m_cursorPositionFrameBuffer = 0;
327
328	if (m_primarySubViewport.size().isEmpty())
329	return;
330
331	m_cursorPositionTexture =
332	m_textureHelper->createCursorPositionTexture(size: m_primarySubViewport.size(),
333	frameBuffer&: m_cursorPositionFrameBuffer);
334	}
335
336	void Abstract3DRenderer::updateTheme(Q3DTheme *theme)
337	{
338	// Synchronize the controller theme with renderer
339	bool updateDrawer = theme->d_ptr->sync(other&: *m_cachedTheme->d_ptr);
340
341	if (updateDrawer)
342	m_drawer->setTheme(m_cachedTheme);
343	}
344
345	void Abstract3DRenderer::updateScene(Q3DScene *scene)
346	{
347	m_viewport = scene->d_ptr->glViewport();
348	m_secondarySubViewport = scene->d_ptr->glSecondarySubViewport();
349
350	if (m_primarySubViewport != scene->d_ptr->glPrimarySubViewport()) {
351	// Resize of primary subviewport means resizing shadow and selection buffers
352	m_primarySubViewport = scene->d_ptr->glPrimarySubViewport();
353	handleResize();
354	}
355
356	if (m_devicePixelRatio != scene->devicePixelRatio()) {
357	m_devicePixelRatio = scene->devicePixelRatio();
358	handleResize();
359	}
360
361	QPoint logicalPixelPosition = scene->selectionQueryPosition();
362	m_inputPosition = QPoint(logicalPixelPosition.x() * m_devicePixelRatio,
363	logicalPixelPosition.y() * m_devicePixelRatio);
364
365	QPoint logicalGraphPosition = scene->graphPositionQuery();
366	m_graphPositionQuery = QPoint(logicalGraphPosition.x() * m_devicePixelRatio,
367	logicalGraphPosition.y() * m_devicePixelRatio);
368
369	// Synchronize the renderer scene to controller scene
370	scene->d_ptr->sync(other&: *m_cachedScene->d_ptr);
371
372	updateCameraViewport();
373
374	if (Q3DScene::invalidSelectionPoint() == logicalPixelPosition) {
375	updateSelectionState(state: SelectNone);
376	} else {
377	if (scene->isSlicingActive()) {
378	if (scene->isPointInPrimarySubView(point: logicalPixelPosition))
379	updateSelectionState(state: SelectOnOverview);
380	else if (scene->isPointInSecondarySubView(point: logicalPixelPosition))
381	updateSelectionState(state: SelectOnSlice);
382	else
383	updateSelectionState(state: SelectNone);
384	} else {
385	updateSelectionState(state: SelectOnScene);
386	}
387	}
388
389	if (Q3DScene::invalidSelectionPoint() != logicalGraphPosition)
390	m_graphPositionQueryPending = true;
391
392	// Queue up another render when we have a query that needs resolving.
393	// This is needed because QtQuick scene graph can sometimes do a sync without following it up
394	// with a render.
395	if (m_graphPositionQueryPending || m_selectionState != SelectNone)
396	emit needRender();
397	}
398
399	void Abstract3DRenderer::updateTextures()
400	{
401	m_axisCacheX.updateTextures();
402	m_axisCacheY.updateTextures();
403	m_axisCacheZ.updateTextures();
404	}
405
406	void Abstract3DRenderer::reInitShaders()
407	{
408	if (!m_isOpenGLES) {
409	if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) {
410	if (m_cachedOptimizationHint.testFlag(flag: QAbstract3DGraph::OptimizationStatic)
411	&& qobject_cast<Scatter3DRenderer *>(object: this)) {
412	initGradientShaders(QStringLiteral(":/shaders/vertexShadow"),
413	QStringLiteral(":/shaders/fragmentShadow"));
414	initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertexShadow"),
415	QStringLiteral(":/shaders/fragmentShadowNoTex"),
416	QStringLiteral(":/shaders/vertexShadow"),
417	QStringLiteral(":/shaders/fragmentShadowNoTexColorOnY"));
418	initShaders(QStringLiteral(":/shaders/vertexShadowNoMatrices"),
419	QStringLiteral(":/shaders/fragmentShadowNoTex"));
420	} else {
421	initGradientShaders(QStringLiteral(":/shaders/vertexShadow"),
422	QStringLiteral(":/shaders/fragmentShadowNoTexColorOnY"));
423	initShaders(QStringLiteral(":/shaders/vertexShadow"),
424	QStringLiteral(":/shaders/fragmentShadowNoTex"));
425	}
426	initBackgroundShaders(QStringLiteral(":/shaders/vertexShadow"),
427	QStringLiteral(":/shaders/fragmentShadowNoTex"));
428	initCustomItemShaders(QStringLiteral(":/shaders/vertexShadow"),
429	QStringLiteral(":/shaders/fragmentShadow"));
430	} else {
431	if (m_cachedOptimizationHint.testFlag(flag: QAbstract3DGraph::OptimizationStatic)
432	&& qobject_cast<Scatter3DRenderer *>(object: this)) {
433	initGradientShaders(QStringLiteral(":/shaders/vertexTexture"),
434	QStringLiteral(":/shaders/fragmentTexture"));
435	initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertex"),
436	QStringLiteral(":/shaders/fragment"),
437	QStringLiteral(":/shaders/vertex"),
438	QStringLiteral(":/shaders/fragmentColorOnY"));
439	initShaders(QStringLiteral(":/shaders/vertexNoMatrices"),
440	QStringLiteral(":/shaders/fragment"));
441	} else {
442	initGradientShaders(QStringLiteral(":/shaders/vertex"),
443	QStringLiteral(":/shaders/fragmentColorOnY"));
444	initShaders(QStringLiteral(":/shaders/vertex"),
445	QStringLiteral(":/shaders/fragment"));
446	}
447	initBackgroundShaders(QStringLiteral(":/shaders/vertex"),
448	QStringLiteral(":/shaders/fragment"));
449	initCustomItemShaders(QStringLiteral(":/shaders/vertexTexture"),
450	QStringLiteral(":/shaders/fragmentTexture"));
451	}
452	initVolumeTextureShaders(QStringLiteral(":/shaders/vertexTexture3D"),
453	QStringLiteral(":/shaders/fragmentTexture3D"),
454	QStringLiteral(":/shaders/fragmentTexture3DLowDef"),
455	QStringLiteral(":/shaders/fragmentTexture3DSlice"),
456	QStringLiteral(":/shaders/vertexPosition"),
457	QStringLiteral(":/shaders/fragment3DSliceFrames"));
458	} else {
459	if (m_cachedOptimizationHint.testFlag(flag: QAbstract3DGraph::OptimizationStatic)
460	&& qobject_cast<Scatter3DRenderer *>(object: this)) {
461	initGradientShaders(QStringLiteral(":/shaders/vertexTexture"),
462	QStringLiteral(":/shaders/fragmentTextureES2"));
463	initStaticSelectedItemShaders(QStringLiteral(":/shaders/vertex"),
464	QStringLiteral(":/shaders/fragmentES2"),
465	QStringLiteral(":/shaders/vertex"),
466	QStringLiteral(":/shaders/fragmentColorOnYES2"));
467	initShaders(QStringLiteral(":/shaders/vertexNoMatrices"),
468	QStringLiteral(":/shaders/fragmentES2"));
469	} else {
470	initGradientShaders(QStringLiteral(":/shaders/vertex"),
471	QStringLiteral(":/shaders/fragmentColorOnYES2"));
472	initShaders(QStringLiteral(":/shaders/vertex"),
473	QStringLiteral(":/shaders/fragmentES2"));
474	}
475	initBackgroundShaders(QStringLiteral(":/shaders/vertex"),
476	QStringLiteral(":/shaders/fragmentES2"));
477	initCustomItemShaders(QStringLiteral(":/shaders/vertexTexture"),
478	QStringLiteral(":/shaders/fragmentTextureES2"));
479	}
480	}
481
482	void Abstract3DRenderer::handleShadowQualityChange()
483	{
484	reInitShaders();
485
486	if (m_cachedScene->activeLight()->isAutoPosition()
487	|| m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) {
488	m_cachedScene->d_ptr->setLightPositionRelativeToCamera(relativePosition: defaultLightPos);
489	emit needRender();
490	}
491	if (m_isOpenGLES && m_cachedShadowQuality != QAbstract3DGraph::ShadowQualityNone) {
492	emit requestShadowQuality(quality: QAbstract3DGraph::ShadowQualityNone);
493	qWarning(msg: "Shadows are not yet supported for OpenGL ES2");
494	m_cachedShadowQuality = QAbstract3DGraph::ShadowQualityNone;
495	}
496	}
497
498	void Abstract3DRenderer::updateSelectionMode(QAbstract3DGraph::SelectionFlags mode)
499	{
500	m_cachedSelectionMode = mode;
501	m_selectionDirty = true;
502	}
503
504	void Abstract3DRenderer::updateAspectRatio(float ratio)
505	{
506	m_graphAspectRatio = ratio;
507	foreach (SeriesRenderCache *cache, m_renderCacheList)
508	cache->setDataDirty(true);
509	}
510
511	void Abstract3DRenderer::updateHorizontalAspectRatio(float ratio)
512	{
513	m_graphHorizontalAspectRatio = ratio;
514	foreach (SeriesRenderCache *cache, m_renderCacheList)
515	cache->setDataDirty(true);
516	}
517
518	void Abstract3DRenderer::updatePolar(bool enable)
519	{
520	m_polarGraph = enable;
521	foreach (SeriesRenderCache *cache, m_renderCacheList)
522	cache->setDataDirty(true);
523	}
524
525	void Abstract3DRenderer::updateRadialLabelOffset(float offset)
526	{
527	m_radialLabelOffset = offset;
528	}
529
530	void Abstract3DRenderer::updateMargin(float margin)
531	{
532	m_requestedMargin = margin;
533	}
534
535	void Abstract3DRenderer::updateOptimizationHint(QAbstract3DGraph::OptimizationHints hint)
536	{
537	m_cachedOptimizationHint = hint;
538	foreach (SeriesRenderCache *cache, m_renderCacheList)
539	cache->setDataDirty(true);
540	}
541
542	void Abstract3DRenderer::handleResize()
543	{
544	if (m_primarySubViewport.width() == 0 || m_primarySubViewport.height() == 0)
545	return;
546
547	// Recalculate zoom
548	calculateZoomLevel();
549
550	// Re-init selection buffer
551	initSelectionBuffer();
552
553	// Re-init depth buffer
554	updateDepthBuffer();
555
556	initCursorPositionBuffer();
557	}
558
559	void Abstract3DRenderer::calculateZoomLevel()
560	{
561	// Calculate zoom level based on aspect ratio
562	GLfloat div;
563	GLfloat zoomAdjustment;
564	div = qMin(a: m_primarySubViewport.width(), b: m_primarySubViewport.height());
565	zoomAdjustment = defaultRatio
566	* ((m_primarySubViewport.width() / div)
567	/ (m_primarySubViewport.height() / div));
568	m_autoScaleAdjustment = qMin(a: zoomAdjustment, b: 1.0f); // clamp to 1.0f
569	}
570
571	void Abstract3DRenderer::updateAxisType(QAbstract3DAxis::AxisOrientation orientation,
572	QAbstract3DAxis::AxisType type)
573	{
574	axisCacheForOrientation(orientation).setType(type);
575	}
576
577	void Abstract3DRenderer::updateAxisTitle(QAbstract3DAxis::AxisOrientation orientation,
578	const QString &title)
579	{
580	axisCacheForOrientation(orientation).setTitle(title);
581	}
582
583	void Abstract3DRenderer::updateAxisLabels(QAbstract3DAxis::AxisOrientation orientation,
584	const QStringList &labels)
585	{
586	axisCacheForOrientation(orientation).setLabels(labels);
587	}
588
589	void Abstract3DRenderer::updateAxisRange(QAbstract3DAxis::AxisOrientation orientation,
590	float min, float max)
591	{
592	AxisRenderCache &cache = axisCacheForOrientation(orientation);
593	cache.setMin(min);
594	cache.setMax(max);
595
596	foreach (SeriesRenderCache *cache, m_renderCacheList)
597	cache->setDataDirty(true);
598	}
599
600	void Abstract3DRenderer::updateAxisSegmentCount(QAbstract3DAxis::AxisOrientation orientation,
601	int count)
602	{
603	AxisRenderCache &cache = axisCacheForOrientation(orientation);
604	cache.setSegmentCount(count);
605	}
606
607	void Abstract3DRenderer::updateAxisSubSegmentCount(QAbstract3DAxis::AxisOrientation orientation,
608	int count)
609	{
610	AxisRenderCache &cache = axisCacheForOrientation(orientation);
611	cache.setSubSegmentCount(count);
612	}
613
614	void Abstract3DRenderer::updateAxisLabelFormat(QAbstract3DAxis::AxisOrientation orientation,
615	const QString &format)
616	{
617	axisCacheForOrientation(orientation).setLabelFormat(format);
618	}
619
620	void Abstract3DRenderer::updateAxisReversed(QAbstract3DAxis::AxisOrientation orientation,
621	bool enable)
622	{
623	axisCacheForOrientation(orientation).setReversed(enable);
624	foreach (SeriesRenderCache *cache, m_renderCacheList)
625	cache->setDataDirty(true);
626	}
627
628	void Abstract3DRenderer::updateAxisFormatter(QAbstract3DAxis::AxisOrientation orientation,
629	QValue3DAxisFormatter *formatter)
630	{
631	AxisRenderCache &cache = axisCacheForOrientation(orientation);
632	if (cache.ctrlFormatter() != formatter) {
633	delete cache.formatter();
634	cache.setFormatter(formatter->createNewInstance());
635	cache.setCtrlFormatter(formatter);
636	}
637	formatter->d_ptr->populateCopy(copy&: *(cache.formatter()));
638	cache.markPositionsDirty();
639
640	foreach (SeriesRenderCache *cache, m_renderCacheList)
641	cache->setDataDirty(true);
642	}
643
644	void Abstract3DRenderer::updateAxisLabelAutoRotation(QAbstract3DAxis::AxisOrientation orientation,
645	float angle)
646	{
647	AxisRenderCache &cache = axisCacheForOrientation(orientation);
648	if (cache.labelAutoRotation() != angle)
649	cache.setLabelAutoRotation(angle);
650	}
651
652	void Abstract3DRenderer::updateAxisTitleVisibility(QAbstract3DAxis::AxisOrientation orientation,
653	bool visible)
654	{
655	AxisRenderCache &cache = axisCacheForOrientation(orientation);
656	if (cache.isTitleVisible() != visible)
657	cache.setTitleVisible(visible);
658	}
659
660	void Abstract3DRenderer::updateAxisTitleFixed(QAbstract3DAxis::AxisOrientation orientation,
661	bool fixed)
662	{
663	AxisRenderCache &cache = axisCacheForOrientation(orientation);
664	if (cache.isTitleFixed() != fixed)
665	cache.setTitleFixed(fixed);
666	}
667
668	void Abstract3DRenderer::modifiedSeriesList(const QList<QAbstract3DSeries *> &seriesList)
669	{
670	foreach (QAbstract3DSeries *series, seriesList) {
671	SeriesRenderCache *cache = m_renderCacheList.value(key: series, defaultValue: 0);
672	if (cache)
673	cache->setDataDirty(true);
674	}
675	}
676
677	void Abstract3DRenderer::fixMeshFileName(QString &fileName, QAbstract3DSeries::Mesh mesh)
678	{
679	// Default implementation does nothing.
680	Q_UNUSED(fileName);
681	Q_UNUSED(mesh);
682	}
683
684	void Abstract3DRenderer::updateSeries(const QList<QAbstract3DSeries *> &seriesList)
685	{
686	foreach (SeriesRenderCache *cache, m_renderCacheList)
687	cache->setValid(false);
688
689	m_visibleSeriesCount = 0;
690	int seriesCount = seriesList.size();
691	for (int i = 0; i < seriesCount; i++) {
692	QAbstract3DSeries *series = seriesList.at(i);
693	SeriesRenderCache *cache = m_renderCacheList.value(key: series);
694	bool newSeries = false;
695	if (!cache) {
696	cache = createNewCache(series);
697	m_renderCacheList[series] = cache;
698	newSeries = true;
699	}
700	cache->setValid(true);
701	cache->populate(newSeries);
702	if (cache->isVisible())
703	m_visibleSeriesCount++;
704	}
705
706	// Remove non-valid objects from the cache list
707	foreach (SeriesRenderCache *cache, m_renderCacheList) {
708	if (!cache->isValid())
709	cleanCache(cache);
710	}
711	}
712
713	void Abstract3DRenderer::updateCustomData(const QList<QCustom3DItem *> &customItems)
714	{
715	if (customItems.isEmpty() && m_customRenderCache.isEmpty())
716	return;
717
718	foreach (CustomRenderItem *item, m_customRenderCache)
719	item->setValid(false);
720
721	int itemCount = customItems.size();
722	// Check custom item list for items that are not yet in render item cache
723	for (int i = 0; i < itemCount; i++) {
724	QCustom3DItem *item = customItems.at(i);
725	CustomRenderItem *renderItem = m_customRenderCache.value(key: item);
726	if (!renderItem)
727	renderItem = addCustomItem(item);
728	if (renderItem) {
729	renderItem->setValid(true);
730	renderItem->setIndex(i); // always update index, as it must match the custom item index
731	}
732	}
733
734	// Check render item cache and remove items that are not in customItems list anymore
735	foreach (CustomRenderItem *renderItem, m_customRenderCache) {
736	if (!renderItem->isValid()) {
737	m_customRenderCache.remove(key: renderItem->itemPointer());
738	GLuint texture = renderItem->texture();
739	m_textureHelper->deleteTexture(texture: &texture);
740	delete renderItem;
741	}
742	}
743
744	m_customItemDrawOrder.clear();
745	m_customItemDrawOrder = QList<QCustom3DItem *>(customItems);
746	}
747
748	void Abstract3DRenderer::updateCustomItems()
749	{
750	// Check all items
751	foreach (CustomRenderItem *item, m_customRenderCache)
752	updateCustomItem(renderItem: item);
753	}
754
755	SeriesRenderCache *Abstract3DRenderer::createNewCache(QAbstract3DSeries *series)
756	{
757	return new SeriesRenderCache(series, this);
758	}
759
760	void Abstract3DRenderer::cleanCache(SeriesRenderCache *cache)
761	{
762	m_renderCacheList.remove(key: cache->series());
763	cache->cleanup(texHelper: m_textureHelper);
764	delete cache;
765	}
766
767	AxisRenderCache &Abstract3DRenderer::axisCacheForOrientation(
768	QAbstract3DAxis::AxisOrientation orientation)
769	{
770	switch (orientation) {
771	case QAbstract3DAxis::AxisOrientationX:
772	return m_axisCacheX;
773	case QAbstract3DAxis::AxisOrientationY:
774	return m_axisCacheY;
775	case QAbstract3DAxis::AxisOrientationZ:
776	return m_axisCacheZ;
777	default:
778	qFatal(msg: "Abstract3DRenderer::axisCacheForOrientation");
779	return m_axisCacheX;
780	}
781	}
782
783	void Abstract3DRenderer::lowerShadowQuality()
784	{
785	QAbstract3DGraph::ShadowQuality newQuality = QAbstract3DGraph::ShadowQualityNone;
786
787	switch (m_cachedShadowQuality) {
788	case QAbstract3DGraph::ShadowQualityHigh:
789	qWarning(msg: "Creating high quality shadows failed. Changing to medium quality.");
790	newQuality = QAbstract3DGraph::ShadowQualityMedium;
791	break;
792	case QAbstract3DGraph::ShadowQualityMedium:
793	qWarning(msg: "Creating medium quality shadows failed. Changing to low quality.");
794	newQuality = QAbstract3DGraph::ShadowQualityLow;
795	break;
796	case QAbstract3DGraph::ShadowQualityLow:
797	qWarning(msg: "Creating low quality shadows failed. Switching shadows off.");
798	newQuality = QAbstract3DGraph::ShadowQualityNone;
799	break;
800	case QAbstract3DGraph::ShadowQualitySoftHigh:
801	qWarning(msg: "Creating soft high quality shadows failed. Changing to soft medium quality.");
802	newQuality = QAbstract3DGraph::ShadowQualitySoftMedium;
803	break;
804	case QAbstract3DGraph::ShadowQualitySoftMedium:
805	qWarning(msg: "Creating soft medium quality shadows failed. Changing to soft low quality.");
806	newQuality = QAbstract3DGraph::ShadowQualitySoftLow;
807	break;
808	case QAbstract3DGraph::ShadowQualitySoftLow:
809	qWarning(msg: "Creating soft low quality shadows failed. Switching shadows off.");
810	newQuality = QAbstract3DGraph::ShadowQualityNone;
811	break;
812	default:
813	// You'll never get here
814	break;
815	}
816
817	emit requestShadowQuality(quality: newQuality);
818	updateShadowQuality(quality: newQuality);
819	}
820
821	void Abstract3DRenderer::drawAxisTitleY(const QVector3D &sideLabelRotation,
822	const QVector3D &backLabelRotation,
823	const QVector3D &sideLabelTrans,
824	const QVector3D &backLabelTrans,
825	const QQuaternion &totalSideRotation,
826	const QQuaternion &totalBackRotation,
827	AbstractRenderItem &dummyItem,
828	const Q3DCamera *activeCamera,
829	float labelsMaxWidth,
830	const QMatrix4x4 &viewMatrix,
831	const QMatrix4x4 &projectionMatrix,
832	ShaderHelper *shader)
833	{
834	float scaleFactor = m_drawer->scaledFontSize() / m_axisCacheY.titleItem().size().height();
835	float titleOffset = 2.0f * (labelMargin + (labelsMaxWidth * scaleFactor));
836	float yRotation;
837	QVector3D titleTrans;
838	QQuaternion totalRotation;
839	if (m_xFlipped == m_zFlipped) {
840	yRotation = backLabelRotation.y();
841	titleTrans = backLabelTrans;
842	totalRotation = totalBackRotation;
843	} else {
844	yRotation = sideLabelRotation.y();
845	titleTrans = sideLabelTrans;
846	totalRotation = totalSideRotation;
847	}
848
849	QQuaternion offsetRotator = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: yRotation);
850	QVector3D titleOffsetVector =
851	offsetRotator.rotatedVector(vector: QVector3D(-titleOffset, 0.0f, 0.0f));
852
853	QQuaternion titleRotation;
854	if (m_axisCacheY.isTitleFixed()) {
855	titleRotation = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: yRotation)
856	* m_zRightAngleRotation;
857	} else {
858	titleRotation = totalRotation * m_zRightAngleRotation;
859	}
860	dummyItem.setTranslation(titleTrans + titleOffsetVector);
861
862	m_drawer->drawLabel(item: dummyItem, labelItem: m_axisCacheY.titleItem(), viewmatrix: viewMatrix,
863	projectionmatrix: projectionMatrix, positionComp: zeroVector, rotation: titleRotation, itemHeight: 0,
864	mode: m_cachedSelectionMode, shader, object: m_labelObj, camera: activeCamera,
865	useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment: Qt::AlignBottom);
866	}
867
868	void Abstract3DRenderer::drawAxisTitleX(const QVector3D &labelRotation,
869	const QVector3D &labelTrans,
870	const QQuaternion &totalRotation,
871	AbstractRenderItem &dummyItem,
872	const Q3DCamera *activeCamera,
873	float labelsMaxWidth,
874	const QMatrix4x4 &viewMatrix,
875	const QMatrix4x4 &projectionMatrix,
876	ShaderHelper *shader,
877	bool radial)
878	{
879	float scaleFactor = m_drawer->scaledFontSize() / m_axisCacheX.titleItem().size().height();
880	float titleOffset;
881	if (radial)
882	titleOffset = -2.0f * (labelMargin + m_drawer->scaledFontSize());
883	else
884	titleOffset = 2.0f * (labelMargin + (labelsMaxWidth * scaleFactor));
885	float zRotation = 0.0f;
886	float yRotation = 0.0f;
887	float xRotation = -90.0f + labelRotation.z();
888	float offsetRotation = labelRotation.z();
889	float extraRotation = -90.0f;
890	Qt::AlignmentFlag alignment = Qt::AlignTop;
891	if (m_yFlippedForGrid) {
892	alignment = Qt::AlignBottom;
893	zRotation = 180.0f;
894	if (m_zFlipped) {
895	titleOffset = -titleOffset;
896	if (m_xFlipped) {
897	offsetRotation = -offsetRotation;
898	extraRotation = -extraRotation;
899	} else {
900	xRotation = -90.0f - labelRotation.z();
901	}
902	} else {
903	yRotation = 180.0f;
904	if (m_xFlipped) {
905	offsetRotation = -offsetRotation;
906	xRotation = -90.0f - labelRotation.z();
907	} else {
908	extraRotation = -extraRotation;
909	}
910	}
911	} else {
912	if (m_zFlipped) {
913	titleOffset = -titleOffset;
914	if (m_xFlipped) {
915	yRotation = 180.0f;
916	offsetRotation = -offsetRotation;
917	} else {
918	yRotation = 180.0f;
919	xRotation = -90.0f - labelRotation.z();
920	extraRotation = -extraRotation;
921	}
922	if (m_yFlipped) {
923	alignment = Qt::AlignBottom;
924	extraRotation = -extraRotation;
925	if (m_xFlipped)
926	xRotation = 90.0f + labelRotation.z();
927	else
928	xRotation = 90.0f - labelRotation.z();
929	}
930	} else {
931	if (m_xFlipped) {
932	offsetRotation = -offsetRotation;
933	xRotation = -90.0f - labelRotation.z();
934	extraRotation = -extraRotation;
935	}
936	if (m_yFlipped) {
937	xRotation = 90.0f + labelRotation.z();
938	alignment = Qt::AlignBottom;
939	extraRotation = -extraRotation;
940	if (m_xFlipped)
941	xRotation = 90.0f - labelRotation.z();
942	}
943	}
944	}
945
946	if (radial) {
947	if (m_zFlipped) {
948	titleOffset = -titleOffset;
949	} else {
950	if (m_yFlippedForGrid)
951	alignment = Qt::AlignTop;
952	else
953	alignment = Qt::AlignBottom;
954	}
955	}
956
957	if (offsetRotation == 180.0f || offsetRotation == -180.0f)
958	offsetRotation = 0.0f;
959	QQuaternion offsetRotator = QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: offsetRotation);
960	QVector3D titleOffsetVector =
961	offsetRotator.rotatedVector(vector: QVector3D(0.0f, 0.0f, titleOffset));
962
963	QQuaternion titleRotation;
964	if (m_axisCacheX.isTitleFixed()) {
965	titleRotation = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: zRotation)
966	* QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: yRotation)
967	* QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: xRotation);
968	} else {
969	titleRotation = totalRotation
970	* QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: extraRotation);
971	}
972	dummyItem.setTranslation(labelTrans + titleOffsetVector);
973
974	m_drawer->drawLabel(item: dummyItem, labelItem: m_axisCacheX.titleItem(), viewmatrix: viewMatrix,
975	projectionmatrix: projectionMatrix, positionComp: zeroVector, rotation: titleRotation, itemHeight: 0,
976	mode: m_cachedSelectionMode, shader, object: m_labelObj, camera: activeCamera,
977	useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment);
978	}
979
980	void Abstract3DRenderer::drawAxisTitleZ(const QVector3D &labelRotation,
981	const QVector3D &labelTrans,
982	const QQuaternion &totalRotation,
983	AbstractRenderItem &dummyItem,
984	const Q3DCamera *activeCamera,
985	float labelsMaxWidth,
986	const QMatrix4x4 &viewMatrix,
987	const QMatrix4x4 &projectionMatrix,
988	ShaderHelper *shader)
989	{
990	float scaleFactor = m_drawer->scaledFontSize() / m_axisCacheZ.titleItem().size().height();
991	float titleOffset = 2.0f * (labelMargin + (labelsMaxWidth * scaleFactor));
992	float zRotation = labelRotation.z();
993	float yRotation = -90.0f;
994	float xRotation = -90.0f;
995	float extraRotation = 90.0f;
996	Qt::AlignmentFlag alignment = Qt::AlignTop;
997	if (m_yFlippedForGrid) {
998	alignment = Qt::AlignBottom;
999	xRotation = -xRotation;
1000	if (m_zFlipped) {
1001	if (m_xFlipped) {
1002	titleOffset = -titleOffset;
1003	zRotation = -zRotation;
1004	extraRotation = -extraRotation;
1005	} else {
1006	zRotation = -zRotation;
1007	yRotation = -yRotation;
1008	}
1009	} else {
1010	if (m_xFlipped) {
1011	titleOffset = -titleOffset;
1012	} else {
1013	extraRotation = -extraRotation;
1014	yRotation = -yRotation;
1015	}
1016	}
1017	} else {
1018	if (m_zFlipped) {
1019	zRotation = -zRotation;
1020	if (m_xFlipped) {
1021	titleOffset = -titleOffset;
1022	} else {
1023	extraRotation = -extraRotation;
1024	yRotation = -yRotation;
1025	}
1026	} else {
1027	if (m_xFlipped) {
1028	titleOffset = -titleOffset;
1029	extraRotation = -extraRotation;
1030	} else {
1031	yRotation = -yRotation;
1032	}
1033	}
1034	if (m_yFlipped) {
1035	xRotation = -xRotation;
1036	alignment = Qt::AlignBottom;
1037	extraRotation = -extraRotation;
1038	}
1039	}
1040
1041	float offsetRotation = zRotation;
1042	if (offsetRotation == 180.0f || offsetRotation == -180.0f)
1043	offsetRotation = 0.0f;
1044	QQuaternion offsetRotator = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: offsetRotation);
1045	QVector3D titleOffsetVector =
1046	offsetRotator.rotatedVector(vector: QVector3D(titleOffset, 0.0f, 0.0f));
1047
1048	QQuaternion titleRotation;
1049	if (m_axisCacheZ.isTitleFixed()) {
1050	titleRotation = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: zRotation)
1051	* QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: yRotation)
1052	* QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: xRotation);
1053	} else {
1054	titleRotation = totalRotation
1055	* QQuaternion::fromAxisAndAngle(x: 0.0f, y: 0.0f, z: 1.0f, angle: extraRotation);
1056	}
1057	dummyItem.setTranslation(labelTrans + titleOffsetVector);
1058
1059	m_drawer->drawLabel(item: dummyItem, labelItem: m_axisCacheZ.titleItem(), viewmatrix: viewMatrix,
1060	projectionmatrix: projectionMatrix, positionComp: zeroVector, rotation: titleRotation, itemHeight: 0,
1061	mode: m_cachedSelectionMode, shader, object: m_labelObj, camera: activeCamera,
1062	useDepth: true, rotateAlong: true, position: Drawer::LabelMid, alignment);
1063	}
1064
1065	void Abstract3DRenderer::loadGridLineMesh()
1066	{
1067	ObjectHelper::resetObjectHelper(cacheId: this, obj&: m_gridLineObj,
1068	QStringLiteral(":/defaultMeshes/plane"));
1069	}
1070
1071	void Abstract3DRenderer::loadLabelMesh()
1072	{
1073	ObjectHelper::resetObjectHelper(cacheId: this, obj&: m_labelObj,
1074	QStringLiteral(":/defaultMeshes/plane"));
1075	}
1076
1077	void Abstract3DRenderer::loadPositionMapperMesh()
1078	{
1079	ObjectHelper::resetObjectHelper(cacheId: this, obj&: m_positionMapperObj,
1080	QStringLiteral(":/defaultMeshes/barFull"));
1081	}
1082
1083	void Abstract3DRenderer::generateBaseColorTexture(const QColor &color, GLuint *texture)
1084	{
1085	m_textureHelper->deleteTexture(texture);
1086	*texture = m_textureHelper->createUniformTexture(color);
1087	}
1088
1089	void Abstract3DRenderer::fixGradientAndGenerateTexture(QLinearGradient *gradient,
1090	GLuint *gradientTexture)
1091	{
1092	// Readjust start/stop to match gradient texture size
1093	gradient->setStart(x: qreal(gradientTextureWidth), y: qreal(gradientTextureHeight));
1094	gradient->setFinalStop(x: 0.0, y: 0.0);
1095
1096	m_textureHelper->deleteTexture(texture: gradientTexture);
1097
1098	*gradientTexture = m_textureHelper->createGradientTexture(gradient: *gradient);
1099	}
1100
1101	LabelItem &Abstract3DRenderer::selectionLabelItem()
1102	{
1103	if (!m_selectionLabelItem)
1104	m_selectionLabelItem = new LabelItem;
1105	return *m_selectionLabelItem;
1106	}
1107
1108	void Abstract3DRenderer::setSelectionLabel(const QString &label)
1109	{
1110	if (m_selectionLabelItem)
1111	m_selectionLabelItem->clear();
1112	m_selectionLabel = label;
1113	}
1114
1115	QString &Abstract3DRenderer::selectionLabel()
1116	{
1117	return m_selectionLabel;
1118	}
1119
1120	QVector4D Abstract3DRenderer::indexToSelectionColor(GLint index)
1121	{
1122	GLubyte idxRed = index & 0xff;
1123	GLubyte idxGreen = (index & 0xff00) >> 8;
1124	GLubyte idxBlue = (index & 0xff0000) >> 16;
1125
1126	return QVector4D(idxRed, idxGreen, idxBlue, 0);
1127	}
1128
1129	CustomRenderItem *Abstract3DRenderer::addCustomItem(QCustom3DItem *item)
1130	{
1131	CustomRenderItem *newItem = new CustomRenderItem();
1132	newItem->setRenderer(this);
1133	newItem->setItemPointer(item); // Store pointer for render item updates
1134	if (!newItem->setMesh(item->meshFile())) {
1135	delete newItem;
1136	return nullptr;
1137	}
1138	newItem->setOrigPosition(item->position());
1139	newItem->setOrigScaling(item->scaling());
1140	newItem->setScalingAbsolute(item->isScalingAbsolute());
1141	newItem->setPositionAbsolute(item->isPositionAbsolute());
1142	QImage textureImage = item->d_ptr->textureImage();
1143	bool facingCamera = false;
1144	GLuint texture = 0;
1145	if (item->d_ptr->m_isLabelItem) {
1146	QCustom3DLabel *labelItem = static_cast<QCustom3DLabel *>(item);
1147	newItem->setLabelItem(true);
1148	float pointSize = labelItem->font().pointSizeF();
1149	// Check do we have custom visuals or need to use theme
1150	if (!labelItem->dptr()->m_customVisuals) {
1151	// Recreate texture using theme
1152	labelItem->dptr()->createTextureImage(bgrColor: m_cachedTheme->labelBackgroundColor(),
1153	txtColor: m_cachedTheme->labelTextColor(),
1154	background: m_cachedTheme->isLabelBackgroundEnabled(),
1155	borders: m_cachedTheme->isLabelBorderEnabled());
1156	pointSize = m_cachedTheme->font().pointSizeF();
1157	textureImage = item->d_ptr->textureImage();
1158	}
1159	// Calculate scaling based on text (texture size), font size and asked scaling
1160	float scaledFontSize = (0.05f + pointSize / 500.0f) / float(textureImage.height());
1161	QVector3D scaling = newItem->origScaling();
1162	scaling.setX(scaling.x() * textureImage.width() * scaledFontSize);
1163	scaling.setY(scaling.y() * textureImage.height() * scaledFontSize);
1164	newItem->setOrigScaling(scaling);
1165	// Check if facing camera
1166	facingCamera = labelItem->isFacingCamera();
1167	} else if (item->d_ptr->m_isVolumeItem && !m_isOpenGLES) {
1168	QCustom3DVolume *volumeItem = static_cast<QCustom3DVolume *>(item);
1169	newItem->setTextureWidth(volumeItem->textureWidth());
1170	newItem->setTextureHeight(volumeItem->textureHeight());
1171	newItem->setTextureDepth(volumeItem->textureDepth());
1172	if (volumeItem->textureFormat() == QImage::Format_Indexed8)
1173	newItem->setColorTable(volumeItem->colorTable());
1174	newItem->setTextureFormat(volumeItem->textureFormat());
1175	newItem->setVolume(true);
1176	newItem->setBlendNeeded(true);
1177	texture = m_textureHelper->create3DTexture(data: volumeItem->textureData(),
1178	width: volumeItem->textureWidth(),
1179	height: volumeItem->textureHeight(),
1180	depth: volumeItem->textureDepth(),
1181	dataFormat: volumeItem->textureFormat());
1182	newItem->setSliceIndexX(volumeItem->sliceIndexX());
1183	newItem->setSliceIndexY(volumeItem->sliceIndexY());
1184	newItem->setSliceIndexZ(volumeItem->sliceIndexZ());
1185	newItem->setAlphaMultiplier(volumeItem->alphaMultiplier());
1186	newItem->setPreserveOpacity(volumeItem->preserveOpacity());
1187	newItem->setUseHighDefShader(volumeItem->useHighDefShader());
1188
1189	newItem->setDrawSlices(volumeItem->drawSlices());
1190	newItem->setDrawSliceFrames(volumeItem->drawSliceFrames());
1191	newItem->setSliceFrameColor(volumeItem->sliceFrameColor());
1192	newItem->setSliceFrameWidths(volumeItem->sliceFrameWidths());
1193	newItem->setSliceFrameGaps(volumeItem->sliceFrameGaps());
1194	newItem->setSliceFrameThicknesses(volumeItem->sliceFrameThicknesses());
1195	}
1196	recalculateCustomItemScalingAndPos(item: newItem);
1197	newItem->setRotation(item->rotation());
1198
1199	// In OpenGL ES we simply draw volumes as regular custom item placeholders.
1200	if (!item->d_ptr->m_isVolumeItem || m_isOpenGLES)
1201	{
1202	newItem->setBlendNeeded(textureImage.hasAlphaChannel());
1203	texture = m_textureHelper->create2DTexture(image: textureImage, useTrilinearFiltering: true, convert: true, smoothScale: true);
1204	}
1205	newItem->setTexture(texture);
1206	item->d_ptr->clearTextureImage();
1207	newItem->setVisible(item->isVisible());
1208	newItem->setShadowCasting(item->isShadowCasting());
1209	newItem->setFacingCamera(facingCamera);
1210	m_customRenderCache.insert(key: item, value: newItem);
1211	return newItem;
1212	}
1213
1214	void Abstract3DRenderer::recalculateCustomItemScalingAndPos(CustomRenderItem *item)
1215	{
1216	if (!m_polarGraph && !item->isLabel() && !item->isScalingAbsolute()
1217	&& !item->isPositionAbsolute()) {
1218	QVector3D scale = item->origScaling() / 2.0f;
1219	QVector3D pos = item->origPosition();
1220	QVector3D minBounds(pos.x() - scale.x(),
1221	pos.y() - scale.y(),
1222	pos.z() + scale.z());
1223	QVector3D maxBounds(pos.x() + scale.x(),
1224	pos.y() + scale.y(),
1225	pos.z() - scale.z());
1226	QVector3D minCorner = convertPositionToTranslation(position: minBounds, isAbsolute: false);
1227	QVector3D maxCorner = convertPositionToTranslation(position: maxBounds, isAbsolute: false);
1228	scale = QVector3D(qAbs(t: maxCorner.x() - minCorner.x()),
1229	qAbs(t: maxCorner.y() - minCorner.y()),
1230	qAbs(t: maxCorner.z() - minCorner.z())) / 2.0f;
1231	if (item->isVolume()) {
1232	// Only volume items need to scale and reposition according to bounds
1233	QVector3D minBoundsNormal = minCorner;
1234	QVector3D maxBoundsNormal = maxCorner;
1235	// getVisibleItemBounds returns bounds normalized for fragment shader [-1,1]
1236	// Y and Z are also flipped.
1237	getVisibleItemBounds(minBounds&: minBoundsNormal, maxBounds&: maxBoundsNormal);
1238	item->setMinBounds(minBoundsNormal);
1239	item->setMaxBounds(maxBoundsNormal);
1240	// For scaling calculations, we want [0,1] normalized values
1241	minBoundsNormal = item->minBoundsNormal();
1242	maxBoundsNormal = item->maxBoundsNormal();
1243
1244	// Rescale and reposition the item so that it doesn't go over the edges
1245	QVector3D adjScaling =
1246	QVector3D(scale.x() * (maxBoundsNormal.x() - minBoundsNormal.x()),
1247	scale.y() * (maxBoundsNormal.y() - minBoundsNormal.y()),
1248	scale.z() * (maxBoundsNormal.z() - minBoundsNormal.z()));
1249
1250	item->setScaling(adjScaling);
1251
1252	QVector3D adjPos = item->origPosition();
1253	QVector3D dataExtents = QVector3D(maxBounds.x() - minBounds.x(),
1254	maxBounds.y() - minBounds.y(),
1255	maxBounds.z() - minBounds.z()) / 2.0f;
1256	adjPos.setX(adjPos.x() + (dataExtents.x() * minBoundsNormal.x())
1257	- (dataExtents.x() * (1.0f - maxBoundsNormal.x())));
1258	adjPos.setY(adjPos.y() + (dataExtents.y() * minBoundsNormal.y())
1259	- (dataExtents.y() * (1.0f - maxBoundsNormal.y())));
1260	adjPos.setZ(adjPos.z() + (dataExtents.z() * minBoundsNormal.z())
1261	- (dataExtents.z() * (1.0f - maxBoundsNormal.z())));
1262	item->setPosition(adjPos);
1263	} else {
1264	// Only scale for non-volume items, and do not readjust position
1265	item->setScaling(scale);
1266	item->setPosition(item->origPosition());
1267	}
1268	} else {
1269	item->setScaling(item->origScaling());
1270	item->setPosition(item->origPosition());
1271	if (item->isVolume()) {
1272	// Y and Z need to be flipped as shader flips those axes
1273	item->setMinBounds(QVector3D(-1.0f, 1.0f, 1.0f));
1274	item->setMaxBounds(QVector3D(1.0f, -1.0f, -1.0f));
1275	}
1276	}
1277	QVector3D translation = convertPositionToTranslation(position: item->position(),
1278	isAbsolute: item->isPositionAbsolute());
1279	item->setTranslation(translation);
1280	}
1281
1282	void Abstract3DRenderer::updateCustomItem(CustomRenderItem *renderItem)
1283	{
1284	QCustom3DItem *item = renderItem->itemPointer();
1285	if (item->d_ptr->m_dirtyBits.meshDirty) {
1286	renderItem->setMesh(item->meshFile());
1287	item->d_ptr->m_dirtyBits.meshDirty = false;
1288	}
1289	if (item->d_ptr->m_dirtyBits.positionDirty) {
1290	renderItem->setOrigPosition(item->position());
1291	renderItem->setPositionAbsolute(item->isPositionAbsolute());
1292	if (!item->d_ptr->m_dirtyBits.scalingDirty)
1293	recalculateCustomItemScalingAndPos(item: renderItem);
1294	item->d_ptr->m_dirtyBits.positionDirty = false;
1295	}
1296	if (item->d_ptr->m_dirtyBits.scalingDirty) {
1297	QVector3D scaling = item->scaling();
1298	renderItem->setOrigScaling(scaling);
1299	renderItem->setScalingAbsolute(item->isScalingAbsolute());
1300	// In case we have label item, we need to recreate texture for scaling adjustment
1301	if (item->d_ptr->m_isLabelItem) {
1302	QCustom3DLabel *labelItem = static_cast<QCustom3DLabel *>(item);
1303	float pointSize = labelItem->font().pointSizeF();
1304	// Check do we have custom visuals or need to use theme
1305	if (labelItem->dptr()->m_customVisuals) {
1306	// Recreate texture
1307	labelItem->dptr()->createTextureImage();
1308	} else {
1309	// Recreate texture using theme
1310	labelItem->dptr()->createTextureImage(bgrColor: m_cachedTheme->labelBackgroundColor(),
1311	txtColor: m_cachedTheme->labelTextColor(),
1312	background: m_cachedTheme->isLabelBackgroundEnabled(),
1313	borders: m_cachedTheme->isLabelBorderEnabled());
1314	pointSize = m_cachedTheme->font().pointSizeF();
1315	}
1316	QImage textureImage = item->d_ptr->textureImage();
1317	// Calculate scaling based on text (texture size), font size and asked scaling
1318	float scaledFontSize = (0.05f + pointSize / 500.0f) / float(textureImage.height());
1319	scaling.setX(scaling.x() * textureImage.width() * scaledFontSize);
1320	scaling.setY(scaling.y() * textureImage.height() * scaledFontSize);
1321	item->d_ptr->clearTextureImage();
1322	renderItem->setOrigScaling(scaling);
1323	}
1324	recalculateCustomItemScalingAndPos(item: renderItem);
1325	item->d_ptr->m_dirtyBits.scalingDirty = false;
1326	}
1327	if (item->d_ptr->m_dirtyBits.rotationDirty) {
1328	renderItem->setRotation(item->rotation());
1329	item->d_ptr->m_dirtyBits.rotationDirty = false;
1330	}
1331	if (item->d_ptr->m_dirtyBits.textureDirty) {
1332	QImage textureImage = item->d_ptr->textureImage();
1333	if (item->d_ptr->m_isLabelItem) {
1334	QCustom3DLabel *labelItem = static_cast<QCustom3DLabel *>(item);
1335	// Check do we have custom visuals or need to use theme
1336	if (!labelItem->dptr()->m_customVisuals) {
1337	// Recreate texture using theme
1338	labelItem->dptr()->createTextureImage(bgrColor: m_cachedTheme->labelBackgroundColor(),
1339	txtColor: m_cachedTheme->labelTextColor(),
1340	background: m_cachedTheme->isLabelBackgroundEnabled(),
1341	borders: m_cachedTheme->isLabelBorderEnabled());
1342	textureImage = item->d_ptr->textureImage();
1343	}
1344	} else if (!item->d_ptr->m_isVolumeItem || m_isOpenGLES) {
1345	renderItem->setBlendNeeded(textureImage.hasAlphaChannel());
1346	GLuint oldTexture = renderItem->texture();
1347	m_textureHelper->deleteTexture(texture: &oldTexture);
1348	GLuint texture = m_textureHelper->create2DTexture(image: textureImage, useTrilinearFiltering: true, convert: true, smoothScale: true);
1349	renderItem->setTexture(texture);
1350	}
1351	item->d_ptr->clearTextureImage();
1352	item->d_ptr->m_dirtyBits.textureDirty = false;
1353	}
1354	if (item->d_ptr->m_dirtyBits.visibleDirty) {
1355	renderItem->setVisible(item->isVisible());
1356	item->d_ptr->m_dirtyBits.visibleDirty = false;
1357	}
1358	if (item->d_ptr->m_dirtyBits.shadowCastingDirty) {
1359	renderItem->setShadowCasting(item->isShadowCasting());
1360	item->d_ptr->m_dirtyBits.shadowCastingDirty = false;
1361	}
1362	if (item->d_ptr->m_isLabelItem) {
1363	QCustom3DLabel *labelItem = static_cast<QCustom3DLabel *>(item);
1364	if (labelItem->dptr()->m_facingCameraDirty) {
1365	renderItem->setFacingCamera(labelItem->isFacingCamera());
1366	labelItem->dptr()->m_facingCameraDirty = false;
1367	}
1368	} else if (item->d_ptr->m_isVolumeItem && !m_isOpenGLES) {
1369	QCustom3DVolume *volumeItem = static_cast<QCustom3DVolume *>(item);
1370	if (volumeItem->dptr()->m_dirtyBitsVolume.colorTableDirty) {
1371	renderItem->setColorTable(volumeItem->colorTable());
1372	volumeItem->dptr()->m_dirtyBitsVolume.colorTableDirty = false;
1373	}
1374	if (volumeItem->dptr()->m_dirtyBitsVolume.textureDimensionsDirty
1375	|| volumeItem->dptr()->m_dirtyBitsVolume.textureDataDirty
1376	|| volumeItem->dptr()->m_dirtyBitsVolume.textureFormatDirty) {
1377	GLuint oldTexture = renderItem->texture();
1378	m_textureHelper->deleteTexture(texture: &oldTexture);
1379	GLuint texture = m_textureHelper->create3DTexture(data: volumeItem->textureData(),
1380	width: volumeItem->textureWidth(),
1381	height: volumeItem->textureHeight(),
1382	depth: volumeItem->textureDepth(),
1383	dataFormat: volumeItem->textureFormat());
1384	renderItem->setTexture(texture);
1385	renderItem->setTextureWidth(volumeItem->textureWidth());
1386	renderItem->setTextureHeight(volumeItem->textureHeight());
1387	renderItem->setTextureDepth(volumeItem->textureDepth());
1388	renderItem->setTextureFormat(volumeItem->textureFormat());
1389	volumeItem->dptr()->m_dirtyBitsVolume.textureDimensionsDirty = false;
1390	volumeItem->dptr()->m_dirtyBitsVolume.textureDataDirty = false;
1391	volumeItem->dptr()->m_dirtyBitsVolume.textureFormatDirty = false;
1392	}
1393	if (volumeItem->dptr()->m_dirtyBitsVolume.slicesDirty) {
1394	renderItem->setDrawSlices(volumeItem->drawSlices());
1395	renderItem->setDrawSliceFrames(volumeItem->drawSliceFrames());
1396	renderItem->setSliceFrameColor(volumeItem->sliceFrameColor());
1397	renderItem->setSliceFrameWidths(volumeItem->sliceFrameWidths());
1398	renderItem->setSliceFrameGaps(volumeItem->sliceFrameGaps());
1399	renderItem->setSliceFrameThicknesses(volumeItem->sliceFrameThicknesses());
1400	renderItem->setSliceIndexX(volumeItem->sliceIndexX());
1401	renderItem->setSliceIndexY(volumeItem->sliceIndexY());
1402	renderItem->setSliceIndexZ(volumeItem->sliceIndexZ());
1403	volumeItem->dptr()->m_dirtyBitsVolume.slicesDirty = false;
1404	}
1405	if (volumeItem->dptr()->m_dirtyBitsVolume.alphaDirty) {
1406	renderItem->setAlphaMultiplier(volumeItem->alphaMultiplier());
1407	renderItem->setPreserveOpacity(volumeItem->preserveOpacity());
1408	volumeItem->dptr()->m_dirtyBitsVolume.alphaDirty = false;
1409	}
1410	if (volumeItem->dptr()->m_dirtyBitsVolume.shaderDirty) {
1411	renderItem->setUseHighDefShader(volumeItem->useHighDefShader());
1412	volumeItem->dptr()->m_dirtyBitsVolume.shaderDirty = false;
1413	}
1414	}
1415	}
1416
1417	void Abstract3DRenderer::updateCustomItemPositions()
1418	{
1419	foreach (CustomRenderItem *renderItem, m_customRenderCache)
1420	recalculateCustomItemScalingAndPos(item: renderItem);
1421	}
1422
1423	void Abstract3DRenderer::drawCustomItems(RenderingState state,
1424	ShaderHelper *regularShader,
1425	const QMatrix4x4 &viewMatrix,
1426	const QMatrix4x4 &projectionViewMatrix,
1427	const QMatrix4x4 &depthProjectionViewMatrix,
1428	GLuint depthTexture,
1429	GLfloat shadowQuality,
1430	GLfloat reflection)
1431	{
1432	if (m_customRenderCache.isEmpty())
1433	return;
1434
1435	ShaderHelper *shader = regularShader;
1436	shader->bind();
1437
1438	if (RenderingNormal == state) {
1439	shader->setUniformValue(uniform: shader->lightP(), value: m_cachedScene->activeLight()->position());
1440	shader->setUniformValue(uniform: shader->ambientS(), value: m_cachedTheme->ambientLightStrength());
1441	shader->setUniformValue(uniform: shader->lightColor(),
1442	value: Utils::vectorFromColor(color: m_cachedTheme->lightColor()));
1443	shader->setUniformValue(uniform: shader->view(), value: viewMatrix);
1444	}
1445
1446	// Draw custom items - first regular and then volumes
1447	bool volumeDetected = false;
1448	int loopCount = 0;
1449	while (loopCount < 2) {
1450	for (QCustom3DItem *customItem : std::as_const(t&: m_customItemDrawOrder)) {
1451	CustomRenderItem *item = m_customRenderCache.value(key: customItem);
1452	// Check that the render item is visible, and skip drawing if not
1453	// Also check if reflected item is on the "wrong" side, and skip drawing if it is
1454	if (!item->isVisible() || ((m_reflectionEnabled && reflection < 0.0f)
1455	&& (m_yFlipped == (item->translation().y() >= 0.0)))) {
1456	continue;
1457	}
1458	if (loopCount == 0) {
1459	if (item->isVolume()) {
1460	volumeDetected = true;
1461	continue;
1462	}
1463	} else {
1464	if (!item->isVolume())
1465	continue;
1466	}
1467
1468	// If the render item is in data coordinates and not within axis ranges, skip it
1469	if (!item->isPositionAbsolute()
1470	&& (item->position().x() < m_axisCacheX.min()
1471	|| item->position().x() > m_axisCacheX.max()
1472	|| item->position().z() < m_axisCacheZ.min()
1473	|| item->position().z() > m_axisCacheZ.max()
1474	|| item->position().y() < m_axisCacheY.min()
1475	|| item->position().y() > m_axisCacheY.max())) {
1476	continue;
1477	}
1478
1479	QMatrix4x4 modelMatrix;
1480	QMatrix4x4 itModelMatrix;
1481	QMatrix4x4 MVPMatrix;
1482
1483	QQuaternion rotation = item->rotation();
1484	// Check if the (label) item should be facing camera, and adjust rotation accordingly
1485	if (item->isFacingCamera()) {
1486	float camRotationX = m_cachedScene->activeCamera()->xRotation();
1487	float camRotationY = m_cachedScene->activeCamera()->yRotation();
1488	rotation = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f, angle: -camRotationX)
1489	* QQuaternion::fromAxisAndAngle(x: 1.0f, y: 0.0f, z: 0.0f, angle: -camRotationY);
1490	}
1491
1492	if (m_reflectionEnabled) {
1493	if (reflection < 0.0f) {
1494	if (item->itemPointer()->d_ptr->m_isLabelItem)
1495	continue;
1496	else
1497	glCullFace(GL_FRONT);
1498	} else {
1499	glCullFace(GL_BACK);
1500	}
1501	QVector3D trans = item->translation();
1502	trans.setY(reflection * trans.y());
1503	modelMatrix.translate(vector: trans);
1504	if (reflection < 0.0f) {
1505	QQuaternion mirror = QQuaternion(rotation.scalar(),
1506	-rotation.x(), rotation.y(), -rotation.z());
1507	modelMatrix.rotate(quaternion: mirror);
1508	itModelMatrix.rotate(quaternion: mirror);
1509	} else {
1510	modelMatrix.rotate(quaternion: rotation);
1511	itModelMatrix.rotate(quaternion: rotation);
1512	}
1513	QVector3D scale = item->scaling();
1514	scale.setY(reflection * scale.y());
1515	modelMatrix.scale(vector: scale);
1516	} else {
1517	modelMatrix.translate(vector: item->translation());
1518	modelMatrix.rotate(quaternion: rotation);
1519	modelMatrix.scale(vector: item->scaling());
1520	itModelMatrix.rotate(quaternion: rotation);
1521	}
1522	if (!item->isFacingCamera())
1523	itModelMatrix.scale(vector: item->scaling());
1524	MVPMatrix = projectionViewMatrix * modelMatrix;
1525
1526	if (RenderingNormal == state) {
1527	// Normal render
1528	ShaderHelper *prevShader = shader;
1529	if (item->isVolume() && !m_isOpenGLES) {
1530	if (item->drawSlices() &&
1531	(item->sliceIndexX() >= 0
1532	|| item->sliceIndexY() >= 0
1533	|| item->sliceIndexZ() >= 0)) {
1534	shader = m_volumeTextureSliceShader;
1535	} else if (item->useHighDefShader()) {
1536	shader = m_volumeTextureShader;
1537	} else {
1538	shader = m_volumeTextureLowDefShader;
1539	}
1540	} else if (item->isLabel()) {
1541	shader = m_labelShader;
1542	} else {
1543	shader = regularShader;
1544	}
1545	if (shader != prevShader)
1546	shader->bind();
1547	shader->setUniformValue(uniform: shader->model(), value: modelMatrix);
1548	shader->setUniformValue(uniform: shader->MVP(), value: MVPMatrix);
1549	shader->setUniformValue(uniform: shader->nModel(), value: itModelMatrix.inverted().transposed());
1550
1551	if (item->isBlendNeeded()) {
1552	glEnable(GL_BLEND);
1553	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1554	if (!item->isVolume() && !m_isOpenGLES)
1555	glDisable(GL_CULL_FACE);
1556	} else {
1557	glDisable(GL_BLEND);
1558	glEnable(GL_CULL_FACE);
1559	}
1560
1561	if (!m_isOpenGLES && m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone
1562	&& !item->isVolume()) {
1563	// Set shadow shader bindings
1564	shader->setUniformValue(uniform: shader->shadowQ(), value: shadowQuality);
1565	shader->setUniformValue(uniform: shader->depth(), value: depthProjectionViewMatrix * modelMatrix);
1566	shader->setUniformValue(uniform: shader->lightS(), value: m_cachedTheme->lightStrength() / 10.0f);
1567	m_drawer->drawObject(shader, object: item->mesh(), textureId: item->texture(), depthTextureId: depthTexture);
1568	} else {
1569	// Set shadowless shader bindings
1570	if (item->isVolume() && !m_isOpenGLES) {
1571	QVector3D cameraPos = m_cachedScene->activeCamera()->position();
1572	cameraPos = MVPMatrix.inverted().map(point: cameraPos);
1573	// Adjust camera position according to min/max bounds
1574	cameraPos = -(cameraPos
1575	+ ((oneVector - cameraPos) * item->minBoundsNormal())
1576	- ((oneVector + cameraPos) * (oneVector - item->maxBoundsNormal())));
1577	shader->setUniformValue(uniform: shader->cameraPositionRelativeToModel(), value: cameraPos);
1578	GLint color8Bit = (item->textureFormat() == QImage::Format_Indexed8) ? 1 : 0;
1579	if (color8Bit) {
1580	shader->setUniformValueArray(uniform: shader->colorIndex(),
1581	values: item->colorTable().constData(), count: 256);
1582	}
1583	shader->setUniformValue(uniform: shader->color8Bit(), value: color8Bit);
1584	shader->setUniformValue(uniform: shader->alphaMultiplier(), value: item->alphaMultiplier());
1585	shader->setUniformValue(uniform: shader->preserveOpacity(),
1586	value: item->preserveOpacity() ? 1 : 0);
1587
1588	shader->setUniformValue(uniform: shader->minBounds(), value: item->minBounds());
1589	shader->setUniformValue(uniform: shader->maxBounds(), value: item->maxBounds());
1590
1591	if (shader == m_volumeTextureSliceShader) {
1592	shader->setUniformValue(uniform: shader->volumeSliceIndices(),
1593	value: item->sliceFractions());
1594	} else {
1595	// Precalculate texture dimensions so we can optimize
1596	// ray stepping to hit every texture layer.
1597	QVector3D textureDimensions(1.0f / float(item->textureWidth()),
1598	1.0f / float(item->textureHeight()),
1599	1.0f / float(item->textureDepth()));
1600
1601	// Worst case scenario sample count
1602	int sampleCount;
1603	if (shader == m_volumeTextureLowDefShader) {
1604	sampleCount = qMax(a: item->textureWidth(),
1605	b: qMax(a: item->textureDepth(), b: item->textureHeight()));
1606	// Further improve speed with big textures by simply dropping every
1607	// other sample:
1608	if (sampleCount > 256)
1609	sampleCount /= 2;
1610	} else {
1611	sampleCount = item->textureWidth() + item->textureHeight()
1612	+ item->textureDepth();
1613	}
1614	shader->setUniformValue(uniform: shader->textureDimensions(), value: textureDimensions);
1615	shader->setUniformValue(uniform: shader->sampleCount(), value: sampleCount);
1616	}
1617	if (item->drawSliceFrames()) {
1618	// Set up the slice frame shader
1619	glDisable(GL_CULL_FACE);
1620	m_volumeSliceFrameShader->bind();
1621	m_volumeSliceFrameShader->setUniformValue(
1622	uniform: m_volumeSliceFrameShader->color(), value: item->sliceFrameColor());
1623
1624	// Draw individual slice frames.
1625	if (item->sliceIndexX() >= 0)
1626	drawVolumeSliceFrame(item, axis: Qt::XAxis, projectionViewMatrix);
1627	if (item->sliceIndexY() >= 0)
1628	drawVolumeSliceFrame(item, axis: Qt::YAxis, projectionViewMatrix);
1629	if (item->sliceIndexZ() >= 0)
1630	drawVolumeSliceFrame(item, axis: Qt::ZAxis, projectionViewMatrix);
1631
1632	glEnable(GL_CULL_FACE);
1633	shader->bind();
1634	}
1635	m_drawer->drawObject(shader, object: item->mesh(), textureId: 0, depthTextureId: 0, textureId3D: item->texture());
1636	} else {
1637	shader->setUniformValue(uniform: shader->lightS(), value: m_cachedTheme->lightStrength());
1638	m_drawer->drawObject(shader, object: item->mesh(), textureId: item->texture());
1639	}
1640	}
1641	} else if (RenderingSelection == state && !volumeDetected) {
1642	// Selection render
1643	shader->setUniformValue(uniform: shader->MVP(), value: MVPMatrix);
1644	QVector4D itemColor = indexToSelectionColor(index: item->index());
1645	itemColor.setW(customItemAlpha);
1646	itemColor /= 255.0f;
1647	shader->setUniformValue(uniform: shader->color(), value: itemColor);
1648	m_drawer->drawObject(shader, object: item->mesh());
1649	} else if (item->isShadowCasting()) {
1650	// Depth render
1651	shader->setUniformValue(uniform: shader->MVP(), value: depthProjectionViewMatrix * modelMatrix);
1652	m_drawer->drawObject(shader, object: item->mesh());
1653	}
1654	}
1655	loopCount++;
1656	if (!volumeDetected)
1657	loopCount++; // Skip second run if no volumes detected
1658	}
1659
1660	if (RenderingNormal == state) {
1661	glDisable(GL_BLEND);
1662	glEnable(GL_CULL_FACE);
1663	}
1664	}
1665
1666	void Abstract3DRenderer::drawVolumeSliceFrame(const CustomRenderItem *item, Qt::Axis axis,
1667	const QMatrix4x4 &projectionViewMatrix)
1668	{
1669	QVector2D frameWidth;
1670	QVector3D frameScaling;
1671	QVector3D translation = item->translation();
1672	QQuaternion rotation = item->rotation();
1673	float fracTrans;
1674	bool needRotate = !rotation.isIdentity();
1675	QMatrix4x4 rotationMatrix;
1676	if (needRotate)
1677	rotationMatrix.rotate(quaternion: rotation);
1678
1679	if (axis == Qt::XAxis) {
1680	fracTrans = item->sliceFractions().x();
1681	float range = item->maxBoundsNormal().x() - item->minBoundsNormal().x();
1682	float minMult = item->minBoundsNormal().x() / range;
1683	float maxMult = (1.0f - item->maxBoundsNormal().x()) / range;
1684	fracTrans = fracTrans - ((1.0f - fracTrans) * minMult) + ((1.0f + fracTrans) * maxMult);
1685	if (needRotate)
1686	translation += rotationMatrix.map(point: QVector3D(fracTrans * item->scaling().x(), 0.0f, 0.0f));
1687	else
1688	translation.setX(translation.x() + fracTrans * item->scaling().x());
1689	frameScaling = QVector3D(item->scaling().z()
1690	+ (item->scaling().z() * item->sliceFrameGaps().z())
1691	+ (item->scaling().z() * item->sliceFrameWidths().z()),
1692	item->scaling().y()
1693	+ (item->scaling().y() * item->sliceFrameGaps().y())
1694	+ (item->scaling().y() * item->sliceFrameWidths().y()),
1695	item->scaling().x() * item->sliceFrameThicknesses().x());
1696	frameWidth = QVector2D(item->scaling().z() * item->sliceFrameWidths().z(),
1697	item->scaling().y() * item->sliceFrameWidths().y());
1698	rotation *= m_yRightAngleRotation;
1699	} else if (axis == Qt::YAxis) {
1700	fracTrans = item->sliceFractions().y();
1701	float range = item->maxBoundsNormal().y() - item->minBoundsNormal().y();
1702	// Y axis is logically flipped, so we need to swam min and max bounds
1703	float minMult = (1.0f - item->maxBoundsNormal().y()) / range;
1704	float maxMult = item->minBoundsNormal().y() / range;
1705	fracTrans = fracTrans - ((1.0f - fracTrans) * minMult) + ((1.0f + fracTrans) * maxMult);
1706	if (needRotate)
1707	translation -= rotationMatrix.map(point: QVector3D(0.0f, fracTrans * item->scaling().y(), 0.0f));
1708	else
1709	translation.setY(translation.y() - fracTrans * item->scaling().y());
1710	frameScaling = QVector3D(item->scaling().x()
1711	+ (item->scaling().x() * item->sliceFrameGaps().x())
1712	+ (item->scaling().x() * item->sliceFrameWidths().x()),
1713	item->scaling().z()
1714	+ (item->scaling().z() * item->sliceFrameGaps().z())
1715	+ (item->scaling().z() * item->sliceFrameWidths().z()),
1716	item->scaling().y() * item->sliceFrameThicknesses().y());
1717	frameWidth = QVector2D(item->scaling().x() * item->sliceFrameWidths().x(),
1718	item->scaling().z() * item->sliceFrameWidths().z());
1719	rotation *= m_xRightAngleRotation;
1720	} else { // Z axis
1721	fracTrans = item->sliceFractions().z();
1722	float range = item->maxBoundsNormal().z() - item->minBoundsNormal().z();
1723	// Z axis is logically flipped, so we need to swam min and max bounds
1724	float minMult = (1.0f - item->maxBoundsNormal().z()) / range;
1725	float maxMult = item->minBoundsNormal().z() / range;
1726	fracTrans = fracTrans - ((1.0f - fracTrans) * minMult) + ((1.0f + fracTrans) * maxMult);
1727	if (needRotate)
1728	translation -= rotationMatrix.map(point: QVector3D(0.0f, 0.0f, fracTrans * item->scaling().z()));
1729	else
1730	translation.setZ(translation.z() - fracTrans * item->scaling().z());
1731	frameScaling = QVector3D(item->scaling().x()
1732	+ (item->scaling().x() * item->sliceFrameGaps().x())
1733	+ (item->scaling().x() * item->sliceFrameWidths().x()),
1734	item->scaling().y()
1735	+ (item->scaling().y() * item->sliceFrameGaps().y())
1736	+ (item->scaling().y() * item->sliceFrameWidths().y()),
1737	item->scaling().z() * item->sliceFrameThicknesses().z());
1738	frameWidth = QVector2D(item->scaling().x() * item->sliceFrameWidths().x(),
1739	item->scaling().y() * item->sliceFrameWidths().y());
1740	}
1741
1742	// If the slice is outside the shown area, don't show the frame
1743	if (fracTrans < -1.0 || fracTrans > 1.0)
1744	return;
1745
1746	// Shader needs the width of clear space in the middle.
1747	frameWidth.setX(1.0f - (frameWidth.x() / frameScaling.x()));
1748	frameWidth.setY(1.0f - (frameWidth.y() / frameScaling.y()));
1749
1750	QMatrix4x4 modelMatrix;
1751	QMatrix4x4 mvpMatrix;
1752
1753	modelMatrix.translate(vector: translation);
1754	modelMatrix.rotate(quaternion: rotation);
1755	modelMatrix.scale(vector: frameScaling);
1756	mvpMatrix = projectionViewMatrix * modelMatrix;
1757	m_volumeSliceFrameShader->setUniformValue(uniform: m_volumeSliceFrameShader->MVP(), value: mvpMatrix);
1758	m_volumeSliceFrameShader->setUniformValue(uniform: m_volumeSliceFrameShader->sliceFrameWidth(),
1759	value: frameWidth);
1760
1761	m_drawer->drawObject(shader: m_volumeSliceFrameShader, object: item->mesh());
1762
1763	}
1764
1765	void Abstract3DRenderer::queriedGraphPosition(const QMatrix4x4 &projectionViewMatrix,
1766	const QVector3D &scaling,
1767	GLuint defaultFboHandle)
1768	{
1769	m_cursorPositionShader->bind();
1770
1771	// Set up mapper framebuffer
1772	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: m_cursorPositionFrameBuffer);
1773	glViewport(x: 0, y: 0,
1774	width: m_primarySubViewport.width(),
1775	height: m_primarySubViewport.height());
1776	glClearColor(red: 1.0f, green: 1.0f, blue: 1.0f, alpha: 1.0f);
1777	glClear(GL_COLOR_BUFFER_BIT);
1778	glDisable(GL_DITHER); // Dither may affect colors if enabled
1779	glEnable(GL_CULL_FACE);
1780	glCullFace(GL_FRONT);
1781
1782	// Draw a cube scaled to the graph dimensions
1783	QMatrix4x4 modelMatrix;
1784	QMatrix4x4 MVPMatrix;
1785
1786	modelMatrix.scale(vector: scaling);
1787
1788	MVPMatrix = projectionViewMatrix * modelMatrix;
1789	m_cursorPositionShader->setUniformValue(uniform: m_cursorPositionShader->MVP(), value: MVPMatrix);
1790	m_drawer->drawObject(shader: m_cursorPositionShader, object: m_positionMapperObj);
1791
1792	QVector4D dataColor = Utils::getSelection(mousepos: m_graphPositionQuery,
1793	height: m_primarySubViewport.height());
1794	if (dataColor.w() > 0.0f) {
1795	// If position is outside the graph, set the position well outside the graph boundaries
1796	dataColor = QVector4D(-10000.0f, -10000.0f, -10000.0f, 0.0f);
1797	} else {
1798	// Normalize to range [0.0, 1.0]
1799	dataColor /= 255.0f;
1800	}
1801
1802	// Restore state
1803	glEnable(GL_DITHER);
1804	glCullFace(GL_BACK);
1805
1806	// Note: Zeroing the frame buffer before resetting it is a workaround for flickering that occurs
1807	// during zoom in some environments.
1808	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: 0);
1809
1810	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer: defaultFboHandle);
1811	glViewport(x: m_primarySubViewport.x(),
1812	y: m_primarySubViewport.y(),
1813	width: m_primarySubViewport.width(),
1814	height: m_primarySubViewport.height());
1815
1816	QVector3D normalizedValues = dataColor.toVector3D() * 2.0f;
1817	normalizedValues -= oneVector;
1818	m_queriedGraphPosition = QVector3D(normalizedValues.x(),
1819	normalizedValues.y(),
1820	normalizedValues.z());
1821	m_graphPositionQueryResolved = true;
1822	m_graphPositionQueryPending = false;
1823	}
1824
1825	void Abstract3DRenderer::calculatePolarXZ(const QVector3D &dataPos, float &x, float &z) const
1826	{
1827	// x is angular, z is radial
1828	qreal angle = m_axisCacheX.formatter()->positionAt(value: dataPos.x()) * doublePi;
1829	qreal radius = m_axisCacheZ.formatter()->positionAt(value: dataPos.z());
1830
1831	// Convert angle & radius to X and Z coords
1832	x = float(radius * qSin(v: angle)) * m_polarRadius;
1833	z = -float(radius * qCos(v: angle)) * m_polarRadius;
1834	}
1835
1836	void Abstract3DRenderer::drawRadialGrid(ShaderHelper *shader, float yFloorLinePos,
1837	const QMatrix4x4 &projectionViewMatrix,
1838	const QMatrix4x4 &depthMatrix)
1839	{
1840	static QList<QQuaternion> lineRotations;
1841	if (!lineRotations.size()) {
1842	lineRotations.resize(size: polarGridRoundness);
1843	for (int j = 0; j < polarGridRoundness; j++) {
1844	lineRotations[j] = QQuaternion::fromAxisAndAngle(x: 0.0f, y: 1.0f, z: 0.0f,
1845	angle: polarGridAngleDegrees * float(j));
1846	}
1847	}
1848	int gridLineCount = m_axisCacheZ.gridLineCount();
1849	const QList<float> &gridPositions = m_axisCacheZ.formatter()->gridPositions();
1850	const QList<float> &subGridPositions = m_axisCacheZ.formatter()->subGridPositions();
1851	int mainSize = gridPositions.size();
1852	QVector3D translateVector(0.0f, yFloorLinePos, 0.0f);
1853	QQuaternion finalRotation = m_xRightAngleRotationNeg;
1854	if (m_yFlippedForGrid)
1855	finalRotation *= m_xFlipRotation;
1856
1857	for (int i = 0; i < gridLineCount; i++) {
1858	float gridPosition = (i >= mainSize)
1859	? subGridPositions.at(i: i - mainSize) : gridPositions.at(i);
1860	float radiusFraction = m_polarRadius * gridPosition;
1861	QVector3D gridLineScaler(radiusFraction * float(qSin(v: polarGridHalfAngle)),
1862	gridLineWidth, gridLineWidth);
1863	translateVector.setZ(gridPosition * m_polarRadius);
1864	for (int j = 0; j < polarGridRoundness; j++) {
1865	QMatrix4x4 modelMatrix;
1866	QMatrix4x4 itModelMatrix;
1867	modelMatrix.rotate(quaternion: lineRotations.at(i: j));
1868	itModelMatrix.rotate(quaternion: lineRotations.at(i: j));
1869	modelMatrix.translate(vector: translateVector);
1870	modelMatrix.scale(vector: gridLineScaler);
1871	itModelMatrix.scale(vector: gridLineScaler);
1872	modelMatrix.rotate(quaternion: finalRotation);
1873	itModelMatrix.rotate(quaternion: finalRotation);
1874	QMatrix4x4 MVPMatrix = projectionViewMatrix * modelMatrix;
1875
1876	shader->setUniformValue(uniform: shader->model(), value: modelMatrix);
1877	shader->setUniformValue(uniform: shader->nModel(), value: itModelMatrix.inverted().transposed());
1878	shader->setUniformValue(uniform: shader->MVP(), value: MVPMatrix);
1879	if (!m_isOpenGLES) {
1880	if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) {
1881	// Set shadow shader bindings
1882	QMatrix4x4 depthMVPMatrix = depthMatrix * modelMatrix;
1883	shader->setUniformValue(uniform: shader->depth(), value: depthMVPMatrix);
1884	// Draw the object
1885	m_drawer->drawObject(shader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture);
1886	} else {
1887	// Draw the object
1888	m_drawer->drawObject(shader, object: m_gridLineObj);
1889	}
1890	} else {
1891	m_drawer->drawLine(shader);
1892	}
1893	}
1894	}
1895	}
1896
1897	void Abstract3DRenderer::drawAngularGrid(ShaderHelper *shader, float yFloorLinePos,
1898	const QMatrix4x4 &projectionViewMatrix,
1899	const QMatrix4x4 &depthMatrix)
1900	{
1901	float halfRatio((m_polarRadius + (labelMargin / 2.0f)) / 2.0f);
1902	QVector3D gridLineScaler(gridLineWidth, gridLineWidth, halfRatio);
1903	int gridLineCount = m_axisCacheX.gridLineCount();
1904	const QList<float> &gridPositions = m_axisCacheX.formatter()->gridPositions();
1905	const QList<float> &subGridPositions = m_axisCacheX.formatter()->subGridPositions();
1906	int mainSize = gridPositions.size();
1907	QVector3D translateVector(0.0f, yFloorLinePos, -halfRatio);
1908	QQuaternion finalRotation;
1909	if (m_isOpenGLES)
1910	finalRotation = m_yRightAngleRotationNeg;
1911	else
1912	finalRotation = m_xRightAngleRotationNeg;
1913	if (m_yFlippedForGrid)
1914	finalRotation *= m_xFlipRotation;
1915	for (int i = 0; i < gridLineCount; i++) {
1916	QMatrix4x4 modelMatrix;
1917	QMatrix4x4 itModelMatrix;
1918	float gridPosition = (i >= mainSize)
1919	? subGridPositions.at(i: i - mainSize) : gridPositions.at(i);
1920	QQuaternion lineRotation = QQuaternion::fromAxisAndAngle(axis: upVector, angle: gridPosition * 360.0f);
1921	modelMatrix.rotate(quaternion: lineRotation);
1922	itModelMatrix.rotate(quaternion: lineRotation);
1923	modelMatrix.translate(vector: translateVector);
1924	modelMatrix.scale(vector: gridLineScaler);
1925	itModelMatrix.scale(vector: gridLineScaler);
1926	modelMatrix.rotate(quaternion: finalRotation);
1927	itModelMatrix.rotate(quaternion: finalRotation);
1928	QMatrix4x4 MVPMatrix = projectionViewMatrix * modelMatrix;
1929
1930	shader->setUniformValue(uniform: shader->model(), value: modelMatrix);
1931	shader->setUniformValue(uniform: shader->nModel(), value: itModelMatrix.inverted().transposed());
1932	shader->setUniformValue(uniform: shader->MVP(), value: MVPMatrix);
1933	if (m_isOpenGLES) {
1934	m_drawer->drawLine(shader);
1935	} else {
1936	if (m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) {
1937	// Set shadow shader bindings
1938	QMatrix4x4 depthMVPMatrix = depthMatrix * modelMatrix;
1939	shader->setUniformValue(uniform: shader->depth(), value: depthMVPMatrix);
1940	// Draw the object
1941	m_drawer->drawObject(shader, object: m_gridLineObj, textureId: 0, depthTextureId: m_depthTexture);
1942	} else {
1943	// Draw the object
1944	m_drawer->drawObject(shader, object: m_gridLineObj);
1945	}
1946	}
1947	}
1948	}
1949
1950	float Abstract3DRenderer::calculatePolarBackgroundMargin()
1951	{
1952	// Check each extents of each angular label
1953	// Calculate angular position
1954	QList<float> &labelPositions = m_axisCacheX.formatter()->labelPositions();
1955	float actualLabelHeight = m_drawer->scaledFontSize() * 2.0f; // All labels are same height
1956	float maxNeededMargin = 0.0f;
1957
1958	// Axis title needs to be accounted for
1959	if (m_axisCacheX.isTitleVisible())
1960	maxNeededMargin = 2.0f * actualLabelHeight + 3.0f * labelMargin;
1961
1962	for (int label = 0; label < labelPositions.size(); label++) {
1963	QSize labelSize = m_axisCacheX.labelItems().at(i: label)->size();
1964	float actualLabelWidth = actualLabelHeight / labelSize.height() * labelSize.width();
1965	float labelPosition = labelPositions.at(i: label);
1966	qreal angle = labelPosition * M_PI * 2.0;
1967	float x = qAbs(t: (m_polarRadius + labelMargin) * float(qSin(v: angle)))
1968	+ actualLabelWidth - m_polarRadius + labelMargin;
1969	float z = qAbs(t: -(m_polarRadius + labelMargin) * float(qCos(v: angle)))
1970	+ actualLabelHeight - m_polarRadius + labelMargin;
1971	float neededMargin = qMax(a: x, b: z);
1972	maxNeededMargin = qMax(a: maxNeededMargin, b: neededMargin);
1973	}
1974
1975	return maxNeededMargin;
1976	}
1977
1978	void Abstract3DRenderer::updateCameraViewport()
1979	{
1980	QVector3D adjustedTarget = m_cachedScene->activeCamera()->target();
1981	fixCameraTarget(target&: adjustedTarget);
1982	if (m_oldCameraTarget != adjustedTarget) {
1983	QVector3D cameraBase = cameraDistanceVector + adjustedTarget;
1984
1985	m_cachedScene->activeCamera()->d_ptr->setBaseOrientation(defaultPosition: cameraBase,
1986	defaultTarget: adjustedTarget,
1987	defaultUp: upVector);
1988	m_oldCameraTarget = adjustedTarget;
1989	}
1990	m_cachedScene->activeCamera()->d_ptr->updateViewMatrix(zoomAdjustment: m_autoScaleAdjustment);
1991	// Set light position (i.e rotate light with activeCamera, a bit above it).
1992	// Check if we want to use automatic light positioning even without shadows
1993	if (m_cachedScene->activeLight()->isAutoPosition()
1994	|| m_cachedShadowQuality > QAbstract3DGraph::ShadowQualityNone) {
1995	m_cachedScene->d_ptr->setLightPositionRelativeToCamera(relativePosition: defaultLightPos);
1996	}
1997	}
1998
1999	QT_END_NAMESPACE
2000