From 9124a61eb1c10ed3bb7251baf2f42ac4a865e514 Mon Sep 17 00:00:00 2001 From: Paul Lemire Date: Wed, 7 Jun 2017 10:49:04 +0200 Subject: Introduce a GLShader class GLShader is renderer specific shader implementation for OpenGL. Shader now contains only backend information for a QShaderProgram frontend node. - Similar to the GLTexture handling, a generic adopt/abandon manager for shaders was introduced (regardless of the actually GraphicsAPIShader class). - The renderer and renderviews were adapted to the new changes. This was the last major thing preventing the modularisation of the QRenderAspect and renderers Change-Id: If671d60928b433977e9d6e5c58199827f9408a3f Task-number: QTBUG-61151 Reviewed-by: Mike Krus --- .../render/glshadermanager/glshadermanager.pro | 12 + .../render/glshadermanager/tst_glshadermanager.cpp | 199 ++++++++++++++ tests/auto/render/render.pro | 2 +- tests/auto/render/renderviews/tst_renderviews.cpp | 111 ++++++-- tests/auto/render/shader/tst_shader.cpp | 46 +--- tests/auto/render/shadercache/shadercache.pro | 11 - tests/auto/render/shadercache/tst_shadercache.cpp | 293 --------------------- 7 files changed, 308 insertions(+), 366 deletions(-) create mode 100644 tests/auto/render/glshadermanager/glshadermanager.pro create mode 100644 tests/auto/render/glshadermanager/tst_glshadermanager.cpp delete mode 100644 tests/auto/render/shadercache/shadercache.pro delete mode 100644 tests/auto/render/shadercache/tst_shadercache.cpp (limited to 'tests') diff --git a/tests/auto/render/glshadermanager/glshadermanager.pro b/tests/auto/render/glshadermanager/glshadermanager.pro new file mode 100644 index 000000000..27aadf84f --- /dev/null +++ b/tests/auto/render/glshadermanager/glshadermanager.pro @@ -0,0 +1,12 @@ +TEMPLATE = app + +TARGET = tst_glshadermanager + +QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib + +CONFIG += testcase + +SOURCES += tst_glshadermanager.cpp + +include(../../core/common/common.pri) +include(../commons/commons.pri) diff --git a/tests/auto/render/glshadermanager/tst_glshadermanager.cpp b/tests/auto/render/glshadermanager/tst_glshadermanager.cpp new file mode 100644 index 000000000..c18fb4793 --- /dev/null +++ b/tests/auto/render/glshadermanager/tst_glshadermanager.cpp @@ -0,0 +1,199 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB). +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the Qt3D 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 +#include +#include +#include "qbackendnodetester.h" +#include "testrenderer.h" + +class tst_GLShaderManager : public Qt3DCore::QBackendNodeTester +{ + Q_OBJECT + +private Q_SLOTS: + void adopt(); + void lookupResource(); + void abandon(); + void insertAfterRemoval(); +}; + +void tst_GLShaderManager::adopt() +{ + // GIVEN + Qt3DRender::Render::GLShaderManager cache; + Qt3DRender::QShaderProgram frontendShader1; + Qt3DRender::QShaderProgram frontendShader2; + TestRenderer renderer; + Qt3DRender::Render::Shader backendShaderNode1; + Qt3DRender::Render::Shader backendShaderNode2; + + backendShaderNode1.setRenderer(&renderer); + backendShaderNode2.setRenderer(&renderer); + simulateInitialization(&frontendShader1, &backendShaderNode1); + simulateInitialization(&frontendShader2, &backendShaderNode2); + + // THEN + QVERIFY(cache.lookupResource(backendShaderNode1.peerId()) == nullptr); + QVERIFY(cache.lookupResource(backendShaderNode2.peerId()) == nullptr); + QVERIFY(backendShaderNode1.peerId() != backendShaderNode2.peerId()); + + // WHEN + Qt3DRender::Render::GLShader *glShader1 = cache.createOrAdoptExisting(&backendShaderNode1); + + // THEN + QVERIFY(glShader1 != nullptr); + QVector shaderNodeIds = cache.shaderIdsForProgram(glShader1); + QCOMPARE(shaderNodeIds.size(), 1); + QCOMPARE(shaderNodeIds.first(), backendShaderNode1.peerId()); + + // WHEN + Qt3DRender::Render::GLShader *glShader2 = cache.createOrAdoptExisting(&backendShaderNode2); + + // THEN + QCOMPARE(glShader1, glShader2); + + shaderNodeIds = cache.shaderIdsForProgram(glShader2); + QCOMPARE(shaderNodeIds.size(), 2); + QCOMPARE(shaderNodeIds.first(), backendShaderNode1.peerId()); + QCOMPARE(shaderNodeIds.last(), backendShaderNode2.peerId()); +} + +void tst_GLShaderManager::lookupResource() +{ + // GIVEN + Qt3DRender::Render::GLShaderManager cache; + Qt3DRender::QShaderProgram frontendShader1; + Qt3DRender::QShaderProgram frontendShader2; + TestRenderer renderer; + Qt3DRender::Render::Shader backendShaderNode1; + Qt3DRender::Render::Shader backendShaderNode2; + + backendShaderNode1.setRenderer(&renderer); + backendShaderNode2.setRenderer(&renderer); + simulateInitialization(&frontendShader1, &backendShaderNode1); + simulateInitialization(&frontendShader2, &backendShaderNode2); + + // WHEN + cache.createOrAdoptExisting(&backendShaderNode1); + cache.createOrAdoptExisting(&backendShaderNode2); + + // THEN + Qt3DRender::Render::GLShader *glShader1 = cache.lookupResource(backendShaderNode1.peerId()); + Qt3DRender::Render::GLShader *glShader2 = cache.lookupResource(backendShaderNode2.peerId()); + QVERIFY(glShader1 != nullptr); + QCOMPARE(glShader1, glShader2); + const QVector shaderNodeIds = cache.shaderIdsForProgram(glShader1); + QCOMPARE(shaderNodeIds.size(), 2); + QVERIFY(shaderNodeIds.contains(frontendShader1.id())); + QVERIFY(shaderNodeIds.contains(frontendShader2.id())); +} + +void tst_GLShaderManager::abandon() +{ + // GIVEN + Qt3DRender::Render::GLShaderManager cache; + Qt3DRender::QShaderProgram frontendShader1; + Qt3DRender::QShaderProgram frontendShader2; + TestRenderer renderer; + Qt3DRender::Render::Shader backendShaderNode1; + Qt3DRender::Render::Shader backendShaderNode2; + + backendShaderNode1.setRenderer(&renderer); + backendShaderNode2.setRenderer(&renderer); + simulateInitialization(&frontendShader1, &backendShaderNode1); + simulateInitialization(&frontendShader2, &backendShaderNode2); + cache.createOrAdoptExisting(&backendShaderNode1); + cache.createOrAdoptExisting(&backendShaderNode2); + + // WHEN + Qt3DRender::Render::GLShader *glShader = cache.lookupResource(backendShaderNode1.peerId()); + cache.abandon(glShader, &backendShaderNode1); + + // THEN + QVector shaderNodeIds = cache.shaderIdsForProgram(glShader); + QVERIFY(cache.takeAbandonned().isEmpty()); + QCOMPARE(shaderNodeIds.size(), 1); + QCOMPARE(shaderNodeIds.first(), backendShaderNode2.peerId()); + + // WHEN + cache.abandon(glShader, &backendShaderNode2); + + // THEN + shaderNodeIds = cache.shaderIdsForProgram(glShader); + QCOMPARE(shaderNodeIds.size(), 0); + const QVector releasedShaders = cache.takeAbandonned(); + QCOMPARE(releasedShaders.size(), 1); + QCOMPARE(releasedShaders.first(), glShader); +} + +void tst_GLShaderManager::insertAfterRemoval() +{ + // GIVEN + Qt3DRender::Render::GLShaderManager cache; + Qt3DRender::QShaderProgram frontendShader; + TestRenderer renderer; + Qt3DRender::Render::Shader backendShaderNode; + + + backendShaderNode.setRenderer(&renderer); + simulateInitialization(&frontendShader, &backendShaderNode); + + // WHEN + Qt3DRender::Render::GLShader *apiShader1 = cache.createOrAdoptExisting(&backendShaderNode); + const Qt3DRender::Render::GLShader *originalApiShader = apiShader1; + + // THEN + auto apiShader2 = cache.lookupResource(frontendShader.id()); + QVERIFY(apiShader1 != nullptr); + QVERIFY(apiShader2 != nullptr); + QVERIFY(apiShader1 == originalApiShader); + QVERIFY(apiShader1 == apiShader2); + + // WHEN + cache.abandon(apiShader1, &backendShaderNode); + + // THEN + Qt3DRender::Render::GLShader *apiShaderEmpty = cache.lookupResource(frontendShader.id()); + QVERIFY(apiShaderEmpty == nullptr); + + // WHEN + apiShader1 = cache.createOrAdoptExisting(&backendShaderNode); + cache.purge(); + apiShader2 = cache.lookupResource(frontendShader.id()); + + // THEN + QVERIFY(apiShader1 != nullptr); + QVERIFY(apiShader2 != nullptr); + QVERIFY(apiShader1 == apiShader2); + QVERIFY(apiShader2 == originalApiShader); +} + +QTEST_APPLESS_MAIN(tst_GLShaderManager) + +#include "tst_glshadermanager.moc" diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro index 908426570..2b73ec8b7 100644 --- a/tests/auto/render/render.pro +++ b/tests/auto/render/render.pro @@ -42,7 +42,6 @@ qtConfig(private_tests) { # boundingvolumedebug \ ddstextures \ ktxtextures \ - shadercache \ layerfiltering \ filterentitybycomponent \ genericlambdajob \ @@ -130,6 +129,7 @@ qtConfig(qt3d-opengl-renderer):qtConfig(private_tests) { graphicshelpergl3_3 \ graphicshelpergl3_2 \ graphicshelpergl2 \ + glshadermanager \ materialparametergathererjob \ textures \ renderer \ diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp index 086ff0220..b434fe83a 100644 --- a/tests/auto/render/renderviews/tst_renderviews.cpp +++ b/tests/auto/render/renderviews/tst_renderviews.cpp @@ -36,6 +36,9 @@ #include #include #include +#include +#include +#include QT_BEGIN_NAMESPACE @@ -64,6 +67,7 @@ void compareShaderParameterPacks(const ShaderParameterPack &t1, class tst_RenderViews : public Qt3DCore::QBackendNodeTester { Q_OBJECT + private Q_SLOTS: void checkRenderViewSizeFitsWithAllocator() @@ -132,10 +136,15 @@ private Q_SLOTS: void checkRenderCommandBackToFrontSorting() { // GIVEN + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); RenderView renderView; QVector rawCommands; QVector sortTypes; + renderer.setNodeManagers(&nodeManagers); + renderView.setRenderer(&renderer); + sortTypes.push_back(QSortPolicy::BackToFront); for (int i = 0; i < 200; ++i) { @@ -156,28 +165,34 @@ private Q_SLOTS: QVERIFY(sortedCommands.at(j - 1).m_depth > sortedCommands.at(j).m_depth); // RenderCommands are deleted by RenderView dtor + renderer.shutdown(); } void checkRenderCommandMaterialSorting() { // GIVEN + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); RenderView renderView; QVector rawCommands; QVector sortTypes; + renderer.setNodeManagers(&nodeManagers); + renderView.setRenderer(&renderer); + sortTypes.push_back(QSortPolicy::Material); - ProgramDNA dnas[5] = { - ProgramDNA(250), - ProgramDNA(500), - ProgramDNA(1000), - ProgramDNA(1500), - ProgramDNA(2000), + GLShader *dnas[5] = { + reinterpret_cast(0x250), + reinterpret_cast(0x500), + reinterpret_cast(0x1000), + reinterpret_cast(0x1500), + reinterpret_cast(0x2000) }; for (int i = 0; i < 20; ++i) { RenderCommand c; - c.m_shaderDna = dnas[i % 5]; + c.m_glShader = dnas[i % 5]; rawCommands.push_back(c); } @@ -189,24 +204,25 @@ private Q_SLOTS: // THEN const QVector sortedCommands = renderView.commands(); QCOMPARE(rawCommands.size(), sortedCommands.size()); - ProgramDNA targetDNA; + GLShader *targetShader; for (int j = 0; j < sortedCommands.size(); ++j) { if (j % 4 == 0) { - targetDNA = sortedCommands.at(j).m_shaderDna; + targetShader = sortedCommands.at(j).m_glShader; if (j > 0) - QVERIFY(targetDNA != sortedCommands.at(j - 1).m_shaderDna); + QVERIFY(targetShader != sortedCommands.at(j - 1).m_glShader); } - QCOMPARE(targetDNA, sortedCommands.at(j).m_shaderDna); + QCOMPARE(targetShader, sortedCommands.at(j).m_glShader); } // RenderCommands are deleted by RenderView dtor + renderer.shutdown(); } void checkRenderViewUniformMinification_data() { - QTest::addColumn>("programDNAs"); + QTest::addColumn>("shaders"); QTest::addColumn>("rawParameters"); QTest::addColumn>("expectedMinimizedParameters"); @@ -217,36 +233,56 @@ private Q_SLOTS: pack1.setUniform(2, UniformValue(1584.0f)); pack1.setTexture(3, 0, fakeTextureNodeId); + QShaderProgram *shader1 = new QShaderProgram(); + QShaderProgram *shader2 = new QShaderProgram(); + + shader1->setShaderCode(QShaderProgram::Vertex, QByteArrayLiteral("1")); + shader2->setShaderCode(QShaderProgram::Vertex, QByteArrayLiteral("2")); + ShaderParameterPack minifiedPack1; QTest::newRow("NoMinification") - << (QVector() << ProgramDNA(883) << ProgramDNA(1584)) + << (QVector() << shader1 << shader2) << (QVector() << pack1 << pack1) << (QVector() << pack1 << pack1); QTest::newRow("SingleShaderMinified") - << (QVector() << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(883)) + << (QVector() << shader1 << shader1 << shader1) << (QVector() << pack1 << pack1 << pack1) << (QVector() << pack1 << minifiedPack1 << minifiedPack1); QTest::newRow("MultipleShadersMinified") - << (QVector() << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(883) << ProgramDNA(1584) << ProgramDNA(1584) << ProgramDNA(1584)) + << (QVector() << shader1 << shader1 << shader1 << shader2 << shader2 << shader2) << (QVector() << pack1 << pack1 << pack1 << pack1 << pack1 << pack1) << (QVector() << pack1 << minifiedPack1 << minifiedPack1 << pack1 << minifiedPack1 << minifiedPack1); } void checkRenderViewUniformMinification() { - QFETCH(QVector, programDNAs); + QFETCH(QVector, shaders); QFETCH(QVector, rawParameters); QFETCH(QVector, expectedMinimizedParameters); + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); + renderer.setNodeManagers(&nodeManagers); + + GLShaderManager *shaderManager = renderer.glResourceManagers()->glShaderManager(); + for (int i = 0, m = shaders.size(); i < m; ++i) { + Shader* backend = new Shader(); + backend->setRenderer(&renderer); + simulateInitializationSync(shaders.at(i), backend); + shaderManager->createOrAdoptExisting(backend); + } + RenderView renderView; QVector rawCommands; + renderView.setRenderer(&renderer); - for (int i = 0, m = programDNAs.size(); i < m; ++i) { + for (int i = 0, m = shaders.size(); i < m; ++i) { RenderCommand c; - c.m_shaderDna = programDNAs.at(i); + c.m_shaderId = shaders.at(i)->id(); + c.m_glShader = shaderManager->lookupResource(c.m_shaderId); c.m_parameterPack = rawParameters.at(i); rawCommands.push_back(c); } @@ -260,21 +296,28 @@ private Q_SLOTS: const QVector sortedCommands = renderView.commands(); QCOMPARE(rawCommands, sortedCommands); - for (int i = 0, m = programDNAs.size(); i < m; ++i) { + for (int i = 0, m = shaders.size(); i < m; ++i) { const RenderCommand c = sortedCommands.at(i); - QCOMPARE(c.m_shaderDna, programDNAs.at(i)); + QCOMPARE(c.m_shaderId, shaders.at(i)->id()); compareShaderParameterPacks(c.m_parameterPack, expectedMinimizedParameters.at(i)); } + + renderer.shutdown(); } void checkRenderCommandFrontToBackSorting() { // GIVEN + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); RenderView renderView; QVector rawCommands; QVector sortTypes; + renderer.setNodeManagers(&nodeManagers); + renderView.setRenderer(&renderer); + sortTypes.push_back(QSortPolicy::FrontToBack); for (int i = 0; i < 200; ++i) { @@ -295,15 +338,21 @@ private Q_SLOTS: QVERIFY(sortedCommands.at(j - 1).m_depth < sortedCommands.at(j).m_depth); // RenderCommands are deleted by RenderView dtor + renderer.shutdown(); } void checkRenderCommandStateCostSorting() { // GIVEN + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); RenderView renderView; QVector rawCommands; QVector sortTypes; + renderer.setNodeManagers(&nodeManagers); + renderView.setRenderer(&renderer); + sortTypes.push_back(QSortPolicy::StateChangeCost); for (int i = 0; i < 200; ++i) { @@ -324,24 +373,31 @@ private Q_SLOTS: QVERIFY(sortedCommands.at(j - 1).m_changeCost > sortedCommands.at(j).m_changeCost); // RenderCommands are deleted by RenderView dtor + renderer.shutdown(); } void checkRenderCommandCombinedStateMaterialDepthSorting() { // GIVEN + Qt3DRender::Render::NodeManagers nodeManagers; + Qt3DRender::Render::Renderer renderer(Qt3DRender::QRenderAspect::Synchronous); RenderView renderView; QVector rawCommands; QVector sortTypes; + renderer.setNodeManagers(&nodeManagers); + renderView.setRenderer(&renderer); + sortTypes.push_back(QSortPolicy::StateChangeCost); sortTypes.push_back(QSortPolicy::Material); sortTypes.push_back(QSortPolicy::BackToFront); - ProgramDNA dna[4] = { - ProgramDNA(250), - ProgramDNA(500), - ProgramDNA(1000), - ProgramDNA(1500) + GLShader *dna[5] = { + reinterpret_cast(0x250), + reinterpret_cast(0x500), + reinterpret_cast(0x1000), + reinterpret_cast(0x1500), + reinterpret_cast(0x2000) }; float depth[3] = { @@ -355,9 +411,9 @@ private Q_SLOTS: 200 }; - auto buildRC = [] (ProgramDNA dna, float depth, int changeCost) { + auto buildRC = [] (GLShader *dna, float depth, int changeCost) { RenderCommand c; - c.m_shaderDna = dna; + c.m_glShader = dna; c.m_depth = depth; c.m_changeCost = changeCost; return c; @@ -400,6 +456,7 @@ private Q_SLOTS: QCOMPARE(c9, sortedCommands.at(6)); // RenderCommands are deleted by RenderView dtor + renderer.shutdown(); } void checkRenderCommandTextureSorting() diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp index d1578aee7..3f0714907 100644 --- a/tests/auto/render/shader/tst_shader.cpp +++ b/tests/auto/render/shader/tst_shader.cpp @@ -79,15 +79,9 @@ void tst_RenderShader::hasCoherentInitialState() { Qt3DRender::Render::Shader *shader = new Qt3DRender::Render::Shader(); - QCOMPARE(shader->isLoaded(), false); - QCOMPARE(shader->dna(), 0U); - QVERIFY(shader->uniformsNames().isEmpty()); - QVERIFY(shader->attributesNames().isEmpty()); - QVERIFY(shader->uniformBlockNames().isEmpty()); - QVERIFY(shader->uniforms().isEmpty()); - QVERIFY(shader->attributes().isEmpty()); - QVERIFY(shader->uniformBlocks().isEmpty()); QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady); + QVERIFY(shader->log().isEmpty()); + QCOMPARE(shader->isDirty(), false); } void tst_RenderShader::matchesFrontendPeer() @@ -98,8 +92,7 @@ void tst_RenderShader::matchesFrontendPeer() backend.setRenderer(&renderer); simulateInitializationSync(frontend.data(), &backend); - QCOMPARE(backend.isLoaded(), false); - QVERIFY(backend.dna() != 0U); + QCOMPARE(backend.isDirty(), true); for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i) QCOMPARE(backend.shaderCode()[i], @@ -117,14 +110,7 @@ void tst_RenderShader::cleanupLeavesACoherentState() shader.cleanup(); - QCOMPARE(shader.isLoaded(), false); - QCOMPARE(shader.dna(), 0U); - QVERIFY(shader.uniformsNames().isEmpty()); - QVERIFY(shader.attributesNames().isEmpty()); - QVERIFY(shader.uniformBlockNames().isEmpty()); - QVERIFY(shader.uniforms().isEmpty()); - QVERIFY(shader.attributes().isEmpty()); - QVERIFY(shader.uniformBlocks().isEmpty()); + QCOMPARE(shader.isDirty(), false); QCOMPARE(shader.status(), Qt3DRender::QShaderProgram::NotReady); } @@ -152,7 +138,7 @@ void tst_RenderShader::dealWithPropertyChanges() Qt3DRender::Render::Shader backend; Qt3DRender::QShaderProgram shader; - backend.setLoaded(true); + TestRenderer renderer; backend.setRenderer(&renderer); simulateInitializationSync(&shader, &backend); @@ -162,11 +148,13 @@ void tst_RenderShader::dealWithPropertyChanges() backend.syncFromFrontEnd(&shader, false); // THEN - QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("foo")); - QVERIFY(!backend.isLoaded()); + QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo")); QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty); + QCOMPARE(backend.isDirty(), true); + renderer.resetDirty(); - backend.setLoaded(true); + QCOMPARE(renderer.dirtyBits(), 0); + backend.unsetDirty(); // WHEN shader.setShaderCode(type, QByteArrayLiteral("foo")); @@ -174,10 +162,8 @@ void tst_RenderShader::dealWithPropertyChanges() // THEN QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("foo")); - QVERIFY(backend.isLoaded()); QCOMPARE(renderer.dirtyBits(), 0); - renderer.resetDirty(); - backend.setLoaded(true); + QCOMPARE(backend.isDirty(), false); // WHEN shader.setShaderCode(type, QByteArrayLiteral("bar")); @@ -185,10 +171,9 @@ void tst_RenderShader::dealWithPropertyChanges() // THEN QCOMPARE(backend.shaderCode().at(type), QByteArrayLiteral("bar")); - QVERIFY(!backend.isLoaded()); QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty); renderer.resetDirty(); - backend.setLoaded(true); + QCOMPARE(backend.isDirty(), true); } void tst_RenderShader::checkSetRendererDirtyOnInitialization() @@ -221,7 +206,6 @@ void tst_RenderShader::allowToChangeShaderCode() QFETCH(Qt3DRender::QShaderProgram::ShaderType, type); Qt3DRender::Render::Shader backend; - backend.setLoaded(true); TestRenderer renderer; backend.setRenderer(&renderer); @@ -230,30 +214,24 @@ void tst_RenderShader::allowToChangeShaderCode() // THEN QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo")); - QVERIFY(!backend.isLoaded()); QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty); renderer.resetDirty(); - backend.setLoaded(true); // WHEN backend.setShaderCode(type, QByteArrayLiteral("foo")); // THEN QCOMPARE(backend.shaderCode().at(type), QStringLiteral("foo")); - QVERIFY(backend.isLoaded()); QCOMPARE(renderer.dirtyBits(), 0); renderer.resetDirty(); - backend.setLoaded(true); // WHEN backend.setShaderCode(type, QByteArrayLiteral("bar")); // THEN QCOMPARE(backend.shaderCode().at(type), QStringLiteral("bar")); - QVERIFY(!backend.isLoaded()); QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty); renderer.resetDirty(); - backend.setLoaded(true); } QTEST_APPLESS_MAIN(tst_RenderShader) diff --git a/tests/auto/render/shadercache/shadercache.pro b/tests/auto/render/shadercache/shadercache.pro deleted file mode 100644 index 38499588d..000000000 --- a/tests/auto/render/shadercache/shadercache.pro +++ /dev/null @@ -1,11 +0,0 @@ -TEMPLATE = app - -TARGET = tst_shadercache - -QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib - -CONFIG += testcase - -SOURCES += tst_shadercache.cpp - -include(../../core/common/common.pri) diff --git a/tests/auto/render/shadercache/tst_shadercache.cpp b/tests/auto/render/shadercache/tst_shadercache.cpp deleted file mode 100644 index 261548d69..000000000 --- a/tests/auto/render/shadercache/tst_shadercache.cpp +++ /dev/null @@ -1,293 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2016 Klaralvdalens Datakonsult AB (KDAB). -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the Qt3D 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 -#include -#include -#include -#include -#include - -QT_BEGIN_NAMESPACE - -using namespace Qt3DCore; - -namespace Qt3DRender { -namespace Render { - -class tst_ShaderCache : public QObject -{ - Q_OBJECT - -private Q_SLOTS: - void insert(); - void insertAfterRemoval(); - void value(); - void removeRef(); - void purge(); - void destruction(); -}; - -void tst_ShaderCache::insert() -{ - // GIVEN - ShaderCache cache; - - // THEN - QCOMPARE(cache.m_programHash.isEmpty(), true); - QCOMPARE(cache.m_programRefs.isEmpty(), true); - QCOMPARE(cache.m_pendingRemoval.isEmpty(), true); - - // WHEN - auto dna = ProgramDNA(12345); - auto nodeId = QNodeId::createId(); - auto shaderProgram = new QOpenGLShaderProgram; - cache.insert(dna, nodeId, shaderProgram); - - // THEN - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programHash.keys().first(), dna); - QCOMPARE(cache.m_programHash.values().first(), shaderProgram); - - QCOMPARE(cache.m_programRefs.size(), 1); - QCOMPARE(cache.m_programRefs.keys().first(), dna); - QCOMPARE(cache.m_programRefs.values().first().size(), 1); - QCOMPARE(cache.m_programRefs.values().first().first(), nodeId); - - QCOMPARE(cache.m_pendingRemoval.isEmpty(), true); -} - -void tst_ShaderCache::insertAfterRemoval() -{ - // GIVEN - ShaderCache cache; - auto dna = ProgramDNA(12345); - auto nodeId = QNodeId::createId(); - - // WHEN - QOpenGLShaderProgram *shaderProgram = new QOpenGLShaderProgram(); - cache.insert(dna, nodeId, shaderProgram); - cache.getShaderProgramAndAddRef(dna, nodeId); - cache.removeRef(dna, nodeId); - shaderProgram = cache.getShaderProgramAndAddRef(dna, nodeId); - - // THEN - QVERIFY(!cache.m_pendingRemoval.contains(dna)); - - // WHEN - cache.removeRef(dna, nodeId); - cache.getShaderProgramAndAddRef(dna, nodeId); - cache.purge(); - - // THEN - QCOMPARE(cache.m_programHash.size(), 1); -} - -void tst_ShaderCache::value() -{ - // GIVEN - ShaderCache cache; - - // WHEN - auto dnaA = ProgramDNA(12345); - auto nodeIdA = QNodeId::createId(); - auto shaderProgramA = new QOpenGLShaderProgram; - cache.insert(dnaA, nodeIdA, shaderProgramA); - auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA); - - // THEN - QCOMPARE(shaderProgramA, cachedProgramA); - - // WHEN - auto nodeIdA2 = QNodeId::createId(); - auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2); - - // THEN - QCOMPARE(shaderProgramA, cachedProgramA2); - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programHash.keys().first(), dnaA); - QCOMPARE(cache.m_programHash.values().first(), shaderProgramA); - - QCOMPARE(cache.m_programRefs.size(), 1); - QCOMPARE(cache.m_programRefs.keys().first(), dnaA); - const QVector refsA = cache.m_programRefs.values().first(); - QCOMPARE(refsA.size(), 2); - QCOMPARE(refsA.at(0), nodeIdA); - QCOMPARE(refsA.at(1), nodeIdA2); - - // WHEN - auto dnaB = ProgramDNA(67890); - auto nodeIdB = QNodeId::createId(); - auto shaderProgramB = new QOpenGLShaderProgram; - cache.insert(dnaB, nodeIdB, shaderProgramB); - - // THEN - QCOMPARE(cache.m_programHash.size(), 2); - QCOMPARE(cache.m_programRefs.size(), 2); - - // WHEN - auto cachedProgramB = cache.getShaderProgramAndAddRef(dnaB, nodeIdB); - QCOMPARE(shaderProgramB, cachedProgramB); - - // WHEN - auto dnaC = ProgramDNA(54321); - auto uncachedProgram = cache.getShaderProgramAndAddRef(dnaC, nodeIdB); - QVERIFY(uncachedProgram == nullptr); - - cache.clear(); - // Test inserting nullptr. - cache.insert(dnaA, nodeIdA, nullptr); - bool wasPresent = false; - cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA, &wasPresent); - QCOMPARE(wasPresent, true); - QCOMPARE(cachedProgramA, nullptr); - cache.clear(); - // Test wasPresent==false. - cachedProgramB = cache.getShaderProgramAndAddRef(dnaB, nodeIdB, &wasPresent); - QCOMPARE(wasPresent, false); - QCOMPARE(cachedProgramB, nullptr); -} - -void tst_ShaderCache::removeRef() -{ - // GIVEN - ShaderCache cache; - - // WHEN we add 2 references and remove one - auto dnaA = ProgramDNA(12345); - auto nodeIdA = QNodeId::createId(); - auto shaderProgramA = new QOpenGLShaderProgram; - cache.insert(dnaA, nodeIdA, shaderProgramA); - auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA); - - auto nodeIdA2 = QNodeId::createId(); - auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2); - - cache.removeRef(dnaA, nodeIdA); - - // THEN - QCOMPARE(cachedProgramA, shaderProgramA); - QCOMPARE(cachedProgramA2, shaderProgramA); - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programRefs.size(), 1); - const auto refs = cache.m_programRefs.value(dnaA); - QCOMPARE(refs.size(), 1); - QCOMPARE(refs.first(), nodeIdA2); - QCOMPARE(cache.m_pendingRemoval.size(), 0); - - // WHEN we remove same ref again - cache.removeRef(dnaA, nodeIdA); - - // THEN no change - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programRefs.size(), 1); - const auto refs2 = cache.m_programRefs.value(dnaA); - QCOMPARE(refs2.size(), 1); - QCOMPARE(refs.first(), nodeIdA2); - - // WHEN we remove other reference - cache.removeRef(dnaA, nodeIdA2); - - // THEN - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programRefs.size(), 1); - const auto refs3 = cache.m_programRefs.value(dnaA); - QCOMPARE(refs3.size(), 0); - QCOMPARE(cache.m_pendingRemoval.size(), 1); - QCOMPARE(cache.m_pendingRemoval.first(), dnaA); -} - -void tst_ShaderCache::purge() -{ - // GIVEN - ShaderCache cache; - - // WHEN we add 2 references and remove one and purge - auto dnaA = ProgramDNA(12345); - auto nodeIdA = QNodeId::createId(); - auto shaderProgramA = new QOpenGLShaderProgram; - QPointer progPointer(shaderProgramA); - cache.insert(dnaA, nodeIdA, shaderProgramA); - auto cachedProgramA = cache.getShaderProgramAndAddRef(dnaA, nodeIdA); - - auto nodeIdA2 = QNodeId::createId(); - auto cachedProgramA2 = cache.getShaderProgramAndAddRef(dnaA, nodeIdA2); - - cache.removeRef(dnaA, nodeIdA); - cache.purge(); - - // THEN no removal - QCOMPARE(cachedProgramA, shaderProgramA); - QCOMPARE(cachedProgramA2, shaderProgramA); - QCOMPARE(cache.m_programHash.size(), 1); - QCOMPARE(cache.m_programRefs.size(), 1); - QCOMPARE(cache.m_pendingRemoval.isEmpty(), true); - - // WHEN we remove final ref and purge - cache.removeRef(dnaA, nodeIdA2); - cache.purge(); - - // THEN shader program is removed from cache and deleted - QCOMPARE(cache.m_programHash.isEmpty(), true); - QCOMPARE(cache.m_programRefs.isEmpty(), true); - QCOMPARE(progPointer.isNull(), true); -} - -void tst_ShaderCache::destruction() -{ - // GIVEN - auto cache = new ShaderCache; - - // WHEN - auto dnaA = ProgramDNA(12345); - auto nodeIdA = QNodeId::createId(); - auto shaderProgramA = new QOpenGLShaderProgram; - QPointer progPointerA(shaderProgramA); - - auto dnaB = ProgramDNA(67890); - auto nodeIdB = QNodeId::createId(); - auto shaderProgramB = new QOpenGLShaderProgram; - QPointer progPointerB(shaderProgramB); - - cache->insert(dnaA, nodeIdA, shaderProgramA); - cache->insert(dnaB, nodeIdB, shaderProgramB); - delete cache; - - // THEN - QCOMPARE(progPointerA.isNull(), true); - QCOMPARE(progPointerB.isNull(), true); -} - -} // namespace Render -} // namespace Qt3DRender - -QT_END_NAMESPACE - -QTEST_APPLESS_MAIN(Qt3DRender::Render::tst_ShaderCache) - -#include "tst_shadercache.moc" -- cgit v1.2.3