HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2863:15eed6371853

Add support for reversed axis when useOpenGL is true...

Andy Shaw -

r2863:15eed6371853

parent child

Context file:

r2863:15eed6371853

Collapse all files

src/charts/chartdataset.cpp +9 -2

                 series->d_ptr->initializeAxes();
                 axis->d_ptr->initializeDomain(domain);
+                connect(axis, &QAbstractAxis::reverseChanged, this, &ChartDataSet::reverseChanged);
                 foreach (AbstractDomain *blockedDomain, blockedDomains)
                     blockedDomain->blockRangeSignals(false);
                 domain->detachAxis(axis);
                 series->d_ptr->m_axes.removeAll(axis);
                 axis->d_ptr->m_series.removeAll(series);
+                disconnect(axis, &QAbstractAxis::reverseChanged, this, &ChartDataSet::reverseChanged);
                 return true;
             }
                 }
             }
+            void ChartDataSet::reverseChanged()
+            {
+                QAbstractAxis *axis = qobject_cast<QAbstractAxis *>(sender());
+                if (axis)
+                    m_glXYSeriesDataManager->handleAxisReverseChanged(axis->d_ptr->m_series);
+            }
             #include "moc_chartdataset_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartdataset_p.h +2 -1

                 void axisRemoved(QAbstractAxis* axis);
                 void seriesAdded(QAbstractSeries* series);
                 void seriesRemoved(QAbstractSeries* series);
+            public Q_SLOTS:
+                void reverseChanged();
             private:
                 void createAxes(QAbstractAxis::AxisTypes type, Qt::Orientation orientation);
                 QAbstractAxis *createAxis(QAbstractAxis::AxisType type, Qt::Orientation orientation);

src/charts/glwidget.cpp +4 -1

                     "uniform highp vec2 min;\n"
                     "uniform highp vec2 delta;\n"
                     "uniform highp float pointSize;\n"
+                    "uniform highp mat4 matrix;\n"
                     "void main() {\n"
                     "  vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
-                    "  gl_Position = vec4(normalPoint, 0, 1);\n"
+                    "  gl_Position = matrix * vec4(normalPoint, 0, 1);\n"
                     "  gl_PointSize = pointSize;\n"
                     "}";
             static const char *fragmentSource =
                 m_minUniformLoc = m_program->uniformLocation("min");
                 m_deltaUniformLoc = m_program->uniformLocation("delta");
                 m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
+                m_matrixUniformLoc = m_program->uniformLocation("matrix");
                 // Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
                     m_program->setUniformValue(m_colorUniformLoc, data->color);
                     m_program->setUniformValue(m_minUniformLoc, data->min);
                     m_program->setUniformValue(m_deltaUniformLoc, data->delta);
+                    m_program->setUniformValue(m_matrixUniformLoc, data->matrix);
                     if (!vbo) {
                         vbo = new QOpenGLBuffer;

src/charts/glwidget_p.h +1 0

                 int m_minUniformLoc;
                 int m_deltaUniformLoc;
                 int m_pointSizeUniformLoc;
+                int m_matrixUniformLoc;
                 QOpenGLVertexArrayObject m_vao;
                 QHash<const QAbstractSeries *, QOpenGLBuffer *> m_seriesBufferMap;

src/charts/xychart/glxyseriesdata.cpp +45 -1

@@ -74,16 +74,30 void GLXYSeriesDataManager::setPoints(QXYSeries series, const AbstractDomain d
74	QVector<float> &array = data->array;	74	QVector<float> &array = data->array;
75		75
76	bool logAxis = false;	76	bool logAxis = false;
		77	bool reverseX = false;
		78	bool reverseY = false;
77	foreach (QAbstractAxis* axis, series->attachedAxes()) {	79	foreach (QAbstractAxis* axis, series->attachedAxes()) {
78	if (axis->type() == QAbstractAxis::AxisTypeLogValue) {	80	if (axis->type() == QAbstractAxis::AxisTypeLogValue) {
79	logAxis = true;	81	logAxis = true;
		82	}
		83	if (axis->isReverse()) {
		84	if (axis->orientation() == Qt::Horizontal)
		85	reverseX = true;
		86	else
		87	reverseY = true;
		88	if (reverseX && reverseY)
80	break;	89	break;
81	}	90	}
82	}	91	}
83
84	int count = series->count();	92	int count = series->count();
85	int index = 0;	93	int index = 0;
86	array.resize(count * 2);	94	array.resize(count * 2);
		95	QMatrix4x4 matrix;
		96	if (reverseX)
		97	matrix.scale(-1.0, 1.0);
		98	if (reverseY)
		99	matrix.scale(1.0, -1.0);
		100	data->matrix = matrix;
87	if (logAxis) {	101	if (logAxis) {
88	// Use domain to resolve geometry points. Not as fast as shaders, but simpler that way	102	// Use domain to resolve geometry points. Not as fast as shaders, but simpler that way
89	QVector<QPointF> geometryPoints = domain->calculateGeometryPoints(series->pointsVector());	103	QVector<QPointF> geometryPoints = domain->calculateGeometryPoints(series->pointsVector());
@@ -185,5 +199,35 void GLXYSeriesDataManager::handleScatterMarkerSizeChange()
185	}	199	}
186	}	200	}
187		201
		202	void GLXYSeriesDataManager::handleAxisReverseChanged(const QList<QAbstractSeries *> &seriesList)
		203	{
		204	bool reverseX = false;
		205	bool reverseY = false;
		206	foreach (QAbstractSeries *series, seriesList) {
		207	if (QXYSeries xyseries = qobject_cast<QXYSeries >(series)) {
		208	GLXYSeriesData *data = m_seriesDataMap.value(xyseries);
		209	if (data) {
		210	foreach (QAbstractAxis* axis, xyseries->attachedAxes()) {
		211	if (axis->isReverse()) {
		212	if (axis->orientation() == Qt::Horizontal)
		213	reverseX = true;
		214	else
		215	reverseY = true;
		216	}
		217	if (reverseX && reverseY)
		218	break;
		219	}
		220	QMatrix4x4 matrix;
		221	if (reverseX)
		222	matrix.scale(-1.0, 1.0);
		223	if (reverseY)
		224	matrix.scale(1.0, -1.0);
		225	data->matrix = matrix;
		226	data->dirty = true;
		227	}
		228	}
		229	}
		230	}
		231
188	QT_CHARTS_END_NAMESPACE	232	QT_CHARTS_END_NAMESPACE
189		233

src/charts/xychart/glxyseriesdata_p.h +15 0

             #include <QtCharts/QXYSeries>
             #include <QtGui/QVector3D>
             #include <QtGui/QVector2D>
+            #include <QtGui/QMatrix4x4>
             QT_CHARTS_BEGIN_NAMESPACE
                 QAbstractSeries::SeriesType type;
                 QVector2D min;
                 QVector2D delta;
+                QMatrix4x4 matrix;
+            public:
+                GLXYSeriesData &operator=(const GLXYSeriesData &data) {
+                    array = data.array;
+                    dirty = data.dirty;
+                    color = data.color;
+                    width = data.width;
+                    type = data.type;
+                    min = data.min;
+                    delta = data.delta;
+                    matrix = data.matrix;
+                    return *this;
+                }
             };
             typedef QMap<const QXYSeries *, GLXYSeriesData *> GLXYDataMap;
                     foreach (GLXYSeriesData *data, m_seriesDataMap.values())
                         data->dirty = false;
                 }
+                void handleAxisReverseChanged(const QList<QAbstractSeries *> &seriesList);
             public Q_SLOTS:
                 void cleanup();

src/chartsqml2/declarativerendernode.cpp +7 -17

                     "uniform highp vec2 min;\n"
                     "uniform highp vec2 delta;\n"
                     "uniform highp float pointSize;\n"
+                    "uniform highp mat4 matrix;\n"
                     "void main() {\n"
                     "  vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
-                    "  gl_Position = vec4(normalPoint, 0, 1);\n"
+                    "  gl_Position = matrix * vec4(normalPoint, 0, 1);\n"
                     "  gl_PointSize = pointSize;\n"
                     "}";
             static const char *fragmentSource =
                 m_minUniformLoc = m_program->uniformLocation("min");
                 m_deltaUniformLoc = m_program->uniformLocation("delta");
                 m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
+                m_matrixUniformLoc = m_program->uniformLocation("matrix");
                 // Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
                 // implementations this is optional and support may not be present
                         const GLXYSeriesData *newData = i.value();
                         if (!data || newData->dirty) {
                             data = new GLXYSeriesData;
-                            data->array = newData->array;
+                            *data = *newData;
-                            data->color = newData->color;
-                            data->dirty = newData->dirty;
-                            data->width = newData->width;
-                            data->type = newData->type;
-                            data->min = newData->min;
-                            data->delta = newData->delta;
                         }
                         m_xyDataMap.insert(i.key(), data);
                     }
                         const GLXYSeriesData *newData = i.value();
                         if (i.value()->dirty) {
                             GLXYSeriesData *data = m_xyDataMap.value(i.key());
-                            if (data) {
+                            if (data)
-                                data->array = newData->array;
+                                *data = *newData;
-                                data->color = newData->color;
-                                data->dirty = newData->dirty;
-                                data->width = newData->width;
-                                data->type = newData->type;
-                                data->min = newData->min;
-                                data->delta = newData->delta;
                         }
                     }
                 }
                     m_program->setUniformValue(m_colorUniformLoc, data->color);
                     m_program->setUniformValue(m_minUniformLoc, data->min);
                     m_program->setUniformValue(m_deltaUniformLoc, data->delta);
+                    m_program->setUniformValue(m_matrixUniformLoc, data->matrix);
                     if (!vbo) {
                         vbo = new QOpenGLBuffer;

src/chartsqml2/declarativerendernode.h +1 0

                 int m_minUniformLoc;
                 int m_deltaUniformLoc;
                 int m_pointSizeUniformLoc;
+                int m_matrixUniformLoc;
                 QOpenGLVertexArrayObject m_vao;
                 QHash<const QAbstractSeries *, QOpenGLBuffer *> m_seriesBufferMap;
                 bool m_renderNeeded;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages