qt-everywhere-src-5.14.1/qtbase/tests/auto/opengl/qglbuffer/tst_qglbuffer.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtOpenGL module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 3 as published by the Free Software
 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
 ** included in the packaging of this file. Please review the following
 ** information to ensure the GNU General Public License requirements will
 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <QtTest/QtTest>
 #include <QtOpenGL/qgl.h>
 #include <QtOpenGL/qglbuffer.h>

 class tst_QGLBuffer : public QObject
 {
     Q_OBJECT
 public:
     tst_QGLBuffer() {}
     ~tst_QGLBuffer() {}

 private slots:
     void vertexBuffer_data();
     void vertexBuffer();
     void indexBuffer_data();
     void indexBuffer();
     void bufferSharing();

 private:
     void testBuffer(QGLBuffer::Type type);
 };

 void tst_QGLBuffer::vertexBuffer_data()
 {
     QTest::addColumn<int>("usagePattern");

     QTest::newRow("StreamDraw") << int(QGLBuffer::StreamDraw);
     QTest::newRow("StaticDraw") << int(QGLBuffer::StaticDraw);
     QTest::newRow("DynamicDraw") << int(QGLBuffer::DynamicDraw);
 }

 void tst_QGLBuffer::vertexBuffer()
 {
     testBuffer(QGLBuffer::VertexBuffer);
 }

 void tst_QGLBuffer::indexBuffer_data()
 {
     vertexBuffer_data();
 }

 void tst_QGLBuffer::indexBuffer()
 {
     testBuffer(QGLBuffer::IndexBuffer);
 }

 void tst_QGLBuffer::testBuffer(QGLBuffer::Type type)
 {
     QFETCH(int, usagePattern);

     QGLWidget w;
     w.makeCurrent();

     // Create the local object, but not the buffer in the server.
     QGLBuffer buffer(type);
     QCOMPARE(buffer.usagePattern(), QGLBuffer::StaticDraw);
     buffer.setUsagePattern(QGLBuffer::UsagePattern(usagePattern));

     // Check the initial state.
     QCOMPARE(buffer.type(), type);
     QVERIFY(!buffer.isCreated());
     QCOMPARE(buffer.bufferId(), GLuint(0));
     QCOMPARE(buffer.usagePattern(), QGLBuffer::UsagePattern(usagePattern));
     QCOMPARE(buffer.size(), -1);

     // Should not be able to bind it yet because it isn't created.
     QVERIFY(!buffer.bind());

     // Create the buffer - if this fails, then assume that the
     // GL implementation does not support buffers at all.
     if (!buffer.create())
         QSKIP("Buffers are not supported on this platform");

     // Should now have a buffer id.
     QVERIFY(buffer.bufferId() != 0);

     // Bind the buffer and upload some data.
     QVERIFY(buffer.bind());
     static GLfloat const data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     buffer.allocate(data, sizeof(data));

     // Check the buffer size.
     QCOMPARE(buffer.size(), int(sizeof(data)));

     // Map the buffer and read back its contents.
     bool haveMap = false;
     GLfloat *mapped = reinterpret_cast<GLfloat *>
         (buffer.map(QGLBuffer::ReadOnly));
     if (mapped) {
         for (int index = 0; index < 9; ++index)
             QCOMPARE(mapped[index], data[index]);
         buffer.unmap();
         haveMap = true;
     } else {
         qWarning("QGLBuffer::map() is not supported on this platform");
     }

     // Read back the buffer contents using read().
     bool haveRead = false;
     GLfloat readdata[9];
     if (buffer.read(0, readdata, sizeof(readdata))) {
         for (int index = 0; index < 9; ++index)
             QCOMPARE(readdata[index], data[index]);
         haveRead = true;
     } else {
         qWarning("QGLBuffer::read() is not supported on this platform");
     }

     // Write some different data to a specific location and check it.
     static GLfloat const diffdata[] = {11, 12, 13};
     buffer.write(sizeof(GLfloat) * 3, diffdata, sizeof(diffdata));
     if (haveMap) {
         mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::ReadOnly));
         QVERIFY(mapped != 0);
         for (int index = 0; index < 9; ++index) {
             if (index >= 3 && index <= 5)
                 QCOMPARE(mapped[index], diffdata[index - 3]);
             else
                 QCOMPARE(mapped[index], data[index]);
         }
         buffer.unmap();
     }
     if (haveRead) {
         QVERIFY(buffer.read(0, readdata, sizeof(readdata)));
         for (int index = 0; index < 9; ++index) {
             if (index >= 3 && index <= 5)
                 QCOMPARE(readdata[index], diffdata[index - 3]);
             else
                 QCOMPARE(readdata[index], data[index]);
         }
     }

     // Write to the buffer using the return value from map.
     if (haveMap) {
         mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::WriteOnly));
         QVERIFY(mapped != 0);
         mapped[6] = 14;
         buffer.unmap();

         mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::ReadOnly));
         QVERIFY(mapped != 0);
         static GLfloat const diff2data[] = {11, 12, 13, 14};
         for (int index = 0; index < 9; ++index) {
             if (index >= 3 && index <= 6)
                 QCOMPARE(mapped[index], diff2data[index - 3]);
             else
                 QCOMPARE(mapped[index], data[index]);
         }
         buffer.unmap();
     }

     // Resize the buffer.
     buffer.allocate(sizeof(GLfloat) * 20);
     QCOMPARE(buffer.size(), int(sizeof(GLfloat) * 20));
     buffer.allocate(0, sizeof(GLfloat) * 32);
     QCOMPARE(buffer.size(), int(sizeof(GLfloat) * 32));

     // Release the buffer.
     buffer.release();
 }

 void tst_QGLBuffer::bufferSharing()
 {
 #if defined(Q_OS_WIN)
     // Needs investigation on Windows: QTBUG-29692
     QSKIP("Unreproducible timeout on Windows (MSVC/MinGW) CI bots");
 #endif

 #if defined(Q_OS_QNX)
     QSKIP("Crashes on QNX when destroying the second QGLWidget (see QTBUG-38275)");
 #endif

     QGLWidget *w1 = new QGLWidget();
     w1->makeCurrent();

     QGLWidget *w2 = new QGLWidget(0, w1);
     if (!w2->isSharing()) {
         delete w2;
         delete w1;
         QSKIP("Context sharing is not supported on this platform");
     }

     // Bind the buffer in the first context and write some data to it.
     QGLBuffer buffer(QGLBuffer::VertexBuffer);
     if (!buffer.create())
         QSKIP("Buffers are not supported on this platform");
     QVERIFY(buffer.isCreated());
     QVERIFY(buffer.bind());
     static GLfloat const data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     buffer.allocate(data, sizeof(data));
     QCOMPARE(buffer.size(), int(sizeof(data)));
     buffer.release();

     // Bind the buffer in the second context and read back the data.
     w2->makeCurrent();
     QVERIFY(buffer.bind());
     QCOMPARE(buffer.size(), int(sizeof(data)));
     GLfloat readdata[9];
     if (buffer.read(0, readdata, sizeof(readdata))) {
         for (int index = 0; index < 9; ++index)
             QCOMPARE(readdata[index], data[index]);
     }
     buffer.release();

     // Delete the first context.
     delete w1;

     // Make the second context current again because deleting the first
     // one will call doneCurrent() even though it wasn't current!
     w2->makeCurrent();

     // The buffer should still be valid in the second context.
     QVERIFY(buffer.bufferId() != 0);
     QVERIFY(buffer.isCreated());
     QVERIFY(buffer.bind());
     QCOMPARE(buffer.size(), int(sizeof(data)));
     buffer.release();

     // Delete the second context.
     delete w2;

     // The buffer should now be invalid.
     QCOMPARE(buffer.bufferId(), GLuint(0));
     QVERIFY(!buffer.isCreated());
 }

 QTEST_MAIN(tst_QGLBuffer)

 #include "tst_qglbuffer.moc"
	/****************************************************************************
	**
	** Copyright (C) 2016 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the QtOpenGL module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:GPL-EXCEPT$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 3 as published by the Free Software
	** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
	** included in the packaging of this file. Please review the following
	** information to ensure the GNU General Public License requirements will
	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include <QtTest/QtTest>
	#include <QtOpenGL/qgl.h>
	#include <QtOpenGL/qglbuffer.h>

	class tst_QGLBuffer : public QObject
	{
	Q_OBJECT
	public:
	tst_QGLBuffer() {}
	~tst_QGLBuffer() {}

	private slots:
	void vertexBuffer_data();
	void vertexBuffer();
	void indexBuffer_data();
	void indexBuffer();
	void bufferSharing();

	private:
	void testBuffer(QGLBuffer::Type type);
	};

	void tst_QGLBuffer::vertexBuffer_data()
	{
	QTest::addColumn<int>("usagePattern");

	QTest::newRow("StreamDraw") << int(QGLBuffer::StreamDraw);
	QTest::newRow("StaticDraw") << int(QGLBuffer::StaticDraw);
	QTest::newRow("DynamicDraw") << int(QGLBuffer::DynamicDraw);
	}

	void tst_QGLBuffer::vertexBuffer()
	{
	testBuffer(QGLBuffer::VertexBuffer);
	}

	void tst_QGLBuffer::indexBuffer_data()
	{
	vertexBuffer_data();
	}

	void tst_QGLBuffer::indexBuffer()
	{
	testBuffer(QGLBuffer::IndexBuffer);
	}

	void tst_QGLBuffer::testBuffer(QGLBuffer::Type type)
	{
	QFETCH(int, usagePattern);

	QGLWidget w;
	w.makeCurrent();

	// Create the local object, but not the buffer in the server.
	QGLBuffer buffer(type);
	QCOMPARE(buffer.usagePattern(), QGLBuffer::StaticDraw);
	buffer.setUsagePattern(QGLBuffer::UsagePattern(usagePattern));

	// Check the initial state.
	QCOMPARE(buffer.type(), type);
	QVERIFY(!buffer.isCreated());
	QCOMPARE(buffer.bufferId(), GLuint(0));
	QCOMPARE(buffer.usagePattern(), QGLBuffer::UsagePattern(usagePattern));
	QCOMPARE(buffer.size(), -1);

	// Should not be able to bind it yet because it isn't created.
	QVERIFY(!buffer.bind());

	// Create the buffer - if this fails, then assume that the
	// GL implementation does not support buffers at all.
	if (!buffer.create())
	QSKIP("Buffers are not supported on this platform");

	// Should now have a buffer id.
	QVERIFY(buffer.bufferId() != 0);

	// Bind the buffer and upload some data.
	QVERIFY(buffer.bind());
	static GLfloat const data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	buffer.allocate(data, sizeof(data));

	// Check the buffer size.
	QCOMPARE(buffer.size(), int(sizeof(data)));

	// Map the buffer and read back its contents.
	bool haveMap = false;
	GLfloat mapped = reinterpret_cast<GLfloat >
	(buffer.map(QGLBuffer::ReadOnly));
	if (mapped) {
	for (int index = 0; index < 9; ++index)
	QCOMPARE(mapped[index], data[index]);
	buffer.unmap();
	haveMap = true;
	} else {
	qWarning("QGLBuffer::map() is not supported on this platform");
	}

	// Read back the buffer contents using read().
	bool haveRead = false;
	GLfloat readdata[9];
	if (buffer.read(0, readdata, sizeof(readdata))) {
	for (int index = 0; index < 9; ++index)
	QCOMPARE(readdata[index], data[index]);
	haveRead = true;
	} else {
	qWarning("QGLBuffer::read() is not supported on this platform");
	}

	// Write some different data to a specific location and check it.
	static GLfloat const diffdata[] = {11, 12, 13};
	buffer.write(sizeof(GLfloat) * 3, diffdata, sizeof(diffdata));
	if (haveMap) {
	mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::ReadOnly));
	QVERIFY(mapped != 0);
	for (int index = 0; index < 9; ++index) {
	if (index >= 3 && index <= 5)
	QCOMPARE(mapped[index], diffdata[index - 3]);
	else
	QCOMPARE(mapped[index], data[index]);
	}
	buffer.unmap();
	}
	if (haveRead) {
	QVERIFY(buffer.read(0, readdata, sizeof(readdata)));
	for (int index = 0; index < 9; ++index) {
	if (index >= 3 && index <= 5)
	QCOMPARE(readdata[index], diffdata[index - 3]);
	else
	QCOMPARE(readdata[index], data[index]);
	}
	}

	// Write to the buffer using the return value from map.
	if (haveMap) {
	mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::WriteOnly));
	QVERIFY(mapped != 0);
	mapped[6] = 14;
	buffer.unmap();

	mapped = reinterpret_cast<GLfloat *>(buffer.map(QGLBuffer::ReadOnly));
	QVERIFY(mapped != 0);
	static GLfloat const diff2data[] = {11, 12, 13, 14};
	for (int index = 0; index < 9; ++index) {
	if (index >= 3 && index <= 6)
	QCOMPARE(mapped[index], diff2data[index - 3]);
	else
	QCOMPARE(mapped[index], data[index]);
	}
	buffer.unmap();
	}

	// Resize the buffer.
	buffer.allocate(sizeof(GLfloat) * 20);
	QCOMPARE(buffer.size(), int(sizeof(GLfloat) * 20));
	buffer.allocate(0, sizeof(GLfloat) * 32);
	QCOMPARE(buffer.size(), int(sizeof(GLfloat) * 32));

	// Release the buffer.
	buffer.release();
	}

	void tst_QGLBuffer::bufferSharing()
	{
	#if defined(Q_OS_WIN)
	// Needs investigation on Windows: QTBUG-29692
	QSKIP("Unreproducible timeout on Windows (MSVC/MinGW) CI bots");
	#endif

	#if defined(Q_OS_QNX)
	QSKIP("Crashes on QNX when destroying the second QGLWidget (see QTBUG-38275)");
	#endif

	QGLWidget *w1 = new QGLWidget();
	w1->makeCurrent();

	QGLWidget *w2 = new QGLWidget(0, w1);
	if (!w2->isSharing()) {
	delete w2;
	delete w1;
	QSKIP("Context sharing is not supported on this platform");
	}

	// Bind the buffer in the first context and write some data to it.
	QGLBuffer buffer(QGLBuffer::VertexBuffer);
	if (!buffer.create())
	QSKIP("Buffers are not supported on this platform");
	QVERIFY(buffer.isCreated());
	QVERIFY(buffer.bind());
	static GLfloat const data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	buffer.allocate(data, sizeof(data));
	QCOMPARE(buffer.size(), int(sizeof(data)));
	buffer.release();

	// Bind the buffer in the second context and read back the data.
	w2->makeCurrent();
	QVERIFY(buffer.bind());
	QCOMPARE(buffer.size(), int(sizeof(data)));
	GLfloat readdata[9];
	if (buffer.read(0, readdata, sizeof(readdata))) {
	for (int index = 0; index < 9; ++index)
	QCOMPARE(readdata[index], data[index]);
	}
	buffer.release();

	// Delete the first context.
	delete w1;

	// Make the second context current again because deleting the first
	// one will call doneCurrent() even though it wasn't current!
	w2->makeCurrent();

	// The buffer should still be valid in the second context.
	QVERIFY(buffer.bufferId() != 0);
	QVERIFY(buffer.isCreated());
	QVERIFY(buffer.bind());
	QCOMPARE(buffer.size(), int(sizeof(data)));
	buffer.release();

	// Delete the second context.
	delete w2;

	// The buffer should now be invalid.
	QCOMPARE(buffer.bufferId(), GLuint(0));
	QVERIFY(!buffer.isCreated());
	}

	QTEST_MAIN(tst_QGLBuffer)

	#include "tst_qglbuffer.moc"