bars3drenderer_p.h

++ // Copyright (C) 2016 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is not part of the QtDataVisualization API.  It exists purely as an

++ // implementation detail.  This header file may change from version to

++ // version without notice, or even be removed.

++ //

++ // We mean it.

++

++ #ifndef Q3DBARSRENDERER_P_H

++ #define Q3DBARSRENDERER_P_H

++

++ #include "datavisualizationglobal_p.h"

++ #include "bars3dcontroller_p.h"

++ #include "abstract3drenderer_p.h"

++ #include "barrenderitem_p.h"

++

++ QT_BEGIN_NAMESPACE

++ class QPoint;

++ class QSizeF;

++ QT_END_NAMESPACE

++

++ QT_BEGIN_NAMESPACE

++

++ class ShaderHelper;

++ class LabelItem;

++ class Q3DScene;

++ class BarSeriesRenderCache;

++

++ class Q_DATAVISUALIZATION_EXPORT Bars3DRenderer : public Abstract3DRenderer

++ {

++     Q_OBJECT

++

++ private:

++     // Cached state based on emitted signals from the controller

++     QSizeF m_cachedBarThickness;

++     QSizeF m_cachedBarSpacing;

++     bool m_cachedIsSlicingActivated;

++     int m_cachedRowCount;

++     int m_cachedColumnCount;

++     QSizeF m_cachedBarSeriesMargin;

++

++     // Internal state

++     BarRenderItem *m_selectedBar; // points to renderitem array

++     AxisRenderCache *m_sliceCache; // not owned

++     const LabelItem *m_sliceTitleItem; // not owned

++     bool m_updateLabels;

++     ShaderHelper *m_barShader;

++     ShaderHelper *m_barGradientShader;

++     ShaderHelper *m_depthShader;

++     ShaderHelper *m_selectionShader;

++     ShaderHelper *m_backgroundShader;

++     GLuint m_bgrTexture;

++     GLuint m_selectionTexture;

++     GLuint m_depthFrameBuffer;

++     GLuint m_selectionFrameBuffer;

++     GLuint m_selectionDepthBuffer;

++     GLfloat m_shadowQualityToShader;

++     GLint m_shadowQualityMultiplier;

++     GLfloat m_heightNormalizer;

++     GLfloat m_gradientFraction;

++     GLfloat m_backgroundAdjustment;

++     GLfloat m_rowWidth;

++     GLfloat m_columnDepth;

++     GLfloat m_maxDimension;

++     GLfloat m_scaleX;

++     GLfloat m_scaleZ;

++     GLfloat m_scaleFactor;

++     GLfloat m_maxSceneSize;

++     QPoint m_visualSelectedBarPos;

++     QPoint m_selectedBarPos;

++     BarSeriesRenderCache *m_selectedSeriesCache;

++     BarRenderItem m_dummyBarRenderItem;

++     bool m_noZeroInRange;

++     float m_seriesScaleX;

++     float m_seriesScaleZ;

++     float m_seriesStep;

++     float m_seriesStart;

++     QPoint m_clickedPosition;

++     bool m_keepSeriesUniform;

++     bool m_haveUniformColorSeries;

++     bool m_haveGradientSeries;

++     float m_zeroPosition;

++     float m_xScaleFactor;

++     float m_zScaleFactor;

++     float m_floorLevel;

++     float m_actualFloorLevel;

++

++ public:

++     explicit Bars3DRenderer(Bars3DController *controller);

++     ~Bars3DRenderer();

++

++     void updateData() override;

++     void updateSeries(const QList<QAbstract3DSeries *> &seriesList) override;

++     SeriesRenderCache *createNewCache(QAbstract3DSeries *series) override;

++     void updateRows(const QList<Bars3DController::ChangeRow> &rows);

++     void updateItems(const QList<Bars3DController::ChangeItem> &items);

++     void updateScene(Q3DScene *scene) override;

++     void render(GLuint defaultFboHandle = 0) override;

++

++     QVector3D convertPositionToTranslation(const QVector3D &position, bool isAbsolute) override;

++

++     void updateAspectRatio(float ratio) override;

++     void updateFloorLevel(float level);

++     void updateMargin(float margin) override;

++

++ protected:

++     void contextCleanup() override;

++     void initializeOpenGL() override;

++     void fixCameraTarget(QVector3D &target) override;

++     void getVisibleItemBounds(QVector3D &minBounds, QVector3D &maxBounds) override;

++

++ public Q_SLOTS:

++     void updateMultiSeriesScaling(bool uniform);

++     void updateBarSpecs(GLfloat thicknessRatio = 1.0f,

++                         const QSizeF &spacing = QSizeF(1.0, 1.0),

++                         bool relative = true);

++     void updateBarSeriesMargin(const QSizeF &margin);

++     void updateSlicingActive(bool isSlicing);

++     void updateSelectedBar(const QPoint &position, QBar3DSeries *series);

++     inline QPoint clickedPosition() const { return m_clickedPosition; }

++     void resetClickedStatus();

++

++     // Overloaded from abstract renderer

++     void updateAxisRange(QAbstract3DAxis::AxisOrientation orientation, float min,

++                          float max) override;

++     void updateAxisReversed(QAbstract3DAxis::AxisOrientation orientation,

++                             bool enable) override;

++

++ private:

++     void initShaders(const QString &vertexShader, const QString &fragmentShader) override;

++     void initGradientShaders(const QString &vertexShader, const QString &fragmentShader) override;

++     void updateShadowQuality(QAbstract3DGraph::ShadowQuality quality) override;

++     void updateTextures() override;

++     void fixMeshFileName(QString &fileName, QAbstract3DSeries::Mesh mesh) override;

++

++     void drawSlicedScene();

++     void drawScene(GLuint defaultFboHandle);

++     void drawLabels(bool drawSelection, const Q3DCamera *activeCamera,

++                     const QMatrix4x4 &viewMatrix, const QMatrix4x4 &projectionMatrix);

++

++     bool drawBars(BarRenderItem **selectedBar, const QMatrix4x4 &depthProjectionViewMatrix,

++                   const QMatrix4x4 &projectionViewMatrix, const QMatrix4x4 &viewMatrix,

++                   GLint startRow, GLint stopRow, GLint stepRow,

++                   GLint startBar, GLint stopBar, GLint stepBar, GLfloat reflection = 1.0f);

++     void drawBackground(GLfloat backgroundRotation, const QMatrix4x4 &depthProjectionViewMatrix,

++                         const QMatrix4x4 &projectionViewMatrix, const QMatrix4x4 &viewMatrix,

++                         bool reflectingDraw = false, bool drawingSelectionBuffer = false);

++     void drawGridLines(const QMatrix4x4 &depthProjectionViewMatrix,

++                        const QMatrix4x4 &projectionViewMatrix,

++                        const QMatrix4x4 &viewMatrix);

++

++     void loadBackgroundMesh();

++     void initSelectionShader();

++     void initBackgroundShaders(const QString &vertexShader, const QString &fragmentShader) override;

++     void initSelectionBuffer() override;

++     void initDepthShader();

++     void updateDepthBuffer() override;

++     void calculateSceneScalingFactors();

++     void calculateHeightAdjustment();

++     void calculateSeriesStartPosition();

++     Abstract3DController::SelectionType isSelected(int row, int bar,

++                                                    const BarSeriesRenderCache *cache);

++     QPoint selectionColorToArrayPosition(const QVector4D &selectionColor);

++     QBar3DSeries *selectionColorToSeries(const QVector4D &selectionColor);

++

++     inline void updateRenderRow(const QBarDataRow *dataRow, BarRenderItemRow &renderRow);

++     inline void updateRenderItem(const QBarDataItem &dataItem, BarRenderItem &renderItem);

++

++     Q_DISABLE_COPY(Bars3DRenderer)

++ };

++

++ QT_END_NAMESPACE

++

++ #endif

Revision control