HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2820:79a856530b69

Accelerating lineseries with OpenGL...

Miikka Heikkinen -

r2820:79a856530b69

parent child

Context file:

r2820:79a856530b69

Expand all files

examples/charts/openglseries/datasource.cpp created 644 +118 0

@@ -0,0 +1,118
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "datasource.h"
	20	#include <QtCore/QtMath>
	21
	22	QT_CHARTS_USE_NAMESPACE
	23
	24	DataSource::DataSource(QObject *parent) :
	25	QObject(parent),
	26	m_index(-1)
	27	{
	28	generateData(0, 0, 0);
	29	}
	30
	31	void DataSource::update(QAbstractSeries *series, int seriesIndex)
	32	{
	33	if (series) {
	34	QXYSeries xySeries = static_cast<QXYSeries >(series);
	35	const QVector<QVector<QPointF> > &seriesData = m_data.at(seriesIndex);
	36	if (seriesIndex == 0)
	37	m_index++;
	38	if (m_index > seriesData.count() - 1)
	39	m_index = 0;
	40
	41	QVector<QPointF> points = seriesData.at(m_index);
	42	// Use replace instead of clear + append, it's optimized for performance
	43	xySeries->replace(points);
	44	}
	45	}
	46
	47	void DataSource::handleSceneChanged()
	48	{
	49	m_dataUpdater.start();
	50	}
	51
	52	void DataSource::updateAllSeries()
	53	{
	54	static int frameCount = 0;
	55	static QString labelText = QStringLiteral("FPS: %1");
	56
	57	for (int i = 0; i < m_seriesList.size(); i++)
	58	update(m_seriesList[i], i);
	59
	60	frameCount++;
	61	int elapsed = m_fpsTimer.elapsed();
	62	if (elapsed >= 1000) {
	63	elapsed = m_fpsTimer.restart();
	64	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	65	m_fpsLabel->setText(labelText.arg(QString::number(fps, 'f', 1)));
	66	frameCount = 0;
	67	}
	68	}
	69
	70	void DataSource::startUpdates(const QList<QXYSeries > &seriesList, QLabel fpsLabel)
	71	{
	72	m_seriesList = seriesList;
	73	m_fpsLabel = fpsLabel;
	74
	75	m_dataUpdater.setInterval(0);
	76	m_dataUpdater.setSingleShot(true);
	77	QObject::connect(&m_dataUpdater, &QTimer::timeout,
	78	this, &DataSource::updateAllSeries);
	79
	80	m_fpsTimer.start();
	81	updateAllSeries();
	82	}
	83
	84	void DataSource::generateData(int seriesCount, int rowCount, int colCount)
	85	{
	86	// Remove previous data
	87	foreach (QVector<QVector<QPointF> > seriesData, m_data) {
	88	foreach (QVector<QPointF> row, seriesData)
	89	row.clear();
	90	}
	91
	92	m_data.clear();
	93
	94	qreal xAdjustment = 20.0 / (colCount * rowCount);
	95	qreal yMultiplier = 3.0 / qreal(seriesCount);
	96
	97	// Append the new data depending on the type
	98	for (int k(0); k < seriesCount; k++) {
	99	QVector<QVector<QPointF> > seriesData;
	100	qreal height = qreal(k) * (10.0 / qreal(seriesCount)) + 0.3;
	101	for (int i(0); i < rowCount; i++) {
	102	QVector<QPointF> points;
	103	points.reserve(colCount);
	104	for (int j(0); j < colCount; j++) {
	105	qreal x(0);
	106	qreal y(0);
	107	// data with sin + random component
	108	y = height + (yMultiplier * qSin(3.14159265358979 / 50 * j)
	109	+ (yMultiplier * (qreal) rand() / (qreal) RAND_MAX));
	110	// 0.000001 added to make values logaxis compatible
	111	x = 0.000001 + 20.0 * (qreal(j) / qreal(colCount)) + (xAdjustment * qreal(i));
	112	points.append(QPointF(x, y));
	113	}
	114	seriesData.append(points);
	115	}
	116	m_data.append(seriesData);
	117	}
	118	}

examples/charts/openglseries/datasource.h created 644 +53 0

@@ -0,0 +1,53
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DATASOURCE_H
	20	#define DATASOURCE_H
	21
	22	#include <QtCore/QObject>
	23	#include <QtCharts/QXYSeries>
	24	#include <QtWidgets/QLabel>
	25	#include <QtCore/QElapsedTimer>
	26	#include <QtCore/QTimer>
	27
	28	QT_CHARTS_USE_NAMESPACE
	29
	30	class DataSource : public QObject
	31	{
	32	Q_OBJECT
	33	public:
	34	explicit DataSource(QObject *parent = 0);
	35
	36	void startUpdates(const QList<QXYSeries > &seriesList, QLabel fpsLabel);
	37
	38	public slots:
	39	void generateData(int seriesCount, int rowCount, int colCount);
	40	void update(QAbstractSeries *series, int seriesIndex);
	41	void handleSceneChanged();
	42	void updateAllSeries();
	43
	44	private:
	45	QVector<QVector<QVector<QPointF> > > m_data;
	46	int m_index;
	47	QList<QXYSeries *> m_seriesList;
	48	QLabel *m_fpsLabel;
	49	QElapsedTimer m_fpsTimer;
	50	QTimer m_dataUpdater;
	51	};
	52
	53	#endif // DATASOURCE_H

examples/charts/openglseries/main.cpp created 644 +167 0

@@ -0,0 +1,167
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "datasource.h"
	20	#include <QtWidgets/QApplication>
	21	#include <QtWidgets/QMainWindow>
	22	#include <QtCharts/QChartView>
	23	#include <QtCharts/QLineSeries>
	24	#include <QtCharts/QScatterSeries>
	25	#include <QtCharts/QValueAxis>
	26	#include <QtCharts/QLogValueAxis>
	27	#include <QtWidgets/QLabel>
	28
	29	// Uncomment to use logarithmic axes instead of regular value axes
	30	//#define USE_LOG_AXIS
	31
	32	// Uncomment to use regular series instead of OpenGL accelerated series
	33	//#define DONT_USE_GL_SERIES
	34
	35	// Uncomment to add a simple regular series (thick line) and a matching OpenGL series (thinner line)
	36	// to verify the series have same visible geometry.
	37	//#define ADD_SIMPLE_SERIES
	38
	39	QT_CHARTS_USE_NAMESPACE
	40
	41	int main(int argc, char *argv[])
	42	{
	43	QApplication a(argc, argv);
	44	QStringList colors;
	45	colors << "red" << "blue" << "green" << "black";
	46
	47	QChart *chart = new QChart();
	48	chart->legend()->hide();
	49
	50	#ifdef USE_LOG_AXIS
	51	QLogValueAxis *axisX = new QLogValueAxis;
	52	QLogValueAxis *axisY = new QLogValueAxis;
	53	#else
	54	QValueAxis *axisX = new QValueAxis;
	55	QValueAxis *axisY = new QValueAxis;
	56	#endif
	57
	58	chart->addAxis(axisX, Qt::AlignBottom);
	59	chart->addAxis(axisY, Qt::AlignLeft);
	60
	61	const int seriesCount = 10;
	62	#ifdef DONT_USE_GL_SERIES
	63	const int pointCount = 100;
	64	chart->setTitle("Unaccelerated Series");
	65	#else
	66	const int pointCount = 10000;
	67	chart->setTitle("OpenGL Accelerated Series");
	68	#endif
	69
	70	QList<QXYSeries *> seriesList;
	71	for (int i = 0; i < seriesCount; i++) {
	72	QXYSeries *series = 0;
	73	int colorIndex = i % colors.size();
	74	if (i % 2) {
	75	series = new QScatterSeries;
	76	QScatterSeries scatter = static_cast<QScatterSeries >(series);
	77	scatter->setColor(QColor(colors.at(colorIndex)));
	78	scatter->setMarkerSize(qreal(colorIndex + 2) / 2.0);
	79	// Scatter pen doesn't have affect in OpenGL drawing, but if you disable OpenGL drawing
	80	// this makes the marker border visible and gives comparable marker size to OpenGL
	81	// scatter points.
	82	scatter->setPen(QPen("black"));
	83	} else {
	84	series = new QLineSeries;
	85	series->setPen(QPen(QBrush(QColor(colors.at(colorIndex))),
	86	qreal(colorIndex + 2) / 2.0));
	87	}
	88	seriesList.append(series);
	89	#ifdef DONT_USE_GL_SERIES
	90	series->setUseOpenGL(false);
	91	#else
	92	//![1]
	93	series->setUseOpenGL(true);
	94	//![1]
	95	#endif
	96	chart->addSeries(series);
	97	series->attachAxis(axisX);
	98	series->attachAxis(axisY);
	99	}
	100
	101	if (axisX->type() == QAbstractAxis::AxisTypeLogValue)
	102	axisX->setRange(0.1, 20.0);
	103	else
	104	axisX->setRange(0, 20.0);
	105
	106	if (axisY->type() == QAbstractAxis::AxisTypeLogValue)
	107	axisY->setRange(0.1, 10.0);
	108	else
	109	axisY->setRange(0, 10.0);
	110
	111	#ifdef ADD_SIMPLE_SERIES
	112	QLineSeries *simpleRasterSeries = new QLineSeries;
	113	*simpleRasterSeries << QPointF(0.001, 0.001)
	114	<< QPointF(2.5, 8.0)
	115	<< QPointF(5.0, 4.0)
	116	<< QPointF(7.5, 9.0)
	117	<< QPointF(10.0, 0.001)
	118	<< QPointF(12.5, 2.0)
	119	<< QPointF(15.0, 1.0)
	120	<< QPointF(17.5, 6.0)
	121	<< QPointF(20.0, 10.0);
	122	simpleRasterSeries->setUseOpenGL(false);
	123	simpleRasterSeries->setPen(QPen(QBrush("magenta"), 8));
	124	chart->addSeries(simpleRasterSeries);
	125	simpleRasterSeries->attachAxis(axisX);
	126	simpleRasterSeries->attachAxis(axisY);
	127
	128	QLineSeries *simpleGLSeries = new QLineSeries;
	129	simpleGLSeries->setUseOpenGL(true);
	130	simpleGLSeries->setPen(QPen(QBrush("black"), 2));
	131	simpleGLSeries->replace(simpleRasterSeries->points());
	132	chart->addSeries(simpleGLSeries);
	133	simpleGLSeries->attachAxis(axisX);
	134	simpleGLSeries->attachAxis(axisY);
	135	#endif
	136
	137	QChartView *chartView = new QChartView(chart);
	138
	139	QMainWindow window;
	140	window.setCentralWidget(chartView);
	141	window.resize(600, 400);
	142	window.show();
	143
	144	DataSource dataSource;
	145	dataSource.generateData(seriesCount, 10, pointCount);
	146
	147	QLabel *fpsLabel = new QLabel(&window);
	148	QLabel *countLabel = new QLabel(&window);
	149	QString countText = QStringLiteral("Total point count: %1");
	150	countLabel->setText(countText.arg(pointCount * seriesCount));
	151	countLabel->resize(window.width(), countLabel->height());
	152	fpsLabel->move(10,2);
	153	fpsLabel->raise();
	154	fpsLabel->show();
	155	countLabel->move(10, 14);
	156	fpsLabel->raise();
	157	countLabel->show();
	158
	159	// We can get more than one changed event per frame, so do async update.
	160	// This also allows the application to be responsive.
	161	QObject::connect(chart->scene(), &QGraphicsScene::changed,
	162	&dataSource, &DataSource::handleSceneChanged);
	163
	164	dataSource.startUpdates(seriesList, fpsLabel);
	165
	166	return a.exec();
	167	}

examples/charts/openglseries/openglseries.pro created 644 +9 0

@@ -0,0 +1,9
	1	!include( ../examples.pri ) {
	2	error( "Couldn't find the examples.pri file!" )
	3	}
	4
	5	TARGET = openglseries
	6	SOURCES += main.cpp \
	7	datasource.cpp
	8	HEADERS += datasource.h
	9

src/charts/doc/images/examples_openglseries.png created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

src/charts/doc/src/examples-openglseries.qdoc created 644 +37 0

@@ -0,0 +1,37
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	/*!
	20	\example openglseries
	21	\title OpenGL Accelerated Series Example
	22	\ingroup qtcharts_examples
	23
	24	\brief The example shows how to enable OpenGL acceleration for QLineSeries and QScatterSeries.
	25
	26	\image examples_openglseries.png
	27
	28	To create an OpenGL accelerated series, all you have to do compared to a regular
	29	series is to set QAbstractSeries::useOpenGL property to \c{true}:
	30
	31	\snippet openglseries/main.cpp 1
	32
	33	This makes the chart to instantiate a transparent QOpenGLWidget that is used to draw
	34	the accelerated series on top of the chart.
	35
	36	\note The OpenGL acceleration is only supported for QLineSeries and QScatterSeries.
	37	*/

src/charts/glwidget.cpp created 644 +222 0

@@ -0,0 +1,222
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef QT_NO_OPENGL
	20
	21	#include "private/glwidget_p.h"
	22	#include "private/glxyseriesdata_p.h"
	23	#include <QtGui/QOpenGLShaderProgram>
	24	#include <QtGui/QOpenGLContext>
	25	#include <QtGui/QOpenGLBuffer>
	26
	27	//#define QDEBUG_TRACE_GL_FPS
	28	#ifdef QDEBUG_TRACE_GL_FPS
	29	# include <QElapsedTimer>
	30	#endif
	31
	32	QT_CHARTS_BEGIN_NAMESPACE
	33
	34	GLWidget::GLWidget(GLXYSeriesDataManager xyDataManager, QWidget parent)
	35	: QOpenGLWidget(parent),
	36	m_program(0),
	37	m_shaderAttribLoc(-1),
	38	m_colorUniformLoc(-1),
	39	m_minUniformLoc(-1),
	40	m_deltaUniformLoc(-1),
	41	m_pointSizeUniformLoc(-1),
	42	m_xyDataManager(xyDataManager)
	43	{
	44	setAttribute(Qt::WA_TranslucentBackground);
	45	setAttribute(Qt::WA_AlwaysStackOnTop);
	46	setAttribute(Qt::WA_TransparentForMouseEvents);
	47
	48	QSurfaceFormat surfaceFormat;
	49	surfaceFormat.setDepthBufferSize(0);
	50	surfaceFormat.setStencilBufferSize(0);
	51	surfaceFormat.setRedBufferSize(8);
	52	surfaceFormat.setGreenBufferSize(8);
	53	surfaceFormat.setBlueBufferSize(8);
	54	surfaceFormat.setAlphaBufferSize(8);
	55	surfaceFormat.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
	56	surfaceFormat.setRenderableType(QSurfaceFormat::DefaultRenderableType);
	57	setFormat(surfaceFormat);
	58
	59	connect(xyDataManager, &GLXYSeriesDataManager::seriesRemoved,
	60	this, &GLWidget::cleanXYSeriesResources);
	61	}
	62
	63	GLWidget::~GLWidget()
	64	{
	65	cleanup();
	66	}
	67
	68	void GLWidget::cleanup()
	69	{
	70	makeCurrent();
	71
	72	delete m_program;
	73	m_program = 0;
	74
	75	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	76	delete buffer;
	77	m_seriesBufferMap.clear();
	78
	79	doneCurrent();
	80	}
	81
	82	void GLWidget::cleanXYSeriesResources(const QXYSeries *series)
	83	{
	84	makeCurrent();
	85	if (series) {
	86	delete m_seriesBufferMap.take(series);
	87	} else {
	88	// Null series means all series were removed
	89	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	90	delete buffer;
	91	m_seriesBufferMap.clear();
	92	}
	93	doneCurrent();
	94	}
	95
	96	static const char *vertexSource =
	97	"attribute highp vec2 points;\n"
	98	"uniform highp vec2 min;\n"
	99	"uniform highp vec2 delta;\n"
	100	"uniform highp float pointSize;\n"
	101	"void main() {\n"
	102	" vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
	103	" gl_Position = vec4(normalPoint, 0, 1);\n"
	104	" gl_PointSize = pointSize;\n"
	105	"}";
	106	static const char *fragmentSource =
	107	"uniform highp vec3 color;\n"
	108	"void main() {\n"
	109	" gl_FragColor = vec4(color,1);\n"
	110	"}\n";
	111
	112	void GLWidget::initializeGL()
	113	{
	114	connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &GLWidget::cleanup);
	115
	116	initializeOpenGLFunctions();
	117	glClearColor(0, 0, 0, 0);
	118
	119	m_program = new QOpenGLShaderProgram;
	120	m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
	121	m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
	122	m_program->bindAttributeLocation("points", 0);
	123	m_program->link();
	124
	125	m_program->bind();
	126	m_colorUniformLoc = m_program->uniformLocation("color");
	127	m_minUniformLoc = m_program->uniformLocation("min");
	128	m_deltaUniformLoc = m_program->uniformLocation("delta");
	129	m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
	130
	131
	132	// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
	133	// implementations this is optional and support may not be present
	134	// at all. Nonetheless the below code works in all cases and makes
	135	// sure there is a VAO when one is needed.
	136	m_vao.create();
	137	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	138
	139	glEnableVertexAttribArray(0);
	140
	141	glDisable(GL_DEPTH_TEST);
	142	glDisable(GL_STENCIL_TEST);
	143
	144	#if !defined(QT_OPENGL_ES_2)
	145	if (!QOpenGLContext::currentContext()->isOpenGLES()) {
	146	// Make it possible to change point primitive size and use textures with them in
	147	// the shaders. These are implicitly enabled in ES2.
	148	glEnable(GL_PROGRAM_POINT_SIZE);
	149	}
	150	#endif
	151
	152	m_program->release();
	153	}
	154
	155	void GLWidget::paintGL()
	156	{
	157	glClear(GL_COLOR_BUFFER_BIT);
	158
	159	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	160	m_program->bind();
	161
	162	GLXYDataMapIterator i(m_xyDataManager->dataMap());
	163	while (i.hasNext()) {
	164	i.next();
	165	QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
	166	GLXYSeriesData *data = i.value();
	167
	168	m_program->setUniformValue(m_colorUniformLoc, data->color);
	169	m_program->setUniformValue(m_minUniformLoc, data->min);
	170	m_program->setUniformValue(m_deltaUniformLoc, data->delta);
	171
	172	if (!vbo) {
	173	vbo = new QOpenGLBuffer;
	174	m_seriesBufferMap.insert(i.key(), vbo);
	175	vbo->create();
	176	}
	177	vbo->bind();
	178	if (data->dirty) {
	179	vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
	180	data->dirty = false;
	181	}
	182
	183	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
	184	if (data->type == QAbstractSeries::SeriesTypeLine) {
	185	glLineWidth(data->width);
	186	glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
	187	} else { // Scatter
	188	m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
	189	glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
	190	}
	191	vbo->release();
	192	}
	193
	194	#ifdef QDEBUG_TRACE_GL_FPS
	195	static QElapsedTimer stopWatch;
	196	static int frameCount = -1;
	197	if (frameCount == -1) {
	198	stopWatch.start();
	199	frameCount = 0;
	200	}
	201	frameCount++;
	202	int elapsed = stopWatch.elapsed();
	203	if (elapsed >= 1000) {
	204	elapsed = stopWatch.restart();
	205	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	206	qDebug() << "FPS:" << fps;
	207	frameCount = 0;
	208	}
	209	#endif
	210
	211	m_program->release();
	212	}
	213
	214	void GLWidget::resizeGL(int w, int h)
	215	{
	216	Q_UNUSED(w)
	217	Q_UNUSED(h)
	218	}
	219
	220	QT_CHARTS_END_NAMESPACE
	221
	222	#endif

src/charts/glwidget_p.h created 644 +80 0

@@ -0,0 +1,80
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	// W A R N I N G
	20	// -------------
	21	//
	22	// This file is not part of the Qt Chart API. It exists purely as an
	23	// implementation detail. This header file may change from version to
	24	// version without notice, or even be removed.
	25	//
	26	// We mean it.
	27
	28	#ifndef GLWIDGET_H
	29	#define GLWIDGET_H
	30
	31	#ifndef QT_NO_OPENGL
	32
	33	#include <QtWidgets/QOpenGLWidget>
	34	#include <QtGui/QOpenGLFunctions>
	35	#include <QtGui/QOpenGLVertexArrayObject>
	36	#include <QtCore/QHash>
	37	#include <QtCharts/QAbstractSeries>
	38	#include <QtCharts/QXYSeries>
	39
	40	QT_FORWARD_DECLARE_CLASS(QOpenGLShaderProgram)
	41
	42	class QOpenGLBuffer;
	43
	44	QT_CHARTS_BEGIN_NAMESPACE
	45
	46	class GLXYSeriesDataManager;
	47
	48	class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions
	49	{
	50	Q_OBJECT
	51
	52	public:
	53	GLWidget(GLXYSeriesDataManager xyDataManager, QWidget parent = 0);
	54	~GLWidget();
	55
	56	public Q_SLOTS:
	57	void cleanup();
	58	void cleanXYSeriesResources(const QXYSeries *series);
	59
	60	protected:
	61	void initializeGL() Q_DECL_OVERRIDE;
	62	void paintGL() Q_DECL_OVERRIDE;
	63	void resizeGL(int width, int height) Q_DECL_OVERRIDE;
	64
	65	private:
	66	QOpenGLShaderProgram *m_program;
	67	int m_shaderAttribLoc;
	68	int m_colorUniformLoc;
	69	int m_minUniformLoc;
	70	int m_deltaUniformLoc;
	71	int m_pointSizeUniformLoc;
	72	QOpenGLVertexArrayObject m_vao;
	73
	74	QHash<const QAbstractSeries , QOpenGLBuffer > m_seriesBufferMap;
	75	GLXYSeriesDataManager *m_xyDataManager;
	76	};
	77
	78	QT_CHARTS_END_NAMESPACE
	79	#endif
	80	#endif

src/charts/xychart/glxyseriesdata.cpp created 644 +147 0

@@ -0,0 +1,147
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "private/glxyseriesdata_p.h"
	20	#include "private/abstractdomain_p.h"
	21	#include <QtCharts/QScatterSeries>
	22
	23	QT_CHARTS_BEGIN_NAMESPACE
	24
	25	GLXYSeriesDataManager::GLXYSeriesDataManager(QObject *parent)
	26	: QObject(parent),
	27	m_mapDirty(false)
	28	{
	29	}
	30
	31	GLXYSeriesDataManager::~GLXYSeriesDataManager()
	32	{
	33	cleanup();
	34	}
	35
	36	void GLXYSeriesDataManager::setPoints(QXYSeries series, const AbstractDomain domain)
	37	{
	38	GLXYSeriesData *data = m_seriesDataMap.value(series);
	39	if (!data) {
	40	data = new GLXYSeriesData;
	41	data->type = series->type();
	42	QColor sc;
	43	if (data->type == QAbstractSeries::SeriesTypeScatter) {
	44	QScatterSeries scatter = static_cast<QScatterSeries >(series);
	45	data->width = float(scatter->markerSize());
	46	sc = scatter->color(); // Scatter overwrites color property
	47	} else {
	48	data->width = float(series->pen().widthF());
	49	sc = series->color();
	50	}
	51	data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
	52	connect(series, &QXYSeries::penChanged, this,
	53	&GLXYSeriesDataManager::handleSeriesPenChange);
	54	connect(series, &QXYSeries::useOpenGLChanged, this,
	55	&GLXYSeriesDataManager::handleSeriesOpenGLChange);
	56	m_seriesDataMap.insert(series, data);
	57	m_mapDirty = true;
	58	}
	59	QVector<float> &array = data->array;
	60
	61	bool logAxis = false;
	62	foreach (QAbstractAxis* axis, series->attachedAxes()) {
	63	if (axis->type() == QAbstractAxis::AxisTypeLogValue) {
	64	logAxis = true;
	65	break;
	66	}
	67	}
	68
	69	int count = series->count();
	70	int index = 0;
	71	array.resize(count * 2);
	72	if (logAxis) {
	73	// Use domain to resolve geometry points. Not as fast as shaders, but simpler that way
	74	QVector<QPointF> geometryPoints = domain->calculateGeometryPoints(series->pointsVector());
	75	const float height = domain->size().height();
	76	if (geometryPoints.size()) {
	77	for (int i = 0; i < count; i++) {
	78	const QPointF &point = geometryPoints.at(i);
	79	array[index++] = float(point.x());
	80	array[index++] = float(height - point.y());
	81	}
	82	} else {
	83	// If there are invalid log values, geometry points generation fails
	84	for (int i = 0; i < count; i++) {
	85	array[index++] = 0.0f;
	86	array[index++] = 0.0f;
	87	}
	88	}
	89	data->min = QVector2D(0, 0);
	90	data->delta = QVector2D(domain->size().width() / 2.0f, domain->size().height() / 2.0f);
	91	} else {
	92	// Regular value axes, so we can do the math easily on shaders.
	93	QVector<QPointF> seriesPoints = series->pointsVector();
	94	for (int i = 0; i < count; i++) {
	95	const QPointF &point = seriesPoints.at(i);
	96	array[index++] = float(point.x());
	97	array[index++] = float(point.y());
	98	}
	99	data->min = QVector2D(domain->minX(), domain->minY());
	100	data->delta = QVector2D((domain->maxX() - domain->minX()) / 2.0f,
	101	(domain->maxY() - domain->minY()) / 2.0f);
	102	}
	103	data->dirty = true;
	104	}
	105
	106	void GLXYSeriesDataManager::removeSeries(const QXYSeries *series)
	107	{
	108	GLXYSeriesData *data = m_seriesDataMap.take(series);
	109	if (data) {
	110	disconnect(series, 0, this, 0);
	111	delete data;
	112	emit seriesRemoved(series);
	113	m_mapDirty = true;
	114	}
	115	}
	116
	117	void GLXYSeriesDataManager::cleanup()
	118	{
	119	foreach (GLXYSeriesData *data, m_seriesDataMap.values())
	120	delete data;
	121	m_seriesDataMap.clear();
	122	m_mapDirty = true;
	123	// Signal all series removal by using zero as parameter
	124	emit seriesRemoved(0);
	125	}
	126
	127	void GLXYSeriesDataManager::handleSeriesPenChange()
	128	{
	129	QXYSeries series = qobject_cast<QXYSeries >(sender());
	130	if (series) {
	131	GLXYSeriesData *data = m_seriesDataMap.value(series);
	132	if (data) {
	133	QColor sc = series->color();
	134	data->color = QVector3D(float(sc.redF()), float(sc.greenF()), float(sc.blueF()));
	135	data->width = float(series->pen().widthF());
	136	}
	137	}
	138	}
	139
	140	void GLXYSeriesDataManager::handleSeriesOpenGLChange()
	141	{
	142	QXYSeries series = qobject_cast<QXYSeries >(sender());
	143	if (!series->useOpenGL())
	144	removeSeries(series);
	145	}
	146
	147	QT_CHARTS_END_NAMESPACE

src/charts/xychart/glxyseriesdata_p.h created 644 +91 0

@@ -0,0 +1,91
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	// W A R N I N G
	20	// -------------
	21	//
	22	// This file is not part of the Qt Chart API. It exists purely as an
	23	// implementation detail. This header file may change from version to
	24	// version without notice, or even be removed.
	25	//
	26	// We mean it.
	27
	28	#ifndef GLXYSERIESDATA_H
	29	#define GLXYSERIESDATA_H
	30
	31	#include <QtCore/QMap>
	32	#include <QtCharts/QAbstractSeries>
	33	#include <QtCharts/QXYSeries>
	34	#include <QtGui/QVector3D>
	35	#include <QtGui/QVector2D>
	36
	37	QT_CHARTS_BEGIN_NAMESPACE
	38
	39	class AbstractDomain;
	40
	41	struct GLXYSeriesData {
	42	QVector<float> array;
	43	bool dirty;
	44	QVector3D color;
	45	float width;
	46	QAbstractSeries::SeriesType type;
	47	QVector2D min;
	48	QVector2D delta;
	49	};
	50
	51	typedef QMap<const QXYSeries , GLXYSeriesData > GLXYDataMap;
	52	typedef QMapIterator<const QXYSeries , GLXYSeriesData > GLXYDataMapIterator;
	53
	54	class GLXYSeriesDataManager : public QObject
	55	{
	56	Q_OBJECT
	57
	58	public:
	59	GLXYSeriesDataManager(QObject *parent = 0);
	60	~GLXYSeriesDataManager();
	61
	62	void setPoints(QXYSeries series, const AbstractDomain domain);
	63
	64	void removeSeries(const QXYSeries *series);
	65
	66	GLXYDataMap &dataMap() { return m_seriesDataMap; }
	67
	68	// These functions are needed by qml side, so they must be inline
	69	bool mapDirty() const { return m_mapDirty; }
	70	void clearAllDirty() {
	71	m_mapDirty = false;
	72	foreach (GLXYSeriesData *data, m_seriesDataMap.values())
	73	data->dirty = false;
	74	}
	75
	76	public Q_SLOTS:
	77	void cleanup();
	78	void handleSeriesPenChange();
	79	void handleSeriesOpenGLChange();
	80
	81	Q_SIGNALS:
	82	void seriesRemoved(const QXYSeries *series);
	83
	84	private:
	85	GLXYDataMap m_seriesDataMap;
	86	bool m_mapDirty;
	87	};
	88
	89	QT_CHARTS_END_NAMESPACE
	90
	91	#endif

src/chartsqml2/declarativechartnode.cpp created 644 +78 0

@@ -0,0 +1,78
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "declarativechartnode.h"
	20	#include "declarativerendernode.h"
	21	#include <QtGui/QOpenGLContext>
	22	#include <QtGui/QOpenGLFunctions>
	23	#include <QtGui/QOpenGLFramebufferObjectFormat>
	24	#include <QtGui/QOpenGLFramebufferObject>
	25	#include <QOpenGLShaderProgram>
	26	#include <QtGui/QOpenGLBuffer>
	27
	28	QT_CHARTS_BEGIN_NAMESPACE
	29
	30	// This node handles displaying of the chart itself
	31	DeclarativeChartNode::DeclarativeChartNode(QQuickWindow *window) :
	32	QSGSimpleTextureNode(),
	33	m_texture(0),
	34	m_window(window),
	35	m_textureOptions(0),
	36	m_textureSize(1, 1),
	37	m_glRenderNode(0)
	38	{
	39	initializeOpenGLFunctions();
	40
	41	// Our texture node must have a texture, so use a default one pixel texture
	42	GLuint defaultTexture = 0;
	43	glGenTextures(1, &defaultTexture);
	44	glBindTexture(GL_TEXTURE_2D, defaultTexture);
	45	uchar buf[4] = { 0, 0, 0, 0 };
	46	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf);
	47
	48	QQuickWindow::CreateTextureOptions defaultTextureOptions = QQuickWindow::CreateTextureOptions(
	49	QQuickWindow::TextureHasAlphaChannel \| QQuickWindow::TextureOwnsGLTexture);
	50	m_texture = m_window->createTextureFromId(defaultTexture, QSize(1, 1), defaultTextureOptions);
	51
	52	setTexture(m_texture);
	53	setFiltering(QSGTexture::Linear);
	54
	55	// Create child node for rendering GL graphics
	56	m_glRenderNode = new DeclarativeRenderNode(m_window);
	57	m_glRenderNode->setFlag(OwnedByParent);
	58	appendChildNode(m_glRenderNode);
	59	m_glRenderNode->setRect(0, 0, 0, 0); // Hide child node by default
	60	}
	61
	62	DeclarativeChartNode::~DeclarativeChartNode()
	63	{
	64	delete m_texture;
	65	}
	66
	67	// Must be called on render thread and in context
	68	void DeclarativeChartNode::createTextureFromImage(const QImage &chartImage)
	69	{
	70	if (chartImage.size() != m_textureSize)
	71	m_textureSize = chartImage.size();
	72
	73	delete m_texture;
	74	m_texture = m_window->createTextureFromImage(chartImage, m_textureOptions);
	75	setTexture(m_texture);
	76	}
	77
	78	QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativechartnode.h created 644 +50 0

@@ -0,0 +1,50
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DECLARATIVECHARTNODE_P_H
	20	#define DECLARATIVECHARTNODE_P_H
	21
	22	#include <QtCharts/QChartGlobal>
	23	#include <QtQuick/QSGSimpleTextureNode>
	24	#include <QtQuick/QQuickWindow>
	25	#include <QtGui/QOpenGLFunctions>
	26
	27	QT_CHARTS_BEGIN_NAMESPACE
	28
	29	class DeclarativeRenderNode;
	30
	31	class DeclarativeChartNode : public QSGSimpleTextureNode, QOpenGLFunctions
	32	{
	33	public:
	34	DeclarativeChartNode(QQuickWindow *window);
	35	~DeclarativeChartNode();
	36
	37	void createTextureFromImage(const QImage &chartImage);
	38	DeclarativeRenderNode *glRenderNode() const { return m_glRenderNode; }
	39
	40	private:
	41	QSGTexture *m_texture;
	42	QQuickWindow *m_window;
	43	QQuickWindow::CreateTextureOptions m_textureOptions;
	44	QSize m_textureSize;
	45	DeclarativeRenderNode *m_glRenderNode;
	46	};
	47
	48	QT_CHARTS_END_NAMESPACE
	49
	50	#endif // DECLARATIVECHARTNODE_P_H

src/chartsqml2/declarativerendernode.cpp created 644 +317 0

@@ -0,0 +1,317
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#include "declarativerendernode.h"
	20
	21	#include <QtGui/QOpenGLContext>
	22	#include <QtGui/QOpenGLFunctions>
	23	#include <QtGui/QOpenGLFramebufferObjectFormat>
	24	#include <QtGui/QOpenGLFramebufferObject>
	25	#include <QOpenGLShaderProgram>
	26	#include <QtGui/QOpenGLBuffer>
	27
	28	//#define QDEBUG_TRACE_GL_FPS
	29	#ifdef QDEBUG_TRACE_GL_FPS
	30	# include <QElapsedTimer>
	31	#endif
	32
	33	QT_CHARTS_BEGIN_NAMESPACE
	34
	35	// This node draws the xy series data on a transparent background using OpenGL.
	36	// It is used as a child node of the chart node.
	37	DeclarativeRenderNode::DeclarativeRenderNode(QQuickWindow *window) :
	38	QObject(),
	39	QSGSimpleTextureNode(),
	40	m_texture(0),
	41	m_window(window),
	42	m_textureOptions(QQuickWindow::TextureHasAlphaChannel),
	43	m_textureSize(1, 1),
	44	m_recreateFbo(false),
	45	m_fbo(0),
	46	m_program(0),
	47	m_shaderAttribLoc(-1),
	48	m_colorUniformLoc(-1),
	49	m_minUniformLoc(-1),
	50	m_deltaUniformLoc(-1),
	51	m_pointSizeUniformLoc(-1),
	52	m_renderNeeded(true)
	53	{
	54	initializeOpenGLFunctions();
	55
	56	// Our texture node must have a texture, so use a default one pixel texture
	57	GLuint defaultTexture = 0;
	58	glGenTextures(1, &defaultTexture);
	59	glBindTexture(GL_TEXTURE_2D, defaultTexture);
	60	uchar buf[4] = { 0, 0, 0, 0 };
	61	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buf);
	62
	63	QQuickWindow::CreateTextureOptions defaultTextureOptions = QQuickWindow::CreateTextureOptions(
	64	QQuickWindow::TextureHasAlphaChannel \| QQuickWindow::TextureOwnsGLTexture);
	65	m_texture = m_window->createTextureFromId(defaultTexture, QSize(1, 1), defaultTextureOptions);
	66
	67	setTexture(m_texture);
	68	setFiltering(QSGTexture::Linear);
	69	setTextureCoordinatesTransform(QSGSimpleTextureNode::MirrorVertically);
	70	}
	71
	72	DeclarativeRenderNode::~DeclarativeRenderNode()
	73	{
	74	delete m_texture;
	75	delete m_fbo;
	76
	77	delete m_program;
	78	m_program = 0;
	79
	80	cleanXYSeriesResources(0);
	81	}
	82
	83	static const char *vertexSource =
	84	"attribute highp vec2 points;\n"
	85	"uniform highp vec2 min;\n"
	86	"uniform highp vec2 delta;\n"
	87	"uniform highp float pointSize;\n"
	88	"void main() {\n"
	89	" vec2 normalPoint = vec2(-1, -1) + ((points - min) / delta);\n"
	90	" gl_Position = vec4(normalPoint, 0, 1);\n"
	91	" gl_PointSize = pointSize;\n"
	92	"}";
	93	static const char *fragmentSource =
	94	"uniform highp vec3 color;\n"
	95	"void main() {\n"
	96	" gl_FragColor = vec4(color,1);\n"
	97	"}\n";
	98
	99	// Must be called on render thread and in context
	100	void DeclarativeRenderNode::initGL()
	101	{
	102	recreateFBO();
	103
	104	m_program = new QOpenGLShaderProgram;
	105	m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexSource);
	106	m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentSource);
	107	m_program->bindAttributeLocation("points", 0);
	108	m_program->link();
	109
	110	m_program->bind();
	111	m_colorUniformLoc = m_program->uniformLocation("color");
	112	m_minUniformLoc = m_program->uniformLocation("min");
	113	m_deltaUniformLoc = m_program->uniformLocation("delta");
	114	m_pointSizeUniformLoc = m_program->uniformLocation("pointSize");
	115
	116	// Create a vertex array object. In OpenGL ES 2.0 and OpenGL 2.x
	117	// implementations this is optional and support may not be present
	118	// at all. Nonetheless the below code works in all cases and makes
	119	// sure there is a VAO when one is needed.
	120	m_vao.create();
	121	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	122
	123	#if !defined(QT_OPENGL_ES_2)
	124	if (!QOpenGLContext::currentContext()->isOpenGLES()) {
	125	// Make it possible to change point primitive size and use textures with them in
	126	// the shaders. These are implicitly enabled in ES2.
	127	// Qt Quick doesn't change these flags, so it should be safe to just enable them
	128	// at initialization.
	129	glEnable(GL_PROGRAM_POINT_SIZE);
	130	}
	131	#endif
	132
	133	m_program->release();
	134	}
	135
	136	void DeclarativeRenderNode::recreateFBO()
	137	{
	138	QOpenGLFramebufferObjectFormat fboFormat;
	139	fboFormat.setAttachment(QOpenGLFramebufferObject::NoAttachment);
	140	delete m_fbo;
	141	m_fbo = new QOpenGLFramebufferObject(m_textureSize.width(),
	142	m_textureSize.height(),
	143	fboFormat);
	144
	145	delete m_texture;
	146	m_texture = m_window->createTextureFromId(m_fbo->texture(), m_textureSize, m_textureOptions);
	147	setTexture(m_texture);
	148
	149	m_recreateFbo = false;
	150	}
	151
	152	// Must be called on render thread and in context
	153	void DeclarativeRenderNode::setTextureSize(const QSize &size)
	154	{
	155	m_textureSize = size;
	156	m_recreateFbo = true;
	157	m_renderNeeded = true;
	158	}
	159
	160	// Must be called on render thread while gui thread is blocked, and in context
	161	void DeclarativeRenderNode::setSeriesData(bool mapDirty, const GLXYDataMap &dataMap)
	162	{
	163	if (mapDirty) {
	164	// Series have changed, recreate map, but utilize old data where feasible
	165	GLXYDataMap oldMap = m_xyDataMap;
	166	m_xyDataMap.clear();
	167
	168	GLXYDataMapIterator i(dataMap);
	169	while (i.hasNext()) {
	170	i.next();
	171	GLXYSeriesData *data = oldMap.take(i.key());
	172	const GLXYSeriesData *newData = i.value();
	173	if (!data \|\| newData->dirty) {
	174	data = new GLXYSeriesData;
	175	data->array = newData->array;
	176	data->color = newData->color;
	177	data->dirty = newData->dirty;
	178	data->width = newData->width;
	179	data->type = newData->type;
	180	data->min = newData->min;
	181	data->delta = newData->delta;
	182	}
	183	m_xyDataMap.insert(i.key(), data);
	184	}
	185	// Delete remaining old data
	186	i = oldMap;
	187	while (i.hasNext()) {
	188	i.next();
	189	delete i.value();
	190	cleanXYSeriesResources(i.key());
	191	}
	192	} else {
	193	// Series have not changed, so just copy dirty data over
	194	GLXYDataMapIterator i(dataMap);
	195	while (i.hasNext()) {
	196	i.next();
	197	const GLXYSeriesData *newData = i.value();
	198	if (i.value()->dirty) {
	199	GLXYSeriesData *data = m_xyDataMap.value(i.key());
	200	if (data) {
	201	data->array = newData->array;
	202	data->color = newData->color;
	203	data->dirty = newData->dirty;
	204	data->width = newData->width;
	205	data->type = newData->type;
	206	data->min = newData->min;
	207	data->delta = newData->delta;
	208	}
	209	}
	210	}
	211	}
	212	markDirty(DirtyMaterial);
	213	m_renderNeeded = true;
	214	}
	215
	216	void DeclarativeRenderNode::renderGL()
	217	{
	218	glClearColor(0, 0, 0, 0);
	219
	220	QOpenGLVertexArrayObject::Binder vaoBinder(&m_vao);
	221	m_program->bind();
	222	m_fbo->bind();
	223
	224	glClear(GL_COLOR_BUFFER_BIT);
	225	glEnableVertexAttribArray(0);
	226
	227	glViewport(0, 0, m_textureSize.width(), m_textureSize.height());
	228
	229	GLXYDataMapIterator i(m_xyDataMap);
	230	while (i.hasNext()) {
	231	i.next();
	232	QOpenGLBuffer *vbo = m_seriesBufferMap.value(i.key());
	233	GLXYSeriesData *data = i.value();
	234
	235	m_program->setUniformValue(m_colorUniformLoc, data->color);
	236	m_program->setUniformValue(m_minUniformLoc, data->min);
	237	m_program->setUniformValue(m_deltaUniformLoc, data->delta);
	238
	239	if (!vbo) {
	240	vbo = new QOpenGLBuffer;
	241	m_seriesBufferMap.insert(i.key(), vbo);
	242	vbo->create();
	243	}
	244	vbo->bind();
	245	if (data->dirty) {
	246	vbo->allocate(data->array.constData(), data->array.count() * sizeof(GLfloat));
	247	data->dirty = false;
	248	}
	249
	250	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
	251	if (data->type == QAbstractSeries::SeriesTypeLine) {
	252	glLineWidth(data->width);
	253	glDrawArrays(GL_LINE_STRIP, 0, data->array.size() / 2);
	254	} else { // Scatter
	255	m_program->setUniformValue(m_pointSizeUniformLoc, data->width);
	256	glDrawArrays(GL_POINTS, 0, data->array.size() / 2);
	257	}
	258	vbo->release();
	259	}
	260
	261	#ifdef QDEBUG_TRACE_GL_FPS
	262	static QElapsedTimer stopWatch;
	263	static int frameCount = -1;
	264	if (frameCount == -1) {
	265	stopWatch.start();
	266	frameCount = 0;
	267	}
	268	frameCount++;
	269	int elapsed = stopWatch.elapsed();
	270	if (elapsed >= 1000) {
	271	elapsed = stopWatch.restart();
	272	qreal fps = qreal(0.1 * int(10000.0 * (qreal(frameCount) / qreal(elapsed))));
	273	qDebug() << "FPS:" << fps;
	274	frameCount = 0;
	275	}
	276	#endif
	277
	278	markDirty(DirtyMaterial);
	279	m_window->resetOpenGLState();
	280	}
	281
	282	// Must be called on render thread as response to beforeRendering signal
	283	void DeclarativeRenderNode::render()
	284	{
	285	if (m_renderNeeded) {
	286	if (m_xyDataMap.size()) {
	287	if (!m_program)
	288	initGL();
	289	if (m_recreateFbo)
	290	recreateFBO();
	291	renderGL();
	292	} else {
	293	if (rect() != QRectF()) {
	294	glClearColor(0, 0, 0, 0);
	295	m_fbo->bind();
	296	glClear(GL_COLOR_BUFFER_BIT);
	297
	298	// If last series was removed, zero out the node rect
	299	setRect(QRectF());
	300	}
	301	}
	302	m_renderNeeded = false;
	303	}
	304	}
	305
	306	void DeclarativeRenderNode::cleanXYSeriesResources(const QXYSeries *series)
	307	{
	308	if (series) {
	309	delete m_seriesBufferMap.take(series);
	310	} else {
	311	foreach (QOpenGLBuffer *buffer, m_seriesBufferMap.values())
	312	delete buffer;
	313	m_seriesBufferMap.clear();
	314	}
	315	}
	316
	317	QT_CHARTS_END_NAMESPACE

src/chartsqml2/declarativerendernode.h created 644 +74 0

@@ -0,0 +1,74
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2015 The Qt Company Ltd
	4	** All rights reserved.
	5	** For any questions to The Qt Company, please use contact form at http://qt.io
	6	**
	7	** This file is part of the Qt Charts module.
	8	**
	9	** Licensees holding valid commercial license for Qt may use this file in
	10	** accordance with the Qt License Agreement provided with the Software
	11	** or, alternatively, in accordance with the terms contained in a written
	12	** agreement between you and The Qt Company.
	13	**
	14	** If you have questions regarding the use of this file, please use
	15	** contact form at http://qt.io
	16	**
	17	****************************************************************************/
	18
	19	#ifndef DECLARATIVERENDERNODE_P_H
	20	#define DECLARATIVERENDERNODE_P_H
	21
	22	#include <QtCharts/QChartGlobal>
	23	#include <private/glxyseriesdata_p.h>
	24	#include <QtQuick/QSGSimpleTextureNode>
	25	#include <QtQuick/QQuickWindow>
	26	#include <QtGui/QOpenGLVertexArrayObject>
	27	#include <QtGui/QOpenGLFunctions>
	28
	29	class QOpenGLFramebufferObject;
	30	class QOpenGLBuffer;
	31
	32	QT_CHARTS_BEGIN_NAMESPACE
	33
	34	class DeclarativeRenderNode : public QObject, public QSGSimpleTextureNode, QOpenGLFunctions
	35	{
	36	Q_OBJECT
	37	public:
	38	DeclarativeRenderNode(QQuickWindow *window);
	39	~DeclarativeRenderNode();
	40
	41	void initGL();
	42	QSize textureSize() const { return m_textureSize; }
	43	void setTextureSize(const QSize &size);
	44	void setSeriesData(bool mapDirty, const GLXYDataMap &dataMap);
	45
	46	public Q_SLOTS:
	47	void render();
	48
	49	private:
	50	void renderGL();
	51	void recreateFBO();
	52	void cleanXYSeriesResources(const QXYSeries *series);
	53
	54	QSGTexture *m_texture;
	55	QQuickWindow *m_window;
	56	QQuickWindow::CreateTextureOptions m_textureOptions;
	57	QSize m_textureSize;
	58	bool m_recreateFbo;
	59	GLXYDataMap m_xyDataMap;
	60	QOpenGLFramebufferObject *m_fbo;
	61	QOpenGLShaderProgram *m_program;
	62	int m_shaderAttribLoc;
	63	int m_colorUniformLoc;
	64	int m_minUniformLoc;
	65	int m_deltaUniformLoc;
	66	int m_pointSizeUniformLoc;
	67	QOpenGLVertexArrayObject m_vao;
	68	QHash<const QAbstractSeries , QOpenGLBuffer > m_seriesBufferMap;
	69	bool m_renderNeeded;
	70	};
	71
	72	QT_CHARTS_END_NAMESPACE
	73
	74	#endif // DECLARATIVERENDERNODE_P_H

examples/charts/audio/xyseriesiodevice.cpp +3 -3

             qint64 XYSeriesIODevice::writeData(const char * data, qint64 maxSize)
             {
                 qint64 range = 2000;
-                QList<QPointF> oldPoints = m_series->points();
+                QVector<QPointF> oldPoints = m_series->pointsVector();
-                QList<QPointF> points;
+                QVector<QPointF> points;
                 int resolution = 4;
                 if (oldPoints.count() < range) {
-                    points = m_series->points();
+                    points = m_series->pointsVector();
                 } else {
                     for (int i = maxSize/resolution; i < oldPoints.count(); i++)
                         points.append(QPointF(i - maxSize/resolution, oldPoints.at(i).y()));

examples/charts/charts.pro +7 -1

             qtHaveModule(multimedia) {
                 SUBDIRS += audio
             } else {
-                message("QtMultimedia library not available. Some examples are disabled")
+                message("QtMultimedia library not available. Some examples are disabled.")
+            }
+            contains(QT_CONFIG, opengl) {
+                SUBDIRS += openglseries
+            } else {
+                message("OpenGL not available. Some examples are disabled.")
             }
             !linux-arm*: {

examples/charts/chartthemes/themewidget.cpp +1 -1

                     for (int j(0); j < m_dataTable[i].count(); j++) {
                         Data data = m_dataTable[i].at(j);
                         if (lowerSeries) {
-                            const QList<QPointF>& points = lowerSeries->points();
+                            const QVector<QPointF>& points = lowerSeries->pointsVector();
                             upperSeries->append(QPointF(j, points[i].y() + data.first.y()));
                         } else {
                             upperSeries->append(QPointF(j, data.first.y()));

examples/charts/qmloscilloscope/qml/qmloscilloscope/ControlPanel.qml +11 -1

             **
             ****************************************************************************/
-            import QtQuick 2.0
+            import QtQuick 2.1
             import QtQuick.Layouts 1.0
             ColumnLayout {
+                property alias openGLButton: openGLButton
                 spacing: 8
                 Layout.fillHeight: true
                 signal animationsEnabled(bool enabled)
                 signal refreshRateChanged(variant rate);
                 signal signalSourceChanged(string source, int signalCount, int sampleCount);
                 signal antialiasingEnabled(bool enabled)
+                signal openGlChanged(bool enabled)
                 Text {
                     text: "Scope"
                 }
                 MultiButton {
+                    id: openGLButton
+                    text: "OpenGL: "
+                    items: ["false", "true"]
+                    currentSelection: 0
+                    onSelectionChanged: openGlChanged(currentSelection == 1);
+                }
+                MultiButton {
                     text: "Graph: "
                     items: ["line", "spline", "scatter"]
                     currentSelection: 0

examples/charts/qmloscilloscope/qml/qmloscilloscope/ScopeView.qml +23 -6

             ****************************************************************************/
             import QtQuick 2.0
-            import QtCharts 2.0
+            import QtCharts 2.1
             //![1]
             ChartView {
                 id: chartView
                 animationOptions: ChartView.NoAnimation
                 theme: ChartView.ChartThemeDark
+                property bool openGL: false
+                onOpenGLChanged: {
+                    series("signal 1").useOpenGL = openGL;
+                    series("signal 2").useOpenGL = openGL;
+                }
                 ValueAxis {
                     id: axisY1
                 ValueAxis {
                     id: axisX
                     min: 0
-                    max: 1000
+                    max: 1024
                 }
                 LineSeries {
                     name: "signal 1"
                     axisX: axisX
                     axisY: axisY1
+                    useOpenGL: chartView.openGL
                 }
                 LineSeries {
                     id: lineSeries2
                     name: "signal 2"
                     axisX: axisX
                     axisYRight: axisY2
+                    useOpenGL: chartView.openGL
                 }
             //![1]
                     // but the series have their own y-axes to make it possible to control the y-offset
                     // of the "signal sources".
                     if (type == "line") {
-                        chartView.createSeries(ChartView.SeriesTypeLine, "signal 1", axisX, axisY1);
+                        var series1 = chartView.createSeries(ChartView.SeriesTypeLine, "signal 1",
-                        chartView.createSeries(ChartView.SeriesTypeLine, "signal 2", axisX, axisY2);
+                                                             axisX, axisY1);
+                        series1.useOpenGL = chartView.openGL
+                        var series2 = chartView.createSeries(ChartView.SeriesTypeLine, "signal 2",
+                                                             axisX, axisY2);
+                        series2.useOpenGL = chartView.openGL
                     } else if (type == "spline") {
                         chartView.createSeries(ChartView.SeriesTypeSpline, "signal 1", axisX, axisY1);
                         chartView.createSeries(ChartView.SeriesTypeSpline, "signal 2", axisX, axisY2);
                     } else {
-                        var series1 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 1", axisX, axisY1);
+                        var series1 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 1",
+                                                             axisX, axisY1);
                         series1.markerSize = 3;
                         series1.borderColor = "transparent";
-                        var series2 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 2", axisX, axisY2);
+                        series1.useOpenGL = chartView.openGL
+                        var series2 = chartView.createSeries(ChartView.SeriesTypeScatter, "signal 2",
+                                                             axisX, axisY2);
                         series2.markerSize = 3;
                         series2.borderColor = "transparent";
+                        series2.useOpenGL = chartView.openGL
                     }
                 }

examples/charts/qmloscilloscope/qml/qmloscilloscope/main.qml +15 -3

             //![1]
             Rectangle {
                 id: main
-                width: 400
+                width: 600
-                height: 300
+                height: 400
                 color: "#404040"
                 ControlPanel {
                             dataSource.generateData(0, signalCount, sampleCount);
                         else
                             dataSource.generateData(1, signalCount, sampleCount);
+                        scopeView.axisX().max = sampleCount;
                     }
                     onAnimationsEnabled: scopeView.setAnimations(enabled);
-                    onSeriesTypeChanged: scopeView.changeSeriesType(type);
+                    onSeriesTypeChanged: {
+                        scopeView.changeSeriesType(type);
+                        if (type === "spline") {
+                            controlPanel.openGLButton.currentSelection = 0;
+                            controlPanel.openGLButton.enabled = false;
+                            scopeView.openGL = false;
+                        } else {
+                            controlPanel.openGLButton.enabled = true;
+                        }
+                    }
                     onRefreshRateChanged: scopeView.changeRefreshRate(rate);
                     onAntialiasingEnabled: scopeView.antialiasing = enabled;
+                    onOpenGlChanged: scopeView.openGL = enabled;
                 }
             //![2]
                     height: main.height
                 }
             //![2]
             }

src/charts/areachart/qareaseries.cpp +7 -5

                 \sa pointLabelsVisible
             */
             /*!
-                \fn void QAreaSeries::pointLabelsClippintChanged(bool clipping)
+                \fn void QAreaSeries::pointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
             void QAreaSeries::setUpperSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
-                if (d->m_upperSeries != series)
+                if (d->m_upperSeries != series) {
+                    series->d_ptr->setBlockOpenGL(true);
                     d->m_upperSeries = series;
                 }
+            }
             QLineSeries *QAreaSeries::upperSeries() const
             {
             void QAreaSeries::setLowerSeries(QLineSeries *series)
             {
                 Q_D(QAreaSeries);
+                series->d_ptr->setBlockOpenGL(true);
                 d->m_lowerSeries = series;
             }
                 QLineSeries *lowerSeries = q->lowerSeries();
                 if (upperSeries) {
-                    const QList<QPointF>& points = upperSeries->points();
+                    const QVector<QPointF> &points = upperSeries->pointsVector();
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();
                     }
                 }
                 if (lowerSeries) {
+                    const QVector<QPointF> &points = lowerSeries->pointsVector();
-                    const QList<QPointF>& points = lowerSeries->points();
                     for (int i = 0; i < points.count(); i++) {
                         qreal x = points[i].x();

src/charts/axis/qabstractaxis.cpp +1 -1

             }
             /*!
-              Sets axis, shades, labels and grid lines to be visible.
+              Sets axis, shades, labels and grid lines visibility to \a visible.
             */
             void QAbstractAxis::setVisible(bool visible)
             {

src/charts/barchart/qbarset.cpp +2 -2

             }
             /*!
-                Sets the color of pen for this bar set.
+                Sets the \a color of pen for this bar set.
             */
             void QBarSet::setBorderColor(QColor color)
             {
             }
             /*!
-                Sets the color of labels for this bar set.
+                Sets the \a color of labels for this bar set.
             */
             void QBarSet::setLabelColor(QColor color)
             {

src/charts/chartdataset.cpp +9 -1

             #include <private/xlogypolardomain_p.h>
             #include <private/logxypolardomain_p.h>
             #include <private/logxlogypolardomain_p.h>
+            #include <private/glxyseriesdata_p.h>
             #ifndef QT_ON_ARM
             #include <QtCharts/QDateTimeAxis>
             ChartDataSet::ChartDataSet(QChart *chart)
                 : QObject(chart),
-                  m_chart(chart)
+                  m_chart(chart),
+                  m_glXYSeriesDataManager(new GLXYSeriesDataManager(this))
             {
             }
                         qWarning() << QObject::tr("Can not add series. Series type is not supported by a polar chart.");
                         return;
                     }
+                    // Disable OpenGL for series in polar charts
+                    series->setUseOpenGL(false);
                     series->d_ptr->setDomain(new XYPolarDomain());
                     // Set the correct domain for upper and lower series too
                     if (series->type() == QAbstractSeries::SeriesTypeArea) {
                 series->d_ptr->setDomain(new XYDomain());
                 series->setParent(0);
                 series->d_ptr->m_chart = 0;
+                QXYSeries *xySeries = qobject_cast<QXYSeries *>(series);
+                if (xySeries)
+                    m_glXYSeriesDataManager->removeSeries(xySeries);
             }
             /*

src/charts/chartdataset_p.h +4 0

             class QAbstractAxis;
             class ChartPresenter;
+            class GLXYSeriesDataManager;
             class QT_CHARTS_AUTOTEST_EXPORT ChartDataSet : public QObject
             {
                 QPointF mapToValue(const QPointF &position, QAbstractSeries *series = 0);
                 QPointF mapToPosition(const QPointF &value, QAbstractSeries *series = 0);
+                GLXYSeriesDataManager *glXYSeriesDataManager() { return m_glXYSeriesDataManager; }
             Q_SIGNALS:
                 void axisAdded(QAbstractAxis* axis);
                 void axisRemoved(QAbstractAxis* axis);
                 QList<QAbstractSeries *> m_seriesList;
                 QList<QAbstractAxis *> m_axisList;
                 QChart* m_chart;
+                GLXYSeriesDataManager *m_glXYSeriesDataManager;
             };
             QT_CHARTS_END_NAMESPACE

src/charts/chartelement.cpp +13 -1

             #include <private/chartelement_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
+            #include <private/chartdataset_p.h>
             QT_CHARTS_BEGIN_NAMESPACE
             ChartElement::ChartElement(QGraphicsItem* item):
                   QGraphicsObject(item),
                   m_presenter(0),
-                  m_themeManager(0)
+                  m_themeManager(0),
+                  m_dataSet(0)
             {
             }
                 return m_themeManager;
             }
+            void ChartElement::setDataSet(ChartDataSet *dataSet)
+            {
+                m_dataSet = dataSet;
+            }
+            ChartDataSet *ChartElement::dataSet() const
+            {
+                return m_dataSet;
+            }
             QT_CHARTS_END_NAMESPACE

src/charts/chartelement_p.h +4 0

             class ChartAnimation;
             class ChartThemeManager;
             class AbstractDomain;
+            class ChartDataSet;
             class ChartElement: public QGraphicsObject
             {
                 ChartPresenter *presenter() const;
                 virtual void setThemeManager(ChartThemeManager *manager);
                 ChartThemeManager* themeManager() const;
+                virtual void setDataSet(ChartDataSet *dataSet);
+                ChartDataSet *dataSet() const;
             private:
                 ChartPresenter *m_presenter;
                 ChartThemeManager *m_themeManager;
+                ChartDataSet *m_dataSet;
             };
             QT_CHARTS_END_NAMESPACE

src/charts/chartpresenter.cpp +34 -1

                   m_plotAreaBackground(0),
                   m_title(0),
                   m_localizeNumbers(false)
+            #ifndef QT_NO_OPENGL
+                  , m_glWidget(0)
+                  , m_glUseWidget(true)
+            #endif
             {
                 if (type == QChart::ChartTypeCartesian)
                     m_layout = new CartesianChartLayout(this);
             ChartPresenter::~ChartPresenter()
             {
+            #ifndef QT_NO_OPENGL
+                delete m_glWidget.data();
+            #endif
             }
             void ChartPresenter::setGeometry(const QRectF rect)
                         chart->domain()->setSize(rect.size());
                         chart->setPos(rect.topLeft());
                     }
+            #ifndef QT_NO_OPENGL
+                    if (!m_glWidget.isNull())
+                        m_glWidget->setGeometry(m_rect.toRect());
+            #endif
                     emit plotAreaChanged(m_rect);
                 }
             }
                 ChartItem *chart = series->d_ptr->chartItem();
                 chart->setPresenter(this);
                 chart->setThemeManager(m_chart->d_ptr->m_themeManager);
+                chart->setDataSet(m_chart->d_ptr->m_dataset);
                 chart->domain()->setSize(m_rect.size());
                 chart->setPos(m_rect.topLeft());
                 chart->handleDomainUpdated(); //this could be moved to intializeGraphics when animator is refactored
                     return QString::number(value);
             }
+            void ChartPresenter::ensureGLWidget()
+            {
+            #ifndef QT_NO_OPENGL
+                // GLWidget pointer is wrapped in QPointer as its parent is not in our control, and therefore
+                // can potentially get deleted unexpectedly.
+                if (m_glWidget.isNull() && m_glUseWidget && m_chart->scene()) {
+                    QObject *parent = m_chart->scene()->parent();
+                    while (parent) {
+                        QWidget *parentWidget = qobject_cast<QWidget *>(parent);
+                        if (parentWidget) {
+                            m_glWidget = new GLWidget(m_chart->d_ptr->m_dataset->glXYSeriesDataManager(),
+                                                      parentWidget);
+                            m_glWidget->setGeometry(m_rect.toRect());
+                            m_glWidget->show();
+                            break;
+                        }
+                        parent = parent->parent();
+                    }
+                }
+            #endif
+            }
             #include "moc_chartpresenter_p.cpp"
             QT_CHARTS_END_NAMESPACE

src/charts/chartpresenter_p.h +9 0

             #include <QtCharts/QChartGlobal>
             #include <QtCharts/QChart> //because of QChart::ChartThemeId
+            #include <private/glwidget_p.h>
             #include <QtCore/QRectF>
             #include <QtCore/QMargins>
             #include <QtCore/QLocale>
+            #include <QtCore/QPointer>
             QT_CHARTS_BEGIN_NAMESPACE
                 QString numberToString(double value, char f = 'g', int prec = 6);
                 QString numberToString(int value);
+                void ensureGLWidget();
+                void glSetUseWidget(bool enable) { m_glUseWidget = enable; }
             private:
                 void createBackgroundItem();
                 void createPlotAreaBackgroundItem();
                 QRectF m_rect;
                 bool m_localizeNumbers;
                 QLocale m_locale;
+            #ifndef QT_NO_OPENGL
+                QPointer<GLWidget> m_glWidget;
+            #endif
+                bool m_glUseWidget;
             };
             QT_CHARTS_END_NAMESPACE

src/charts/charts.pro +6 0

                 $$PWD/scroller.cpp \
                 $$PWD/charttitle.cpp \
                 $$PWD/qpolarchart.cpp
+            contains(QT_CONFIG, opengl): SOURCES += $$PWD/glwidget.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/qabstractseries_p.h \
                 $$PWD/charttitle_p.h \
                 $$PWD/charthelpers_p.h
+            contains(QT_CONFIG, opengl): PRIVATE_HEADERS += $$PWD/glwidget_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \

src/charts/domain/abstractdomain_p.h +1 -1

                 virtual QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const = 0;
                 virtual QPointF calculateDomainPoint(const QPointF &point) const = 0;
-                virtual QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const = 0;
+                virtual QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const = 0;
                 virtual bool attachAxis(QAbstractAxis *axis);
                 virtual bool detachAxis(QAbstractAxis *axis);

src/charts/domain/logxlogydomain.cpp +1 -1

                 return QPointF(x, y);
             }
-            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / qAbs(m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);

src/charts/domain/logxlogydomain_p.h +1 -1

                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);

src/charts/domain/logxydomain.cpp +1 -1

                 return QPointF(x, y);
             }
-            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_logRightX - m_logLeftX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);

src/charts/domain/logxydomain_p.h +1 -1

                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);

src/charts/domain/polardomain.cpp +1 -1

                 }
             }
-            QVector<QPointF> PolarDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> PolarDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 QVector<QPointF> result;
                 result.resize(vector.count());

src/charts/domain/polardomain_p.h +1 -1

                 void setSize(const QSizeF &size);
                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 virtual qreal toAngularCoordinate(qreal value, bool &ok) const = 0;
                 virtual qreal toRadialCoordinate(qreal value, bool &ok) const = 0;

src/charts/domain/xlogydomain.cpp +1 -1

                 return QPointF(x, y);
             }
-            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logRightY - m_logLeftY);

src/charts/domain/xlogydomain_p.h +1 -1

                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
                 bool attachAxis(QAbstractAxis *axis);
                 bool detachAxis(QAbstractAxis *axis);

src/charts/domain/xydomain.cpp +1 -1

                 return QPointF(x, y);
             }
-            QVector<QPointF> XYDomain::calculateGeometryPoints(const QList<QPointF> &vector) const
+            QVector<QPointF> XYDomain::calculateGeometryPoints(const QVector<QPointF> &vector) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);

src/charts/domain/xydomain_p.h +1 -1

                 QPointF calculateGeometryPoint(const QPointF &point, bool &ok) const;
                 QPointF calculateDomainPoint(const QPointF &point) const;
-                QVector<QPointF> calculateGeometryPoints(const QList<QPointF> &vector) const;
+                QVector<QPointF> calculateGeometryPoints(const QVector<QPointF> &vector) const;
             };
             QT_CHARTS_END_NAMESPACE

src/charts/linechart/linechartitem.cpp +14 0

             void LineChartItem::updateGeometry()
             {
+                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
+                if (m_series->useOpenGL()) {
+                    // Fake a miniscule region, so we trigger changed signal.
+                    if (m_rect.width() != dummyRect.width()) {
+                        prepareGeometryChange();
+                        m_rect = dummyRect;
+                    }
+                    update();
+                    return;
+                }
                 // Store the points to a local variable so that the old line gets properly cleared
                 // when animation starts.
                 m_linePoints = geometryPoints();
                 Q_UNUSED(widget)
                 Q_UNUSED(option)
+                if (m_series->useOpenGL())
+                    return;
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();

src/charts/qabstractseries.cpp +97 -1

@@ -135,6 +135,69 QT_CHARTS_BEGIN_NAMESPACE
135	*/	135	*/
136		136
137	/*!	137	/*!
		138	\property QAbstractSeries::useOpenGL
		139	\brief Specifies whether or not the series drawing is accelerated with OpenGL.
		140
		141	Drawing series with OpenGL is supported only for QLineSeries and QScatterSeries.
		142	Line series used as edge series for a QAreaSeries cannot use OpenGL acceleration.
		143	When a chart contains any series that are drawn with OpenGL, a transparent QOpenGLWidget
		144	is created on top of the chart plot area. Specified series are not drawn on the underlying
		145	QGraphicsView, but are instead drawn on the created QOpenGLWidget.
		146
		147	Performance gained from using OpenGL to accelerate series drawing depends on the underlying
		148	hardware, but in most cases it is significant. For example, on a standard desktop computer,
		149	enabling OpenGL acceleration for a series typically allows rendering at least hundred times
		150	more points without reduction on the frame rate.
		151	Chart size also has less effect on the frame rate.
		152
		153	The OpenGL acceleration of series drawing is meant for use cases that need fast drawing of
		154	large numbers of points. It is optimized for efficiency, and therefore the series using
		155	it lack support for some features available to non-accelerated series.
		156
		157	There are the following restrictions imposed on charts and series when using OpenGL
		158	acceleration:
		159
		160	\list
		161	\li Series animations are not supported for accelerated series.
		162	\li Antialiasing is not supported for accelerated series.
		163	\li Pen styles and marker shapes are ignored for accelerated series.
		164	Only solid lines and plain scatter dots are supported.
		165	The scatter dots may be circular or rectangular, depending on the underlying graphics
		166	hardware and drivers.
		167	\li Polar charts are not supported for accelerated series.
		168	\li Since the accelerated series are drawn on top of the entire graphics view, they get drawn
		169	on top of any other graphics items that you may have on top chart in the same scene.
		170	\li To enable QOpenGLWidget to be partially transparent, it needs to be stacked on top of
		171	all other widgets. This means you cannot have other widgets partially covering the
		172	chart.
		173	\endlist
		174
		175	The default value is \c{false}.
		176	*/
		177	/*!
		178	\qmlproperty bool AbstractSeries::useOpenGL
		179	Specifies whether or not the series is drawn with OpenGL.
		180
		181	Drawing series with OpenGL is supported only for LineSeries and ScatterSeries.
		182
		183	For more details, see QAbstractSeries::useOpenGL documentation. QML applications have similar
		184	restrictions as those listed in QAbstractSeries::useOpenGL documentation,
		185	except there is no restriction about covering the ChartView partially with other
		186	items due to different rendering mechanism.
		187
		188	The default value is \c{false}.
		189	*/
		190
		191	/*!
		192	\fn void QAbstractSeries::useOpenGLChanged()
		193	Emitted when the useOpenGL property value changes.
		194	*/
		195	/*!
		196	\qmlsignal AbstractSeries::onUseOpenGLChanged()
		197	Emitted when the useOpenGL property value changes.
		198	*/
		199
		200	/*!
138	\internal	201	\internal
139	\brief Constructs QAbstractSeries object with \a parent.	202	\brief Constructs QAbstractSeries object with \a parent.
140	*/	203	*/
@@ -192,6 +255,28 void QAbstractSeries::setOpacity(qreal opacity)
192	}	255	}
193	}	256	}
194		257
		258	void QAbstractSeries::setUseOpenGL(bool enable)
		259	{
		260	#ifdef QT_NO_OPENGL
		261	Q_UNUSED(enable)
		262	#else
		263	bool polarChart = d_ptr->m_chart && d_ptr->m_chart->chartType() == QChart::ChartTypePolar;
		264	bool supportedSeries = (type() == SeriesTypeLine \|\| type() == SeriesTypeScatter);
		265	if ((!enable \|\| !d_ptr->m_blockOpenGL)
		266	&& supportedSeries
		267	&& enable != d_ptr->m_useOpenGL
		268	&& (!enable \|\| !polarChart)) {
		269	d_ptr->m_useOpenGL = enable;
		270	emit useOpenGLChanged();
		271	}
		272	#endif
		273	}
		274
		275	bool QAbstractSeries::useOpenGL() const
		276	{
		277	return d_ptr->m_useOpenGL;
		278	}
		279
195	/*!	280	/*!
196	\brief Returns the chart where series belongs to.	281	\brief Returns the chart where series belongs to.
197		282
@@ -274,7 +359,9 QAbstractSeriesPrivate::QAbstractSeriesPrivate(QAbstractSeries *q)
274	m_item(0),	359	m_item(0),
275	m_domain(new XYDomain()),	360	m_domain(new XYDomain()),
276	m_visible(true),	361	m_visible(true),
277	m_opacity(1.0)	362	m_opacity(1.0),
		363	m_useOpenGL(false),
		364	m_blockOpenGL(false)
278	{	365	{
279	}	366	}
280		367
@@ -354,6 +441,15 bool QAbstractSeriesPrivate::reverseYAxis()
354	return reverseYAxis;	441	return reverseYAxis;
355	}	442	}
356		443
		444	// This function can be used to explicitly block OpenGL use from some otherwise supported series,
		445	// such as the line series used as edge series of an area series.
		446	void QAbstractSeriesPrivate::setBlockOpenGL(bool enable)
		447	{
		448	m_blockOpenGL = enable;
		449	if (enable)
		450	q_ptr->setUseOpenGL(false);
		451	}
		452
357	#include "moc_qabstractseries.cpp"	453	#include "moc_qabstractseries.cpp"
358	#include "moc_qabstractseries_p.cpp"	454	#include "moc_qabstractseries_p.cpp"
359		455

src/charts/qabstractseries.h +5 0

                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
                 Q_PROPERTY(SeriesType type READ type)
+                Q_PROPERTY(bool useOpenGL READ useOpenGL WRITE setUseOpenGL NOTIFY useOpenGLChanged)
                 Q_ENUMS(SeriesType)
             public:
                 bool isVisible() const;
                 qreal opacity() const;
                 void setOpacity(qreal opacity);
+                void setUseOpenGL(bool enable = true);
+                bool useOpenGL() const;
                 QChart *chart() const;
                 void nameChanged();
                 void visibleChanged();
                 void opacityChanged();
+                void useOpenGLChanged();
             protected:
                 QScopedPointer<QAbstractSeriesPrivate> d_ptr;
                 friend class ChartThemeManager;
                 friend class QLegendPrivate;
                 friend class DeclarativeChart;
+                friend class QAreaSeries;
             };
             QT_CHARTS_END_NAMESPACE

src/charts/qabstractseries_p.h +4 0

                 bool reverseXAxis();
                 bool reverseYAxis();
+                void setBlockOpenGL(bool enable);
             Q_SIGNALS:
                 void countChanged();
                 bool m_visible;
                 qreal m_opacity;
                 ChartPresenter *m_presenter;
+                bool m_useOpenGL;
+                bool m_blockOpenGL;
                 friend class QAbstractSeries;
                 friend class ChartDataSet;

src/charts/scatterchart/scatterchartitem.cpp +15 0

             void ScatterChartItem::updateGeometry()
             {
+                static const QRectF dummyRect = QRectF(0.0, 0.0, 0.001, 0.001);
+                if (m_series->useOpenGL()) {
+                    if (m_items.childItems().count())
+                        deletePoints(m_items.childItems().count());
+                    // Fake a miniscule region, so we trigger changed signal.
+                    if (m_rect.width() != dummyRect.width()) {
+                        prepareGeometryChange();
+                        m_rect = dummyRect;
+                    }
+                    update();
+                    return;
+                }
                 const QVector<QPointF>& points = geometryPoints();
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
+                if (m_series->useOpenGL())
+                    return;
                 QRectF clipRect = QRectF(QPointF(0, 0), domain()->size());
                 painter->save();

src/charts/xychart/qxyseries.cpp +21 -4

                 \sa pointLabelsVisible
             */
             /*!
-                \fn void QXYSeries::pointLabelsClippintChanged(bool clipping)
+                \fn void QXYSeries::pointLabelsClippingChanged(bool clipping)
                 The clipping of the data point labels is changed to \a clipping.
             */
             /*!
             */
             /*!
+                \fn void QXYSeries::penChanged(const QPen &pen)
+                \brief Signal is emitted when the line pen has changed to \a pen.
+            */
+            /*!
                 \fn void QXYSeriesPrivate::updated()
                 \brief \internal
             */
               \note This is much faster than replacing data points one by one,
               or first clearing all data, and then appending the new data. Emits QXYSeries::pointsReplaced()
               when the points have been replaced. However, note that using the overload that takes
-              \c{QVector<QPointF>} as parameter is slightly faster than using this overload.
+              \c{QVector<QPointF>} as parameter is faster than using this overload.
               \sa pointsReplaced()
             */
             void QXYSeries::replace(QList<QPointF> points)
             }
             /*!
-                Returns list of points in the series.
+                Returns the points in the series as a list.
+                Use QXYSeries::pointsVector() for better performance.
             */
             QList<QPointF> QXYSeries::points() const
             {
             }
             /*!
+                Returns the points in the series as a vector.
+                This is more efficient that calling QXYSeries::points();
+            */
+            QVector<QPointF> QXYSeries::pointsVector() const
+            {
+                Q_D(const QXYSeries);
+                return d->m_points;
+            }
+            /*!
                 Returns point at \a index in internal points vector.
             */
             const QPointF &QXYSeries::at(int index) const
                     emit d->updated();
                     if (emitColorChanged)
                         emit colorChanged(pen.color());
+                    emit penChanged(pen);
                 }
             }
                 Q_Q(QXYSeries);
-                const QList<QPointF>& points = q->points();
+                const QVector<QPointF> &points = q->pointsVector();
                 if (!points.isEmpty()) {
                     minX = points[0].x();

src/charts/xychart/qxyseries.h +2 0

                 int count() const;
                 QList<QPointF> points() const;
+                QVector<QPointF> pointsVector() const;
                 const QPointF &at(int index) const;
                 QXYSeries &operator << (const QPointF &point);
                 void pointLabelsColorChanged(const QColor &color);
                 void pointLabelsClippingChanged(bool clipping);
                 void pointsRemoved(int index, int count);
+                void penChanged(const QPen &pen);
             private:
                 Q_DECLARE_PRIVATE(QXYSeries)

src/charts/xychart/xychart.cpp +43 -16

             #include <private/qxyseries_p.h>
             #include <private/chartpresenter_p.h>
             #include <private/abstractdomain_p.h>
+            #include <private/chartdataset_p.h>
+            #include <private/glxyseriesdata_p.h>
             #include <QtCharts/QXYModelMapper>
             #include <private/qabstractaxis_p.h>
             #include <QtGui/QPainter>
                 }
             }
+            void XYChart::updateGlChart()
+            {
+                presenter()->ensureGLWidget();
+                dataSet()->glXYSeriesDataManager()->setPoints(m_series, domain());
+                updateGeometry();
+            }
             //handlers
             void XYChart::handlePointAdded(int index)
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
-                    QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
+                        QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
+                                                                         m_validData);
                         if (!m_validData)
                             m_points.clear();
                         else
                             points.insert(index, point);
                     }
                     updateChart(m_points, points, index);
                 }
+            }
             void XYChart::handlePointRemoved(int index)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
                         points.remove(index);
                     }
                     updateChart(m_points, points, index);
                 }
+            }
             void XYChart::handlePointsRemoved(int index, int count)
             {
                 Q_ASSERT(index <= m_series->count());
                 Q_ASSERT(index >= 0);
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
                         points = m_points;
                         points.remove(index, count);
                     }
                     updateChart(m_points, points, index);
                 }
+            }
             void XYChart::handlePointReplaced(int index)
             {
                 Q_ASSERT(index < m_series->count());
                 Q_ASSERT(index >= 0);
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     QVector<QPointF> points;
                     if (m_dirty || m_points.isEmpty()) {
-                    points = domain()->calculateGeometryPoints(m_series->points());
+                        points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     } else {
-                    QPointF point = domain()->calculateGeometryPoint(m_series->points()[index], m_validData);
+                        QPointF point = domain()->calculateGeometryPoint(m_series->pointsVector().at(index),
+                                                                         m_validData);
                         if (!m_validData)
                             m_points.clear();
                         points = m_points;
                         if (m_validData)
                             points.replace(index, point);
                     }
                     updateChart(m_points, points, index);
                 }
+            }
             void XYChart::handlePointsReplaced()
             {
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     // All the points were replaced -> recalculate
-                QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
+                    QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     updateChart(m_points, points, -1);
                 }
+            }
             void XYChart::handleDomainUpdated()
             {
+                if (m_series->useOpenGL()) {
+                    updateGlChart();
+                } else {
                     if (isEmpty()) return;
-                QVector<QPointF> points =  domain()->calculateGeometryPoints(m_series->points());
+                    QVector<QPointF> points = domain()->calculateGeometryPoints(m_series->pointsVector());
                     updateChart(m_points, points);
                 }
+            }
             bool XYChart::isEmpty()
             {

src/charts/xychart/xychart.pri +4 -2

                 $$PWD/qxyseries.cpp \
                 $$PWD/qxymodelmapper.cpp \
                 $$PWD/qvxymodelmapper.cpp \
-                $$PWD/qhxymodelmapper.cpp
+                $$PWD/qhxymodelmapper.cpp  \
+                $$PWD/glxyseriesdata.cpp
             PRIVATE_HEADERS += \
                 $$PWD/xychart_p.h \
                 $$PWD/qxyseries_p.h \
-                $$PWD/qxymodelmapper_p.h
+                $$PWD/qxymodelmapper_p.h \
+                $$PWD/glxyseriesdata_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qxyseries.h \

src/charts/xychart/xychart_p.h +1 0

             protected:
                 virtual void updateChart(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index = -1);
+                virtual void updateGlChart();
             private:
                 inline bool isEmpty();

src/chartsqml2/chartsqml2.pro +6 -2

                 declarativemargins.cpp \
                 declarativeaxes.cpp \
                 declarativepolarchart.cpp \
-                declarativeboxplotseries.cpp
+                declarativeboxplotseries.cpp \
+                declarativechartnode.cpp \
+                declarativerendernode.cpp
             HEADERS += \
                 declarativechart.h \
                 declarativemargins.h \
                 declarativeaxes.h \
                 declarativepolarchart.h \
-                declarativeboxplotseries.h
+                declarativeboxplotseries.h \
+                declarativechartnode.h \
+                declarativerendernode.h
             OTHER_FILES = qmldir

src/chartsqml2/declarativechart.cpp +98 -52

@@ -25,6 +25,8
25	#include "declarativesplineseries.h"	25	#include "declarativesplineseries.h"
26	#include "declarativeboxplotseries.h"	26	#include "declarativeboxplotseries.h"
27	#include "declarativescatterseries.h"	27	#include "declarativescatterseries.h"
		28	#include "declarativechartnode.h"
		29	#include "declarativerendernode.h"
28	#include <QtCharts/QBarCategoryAxis>	30	#include <QtCharts/QBarCategoryAxis>
29	#include <QtCharts/QValueAxis>	31	#include <QtCharts/QValueAxis>
30	#include <QtCharts/QLogValueAxis>	32	#include <QtCharts/QLogValueAxis>
@@ -34,6 +36,7
34	#include <private/chartdataset_p.h>	36	#include <private/chartdataset_p.h>
35	#include "declarativeaxes.h"	37	#include "declarativeaxes.h"
36	#include <private/qchart_p.h>	38	#include <private/qchart_p.h>
		39	#include <private/chartpresenter_p.h>
37	#include <QtCharts/QPolarChart>	40	#include <QtCharts/QPolarChart>
38		41
39	#ifndef QT_ON_ARM	42	#ifndef QT_ON_ARM
@@ -88,6 +91,7 QT_CHARTS_BEGIN_NAMESPACE
88	/*!	91	/*!
89	\qmlproperty easing ChartView::animationEasingCurve	92	\qmlproperty easing ChartView::animationEasingCurve
90	The easing curve of the animation for the chart.	93	The easing curve of the animation for the chart.
		94	*/
91		95
92	/*!	96	/*!
93	\qmlproperty Font ChartView::titleFont	97	\qmlproperty Font ChartView::titleFont
@@ -312,34 +316,42 QT_CHARTS_BEGIN_NAMESPACE
312	*/	316	*/
313		317
314	DeclarativeChart::DeclarativeChart(QQuickItem *parent)	318	DeclarativeChart::DeclarativeChart(QQuickItem *parent)
315	: QQuick~~Painted~~Item(parent)	319	: QQuickItem(parent)
316	{	320	{
317	initChart(QChart::ChartTypeCartesian);	321	initChart(QChart::ChartTypeCartesian);
318	}	322	}
319		323
320	DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)	324	DeclarativeChart::DeclarativeChart(QChart::ChartType type, QQuickItem *parent)
321	: QQuick~~Painted~~Item(parent)	325	: QQuickItem(parent)
322	{	326	{
323	initChart(type);	327	initChart(type);
324	}	328	}
325		329
326	void DeclarativeChart::initChart(QChart::ChartType type)	330	void DeclarativeChart::initChart(QChart::ChartType type)
327	{	331	{
328	m_~~currentS~~ceneImage = 0;	332	m_sceneImage = 0;
		333	m_sceneImageDirty = false;
329	m_guiThreadId = QThread::currentThreadId();	334	m_guiThreadId = QThread::currentThreadId();
330	m_paintThreadId = 0;	335	m_paintThreadId = 0;
331	m_updatePending = false;	336	m_updatePending = false;
332		337
		338	setFlag(ItemHasContents, true);
		339
333	if (type == QChart::ChartTypePolar)	340	if (type == QChart::ChartTypePolar)
334	m_chart = new QPolarChart();	341	m_chart = new QPolarChart();
335	else	342	else
336	m_chart = new QChart();	343	m_chart = new QChart();
337		344
		345	m_chart->d_ptr->m_presenter->glSetUseWidget(false);
		346	m_glXYDataManager = m_chart->d_ptr->m_dataset->glXYSeriesDataManager();
		347
338	m_scene = new QGraphicsScene(this);	348	m_scene = new QGraphicsScene(this);
339	m_scene->addItem(m_chart);	349	m_scene->addItem(m_chart);
340		350
341	setAntialiasing(QQuickItem::antialiasing());	351	setAntialiasing(QQuickItem::antialiasing());
342	connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(sceneChanged(QList<QRectF>)));	352	connect(m_scene, &QGraphicsScene::changed, this, &DeclarativeChart::sceneChanged);
		353	connect(this, &DeclarativeChart::needRender, this, &DeclarativeChart::renderScene,
		354	Qt::QueuedConnection);
343	connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));	355	connect(this, SIGNAL(antialiasingChanged(bool)), this, SLOT(handleAntialiasingChanged(bool)));
344		356
345	setAcceptedMouseButtons(Qt::AllButtons);	357	setAcceptedMouseButtons(Qt::AllButtons);
@@ -377,10 +389,7 void DeclarativeChart::changeMargins(int top, int bottom, int left, int right)
377	DeclarativeChart::~DeclarativeChart()	389	DeclarativeChart::~DeclarativeChart()
378	{	390	{
379	delete m_chart;	391	delete m_chart;
380	m_sceneImage~~Lock~~.~~lock~~();	392	delete m_sceneImage;
381	delete m_currentSceneImage;
382	m_currentSceneImage = 0;
383	m_sceneImageLock.unlock();
384	}	393	}
385		394
386	void DeclarativeChart::childEvent(QChildEvent *event)	395	void DeclarativeChart::childEvent(QChildEvent *event)
@@ -493,65 +502,102 void DeclarativeChart::geometryChanged(const QRectF &newGeometry, const QRectF &
493	QQuickItem::geometryChanged(newGeometry, oldGeometry);	502	QQuickItem::geometryChanged(newGeometry, oldGeometry);
494	}	503	}
495		504
496	void DeclarativeChart::sceneChanged(QList<QRectF> region)	505	QSGNode DeclarativeChart::updatePaintNode(QSGNode oldNode, QQuickItem::UpdatePaintNodeData *)
497	{	506	{
498	Q_UNUSED(region);	507	DeclarativeChartNode node = static_cast<DeclarativeChartNode >(oldNode);
499		508
500	if (m_guiThreadId == m_paintThreadId) {	509	if (!node) {
501	// Rendering in gui thread, no need for shenannigans, just update	510	node = new DeclarativeChartNode(window());
502	update();	511	connect(window(), &QQuickWindow::beforeRendering,
503	} else {	512	node->glRenderNode(), &DeclarativeRenderNode::render);
504	// Multi-threaded rendering, need to ensure scene is actually rendered in gui thread
505	if (!m_updatePending) {
506	m_updatePending = true;
507	// Do async render to avoid some unnecessary renders.
508	QTimer::singleShot(0, this, SLOT(renderScene()));
509	}	513	}
		514
		515	const QRectF &bRect = boundingRect();
		516
		517	// Update GL data
		518	if (m_glXYDataManager->dataMap().size() \|\| m_glXYDataManager->mapDirty()) {
		519	const QRectF &plotArea = m_chart->plotArea();
		520	const QSizeF &chartAreaSize = m_chart->size();
		521
		522	// We can't use chart's plot area directly, as graphicscene has some internal minimum size
		523	const qreal normalizedX = plotArea.x() / chartAreaSize.width();
		524	const qreal normalizedY = plotArea.y() / chartAreaSize.height();
		525	const qreal normalizedWidth = plotArea.width() / chartAreaSize.width();
		526	const qreal normalizedHeight = plotArea.height() / chartAreaSize.height();
		527
		528	QRectF adjustedPlotArea(normalizedX * bRect.width(),
		529	normalizedY * bRect.height(),
		530	normalizedWidth * bRect.width(),
		531	normalizedHeight * bRect.height());
		532
		533	const QSize &adjustedPlotSize = adjustedPlotArea.size().toSize();
		534	if (adjustedPlotSize != node->glRenderNode()->textureSize())
		535	node->glRenderNode()->setTextureSize(adjustedPlotSize);
		536
		537	node->glRenderNode()->setRect(adjustedPlotArea);
		538	node->glRenderNode()->setSeriesData(m_glXYDataManager->mapDirty(),
		539	m_glXYDataManager->dataMap());
		540
		541	// Clear dirty flags from original xy data
		542	m_glXYDataManager->clearAllDirty();
510	}	543	}
		544
		545	// Copy chart (if dirty) to chart node
		546	if (m_sceneImageDirty) {
		547	node->createTextureFromImage(*m_sceneImage);
		548	m_sceneImageDirty = false;
511	}	549	}
512		550
513	void DeclarativeChart::renderScene()	551	node->setRect(bRect);
514	{
515	m_updatePending = false;
516	m_sceneImageLock.lock();
517	delete m_currentSceneImage;
518	m_currentSceneImage = new QImage(m_chart->size().toSize(), QImage::Format_ARGB32);
519	m_currentSceneImage->fill(Qt::transparent);
520	QPainter painter(m_currentSceneImage);
521	if (antialiasing())
522	painter.setRenderHints(QPainter::Antialiasing \| QPainter::TextAntialiasing \| QPainter::SmoothPixmapTransform);
523	QRect renderRect(QPoint(0, 0), m_chart->size().toSize());
524	m_scene->render(&painter, renderRect, renderRect);
525	m_sceneImageLock.unlock();
526		552
527	update();	553	return node;
528	}	554	}
529		555
530	void DeclarativeChart::paint(QPainter *painter)	556	void DeclarativeChart::sceneChanged(QList<QRectF> region)
531	{	557	{
532	if (!m_paintThreadId) {	558	const int count = region.size();
533	m_paintThreadId = QThread::currentThreadId();	559	const qreal limitSize = 0.01;
534	if (m_guiThreadId == m_paintThreadId) {	560	if (count && !m_updatePending) {
535	// No need for scene image in single threaded rendering, so delete	561	qreal totalSize = 0.0;
536	// the one that got made by default before the rendering type was	562	for (int i = 0; i < count; i++) {
537	// detected.	563	const QRectF &reg = region.at(i);
538	delete m_currentSceneImage;	564	totalSize += (reg.height() * reg.width());
539	m_currentSceneImage = 0;	565	if (totalSize >= limitSize)
		566	break;
		567	}
		568	// Ignore region updates that change less than small fraction of a pixel, as there is
		569	// little point regenerating the image in these cases. These are typically cases
		570	// where OpenGL series are drawn to otherwise static chart.
		571	if (totalSize >= limitSize) {
		572	m_updatePending = true;
		573	// Do async render to avoid some unnecessary renders.
		574	emit needRender();
		575	} else {
		576	// We do want to call update to trigger possible gl series updates.
		577	update();
		578	}
540	}	579	}
541	}	580	}
542		581
543	if (m_guiThreadId == m_paintThreadId) {	582	void DeclarativeChart::renderScene()
544	QRectF renderRect(QPointF(0, 0), m_chart->size());	583	{
545	m_scene->render(painter, renderRect, renderRect);	584	m_updatePending = false;
546	} else {	585	m_sceneImageDirty = true;
547	m_sceneImageLock.lock();	586	QSize chartSize = m_chart->size().toSize();
548	if (m_currentSceneImage) {	587	if (!m_sceneImage \|\| chartSize != m_sceneImage->size()) {
549	QRect imageRect(QPoint(0, 0), m_currentSceneImage->size());	588	delete m_sceneImage;
550	QRect itemRect(QPoint(0, 0), QSize(width(), height()));	589	m_sceneImage = new QImage(chartSize, QImage::Format_ARGB32);
551	painter->drawImage(itemRect, *m_currentSceneImage, imageRect);	590	m_sceneImage->fill(Qt::transparent);
552	}	591	}
553	m_sceneImageLock.unlock();	592
		593	QPainter painter(m_sceneImage);
		594	if (antialiasing()) {
		595	painter.setRenderHints(QPainter::Antialiasing \| QPainter::TextAntialiasing
		596	\| QPainter::SmoothPixmapTransform);
554	}	597	}
		598	QRect renderRect(QPoint(0, 0), chartSize);
		599	m_scene->render(&painter, renderRect, renderRect);
		600	update();
555	}	601	}
556		602
557	void DeclarativeChart::mousePressEvent(QMouseEvent *event)	603	void DeclarativeChart::mousePressEvent(QMouseEvent *event)

src/chartsqml2/declarativechart.h +8 -6

             #ifndef DECLARATIVECHART_H
             #define DECLARATIVECHART_H
+            #include <private/glxyseriesdata_p.h>
             #include <QtCore/QtGlobal>
             #include <QtQuick/QQuickItem>
-            #include <QtQuick/QQuickPaintedItem>
             #include <QtWidgets/QGraphicsScene>
-            #include <QtCore/QMutex>
             #include <QtCharts/QChart>
             #include <QtCore/QLocale>
             class Domain;
             class DeclarativeAxes;
-            class DeclarativeChart : public QQuickPaintedItem
+            class DeclarativeChart : public QQuickItem
             {
                 Q_OBJECT
                 Q_PROPERTY(Theme theme READ theme WRITE setTheme)
                 void childEvent(QChildEvent *event);
                 void componentComplete();
                 void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
-                void paint(QPainter *painter);
+                QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 Q_REVISION(4) void localeChanged();
                 Q_REVISION(5) void animationDurationChanged(int msecs);
                 Q_REVISION(5) void animationEasingCurveChanged(QEasingCurve curve);
+                void needRender();
             private Q_SLOTS:
                 void changeMargins(int top, int bottom, int left, int right);
                 QPoint m_lastMouseMoveScreenPoint;
                 Qt::MouseButton m_mousePressButton;
                 Qt::MouseButtons m_mousePressButtons;
-                QMutex m_sceneImageLock;
+                QImage *m_sceneImage;
-                QImage *m_currentSceneImage;
+                bool m_sceneImageDirty;
                 bool m_updatePending;
                 Qt::HANDLE m_paintThreadId;
                 Qt::HANDLE m_guiThreadId;
                 DeclarativeMargins *m_margins;
+                GLXYSeriesDataManager *m_glXYDataManager;
             };
             QT_CHARTS_END_NAMESPACE

tests/auto/qlineseries/tst_qlineseries.cpp +2 -1

             #include "../qxyseries/tst_qxyseries.h"
             #include <QtCharts/QLineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QLineSeries : public tst_QXYSeries
             {
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);
                 QCOMPARE(series.pointLabelsVisible(), false);

tests/auto/qscatterseries/tst_qscatterseries.cpp +2 0

             #include <QtCharts/QScatterSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QScatterSeries : public tst_QXYSeries
             {
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);

tests/auto/qsplineseries/tst_qsplineseries.cpp +2 0

             #include <QtCharts/QSplineSeries>
             Q_DECLARE_METATYPE(QList<QPointF>)
+            Q_DECLARE_METATYPE(QVector<QPointF>)
             class tst_QSplineSeries : public tst_QXYSeries
             {
                 QCOMPARE(series.count(),0);
                 QCOMPARE(series.brush(), QBrush());
                 QCOMPARE(series.points(), QList<QPointF>());
+                QCOMPARE(series.pointsVector(), QVector<QPointF>());
                 QCOMPARE(series.pen(), QPen());
                 QCOMPARE(series.pointsVisible(), false);

tests/auto/qxyseries/tst_qxyseries.cpp +1 0

                 TRY_COMPARE(spy0.count(), 0);
                 TRY_COMPARE(addedSpy.count(), points.count());
                 QCOMPARE(m_series->points(), points);
+                QCOMPARE(m_series->pointsVector(), points.toVector());
                 // Process events between appends
                 foreach (const QPointF &point, otherPoints) {

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