qiurui
/
qtdeclarative
mirror of https://github.com/qt/qtdeclarative.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
qtdeclarative/src/quick/scenegraph/coreapi/qsgbatchrenderer.cpp

4103 lines
148 KiB
C++
Raw Normal View History

Use SPDX license identifiers Replace the current license disclaimer in files by a SPDX-License-Identifier. Files that have to be modified by hand are modified. License files are organized under LICENSES directory. Pick-to: 6.4 Task-number: QTBUG-67283 Change-Id: I63563bbeb6f60f89d2c99660400dca7fab78a294 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
2022-05-13 13:12:05 +00:00
// Copyright (C) 2019 The Qt Company Ltd.
// Copyright (C) 2016 Jolla Ltd, author: <gunnar.sletta@jollamobile.com>
// Copyright (C) 2016 Robin Burchell <robin.burchell@viroteck.net>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
#include "qsgbatchrenderer_p.h"
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
#include <qmath.h>
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
#include <QtCore/QElapsedTimer>
Move QtQuick profiling to own profiler adapter The QtQuick parts of the QML profiler service thus become a proper global profiler which can be independently enabled and disabled. Change-Id: Ifad03801cab2be66a264fc46fdebdae582fcc99b Reviewed-by: Kai Koehne <kai.koehne@digia.com>
2014-01-24 12:24:19 +00:00
#include <QtCore/QtNumeric>
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
#include <QtGui/QGuiApplication>
Make qml-debug a proper feature Change-Id: Iea33ff0200f0bbf43953fedba030edf91d0f1417 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-10-06 15:30:36 +00:00
#include <private/qnumeric_p.h>
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
#include "qsgmaterialshader_p.h"
Enable profiling of materials and atlas textures Task-number: QTBUG-33459 Change-Id: Ie9ea176fbb7ee46a128b4bf66a8f4475a5d4c90b Reviewed-by: Aurindam Jana <aurindam.jana@digia.com>
2013-09-30 11:19:30 +00:00
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
#include "qsgrhivisualizer_p.h"
Remove qSort usages from declarative QtAlgorithms is getting deprecated, see http://www.mail-archive.com/development@qt-project.org/msg01603.html Change-Id: I8fa7d0186cc8f0ba562695974829e37f1eb87f2f Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-09-12 09:06:59 +00:00
#include <algorithm>
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QT_BEGIN_NAMESPACE
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
#ifndef QT_NO_DEBUG
Q_QUICK_PRIVATE_EXPORT bool qsg_test_and_clear_material_failure();
#endif
Quick: Sanitize reading environment variables. Where possible, use qEnvironmentVariableIsSet()/ qEnvironmentVariableIsEmpty() instead of checking on the return value of qgetenv(). Where the value is required, add a check using one of qEnvironmentVariableIsSet()/Empty(). Move QSGAtlasTexture::qsg_envInt() to qsgrenderer.cpp for reuse as qt_sg_envInt() and add qt_sg_envFloat(). Change-Id: I4c93f16c228d4f537154f389a0fa1427654485f7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-10-22 10:36:18 +00:00
int qt_sg_envInt(const char *name, int defaultValue);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
namespace QSGBatchRenderer
{
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
#define DECLARE_DEBUG_VAR(variable) \
static bool debug_ ## variable() \
{ static bool value = qgetenv("QSG_RENDERER_DEBUG").contains(QT_STRINGIFY(variable)); return value; }
DECLARE_DEBUG_VAR(render)
DECLARE_DEBUG_VAR(build)
DECLARE_DEBUG_VAR(change)
DECLARE_DEBUG_VAR(upload)
DECLARE_DEBUG_VAR(roots)
DECLARE_DEBUG_VAR(dump)
DECLARE_DEBUG_VAR(noalpha)
DECLARE_DEBUG_VAR(noopaque)
DECLARE_DEBUG_VAR(noclip)
#undef DECLARE_DEBUG_VAR
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
#define QSGNODE_TRAVERSE(NODE) for (QSGNode *child = NODE->firstChild(); child; child = child->nextSibling())
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
#define SHADOWNODE_TRAVERSE(NODE) for (Node *child = NODE->firstChild(); child; child = child->sibling())
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
static inline int size_of_type(int type)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
static int sizes[] = {
sizeof(char),
sizeof(unsigned char),
sizeof(short),
sizeof(unsigned short),
sizeof(int),
sizeof(unsigned int),
sizeof(float),
2,
3,
4,
sizeof(double)
};
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Q_ASSERT(type >= QSGGeometry::ByteType && type <= QSGGeometry::DoubleType);
return sizes[type - QSGGeometry::ByteType];
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
bool qsg_sort_element_increasing_order(Element *a, Element *b) { return a->order < b->order; }
bool qsg_sort_element_decreasing_order(Element *a, Element *b) { return a->order > b->order; }
bool qsg_sort_batch_is_valid(Batch *a, Batch *b) { return a->first && !b->first; }
bool qsg_sort_batch_increasing_order(Batch *a, Batch *b) { return a->first->order < b->first->order; }
bool qsg_sort_batch_decreasing_order(Batch *a, Batch *b) { return a->first->order > b->first->order; }
Support batching of rotated antialiased elements. Change-Id: I67d961f23941ba5cfa16fd679b609cd0fc3071c7 Reviewed-by: Michael Brasser <michael.brasser@live.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-12-04 14:44:57 +00:00
QSGMaterial::Flag QSGMaterial_FullMatrix = (QSGMaterial::Flag) (QSGMaterial::RequiresFullMatrix & ~QSGMaterial::RequiresFullMatrixExceptTranslate);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
static bool isTranslate(const QMatrix4x4 &m) { return m.flags() <= QMatrix4x4::Translation; }
static bool isScale(const QMatrix4x4 &m) { return m.flags() <= QMatrix4x4::Scale; }
static bool is2DSafe(const QMatrix4x4 &m) { return m.flags() < QMatrix4x4::Rotation; }
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
const float OPAQUE_LIMIT = 0.999f;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const uint DYNAMIC_VERTEX_INDEX_BUFFER_THRESHOLD = 4;
const int VERTEX_BUFFER_BINDING = 0;
const int ZORDER_BUFFER_BINDING = VERTEX_BUFFER_BINDING + 1;
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
template <class Int>
inline Int aligned(Int v, Int byteAlign)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
return (v + byteAlign - 1) & ~(byteAlign - 1);
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
QRhiVertexInputAttribute::Format qsg_vertexInputFormat(const QSGGeometry::Attribute &a)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
switch (a.type) {
case QSGGeometry::FloatType:
if (a.tupleSize == 4)
return QRhiVertexInputAttribute::Float4;
if (a.tupleSize == 3)
return QRhiVertexInputAttribute::Float3;
if (a.tupleSize == 2)
return QRhiVertexInputAttribute::Float2;
if (a.tupleSize == 1)
return QRhiVertexInputAttribute::Float;
break;
case QSGGeometry::UnsignedByteType:
if (a.tupleSize == 4)
return QRhiVertexInputAttribute::UNormByte4;
if (a.tupleSize == 2)
return QRhiVertexInputAttribute::UNormByte2;
if (a.tupleSize == 1)
return QRhiVertexInputAttribute::UNormByte;
break;
default:
break;
}
qWarning("Unsupported attribute type 0x%x with %d components", a.type, a.tupleSize);
Q_UNREACHABLE();
return QRhiVertexInputAttribute::Float;
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
static QRhiVertexInputLayout calculateVertexInputLayout(const QSGMaterialShader *s, const QSGGeometry *geometry, bool batchable)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
Q_ASSERT(geometry);
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
const QSGMaterialShaderPrivate *sd = QSGMaterialShaderPrivate::get(s);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!sd->vertexShader) {
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
qWarning("No vertex shader in QSGMaterialShader %p", s);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return QRhiVertexInputLayout();
}
const int attrCount = geometry->attributeCount();
Follow QRhi improvements and drop QVectors where applicable Task-number: QTBUG-78883 Change-Id: Ifcf5af843b5101a35ecc762a6a3b0196b6d97782 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-10-02 09:10:21 +00:00
QVarLengthArray<QRhiVertexInputAttribute, 8> inputAttributes;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
inputAttributes.reserve(attrCount + 1);
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 offset = 0;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i = 0; i < attrCount; ++i) {
const QSGGeometry::Attribute &a = geometry->attributes()[i];
if (!sd->vertexShader->vertexInputLocations.contains(a.position)) {
qWarning("Vertex input %d is present in material but not in shader. This is wrong.",
a.position);
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
inputAttributes.append(QRhiVertexInputAttribute(VERTEX_BUFFER_BINDING, a.position, qsg_vertexInputFormat(a), offset));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
offset += a.tupleSize * size_of_type(a.type);
}
if (batchable) {
inputAttributes.append(QRhiVertexInputAttribute(ZORDER_BUFFER_BINDING, sd->vertexShader->qt_order_attrib_location,
QRhiVertexInputAttribute::Float, 0));
}
Q_ASSERT(VERTEX_BUFFER_BINDING == 0 && ZORDER_BUFFER_BINDING == 1); // not very flexible
Follow QRhi improvements and drop QVectors where applicable Task-number: QTBUG-78883 Change-Id: Ifcf5af843b5101a35ecc762a6a3b0196b6d97782 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-10-02 09:10:21 +00:00
QVarLengthArray<QRhiVertexInputBinding, 2> inputBindings;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
inputBindings.append(QRhiVertexInputBinding(geometry->sizeOfVertex()));
if (batchable)
inputBindings.append(QRhiVertexInputBinding(sizeof(float)));
QRhiVertexInputLayout inputLayout;
Follow QRhi improvements and drop QVectors where applicable Task-number: QTBUG-78883 Change-Id: Ifcf5af843b5101a35ecc762a6a3b0196b6d97782 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-10-02 09:10:21 +00:00
inputLayout.setBindings(inputBindings.cbegin(), inputBindings.cend());
inputLayout.setAttributes(inputAttributes.cbegin(), inputAttributes.cend());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return inputLayout;
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
QRhiCommandBuffer::IndexFormat qsg_indexFormat(const QSGGeometry *geometry)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
switch (geometry->indexType()) {
case QSGGeometry::UnsignedShortType:
return QRhiCommandBuffer::IndexUInt16;
break;
case QSGGeometry::UnsignedIntType:
return QRhiCommandBuffer::IndexUInt32;
break;
default:
Q_UNREACHABLE();
return QRhiCommandBuffer::IndexUInt16;
}
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
QRhiGraphicsPipeline::Topology qsg_topology(int geomDrawMode)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
QRhiGraphicsPipeline::Topology topology = QRhiGraphicsPipeline::Triangles;
switch (geomDrawMode) {
case QSGGeometry::DrawPoints:
topology = QRhiGraphicsPipeline::Points;
break;
case QSGGeometry::DrawLines:
topology = QRhiGraphicsPipeline::Lines;
break;
case QSGGeometry::DrawLineStrip:
topology = QRhiGraphicsPipeline::LineStrip;
break;
case QSGGeometry::DrawTriangles:
topology = QRhiGraphicsPipeline::Triangles;
break;
case QSGGeometry::DrawTriangleStrip:
topology = QRhiGraphicsPipeline::TriangleStrip;
break;
default:
qWarning("Primitive topology 0x%x not supported", geomDrawMode);
break;
}
return topology;
}
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
ShaderManager::Shader *ShaderManager::prepareMaterial(QSGMaterial *material,
const QSGGeometry *geometry,
QSGRendererInterface::RenderMode renderMode)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
QSGMaterialType *type = material->type();
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
ShaderKey key = qMakePair(type, renderMode);
Shader *shader = rewrittenShaders.value(key, nullptr);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (shader)
return shader;
shader = new Shader;
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
QSGMaterialShader *s = static_cast<QSGMaterialShader *>(material->createShader(renderMode));
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
context->initializeRhiShader(s, QShader::BatchableVertexShader);
shader->programRhi.program = s;
shader->programRhi.inputLayout = calculateVertexInputLayout(s, geometry, true);
QSGMaterialShaderPrivate *sD = QSGMaterialShaderPrivate::get(s);
shader->programRhi.shaderStages = {
{ QRhiGraphicsShaderStage::Vertex, sD->shader(QShader::VertexStage), QShader::BatchableVertexShader },
{ QRhiGraphicsShaderStage::Fragment, sD->shader(QShader::FragmentStage) }
};
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
shader->lastOpacity = 0;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
rewrittenShaders[key] = shader;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
return shader;
}
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
ShaderManager::Shader *ShaderManager::prepareMaterialNoRewrite(QSGMaterial *material,
const QSGGeometry *geometry,
QSGRendererInterface::RenderMode renderMode)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
QSGMaterialType *type = material->type();
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
ShaderKey key = qMakePair(type, renderMode);
Shader *shader = stockShaders.value(key, nullptr);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (shader)
return shader;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
shader = new Shader;
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
QSGMaterialShader *s = static_cast<QSGMaterialShader *>(material->createShader(renderMode));
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
context->initializeRhiShader(s, QShader::StandardShader);
shader->programRhi.program = s;
shader->programRhi.inputLayout = calculateVertexInputLayout(s, geometry, false);
QSGMaterialShaderPrivate *sD = QSGMaterialShaderPrivate::get(s);
shader->programRhi.shaderStages = {
{ QRhiGraphicsShaderStage::Vertex, sD->shader(QShader::VertexStage) },
{ QRhiGraphicsShaderStage::Fragment, sD->shader(QShader::FragmentStage) }
};
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
shader->lastOpacity = 0;
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
stockShaders[key] = shader;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
return shader;
}
void ShaderManager::invalidated()
{
Fix inefficient usages of qDeleteAll() No reason to iterate through all items to create a temporary QList we don't need. Change-Id: I3c5388f026ded0290afb9dd35fc7934011c4998d Reviewed-by: Marc Mutz <marc.mutz@kdab.com> Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com> Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-19 16:57:54 +00:00
qDeleteAll(stockShaders);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
stockShaders.clear();
Fix inefficient usages of qDeleteAll() No reason to iterate through all items to create a temporary QList we don't need. Change-Id: I3c5388f026ded0290afb9dd35fc7934011c4998d Reviewed-by: Marc Mutz <marc.mutz@kdab.com> Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com> Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-19 16:57:54 +00:00
qDeleteAll(rewrittenShaders);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
rewrittenShaders.clear();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Share pipeline state objects between layer renderers ...as long as the renderpass descriptors are compatible. Relies on the new QRhiRenderPassDescriptor::isCompatible() function. In the nodetypes_ng manual test this brings down the number of pipelines created from 16 to 8 in the layer test scene (because most layers use the same materials there, so many pipelines can be reused between them - previously this was prevented by the comparison-by-pointer for the QRhiRenderPassDescriptors). Additionally, any application with more than one layer (Item.layer enabled or ShaderEffect) in the scene will benefit from this. Task-number: QTBUG-80318 Change-Id: Id7437a3baac31891a231643d4787da7186ac107e Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2019-11-25 20:36:23 +00:00
qDeleteAll(pipelineCache);
pipelineCache.clear();
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
qDeleteAll(srbPool);
srbPool.clear();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
void ShaderManager::clearCachedRendererData()
{
Avoid detach of QHash in range-for loops Clazy gives a warning that it might detach. qAsConst makes it go away. Pick-to: 6.2 Change-Id: I293fd5337bc02b3c492464400651358459cf4ab4 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2021-08-17 11:06:47 +00:00
for (ShaderManager::Shader *sms : qAsConst(stockShaders)) {
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader *s = sms->programRhi.program;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (s) {
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShaderPrivate *sd = QSGMaterialShaderPrivate::get(s);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
sd->clearCachedRendererData();
}
}
Avoid detach of QHash in range-for loops Clazy gives a warning that it might detach. qAsConst makes it go away. Pick-to: 6.2 Change-Id: I293fd5337bc02b3c492464400651358459cf4ab4 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2021-08-17 11:06:47 +00:00
for (ShaderManager::Shader *sms : qAsConst(rewrittenShaders)) {
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader *s = sms->programRhi.program;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (s) {
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShaderPrivate *sd = QSGMaterialShaderPrivate::get(s);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
sd->clearCachedRendererData();
}
}
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
void qsg_dumpShadowRoots(BatchRootInfo *i, int indent)
{
static int extraIndent = 0;
++extraIndent;
QByteArray ind(indent + extraIndent + 10, ' ');
if (!i) {
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("%s - no info", ind.constData());
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else {
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
qDebug() << ind.constData() << "- parent:" << i->parentRoot << "orders" << i->firstOrder << "->" << i->lastOrder << ", avail:" << i->availableOrders;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (QSet<Node *>::const_iterator it = i->subRoots.constBegin();
it != i->subRoots.constEnd(); ++it) {
qDebug() << ind.constData() << "-" << *it;
qsg_dumpShadowRoots((*it)->rootInfo(), indent);
}
}
--extraIndent;
}
void qsg_dumpShadowRoots(Node *n)
{
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#ifndef QT_NO_DEBUG_OUTPUT
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
static int indent = 0;
++indent;
QByteArray ind(indent, ' ');
if (n->type() == QSGNode::ClipNodeType || n->isBatchRoot) {
Fix Qt6 build in preparation of qt5 submodule update Fixes the QTextStream usages. Change-Id: I0c009a82fb644a9f3c3d42ec410d18b680977f23 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-06-26 14:46:23 +00:00
qDebug() << ind.constData() << "[X]" << n->sgNode << Qt::hex << uint(n->sgNode->flags());
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
qsg_dumpShadowRoots(n->rootInfo(), indent);
} else {
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
QDebug d = qDebug();
Fix Qt6 build in preparation of qt5 submodule update Fixes the QTextStream usages. Change-Id: I0c009a82fb644a9f3c3d42ec410d18b680977f23 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-06-26 14:46:23 +00:00
d << ind.constData() << "[ ]" << n->sgNode << Qt::hex << uint(n->sgNode->flags());
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
if (n->type() == QSGNode::GeometryNodeType)
Fix Qt6 build in preparation of qt5 submodule update Fixes the QTextStream usages. Change-Id: I0c009a82fb644a9f3c3d42ec410d18b680977f23 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-06-26 14:46:23 +00:00
d << "order" << Qt::dec << n->element()->order;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
SHADOWNODE_TRAVERSE(n)
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
qsg_dumpShadowRoots(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
--indent;
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#else
Add ; to Q_UNUSED and UNUSED_PARAM This is required to remove the ; from the macro with Qt 6. Task-number: QTBUG-82978 Change-Id: Iead53d18fd790fb2d870d80ef2db79666f0d2392 Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2020-06-26 12:43:02 +00:00
Q_UNUSED(n);
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#endif
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Updater::Updater(Renderer *r)
: renderer(r)
, m_roots(32)
, m_rootMatrices(8)
{
m_roots.add(0);
m_combined_matrix_stack.add(&m_identityMatrix);
m_rootMatrices.add(m_identityMatrix);
}
void Updater::updateStates(QSGNode *n)
{
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
m_current_clip = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_added = 0;
m_transformChange = 0;
Ensure m_opacityChange is cleared at the beginning of each frame. Change-Id: Ic5eb5e1955e09884f98975a8ac74b42f00e233d7 Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-02-11 20:55:58 +00:00
m_opacityChange = 0;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Node *sn = renderer->m_nodes.value(n, 0);
Q_ASSERT(sn);
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_roots()))
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
qsg_dumpShadowRoots(sn);
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_build())) {
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("Updater::updateStates()");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (sn->dirtyState & (QSGNode::DirtyNodeAdded << 16))
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug(" - nodes have been added");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (sn->dirtyState & (QSGNode::DirtyMatrix << 16))
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug(" - transforms have changed");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (sn->dirtyState & (QSGNode::DirtyOpacity << 16))
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug(" - opacity has changed");
ICC issue: cast both sides of sign-bit-changing expressions to uint QSGNode::DirtyForceUpdate is 0x8000, so when you shift it left by 16 positions, it becomes the sign bit. Either the result of that shift is int or sn->dirtyState is. qsgbatchrenderer.cpp(302): error #68: integer conversion resulted in a change of sign Change-Id: I84e363d735b443cb9beefffd14b958f9a622348b Reviewed-by: Tony Sarajärvi <tony.sarajarvi@qt.io>
2017-04-27 19:49:40 +00:00
if (uint(sn->dirtyState) & uint(QSGNode::DirtyForceUpdate << 16))
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug(" - forceupdate");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
if (Q_UNLIKELY(renderer->m_visualizer->mode() == Visualizer::VisualizeChanges))
renderer->m_visualizer->visualizeChangesPrepare(sn);
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
visitNode(sn);
}
void Updater::visitNode(Node *n)
{
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
if (m_added == 0 && n->dirtyState == 0 && m_force_update == 0 && m_transformChange == 0 && m_opacityChange == 0)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
return;
int count = m_added;
if (n->dirtyState & QSGNode::DirtyNodeAdded)
++m_added;
Respect DirtyForceUpdate in QSGBatchRenderer. There is a way this could have been done slightly more efficitently. If we moved all "combined" logic out of the scene graph and into the Node shadow tree, we could ignore the forceupdate all together. However, this is a quite large change for what is currently a non-common case. It would also increase overall memory consumption a bit as we would have superfluous combined matrix and opacity in the QSGNodes. Task-number: QTBUG-33838 Change-Id: I06c486ace2be15bef1f1dc72a8b41cb649d7c813 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-04 08:39:20 +00:00
int force = m_force_update;
if (n->dirtyState & QSGNode::DirtyForceUpdate)
++m_force_update;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
switch (n->type()) {
case QSGNode::OpacityNodeType:
visitOpacityNode(n);
break;
case QSGNode::TransformNodeType:
visitTransformNode(n);
break;
case QSGNode::GeometryNodeType:
visitGeometryNode(n);
break;
case QSGNode::ClipNodeType:
visitClipNode(n);
break;
case QSGNode::RenderNodeType:
if (m_added)
n->renderNodeElement()->root = m_roots.last();
Silence GCC 7 warnings about implicit fallthrough in Qt code This only deals with Qt code. MASM has a lot of those left. We should just update from upstream instead to get the fixes. qv4regalloc.cpp:660:52: warning: this statement may fall through [-Wimplicit-fallthrough=] if (leftSource->type == DoubleType || rightSource->type == DoubleType) { ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ qv4regalloc.cpp:666:13: note: here case OpBitAnd: ^~~~ Change-Id: I7814054a102a407d876ffffd14b6b0e2d6b03689 Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
2017-04-19 04:06:54 +00:00
Q_FALLTHROUGH(); // to visit children
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
default:
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
break;
}
m_added = count;
Respect DirtyForceUpdate in QSGBatchRenderer. There is a way this could have been done slightly more efficitently. If we moved all "combined" logic out of the scene graph and into the Node shadow tree, we could ignore the forceupdate all together. However, this is a quite large change for what is currently a non-common case. It would also increase overall memory consumption a bit as we would have superfluous combined matrix and opacity in the QSGNodes. Task-number: QTBUG-33838 Change-Id: I06c486ace2be15bef1f1dc72a8b41cb649d7c813 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-04 08:39:20 +00:00
m_force_update = force;
Avoid initializing QFlags with 0 or nullptr in further cases Amends 744e77b841878fb017c0f2d60607090008f28180. Change-Id: I16e37aaf503eb62f67fca0e48be4c92c4a72ae46 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-11-25 10:49:14 +00:00
n->dirtyState = {};
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Updater::visitClipNode(Node *n)
{
ClipBatchRootInfo *extra = n->clipInfo();
QSGClipNode *cn = static_cast<QSGClipNode *>(n->sgNode);
if (m_roots.last() && m_added > 0)
renderer->registerBatchRoot(n, m_roots.last());
Make matrix and clipList setters' appearance more internal And start using them from the batch renderer as well. Change-Id: I20adc3962b06ac712267dc2be95e9e28cea82e21 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-27 09:36:15 +00:00
cn->setRendererClipList(m_current_clip);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_current_clip = cn;
m_roots << n;
m_rootMatrices.add(m_rootMatrices.last() * *m_combined_matrix_stack.last());
extra->matrix = m_rootMatrices.last();
Make matrix and clipList setters' appearance more internal And start using them from the batch renderer as well. Change-Id: I20adc3962b06ac712267dc2be95e9e28cea82e21 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-27 09:36:15 +00:00
cn->setRendererMatrix(&extra->matrix);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_combined_matrix_stack << &m_identityMatrix;
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Make matrix and clipList setters' appearance more internal And start using them from the batch renderer as well. Change-Id: I20adc3962b06ac712267dc2be95e9e28cea82e21 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-27 09:36:15 +00:00
m_current_clip = cn->clipList();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_rootMatrices.pop_back();
m_combined_matrix_stack.pop_back();
m_roots.pop_back();
}
void Updater::visitOpacityNode(Node *n)
{
QSGOpacityNode *on = static_cast<QSGOpacityNode *>(n->sgNode);
qreal combined = m_opacity_stack.last() * on->opacity();
on->setCombinedOpacity(combined);
m_opacity_stack.add(combined);
if (m_added == 0 && n->dirtyState & QSGNode::DirtyOpacity) {
bool was = n->isOpaque;
bool is = on->opacity() > OPAQUE_LIMIT;
if (was != is) {
renderer->m_rebuild = Renderer::FullRebuild;
n->isOpaque = is;
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
++m_opacityChange;
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
--m_opacityChange;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else {
if (m_added > 0)
n->isOpaque = on->opacity() > OPAQUE_LIMIT;
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
m_opacity_stack.pop_back();
}
void Updater::visitTransformNode(Node *n)
{
bool popMatrixStack = false;
bool popRootStack = false;
bool dirty = n->dirtyState & QSGNode::DirtyMatrix;
QSGTransformNode *tn = static_cast<QSGTransformNode *>(n->sgNode);
if (n->isBatchRoot) {
Fix zero pointer access in renderer. Change-Id: I185af453684c7223c0c9de103eb707d4918b8ae0 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2013-09-18 08:48:41 +00:00
if (m_added > 0 && m_roots.last())
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
renderer->registerBatchRoot(n, m_roots.last());
tn->setCombinedMatrix(m_rootMatrices.last() * *m_combined_matrix_stack.last() * tn->matrix());
// The only change in this subtree is ourselves and we are a batch root, so
// only update subroots and return, saving tons of child-processing (flickable-panning)
Fix opacity issue in the renderer. Given the following tree: OpacityNode | TransformNode (which is a batch root) | GeometryNode If both opacity and transform nodes were changed this frame, we would hit the optimized "scrolling" path while traversing the tree and abort updating that subtree. As a result the opacity change was not propegated to the geometry node and it would be rendered incorrectly. Fix this by skipping the optimized path when there are opacity changes in an ancestor. Task-number: QTBUG-39190 Change-Id: Ieaebfe3de62b961204bd3103fe9913d60e75e412 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-06-04 16:59:58 +00:00
if (!n->becameBatchRoot && m_added == 0 && m_force_update == 0 && m_opacityChange == 0 && dirty && (n->dirtyState & ~QSGNode::DirtyMatrix) == 0) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
BatchRootInfo *info = renderer->batchRootInfo(n);
for (QSet<Node *>::const_iterator it = info->subRoots.constBegin();
it != info->subRoots.constEnd(); ++it) {
updateRootTransforms(*it, n, tn->combinedMatrix());
}
return;
}
n->becameBatchRoot = false;
m_combined_matrix_stack.add(&m_identityMatrix);
m_roots.add(n);
m_rootMatrices.add(tn->combinedMatrix());
popMatrixStack = true;
popRootStack = true;
} else if (!tn->matrix().isIdentity()) {
tn->setCombinedMatrix(*m_combined_matrix_stack.last() * tn->matrix());
m_combined_matrix_stack.add(&tn->combinedMatrix());
popMatrixStack = true;
} else {
tn->setCombinedMatrix(*m_combined_matrix_stack.last());
}
if (dirty)
++m_transformChange;
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (dirty)
--m_transformChange;
if (popMatrixStack)
m_combined_matrix_stack.pop_back();
if (popRootStack) {
m_roots.pop_back();
m_rootMatrices.pop_back();
}
}
void Updater::visitGeometryNode(Node *n)
{
QSGGeometryNode *gn = static_cast<QSGGeometryNode *>(n->sgNode);
Make matrix and clipList setters' appearance more internal And start using them from the batch renderer as well. Change-Id: I20adc3962b06ac712267dc2be95e9e28cea82e21 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-05-27 09:36:15 +00:00
gn->setRendererMatrix(m_combined_matrix_stack.last());
gn->setRendererClipList(m_current_clip);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
gn->setInheritedOpacity(m_opacity_stack.last());
if (m_added) {
Element *e = n->element();
e->root = m_roots.last();
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
e->translateOnlyToRoot = isTranslate(*gn->matrix());
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (e->root) {
BatchRootInfo *info = renderer->batchRootInfo(e->root);
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
while (info != nullptr) {
Fix disappearing nodes when adding in two levels of batch root When having e.g. a clip node inside another clip node and adding children to the innermost, we would get into the situation where we did a partial rebuild for the outermost root, but its available render order count would not be updated to reflect the change deeper down in the tree. Since the z range would be based on the outermost batch root's knowledge of the maximum render order in the tree, what would happen is that the z of the rendered nodes would increase steadily until they went outside of the viewing volume and disappeared. When decreasing the available order count of a batch root, we need to also decrease the available order count of its parents. If any of them drop below zero, we need to rebuild the render lists. [ChangeLog][QtQuick] Fixed nodes sometimes disappearing when adding many new nodes to the tree. Change-Id: I39c34acf0e1e0e87601f0fcd983f8da38cee029f Task-number: QTBUG-42096 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-30 08:08:00 +00:00
info->availableOrders--;
if (info->availableOrders < 0) {
renderer->m_rebuild |= Renderer::BuildRenderLists;
} else {
renderer->m_rebuild |= Renderer::BuildRenderListsForTaggedRoots;
renderer->m_taggedRoots << e->root;
}
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
if (info->parentRoot != nullptr)
Fix disappearing nodes when adding in two levels of batch root When having e.g. a clip node inside another clip node and adding children to the innermost, we would get into the situation where we did a partial rebuild for the outermost root, but its available render order count would not be updated to reflect the change deeper down in the tree. Since the z range would be based on the outermost batch root's knowledge of the maximum render order in the tree, what would happen is that the z of the rendered nodes would increase steadily until they went outside of the viewing volume and disappeared. When decreasing the available order count of a batch root, we need to also decrease the available order count of its parents. If any of them drop below zero, we need to rebuild the render lists. [ChangeLog][QtQuick] Fixed nodes sometimes disappearing when adding many new nodes to the tree. Change-Id: I39c34acf0e1e0e87601f0fcd983f8da38cee029f Task-number: QTBUG-42096 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-30 08:08:00 +00:00
info = renderer->batchRootInfo(info->parentRoot);
else
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
info = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
} else {
renderer->m_rebuild |= Renderer::FullRebuild;
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
} else {
if (m_transformChange) {
Element *e = n->element();
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
e->translateOnlyToRoot = isTranslate(*gn->matrix());
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
}
if (m_opacityChange) {
Element *e = n->element();
if (e->batch)
renderer->invalidateBatchAndOverlappingRenderOrders(e->batch);
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
SHADOWNODE_TRAVERSE(n) visitNode(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Updater::updateRootTransforms(Node *node, Node *root, const QMatrix4x4 &combined)
{
BatchRootInfo *info = renderer->batchRootInfo(node);
QMatrix4x4 m;
Node *n = node;
while (n != root) {
if (n->type() == QSGNode::TransformNodeType)
m = static_cast<QSGTransformNode *>(n->sgNode)->matrix() * m;
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
n = n->parent();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
m = combined * m;
if (node->type() == QSGNode::ClipNodeType) {
static_cast<ClipBatchRootInfo *>(info)->matrix = m;
} else {
Q_ASSERT(node->type() == QSGNode::TransformNodeType);
static_cast<QSGTransformNode *>(node->sgNode)->setCombinedMatrix(m);
}
for (QSet<Node *>::const_iterator it = info->subRoots.constBegin();
it != info->subRoots.constEnd(); ++it) {
updateRootTransforms(*it, node, m);
}
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
int qsg_positionAttribute(QSGGeometry *g)
{
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
int vaOffset = 0;
for (int a=0; a<g->attributeCount(); ++a) {
const QSGGeometry::Attribute &attr = g->attributes()[a];
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (attr.isVertexCoordinate && attr.tupleSize == 2 && attr.type == QSGGeometry::FloatType) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
return vaOffset;
}
vaOffset += attr.tupleSize * size_of_type(attr.type);
}
return -1;
}
Fix boundingbox calculation of rotated items. Task-number: QTBUG-34328 Change-Id: If0202a67d95500333a0fb6f4ca3eb19ecb027770 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-12 11:13:11 +00:00
void Rect::map(const QMatrix4x4 &matrix)
{
const float *m = matrix.constData();
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
if (isScale(matrix)) {
Fix boundingbox calculation of rotated items. Task-number: QTBUG-34328 Change-Id: If0202a67d95500333a0fb6f4ca3eb19ecb027770 Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-12 11:13:11 +00:00
tl.x = tl.x * m[0] + m[12];
tl.y = tl.y * m[5] + m[13];
br.x = br.x * m[0] + m[12];
br.y = br.y * m[5] + m[13];
if (tl.x > br.x)
qSwap(tl.x, br.x);
if (tl.y > br.y)
qSwap(tl.y, br.y);
} else {
Pt mtl = tl;
Pt mtr = { br.x, tl.y };
Pt mbl = { tl.x, br.y };
Pt mbr = br;
mtl.map(matrix);
mtr.map(matrix);
mbl.map(matrix);
mbr.map(matrix);
set(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
(*this) |= mtl;
(*this) |= mtr;
(*this) |= mbl;
(*this) |= mbr;
}
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
void Element::computeBounds()
{
Q_ASSERT(!boundsComputed);
boundsComputed = true;
QSGGeometry *g = node->geometry();
int offset = qsg_positionAttribute(g);
if (offset == -1) {
// No position attribute means overlaps with everything..
bounds.set(-FLT_MAX, -FLT_MAX, FLT_MAX, FLT_MAX);
return;
}
bounds.set(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
char *vd = (char *) g->vertexData() + offset;
for (int i=0; i<g->vertexCount(); ++i) {
bounds |= *(Pt *) vd;
vd += g->sizeOfVertex();
}
bounds.map(*node->matrix());
Tolerate NaN in the geometry without asserting If we come across NaN geometry, we treat it as spanning the entire viewport, similar to other geometries with undefined geometry. Task-number: QTBUG-34520 Change-Id: Ia4171f9f13d876c6c587043ad7decaa19bb85f01 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-04 14:45:22 +00:00
QML: Replace qIsFinite with qt_is_finite. The latter can be inlined. Change-Id: I57747b84889390839a17faa1df6d359210ef4adf Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-04-28 11:07:56 +00:00
if (!qt_is_finite(bounds.tl.x) || bounds.tl.x == FLT_MAX)
Tolerate NaN in the geometry without asserting If we come across NaN geometry, we treat it as spanning the entire viewport, similar to other geometries with undefined geometry. Task-number: QTBUG-34520 Change-Id: Ia4171f9f13d876c6c587043ad7decaa19bb85f01 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-04 14:45:22 +00:00
bounds.tl.x = -FLT_MAX;
QML: Replace qIsFinite with qt_is_finite. The latter can be inlined. Change-Id: I57747b84889390839a17faa1df6d359210ef4adf Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-04-28 11:07:56 +00:00
if (!qt_is_finite(bounds.tl.y) || bounds.tl.y == FLT_MAX)
Tolerate NaN in the geometry without asserting If we come across NaN geometry, we treat it as spanning the entire viewport, similar to other geometries with undefined geometry. Task-number: QTBUG-34520 Change-Id: Ia4171f9f13d876c6c587043ad7decaa19bb85f01 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-04 14:45:22 +00:00
bounds.tl.y = -FLT_MAX;
QML: Replace qIsFinite with qt_is_finite. The latter can be inlined. Change-Id: I57747b84889390839a17faa1df6d359210ef4adf Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-04-28 11:07:56 +00:00
if (!qt_is_finite(bounds.br.x) || bounds.br.x == -FLT_MAX)
Tolerate NaN in the geometry without asserting If we come across NaN geometry, we treat it as spanning the entire viewport, similar to other geometries with undefined geometry. Task-number: QTBUG-34520 Change-Id: Ia4171f9f13d876c6c587043ad7decaa19bb85f01 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-04 14:45:22 +00:00
bounds.br.x = FLT_MAX;
QML: Replace qIsFinite with qt_is_finite. The latter can be inlined. Change-Id: I57747b84889390839a17faa1df6d359210ef4adf Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-04-28 11:07:56 +00:00
if (!qt_is_finite(bounds.br.y) || bounds.br.y == -FLT_MAX)
Tolerate NaN in the geometry without asserting If we come across NaN geometry, we treat it as spanning the entire viewport, similar to other geometries with undefined geometry. Task-number: QTBUG-34520 Change-Id: Ia4171f9f13d876c6c587043ad7decaa19bb85f01 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-04 14:45:22 +00:00
bounds.br.y = FLT_MAX;
Avoid using huge floating point values in the renderer. We pretransform vertices relative to their batch root and upload these using single-precision floats. If the offsets are huge then the floating point numbers start to get unstable and we get rendering artifacts as a result. This typically happens for lists/tables with huge models. Task-number: QTBUG-34312 Change-Id: I2516f2b4fa93f44a1288659d05458fb1af0df943 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-06 09:06:27 +00:00
Handle boundingboxes with NaN in them. NaN does not compare well with other floats. The result is that the bounding box is left at its initial values, FLT_MAX for top-left and FLT_MIN for bottom-right. If so, treat geometry as invalid, aka infinite. Task-number: QTBUG-35192 Change-Id: I1df6987d56a0ce1f500b0eba344a5dcbc55f80a4 Reviewed-by: Mitch Curtis <mitch.curtis@digia.com> Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-28 10:44:39 +00:00
Q_ASSERT(bounds.tl.x <= bounds.br.x);
Q_ASSERT(bounds.tl.y <= bounds.br.y);
Avoid using huge floating point values in the renderer. We pretransform vertices relative to their batch root and upload these using single-precision floats. If the offsets are huge then the floating point numbers start to get unstable and we get rendering artifacts as a result. This typically happens for lists/tables with huge models. Task-number: QTBUG-34312 Change-Id: I2516f2b4fa93f44a1288659d05458fb1af0df943 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-06 09:06:27 +00:00
boundsOutsideFloatRange = bounds.isOutsideFloatRange();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Fix rendering issue with material changes from opaque <-> alpha When I introduced the invalidation of z ranges, I forgot that we need to rebuild render lists when nodes move from opaque to alpha batches or vice versa as that sorting happens in buildRenderLists(). To remedy this, make Batch::isMaterialCompatible report blending changes separately and trigger a full rebuild in this case. Task-number: QTBUG-37422 Change-Id: I020813cb531ed58353f8340fcad58dec8d7856dd Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-12 20:24:26 +00:00
BatchCompatibility Batch::isMaterialCompatible(Element *e) const
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Element *n = first;
// Skip to the first node other than e which has not been removed
while (n && (n == e || n->removed))
n = n->nextInBatch;
// Only 'e' in this batch, so a material change doesn't change anything as long as
// its blending is still in sync with this batch...
if (!n)
Fix rendering issue with material changes from opaque <-> alpha When I introduced the invalidation of z ranges, I forgot that we need to rebuild render lists when nodes move from opaque to alpha batches or vice versa as that sorting happens in buildRenderLists(). To remedy this, make Batch::isMaterialCompatible report blending changes separately and trigger a full rebuild in this case. Task-number: QTBUG-37422 Change-Id: I020813cb531ed58353f8340fcad58dec8d7856dd Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-12 20:24:26 +00:00
return BatchIsCompatible;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Make sure we rebuild batches properly after a Blending material change. If a node sent DirtyGeometry and DirtyMaterial in the same round and DirtyGeometry triggered its batch to be invalidated, we would take the no-batch code path which did set the rebuild state to BuildBatches. This looks ok on screen, but if the node changed from alpha to opaque, it would not be put into an opaque batch. For things like full screen rectangles, this can potentially hurt performance. To prevent doing a full rebuild on any material change on batchless items (aka all Rectangle nodes), we store the blend state of the material in the element and do a full rebuild only when blend state changes. Change-Id: Ifdf06fb72ef02ca47a135c821ddbcbe0d164ca29 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-04-25 14:21:00 +00:00
QSGMaterial *m = e->node->activeMaterial();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QSGMaterial *nm = n->node->activeMaterial();
Fix rendering issue with material changes from opaque <-> alpha When I introduced the invalidation of z ranges, I forgot that we need to rebuild render lists when nodes move from opaque to alpha batches or vice versa as that sorting happens in buildRenderLists(). To remedy this, make Batch::isMaterialCompatible report blending changes separately and trigger a full rebuild in this case. Task-number: QTBUG-37422 Change-Id: I020813cb531ed58353f8340fcad58dec8d7856dd Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-12 20:24:26 +00:00
return (nm->type() == m->type() && nm->compare(m) == 0)
? BatchIsCompatible
: BatchBreaksOnCompare;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
/*
* Marks this batch as dirty or in the case where the geometry node has
* changed to be incompatible with this batch, return false so that
* the caller can mark the entire sg for a full rebuild...
*/
bool Batch::geometryWasChanged(QSGGeometryNode *gn)
{
Element *e = first;
Q_ASSERT_X(e, "Batch::geometryWasChanged", "Batch is expected to 'valid' at this time");
// 'gn' is the first node in the batch, compare against the next one.
while (e && (e->node == gn || e->removed))
e = e->nextInBatch;
if (!e || e->node->geometry()->attributes() == gn->geometry()->attributes()) {
needsUpload = true;
return true;
} else {
return false;
}
}
void Batch::cleanupRemovedElements()
{
Speed up rendering huge static scenes With really big, static scenes, traversal of the geometry list is expensive enough that it becomes a limitation on the frame rate if we do it in the inner loop of every frame. And going through the whole list of geometry every frame just to verify that nothing has been removed is a waste of time. In a test with two million opaque items in a single draw call, I can hit 144 fps with this small optimization versus 50 fps on the same machine without the patch. Pick-to: 5.15 Change-Id: Id11c1d96456e79a62c33b89e5f115bdaacceeacd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-05-20 12:33:50 +00:00
if (!needsPurge)
return;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
// remove from front of batch..
while (first && first->removed) {
first = first->nextInBatch;
}
// Then continue and remove other nodes further out in the batch..
if (first) {
Element *e = first;
while (e->nextInBatch) {
if (e->nextInBatch->removed)
e->nextInBatch = e->nextInBatch->nextInBatch;
else
e = e->nextInBatch;
}
}
Speed up rendering huge static scenes With really big, static scenes, traversal of the geometry list is expensive enough that it becomes a limitation on the frame rate if we do it in the inner loop of every frame. And going through the whole list of geometry every frame just to verify that nothing has been removed is a waste of time. In a test with two million opaque items in a single draw call, I can hit 144 fps with this small optimization versus 50 fps on the same machine without the patch. Pick-to: 5.15 Change-Id: Id11c1d96456e79a62c33b89e5f115bdaacceeacd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-05-20 12:33:50 +00:00
needsPurge = false;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
/*
* Iterates through all geometry nodes in this batch and unsets their batch,
* thus forcing them to be rebuilt
*/
void Batch::invalidate()
{
cleanupRemovedElements();
Element *e = first;
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
first = nullptr;
root = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
while (e) {
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
e->batch = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Element *n = e->nextInBatch;
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
e->nextInBatch = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
e = n;
}
}
bool Batch::isTranslateOnlyToRoot() const {
bool only = true;
Element *e = first;
while (e && only) {
only &= e->translateOnlyToRoot;
e = e->nextInBatch;
}
return only;
}
All matrices in a batch need to be 2D safe when merging. If we merge geometry nodes that make actual use of the z-coordinate, this information becomes lost when merging and the result is that we end up with an arbitrary wrongfully applied transformation to the merged element. Task-number: QTBUG-33897 Change-Id: I6129243e9bb890949023c35dc6b7bce30d31709a Reviewed-by: Andrew Knight <andrew.knight@digia.com> Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-07 08:17:56 +00:00
/*
* Iterates through all the nodes in the batch and returns true if the
Avoid using huge floating point values in the renderer. We pretransform vertices relative to their batch root and upload these using single-precision floats. If the offsets are huge then the floating point numbers start to get unstable and we get rendering artifacts as a result. This typically happens for lists/tables with huge models. Task-number: QTBUG-34312 Change-Id: I2516f2b4fa93f44a1288659d05458fb1af0df943 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-06 09:06:27 +00:00
* nodes are all safe to batch. There are two separate criteria:
*
* - The matrix is such that the z component of the result is of no
* consequence.
*
* - The bounds are inside the stable floating point range. This applies
* to desktop only where we in this case can trigger a fallback to
* unmerged in which case we pass the geometry straight through and
* just apply the matrix.
*
* NOTE: This also means a slight performance impact for geometries which
* are defined to be outside the stable floating point range and still
* use single precision float, but given that this implicitly fixes
* huge lists and tables, it is worth it.
All matrices in a batch need to be 2D safe when merging. If we merge geometry nodes that make actual use of the z-coordinate, this information becomes lost when merging and the result is that we end up with an arbitrary wrongfully applied transformation to the merged element. Task-number: QTBUG-33897 Change-Id: I6129243e9bb890949023c35dc6b7bce30d31709a Reviewed-by: Andrew Knight <andrew.knight@digia.com> Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-07 08:17:56 +00:00
*/
Avoid using huge floating point values in the renderer. We pretransform vertices relative to their batch root and upload these using single-precision floats. If the offsets are huge then the floating point numbers start to get unstable and we get rendering artifacts as a result. This typically happens for lists/tables with huge models. Task-number: QTBUG-34312 Change-Id: I2516f2b4fa93f44a1288659d05458fb1af0df943 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-06 09:06:27 +00:00
bool Batch::isSafeToBatch() const {
All matrices in a batch need to be 2D safe when merging. If we merge geometry nodes that make actual use of the z-coordinate, this information becomes lost when merging and the result is that we end up with an arbitrary wrongfully applied transformation to the merged element. Task-number: QTBUG-33897 Change-Id: I6129243e9bb890949023c35dc6b7bce30d31709a Reviewed-by: Andrew Knight <andrew.knight@digia.com> Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-07 08:17:56 +00:00
Element *e = first;
while (e) {
Avoid using huge floating point values in the renderer. We pretransform vertices relative to their batch root and upload these using single-precision floats. If the offsets are huge then the floating point numbers start to get unstable and we get rendering artifacts as a result. This typically happens for lists/tables with huge models. Task-number: QTBUG-34312 Change-Id: I2516f2b4fa93f44a1288659d05458fb1af0df943 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2013-11-06 09:06:27 +00:00
if (e->boundsOutsideFloatRange)
return false;
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
if (!is2DSafe(*e->node->matrix()))
All matrices in a batch need to be 2D safe when merging. If we merge geometry nodes that make actual use of the z-coordinate, this information becomes lost when merging and the result is that we end up with an arbitrary wrongfully applied transformation to the merged element. Task-number: QTBUG-33897 Change-Id: I6129243e9bb890949023c35dc6b7bce30d31709a Reviewed-by: Andrew Knight <andrew.knight@digia.com> Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-07 08:17:56 +00:00
return false;
e = e->nextInBatch;
}
return true;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
static int qsg_countNodesInBatch(const Batch *batch)
{
int sum = 0;
Element *e = batch->first;
while (e) {
++sum;
e = e->nextInBatch;
}
return sum;
}
static int qsg_countNodesInBatches(const QDataBuffer<Batch *> &batches)
{
int sum = 0;
for (int i=0; i<batches.size(); ++i) {
sum += qsg_countNodesInBatch(batches.at(i));
}
return sum;
}
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
Renderer::Renderer(QSGDefaultRenderContext *ctx, QSGRendererInterface::RenderMode renderMode)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
: QSGRenderer(ctx)
Enable building Qt Quick module with QT_NO_OPENGL defined Currently the Qt Quick module depends on either the OpenGL or OpenGLES headers being available at build time. Since we are adding support for adaptations that do not depend on OpenGL, it should be possible to build Qt Quick in environments that do not have OpenGL development headers. This does present many challenges though because in some cases GL types, and classes that require OpenGL are part of the public APIs. However since these classes were never available when QT_NO_OPENGL was defined, it should be possible to redefine the function signatures under this scenario, since it's not possible to break binary compatibility if there never were any binaries to break compatibility with. One of the bigger changes that was necessary to facilitate this change is creating interfaces out of QSGContext and QSGRenderContext. Here the default behavior was usage of OpenGL directly, even though subclasses could override all OpenGL usage. Making them interfaces should bring QSGContext and QSGRenderContext more in line with the other classes present in the adaptation layer. Change-Id: Iaa54dc0f6cfd18d2da1d059548abf509bd71f200 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-03-15 12:39:41 +00:00
, m_context(ctx)
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
, m_renderMode(renderMode)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
, m_opaqueRenderList(64)
, m_alphaRenderList(64)
, m_nextRenderOrder(0)
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
, m_partialRebuild(false)
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
, m_partialRebuildRoot(nullptr)
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
, m_forceNoDepthBuffer(false)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
, m_opaqueBatches(16)
, m_alphaBatches(16)
, m_batchPool(16)
, m_elementsToDelete(64)
, m_tmpAlphaElements(16)
, m_tmpOpaqueElements(16)
, m_rebuild(FullRebuild)
, m_zRange(0)
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#if defined(QSGBATCHRENDERER_INVALIDATE_WEDGED_NODES)
Invalidate all batches potentially affected by a change. When two separate changes have occurred, we need to not only invalidate the batches directly overlapping those, but also any batch which has render orders between the two. So, keep track of the range of invalidated render orders and invalidate everything in between. Task-number: QTBUG-37422 Change-Id: Ie5a289d5c569b84917ec9ac52671173c566e69b3 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-03-19 10:58:04 +00:00
, m_renderOrderRebuildLower(-1)
, m_renderOrderRebuildUpper(-1)
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#endif
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
, m_currentMaterial(nullptr)
, m_currentShader(nullptr)
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
, m_vertexUploadPool(256)
, m_indexUploadPool(64)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_rhi = m_context->rhi();
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
Q_ASSERT(m_rhi); // no more direct OpenGL code path in Qt 6
m_ubufAlignment = m_rhi->ubufAlignment();
m_uint32IndexForRhi = !m_rhi->isFeatureSupported(QRhi::NonFourAlignedEffectiveIndexBufferOffset);
if (qEnvironmentVariableIntValue("QSG_RHI_UINT32_INDEX"))
m_uint32IndexForRhi = true;
m_visualizer = new RhiVisualizer(this);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
setNodeUpdater(new Updater(this));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// The shader manager is shared between renderers (think for example Item
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
// layers that create a new Renderer each) with the same rendercontext (and
// so same QRhi).
QSGBatchRenderer: look for ShaderManager by type only, ignore name There's only ever one of them, and accessing objectName() from a different than the owning thread is UB (data race). The default-constructed QString() is needed, cf. QTBUG-103986. This is a hotfix for QTBUG-102403, which ran afoul of the guards added in qtbase/3f32dcd1ddcbe04c77ccd83e2eaa566d7212e732 to fix QTBUG-99775. Task-number: QTBUG-102403 Pick-to: 6.3 6.3.1 6.2 Change-Id: Idf07b1119ec393e7fd179e8b545cfeb70f5916ec Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
2022-06-02 16:29:06 +00:00
m_shaderManager = ctx->findChild<ShaderManager *>(QString(), Qt::FindDirectChildrenOnly);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (!m_shaderManager) {
Enable program binary support through QSGRenderContext API. Change-Id: I4eecff3c8a2c727d38d394305d248eddeef87e8e Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-02-11 21:49:08 +00:00
m_shaderManager = new ShaderManager(ctx);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_shaderManager->setObjectName(QStringLiteral("__qt_ShaderManager"));
m_shaderManager->setParent(ctx);
QObject::connect(ctx, SIGNAL(invalidated()), m_shaderManager, SLOT(invalidated()), Qt::DirectConnection);
}
Quick: Sanitize reading environment variables. Where possible, use qEnvironmentVariableIsSet()/ qEnvironmentVariableIsEmpty() instead of checking on the return value of qgetenv(). Where the value is required, add a check using one of qEnvironmentVariableIsSet()/Empty(). Move QSGAtlasTexture::qsg_envInt() to qsgrenderer.cpp for reuse as qt_sg_envInt() and add qt_sg_envFloat(). Change-Id: I4c93f16c228d4f537154f389a0fa1427654485f7 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-10-22 10:36:18 +00:00
m_batchNodeThreshold = qt_sg_envInt("QSG_RENDERER_BATCH_NODE_THRESHOLD", 64);
m_batchVertexThreshold = qt_sg_envInt("QSG_RENDERER_BATCH_VERTEX_THRESHOLD", 1024);
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
m_srbPoolThreshold = qt_sg_envInt("QSG_RENDERER_SRB_POOL_THRESHOLD", 1024);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_build() || debug_render())) {
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
qDebug("Batch thresholds: nodes: %d vertices: %d Srb pool threshold: %d",
m_batchNodeThreshold, m_batchVertexThreshold, m_srbPoolThreshold);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
static void qsg_wipeBuffer(Buffer *buffer)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
delete buffer->buf;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
// The free here is ok because we're in one of two situations.
// 1. We're using the upload pool in which case unmap will have set the
// data pointer to 0 and calling free on 0 is ok.
// 2. We're using dedicated buffers because of visualization or IBO workaround
// and the data something we malloced and must be freed.
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
free(buffer->data);
}
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
static void qsg_wipeBatch(Batch *batch)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
qsg_wipeBuffer(&batch->vbo);
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
qsg_wipeBuffer(&batch->ibo);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
delete batch->ubuf;
batch->stencilClipState.reset();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
delete batch;
}
Renderer::~Renderer()
{
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
if (m_rhi) {
Support shutting down the render thread without an OpenGL context. [ChangeLog][QtQuick][SceneGraph] There might not be an OpenGL context bound when QQuickWindow::sceneGraphInvalidated() is emitted if an error occurs while cleaning up the scene graph (such as EGL_CONTEXT_LOST). This is according to the documentation, but has never occurred in practice before. Change-Id: I13dbfbb4b6d0d27fa42fcb8b54df16ea02284807 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
2014-04-11 14:21:54 +00:00
// Clean up batches and buffers
Use different buffer for indices and vertices only in the WebGL plugin This patch partially reverts 098ba086530ccd555369a9ea88f3c6668726ab81. Only QtWebGL will use separate buffers for indices and vertices. This patch gives a performance boost. Task-number: QTBUG-66191 Task-number: QTBUG-67147 Change-Id: I58b4db2bdf44cd954390e85e079de82031caf9e5 Reviewed-by: Edward Welbourne <edward.welbourne@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2018-02-05 16:20:08 +00:00
for (int i = 0; i < m_opaqueBatches.size(); ++i)
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
qsg_wipeBatch(m_opaqueBatches.at(i));
Use different buffer for indices and vertices only in the WebGL plugin This patch partially reverts 098ba086530ccd555369a9ea88f3c6668726ab81. Only QtWebGL will use separate buffers for indices and vertices. This patch gives a performance boost. Task-number: QTBUG-66191 Task-number: QTBUG-67147 Change-Id: I58b4db2bdf44cd954390e85e079de82031caf9e5 Reviewed-by: Edward Welbourne <edward.welbourne@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2018-02-05 16:20:08 +00:00
for (int i = 0; i < m_alphaBatches.size(); ++i)
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
qsg_wipeBatch(m_alphaBatches.at(i));
Use different buffer for indices and vertices only in the WebGL plugin This patch partially reverts 098ba086530ccd555369a9ea88f3c6668726ab81. Only QtWebGL will use separate buffers for indices and vertices. This patch gives a performance boost. Task-number: QTBUG-66191 Task-number: QTBUG-67147 Change-Id: I58b4db2bdf44cd954390e85e079de82031caf9e5 Reviewed-by: Edward Welbourne <edward.welbourne@qt.io> Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
2018-02-05 16:20:08 +00:00
for (int i = 0; i < m_batchPool.size(); ++i)
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
qsg_wipeBatch(m_batchPool.at(i));
Support shutting down the render thread without an OpenGL context. [ChangeLog][QtQuick][SceneGraph] There might not be an OpenGL context bound when QQuickWindow::sceneGraphInvalidated() is emitted if an error occurs while cleaning up the scene graph (such as EGL_CONTEXT_LOST). This is according to the documentation, but has never occurred in practice before. Change-Id: I13dbfbb4b6d0d27fa42fcb8b54df16ea02284807 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com> Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
2014-04-11 14:21:54 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Fixed another batch of QHash/QMap::values() (mis)use Avoid memory allocations. Change-Id: I0b4cbef6a8c22184781a44d92172d93ac38e778c Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io> Reviewed-by: Anton Kudryavtsev <a.kudryavtsev@netris.ru> Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2016-05-13 15:57:24 +00:00
for (Node *n : qAsConst(m_nodes))
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
m_nodeAllocator.release(n);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
// Remaining elements...
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
for (int i=0; i<m_elementsToDelete.size(); ++i)
releaseElement(m_elementsToDelete.at(i), true);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
destroyGraphicsResources();
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
delete m_visualizer;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
void Renderer::destroyGraphicsResources()
{
// If this is from the dtor, then the shader manager and its already
// prepared shaders will stay around for other renderers -> the cached data
// in the rhi shaders have to be purged as it may refer to samplers we
// are going to destroy.
m_shaderManager->clearCachedRendererData();
qDeleteAll(m_samplers);
m_stencilClipCommon.reset();
delete m_dummyTexture;
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
m_visualizer->releaseResources();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
void Renderer::releaseCachedResources()
{
m_shaderManager->invalidated();
destroyGraphicsResources();
m_samplers.clear();
m_dummyTexture = nullptr;
Drop expendable rhi data when in release(Cached)Resources Now that a suitable function is introduced in QRhi, call it. Change-Id: I6328a4be90418015384b472655c9b8ad34a07e12 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-09-09 08:21:40 +00:00
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
m_rhi->releaseCachedResources();
sg: Drop internal pool allocs upon QQuickWindow::releaseResources Pick-to: 6.2 5.15 Task-number: QTBUG-93956 Change-Id: Iba89c491c2ce33ed2a51713f480b41bea1c82519 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-10-14 09:03:31 +00:00
Use resize instead of shrink when clearing upload pools Fix creator qml puppet crash at startup due to nullptr exception. The puppet clears the cached resources, which calls shrink(0) to the vertex and index upload pools. The shrink only sets the capacity to 0 and deallocates the buffer, but leaves the size intact. The next time the upload pools are used they are not reallocated, because only the size gets checked. Use resize instead of shrink since it calls the shrink and also sets the size to zero. Fixes: QTBUG-98150 Pick-to: 6.2 5.15 Change-Id: Id852e71d4caa0f6c5ca560142024ca9d143df7f8 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2021-11-10 12:15:24 +00:00
m_vertexUploadPool.resize(0);
m_indexUploadPool.resize(0);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::invalidateAndRecycleBatch(Batch *b)
{
b->invalidate();
for (int i=0; i<m_batchPool.size(); ++i)
if (b == m_batchPool.at(i))
return;
m_batchPool.add(b);
}
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
void Renderer::map(Buffer *buffer, quint32 byteSize, bool isIndexBuf)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Make rendercontext OpenGL clean Task-number: QTBUG-84623 Change-Id: I5cf3c0db01b0c519f803fd49be820a910881dcff Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-08 08:25:22 +00:00
if (m_visualizer->mode() == Visualizer::VisualizeNothing) {
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
// Common case, use a shared memory pool for uploading vertex data to avoid
// excessive reevaluation
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
QDataBuffer<char> &pool = isIndexBuf ? m_indexUploadPool : m_vertexUploadPool;
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
if (byteSize > quint32(pool.size()))
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
pool.resize(byteSize);
buffer->data = pool.data();
Scene Graph: Fixed memory leak in QSGBatchRenderer::Renderer::map() In the uncommon case (m_context->hasBrokenIndexBufferObjects() || m_visualizeMode != VisualizeNothing) of mapping a buffer, malloc is called without first freeing the previous malloc. Regression was introduced with: qt5 commit: 9347499e78f03710eaf24af3c1e7ac650d0ef81d qtdeclarative commit: a371bac3fba73f92aaa63a68d8ab1ae81a1d1031 [ChangeLog][QtQuick][Scene Graph] Fixed memory leak in QSGBatchRenderer::Renderer::map() Task-number: QTBUG-48799 Change-Id: I5ef4b7301d390463845aeb192851f86655962499 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-10-16 06:07:32 +00:00
} else if (buffer->size != byteSize) {
free(buffer->data);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
buffer->data = (char *) malloc(byteSize);
Q_CHECK_PTR the result of malloc() in batch renderer We want to cleanly crash if it fails. Change-Id: Ib32d3d6ae0c5d58e0a954e55adca8b2c4081a7f5 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2016-12-12 12:44:49 +00:00
Q_CHECK_PTR(buffer->data);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
buffer->size = byteSize;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add support for a separate index buffer The renderer binds same buffer both for vertex and index data. This is allowed on desktop & ES but is forbidden in WebGL. Add a compile-time flag to disable this optimization(?) and force using a separate buffer for the index data. Change-Id: I57c17c883a55e02513a8e4427efb202cafaaf37e Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-05 19:36:13 +00:00
void Renderer::unmap(Buffer *buffer, bool isIndexBuf)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
// Batches are pooled and reused which means the QRhiBuffer will be
// still valid in a recycled Batch. We only hit the newBuffer() path
// for brand new Batches.
if (!buffer->buf) {
buffer->buf = m_rhi->newBuffer(QRhiBuffer::Immutable,
isIndexBuf ? QRhiBuffer::IndexBuffer : QRhiBuffer::VertexBuffer,
buffer->size);
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (!buffer->buf->create()) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
qWarning("Failed to build vertex/index buffer of size %u", buffer->size);
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
delete buffer->buf;
buffer->buf = nullptr;
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
} else {
bool needsRebuild = false;
if (buffer->buf->size() < buffer->size) {
buffer->buf->setSize(buffer->size);
needsRebuild = true;
}
if (buffer->buf->type() != QRhiBuffer::Dynamic
&& buffer->nonDynamicChangeCount > DYNAMIC_VERTEX_INDEX_BUFFER_THRESHOLD)
{
buffer->buf->setType(QRhiBuffer::Dynamic);
buffer->nonDynamicChangeCount = 0;
needsRebuild = true;
}
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (needsRebuild) {
if (!buffer->buf->create()) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
qWarning("Failed to (re)build vertex/index buffer of size %u", buffer->size);
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
delete buffer->buf;
buffer->buf = nullptr;
}
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
}
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (buffer->buf) {
if (buffer->buf->type() != QRhiBuffer::Dynamic) {
m_resourceUpdates->uploadStaticBuffer(buffer->buf,
0, buffer->size, buffer->data);
buffer->nonDynamicChangeCount += 1;
} else {
m_resourceUpdates->updateDynamicBuffer(buffer->buf, 0, buffer->size,
buffer->data);
}
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
if (m_visualizer->mode() == Visualizer::VisualizeNothing)
buffer->data = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
BatchRootInfo *Renderer::batchRootInfo(Node *node)
{
BatchRootInfo *info = node->rootInfo();
if (!info) {
if (node->type() == QSGNode::ClipNodeType)
info = new ClipBatchRootInfo;
else {
Q_ASSERT(node->type() == QSGNode::TransformNodeType);
info = new BatchRootInfo;
}
node->data = info;
}
return info;
}
void Renderer::removeBatchRootFromParent(Node *childRoot)
{
BatchRootInfo *childInfo = batchRootInfo(childRoot);
if (!childInfo->parentRoot)
return;
BatchRootInfo *parentInfo = batchRootInfo(childInfo->parentRoot);
Q_ASSERT(parentInfo->subRoots.contains(childRoot));
parentInfo->subRoots.remove(childRoot);
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
childInfo->parentRoot = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::registerBatchRoot(Node *subRoot, Node *parentRoot)
{
BatchRootInfo *subInfo = batchRootInfo(subRoot);
BatchRootInfo *parentInfo = batchRootInfo(parentRoot);
subInfo->parentRoot = parentRoot;
parentInfo->subRoots << subRoot;
}
bool Renderer::changeBatchRoot(Node *node, Node *root)
{
BatchRootInfo *subInfo = batchRootInfo(node);
if (subInfo->parentRoot == root)
return false;
if (subInfo->parentRoot) {
BatchRootInfo *oldRootInfo = batchRootInfo(subInfo->parentRoot);
oldRootInfo->subRoots.remove(node);
}
BatchRootInfo *newRootInfo = batchRootInfo(root);
newRootInfo->subRoots << node;
subInfo->parentRoot = root;
return true;
}
void Renderer::nodeChangedBatchRoot(Node *node, Node *root)
{
if (node->type() == QSGNode::ClipNodeType || node->isBatchRoot) {
Fix excessive recursion in renderer Change-Id: Iffee781932773fe22c7d946b532ba74492e1e2df Task-number: QTBUG-59789 Reviewed-by: Robin Burchell <robin.burchell@crimson.no>
2017-06-16 06:03:45 +00:00
// When we reach a batchroot, we only need to update it. Its subtree
// is relative to that root, so no need to recurse further.
changeBatchRoot(node, root);
return;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else if (node->type() == QSGNode::GeometryNodeType) {
// Only need to change the root as nodeChanged anyway flags a full update.
Element *e = node->element();
Invalidate the bounding rects when the roots change. When roots change, matrices are updated in the nodes, so we need to also invalidate the bounding rects for geometry nodes. Change-Id: I61f60ad069c3b1d018ce31c57310a1e5c4807684 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-02 10:58:42 +00:00
if (e) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
e->root = root;
Invalidate the bounding rects when the roots change. When roots change, matrices are updated in the nodes, so we need to also invalidate the bounding rects for geometry nodes. Change-Id: I61f60ad069c3b1d018ce31c57310a1e5c4807684 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-02 10:58:42 +00:00
e->boundsComputed = false;
}
Propagate root changes to rendernodes too Otherwise weird things will happen once a node gets turned into a batch root and the rendernodes in the child subtree still refers to their old root. Change-Id: I42b0ba514c2fbeed833f0f665e49b275c19b5686 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-12-13 13:24:49 +00:00
} else if (node->type() == QSGNode::RenderNodeType) {
RenderNodeElement *e = node->renderNodeElement();
if (e)
e->root = root;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
SHADOWNODE_TRAVERSE(node)
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
nodeChangedBatchRoot(child, root);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::nodeWasTransformed(Node *node, int *vertexCount)
{
if (node->type() == QSGNode::GeometryNodeType) {
QSGGeometryNode *gn = static_cast<QSGGeometryNode *>(node->sgNode);
*vertexCount += gn->geometry()->vertexCount();
Element *e = node->element();
if (e) {
e->boundsComputed = false;
if (e->batch) {
if (!e->batch->isOpaque) {
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
invalidateBatchAndOverlappingRenderOrders(e->batch);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else if (e->batch->merged) {
e->batch->needsUpload = true;
}
}
}
}
SHADOWNODE_TRAVERSE(node)
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
nodeWasTransformed(child, vertexCount);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::nodeWasAdded(QSGNode *node, Node *shadowParent)
{
Q_ASSERT(!m_nodes.contains(node));
if (node->isSubtreeBlocked())
return;
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
Node *snode = m_nodeAllocator.allocate();
snode->sgNode = node;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_nodes.insert(node, snode);
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
if (shadowParent)
shadowParent->append(snode);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (node->type() == QSGNode::GeometryNodeType) {
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
snode->data = m_elementAllocator.allocate();
snode->element()->setNode(static_cast<QSGGeometryNode *>(node));
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else if (node->type() == QSGNode::ClipNodeType) {
snode->data = new ClipBatchRootInfo;
Fix rendering errors in Qt Quick Controls gallery First, when doing a partial rebuild, we need to mark all elements for orphaning, not just those without a batch, as the renderlist should at all times contain everything that is rendered on screen. Second, we had a small bug with material changes where we would overwrite the rebuild state instead of adding to it. This led to the render lists not being rebuilt from scratch in some scenarios. Third, after the shadow nodes rewrite, we didn't mark for a full rebuild when clips were added. Change-Id: I6707ebfa2908fcedd7fb636fb25b844be15fdea1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-04 12:08:41 +00:00
m_rebuild |= FullRebuild;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else if (node->type() == QSGNode::RenderNodeType) {
Add optional flags and rect to QSGRenderNode Having rendernodes triggering fullscreen updates with the software backend is not ideal. Therefore, introduce the option of reporting that the rendernode is well-behaving, meaning it only writes inside the reported bounding rectangle. Similarly, the OpenGL batch renderer can keep using the depth buffer when the rendernode is known to behave like the renderer expects. Change-Id: I6acc434432c2504776f26e8917b5434b44be293d Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-07-27 09:59:17 +00:00
QSGRenderNode *rn = static_cast<QSGRenderNode *>(node);
RenderNodeElement *e = new RenderNodeElement(rn);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
snode->data = e;
Add optional flags and rect to QSGRenderNode Having rendernodes triggering fullscreen updates with the software backend is not ideal. Therefore, introduce the option of reporting that the rendernode is well-behaving, meaning it only writes inside the reported bounding rectangle. Similarly, the OpenGL batch renderer can keep using the depth buffer when the rendernode is known to behave like the renderer expects. Change-Id: I6acc434432c2504776f26e8917b5434b44be293d Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-07-27 09:59:17 +00:00
Q_ASSERT(!m_renderNodeElements.contains(rn));
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_renderNodeElements.insert(e->renderNode, e);
Add optional flags and rect to QSGRenderNode Having rendernodes triggering fullscreen updates with the software backend is not ideal. Therefore, introduce the option of reporting that the rendernode is well-behaving, meaning it only writes inside the reported bounding rectangle. Similarly, the OpenGL batch renderer can keep using the depth buffer when the rendernode is known to behave like the renderer expects. Change-Id: I6acc434432c2504776f26e8917b5434b44be293d Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2016-07-27 09:59:17 +00:00
if (!rn->flags().testFlag(QSGRenderNode::DepthAwareRendering))
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
m_forceNoDepthBuffer = true;
Revert QSGRenderNode to the old "in context" behavior There is already a lot of code out there that makes use of the rendernode hook and some of it is not capable of dealing with the render target being something other than 0. (Mozilla in this case). By forcing everything into the "alpha" code path, the hit on the renderer should be fairly minimal as long as render nodes are kept to a minimum, so reverting back to the ugly old behavior is acceptable. The API is still internal and highly discouraged. Change-Id: Ie35484f52da6b0420257c95710fdda07a2be2c23 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-01-21 14:57:19 +00:00
m_rebuild |= FullRebuild;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
QSGNODE_TRAVERSE(node)
nodeWasAdded(child, snode);
}
void Renderer::nodeWasRemoved(Node *node)
{
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
// Prefix traversal as removeBatchRootFromParent below removes nodes
// in a bottom-up manner. Note that we *cannot* use SHADOWNODE_TRAVERSE
// here, because we delete 'child' (when recursed, down below), so we'd
// have a use-after-free.
{
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
Node *child = node->firstChild();
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
while (child) {
// Remove (and delete) child
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
node->remove(child);
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
nodeWasRemoved(child);
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
child = node->firstChild();
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
}
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (node->type() == QSGNode::GeometryNodeType) {
Element *e = node->element();
if (e) {
e->removed = true;
m_elementsToDelete.add(e);
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
e->node = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (e->root) {
BatchRootInfo *info = batchRootInfo(e->root);
info->availableOrders++;
}
if (e->batch) {
e->batch->needsUpload = true;
Speed up rendering huge static scenes With really big, static scenes, traversal of the geometry list is expensive enough that it becomes a limitation on the frame rate if we do it in the inner loop of every frame. And going through the whole list of geometry every frame just to verify that nothing has been removed is a waste of time. In a test with two million opaque items in a single draw call, I can hit 144 fps with this small optimization versus 50 fps on the same machine without the patch. Pick-to: 5.15 Change-Id: Id11c1d96456e79a62c33b89e5f115bdaacceeacd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-05-20 12:33:50 +00:00
e->batch->needsPurge = true;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
} else if (node->type() == QSGNode::ClipNodeType) {
removeBatchRootFromParent(node);
delete node->clipInfo();
m_rebuild |= FullRebuild;
m_taggedRoots.remove(node);
} else if (node->isBatchRoot) {
removeBatchRootFromParent(node);
delete node->rootInfo();
m_rebuild |= FullRebuild;
m_taggedRoots.remove(node);
} else if (node->type() == QSGNode::RenderNodeType) {
RenderNodeElement *e = m_renderNodeElements.take(static_cast<QSGRenderNode *>(node->sgNode));
if (e) {
e->removed = true;
m_elementsToDelete.add(e);
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (m_renderNodeElements.isEmpty())
m_forceNoDepthBuffer = false;
Speed up rendering huge static scenes With really big, static scenes, traversal of the geometry list is expensive enough that it becomes a limitation on the frame rate if we do it in the inner loop of every frame. And going through the whole list of geometry every frame just to verify that nothing has been removed is a waste of time. In a test with two million opaque items in a single draw call, I can hit 144 fps with this small optimization versus 50 fps on the same machine without the patch. Pick-to: 5.15 Change-Id: Id11c1d96456e79a62c33b89e5f115bdaacceeacd Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2020-05-20 12:33:50 +00:00
if (e->batch != nullptr)
e->batch->needsPurge = true;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
Q_ASSERT(m_nodes.contains(node->sgNode));
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
m_nodeAllocator.release(m_nodes.take(node->sgNode));
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::turnNodeIntoBatchRoot(Node *node)
{
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
if (Q_UNLIKELY(debug_change())) qDebug(" - new batch root");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_rebuild |= FullRebuild;
node->isBatchRoot = true;
node->becameBatchRoot = true;
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
Node *p = node->parent();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
while (p) {
if (p->type() == QSGNode::ClipNodeType || p->isBatchRoot) {
registerBatchRoot(node, p);
break;
}
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
p = p->parent();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
SHADOWNODE_TRAVERSE(node)
QSBatchRenderer: Replace Node::children QList with a singly linked list. This reduces transient allocations by 10mb on the Rectangle creation benchmark, at the cost of an additional two pointers per shadow node (and just that pointer -- no additional allocation ala QList is required, so this will actually end up around the same size if not better.) Change-Id: I6c25c93fe31ed892e3c42ed66d6c6656e5d7b38a Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-06-04 22:45:31 +00:00
nodeChangedBatchRoot(child, node);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::nodeChanged(QSGNode *node, QSGNode::DirtyState state)
{
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#ifndef QT_NO_DEBUG_OUTPUT
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_change())) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QDebug debug = qDebug();
debug << "dirty:";
if (state & QSGNode::DirtyGeometry)
debug << "Geometry";
if (state & QSGNode::DirtyMaterial)
debug << "Material";
if (state & QSGNode::DirtyMatrix)
debug << "Matrix";
if (state & QSGNode::DirtyNodeAdded)
debug << "Added";
if (state & QSGNode::DirtyNodeRemoved)
debug << "Removed";
if (state & QSGNode::DirtyOpacity)
debug << "Opacity";
if (state & QSGNode::DirtySubtreeBlocked)
debug << "SubtreeBlocked";
if (state & QSGNode::DirtyForceUpdate)
debug << "ForceUpdate";
// when removed, some parts of the node could already have been destroyed
// so don't debug it out.
if (state & QSGNode::DirtyNodeRemoved)
debug << (void *) node << node->type();
else
debug << node;
}
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#endif
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
// As this function calls nodeChanged recursively, we do it at the top
// to avoid that any of the others are processed twice.
if (state & QSGNode::DirtySubtreeBlocked) {
Node *sn = m_nodes.value(node);
Force Batch Rebuild if SubtreeBlocked includes an opacity change Fixes: QTBUG-85965 Pick-to: 5.15 Change-Id: I2f5aba7fbde7ad2149d408d29db9219f33f13ca8 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-08-11 09:28:36 +00:00
// Force a batch rebuild if this includes an opacity change
if (state & QSGNode::DirtyOpacity)
m_rebuild |= FullRebuild;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
bool blocked = node->isSubtreeBlocked();
if (blocked && sn) {
nodeChanged(node, QSGNode::DirtyNodeRemoved);
Q_ASSERT(m_nodes.value(node) == 0);
} else if (!blocked && !sn) {
nodeChanged(node, QSGNode::DirtyNodeAdded);
}
return;
}
if (state & QSGNode::DirtyNodeAdded) {
if (nodeUpdater()->isNodeBlocked(node, rootNode())) {
QSGRenderer::nodeChanged(node, state);
return;
}
if (node == rootNode())
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
nodeWasAdded(node, nullptr);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
else
nodeWasAdded(node, m_nodes.value(node->parent()));
}
// Mark this node dirty in the shadow tree.
Node *shadowNode = m_nodes.value(node);
// Blocked subtrees won't have shadow nodes, so we can safely abort
// here..
if (!shadowNode) {
QSGRenderer::nodeChanged(node, state);
return;
}
shadowNode->dirtyState |= state;
if (state & QSGNode::DirtyMatrix && !shadowNode->isBatchRoot) {
Q_ASSERT(node->type() == QSGNode::TransformNodeType);
if (node->m_subtreeRenderableCount > m_batchNodeThreshold) {
turnNodeIntoBatchRoot(shadowNode);
} else {
int vertices = 0;
nodeWasTransformed(shadowNode, &vertices);
if (vertices > m_batchVertexThreshold) {
turnNodeIntoBatchRoot(shadowNode);
}
}
}
if (state & QSGNode::DirtyGeometry && node->type() == QSGNode::GeometryNodeType) {
QSGGeometryNode *gn = static_cast<QSGGeometryNode *>(node);
Element *e = shadowNode->element();
if (e) {
e->boundsComputed = false;
Batch *b = e->batch;
if (b) {
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
if (!e->batch->geometryWasChanged(gn) || !e->batch->isOpaque) {
invalidateBatchAndOverlappingRenderOrders(e->batch);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else {
b->needsUpload = true;
}
}
}
}
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
if (state & QSGNode::DirtyMaterial && node->type() == QSGNode::GeometryNodeType) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Element *e = shadowNode->element();
if (e) {
Make sure we rebuild batches properly after a Blending material change. If a node sent DirtyGeometry and DirtyMaterial in the same round and DirtyGeometry triggered its batch to be invalidated, we would take the no-batch code path which did set the rebuild state to BuildBatches. This looks ok on screen, but if the node changed from alpha to opaque, it would not be put into an opaque batch. For things like full screen rectangles, this can potentially hurt performance. To prevent doing a full rebuild on any material change on batchless items (aka all Rectangle nodes), we store the blend state of the material in the element and do a full rebuild only when blend state changes. Change-Id: Ifdf06fb72ef02ca47a135c821ddbcbe0d164ca29 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-04-25 14:21:00 +00:00
bool blended = hasMaterialWithBlending(static_cast<QSGGeometryNode *>(node));
if (e->isMaterialBlended != blended) {
m_rebuild |= Renderer::FullRebuild;
e->isMaterialBlended = blended;
Revert "Avoid rebuiding batches during a material animation" This reverts commit 26a230ee0ed68d39d4d13bfeaafd9839ee2a2a00. This optimization breaks when we have a single material change in the scene within a batch as the geometry node does not get visited on the next render. Task-number: QTBUG-52983 Change-Id: Ib385407a9fc35ca03ab18727d1e7b550431416f1 Reviewed-by: Michael Brasser <michael.brasser@live.com> Reviewed-by: Jocelyn Turcotte (Woboq GmbH) <jturcotte@woboq.com>
2016-04-26 06:39:15 +00:00
} else if (e->batch) {
if (e->batch->isMaterialCompatible(e) == BatchBreaksOnCompare)
invalidateBatchAndOverlappingRenderOrders(e->batch);
} else {
Fix rendering errors in Qt Quick Controls gallery First, when doing a partial rebuild, we need to mark all elements for orphaning, not just those without a batch, as the renderlist should at all times contain everything that is rendered on screen. Second, we had a small bug with material changes where we would overwrite the rebuild state instead of adding to it. This led to the render lists not being rebuilt from scratch in some scenarios. Third, after the shadow nodes rewrite, we didn't mark for a full rebuild when clips were added. Change-Id: I6707ebfa2908fcedd7fb636fb25b844be15fdea1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-04 12:08:41 +00:00
m_rebuild |= Renderer::BuildBatches;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
}
// Mark the shadow tree dirty all the way back to the root...
QSGNode::DirtyState dirtyChain = state & (QSGNode::DirtyNodeAdded
| QSGNode::DirtyOpacity
| QSGNode::DirtyMatrix
Respect DirtyForceUpdate in QSGBatchRenderer. There is a way this could have been done slightly more efficitently. If we moved all "combined" logic out of the scene graph and into the Node shadow tree, we could ignore the forceupdate all together. However, this is a quite large change for what is currently a non-common case. It would also increase overall memory consumption a bit as we would have superfluous combined matrix and opacity in the QSGNodes. Task-number: QTBUG-33838 Change-Id: I06c486ace2be15bef1f1dc72a8b41cb649d7c813 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-04 08:39:20 +00:00
| QSGNode::DirtySubtreeBlocked
| QSGNode::DirtyForceUpdate);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (dirtyChain != 0) {
dirtyChain = QSGNode::DirtyState(dirtyChain << 16);
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
Node *sn = shadowNode->parent();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
while (sn) {
sn->dirtyState |= dirtyChain;
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
sn = sn->parent();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
// Delete happens at the very end because it deletes the shadownode.
if (state & QSGNode::DirtyNodeRemoved) {
Change implementation of shadow nodes to use a double-linked list Since eea8fa64ab27854b71f46ef143e35b6c9acbba14, we're seeing increased times in QSGNode::removeChildNode(). The reason for this seems to be that iteration through the linked list is significantly slower than iteration through a QList<> due to that each node needs to be loaded in memory to iterate to the next, compared a more plain sequential pointer compare with QList<>. This implementation changes the nodes to use a circular double-linked list so we can drop the iteration when removing nodes. This brings us slightly better performance than the original QList based implementation while still using the same amount of memory as the single-linked list one. Change-Id: I0b693730f5b82ad7767e507accafd90551e03fbc Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2016-11-08 11:47:25 +00:00
Node *parent = shadowNode->parent();
if (parent)
parent->remove(shadowNode);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
nodeWasRemoved(shadowNode);
Q_ASSERT(m_nodes.value(node) == 0);
}
QSGRenderer::nodeChanged(node, state);
}
/*
* Traverses the tree and builds two list of geometry nodes. One for
* the opaque and one for the translucent. These are populated
* in the order they should visually appear in, meaning first
* to the back and last to the front.
*
* We split opaque and translucent as we can perform different
* types of reordering / batching strategies on them, depending
*
* Note: It would be tempting to use the shadow nodes instead of the QSGNodes
* for traversal to avoid hash lookups, but the order of the children
* is important and they are not preserved in the shadow tree, so we must
* use the actual QSGNode tree.
*/
void Renderer::buildRenderLists(QSGNode *node)
{
if (node->isSubtreeBlocked())
return;
Node *shadowNode = m_nodes.value(node);
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
Q_ASSERT(shadowNode);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (node->type() == QSGNode::GeometryNodeType) {
QSGGeometryNode *gn = static_cast<QSGGeometryNode *>(node);
Element *e = shadowNode->element();
Q_ASSERT(e);
bool opaque = gn->inheritedOpacity() > OPAQUE_LIMIT && !(gn->activeMaterial()->flags() & QSGMaterial::Blending);
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (opaque && useDepthBuffer())
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_opaqueRenderList << e;
else
m_alphaRenderList << e;
e->order = ++m_nextRenderOrder;
// Used while rebuilding partial roots.
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
if (m_partialRebuild)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
e->orphaned = false;
} else if (node->type() == QSGNode::ClipNodeType || shadowNode->isBatchRoot) {
Q_ASSERT(m_nodes.contains(node));
Use an allocator for QSGBatchRenderer::Node and Element instances. Cuts down quite a bit on the time spent on the render thread during the sync phase. Change-Id: Ide8c4348141c84ed8abd9a869607a022652c2828 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2014-10-22 11:32:27 +00:00
BatchRootInfo *info = batchRootInfo(shadowNode);
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
if (node == m_partialRebuildRoot) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_nextRenderOrder = info->firstOrder;
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
QSGNODE_TRAVERSE(node)
buildRenderLists(child);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_nextRenderOrder = info->lastOrder + 1;
} else {
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
int currentOrder = m_nextRenderOrder;
QSGNODE_TRAVERSE(node)
buildRenderLists(child);
int padding = (m_nextRenderOrder - currentOrder) >> 2;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
info->firstOrder = currentOrder;
info->availableOrders = padding;
info->lastOrder = m_nextRenderOrder + padding;
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
m_nextRenderOrder = info->lastOrder;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
return;
} else if (node->type() == QSGNode::RenderNodeType) {
RenderNodeElement *e = shadowNode->renderNodeElement();
m_alphaRenderList << e;
e->order = ++m_nextRenderOrder;
Q_ASSERT(e);
}
QSGNODE_TRAVERSE(node)
buildRenderLists(child);
}
void Renderer::tagSubRoots(Node *node)
{
BatchRootInfo *i = batchRootInfo(node);
m_taggedRoots << node;
for (QSet<Node *>::const_iterator it = i->subRoots.constBegin();
it != i->subRoots.constEnd(); ++it) {
tagSubRoots(*it);
}
}
static void qsg_addOrphanedElements(QDataBuffer<Element *> &orphans, const QDataBuffer<Element *> &renderList)
{
orphans.reset();
for (int i=0; i<renderList.size(); ++i) {
Element *e = renderList.at(i);
Fix rendering errors in Qt Quick Controls gallery First, when doing a partial rebuild, we need to mark all elements for orphaning, not just those without a batch, as the renderlist should at all times contain everything that is rendered on screen. Second, we had a small bug with material changes where we would overwrite the rebuild state instead of adding to it. This led to the render lists not being rebuilt from scratch in some scenarios. Third, after the shadow nodes rewrite, we didn't mark for a full rebuild when clips were added. Change-Id: I6707ebfa2908fcedd7fb636fb25b844be15fdea1 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-04 12:08:41 +00:00
if (e && !e->removed) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
e->orphaned = true;
orphans.add(e);
}
}
}
static void qsg_addBackOrphanedElements(QDataBuffer<Element *> &orphans, QDataBuffer<Element *> &renderList)
{
for (int i=0; i<orphans.size(); ++i) {
Element *e = orphans.at(i);
if (e->orphaned)
renderList.add(e);
}
orphans.reset();
}
/*
* To rebuild the tagged roots, we start by putting all subroots of tagged
* roots into the list of tagged roots. This is to make the rest of the
* algorithm simpler.
*
* Second, we invalidate all batches which belong to tagged roots, which now
* includes the entire subtree under a given root
*
* Then we call buildRenderLists for all tagged subroots which do not have
* parents which are tagged, aka, we traverse only the topmosts roots.
*
* Then we sort the render lists based on their render order, to restore the
* right order for rendering.
*/
void Renderer::buildRenderListsForTaggedRoots()
{
// Flag any element that is currently in the render lists, but which
// is not in a batch. This happens when we have a partial rebuild
// in one sub tree while we have a BuildBatches change in another
// isolated subtree. So that batch-building takes into account
// these "orphaned" nodes, we flag them now. The ones under tagged
// roots will be cleared again. The remaining ones are added into the
// render lists so that they contain all visual nodes after the
// function completes.
qsg_addOrphanedElements(m_tmpOpaqueElements, m_opaqueRenderList);
qsg_addOrphanedElements(m_tmpAlphaElements, m_alphaRenderList);
// Take a copy now, as we will be adding to this while traversing..
QSet<Node *> roots = m_taggedRoots;
for (QSet<Node *>::const_iterator it = roots.constBegin();
it != roots.constEnd(); ++it) {
tagSubRoots(*it);
}
for (int i=0; i<m_opaqueBatches.size(); ++i) {
Batch *b = m_opaqueBatches.at(i);
if (m_taggedRoots.contains(b->root))
invalidateAndRecycleBatch(b);
}
for (int i=0; i<m_alphaBatches.size(); ++i) {
Batch *b = m_alphaBatches.at(i);
if (m_taggedRoots.contains(b->root))
invalidateAndRecycleBatch(b);
}
m_opaqueRenderList.reset();
m_alphaRenderList.reset();
int maxRenderOrder = m_nextRenderOrder;
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
m_partialRebuild = true;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
// Traverse each root, assigning it
for (QSet<Node *>::const_iterator it = m_taggedRoots.constBegin();
it != m_taggedRoots.constEnd(); ++it) {
Node *root = *it;
BatchRootInfo *i = batchRootInfo(root);
if ((!i->parentRoot || !m_taggedRoots.contains(i->parentRoot))
&& !nodeUpdater()->isNodeBlocked(root->sgNode, rootNode())) {
m_nextRenderOrder = i->firstOrder;
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
m_partialRebuildRoot = root->sgNode;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
buildRenderLists(root->sgNode);
}
}
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
m_partialRebuild = false;
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
m_partialRebuildRoot = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_taggedRoots.clear();
m_nextRenderOrder = qMax(m_nextRenderOrder, maxRenderOrder);
// Add orphaned elements back into the list and then sort it..
qsg_addBackOrphanedElements(m_tmpOpaqueElements, m_opaqueRenderList);
qsg_addBackOrphanedElements(m_tmpAlphaElements, m_alphaRenderList);
if (m_opaqueRenderList.size())
Remove qSort usages from declarative QtAlgorithms is getting deprecated, see http://www.mail-archive.com/development@qt-project.org/msg01603.html Change-Id: I8fa7d0186cc8f0ba562695974829e37f1eb87f2f Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-09-12 09:06:59 +00:00
std::sort(&m_opaqueRenderList.first(), &m_opaqueRenderList.last() + 1, qsg_sort_element_decreasing_order);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (m_alphaRenderList.size())
Remove qSort usages from declarative QtAlgorithms is getting deprecated, see http://www.mail-archive.com/development@qt-project.org/msg01603.html Change-Id: I8fa7d0186cc8f0ba562695974829e37f1eb87f2f Reviewed-by: Gunnar Sletta <gunnar.sletta@digia.com> Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-09-12 09:06:59 +00:00
std::sort(&m_alphaRenderList.first(), &m_alphaRenderList.last() + 1, qsg_sort_element_increasing_order);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
void Renderer::buildRenderListsFromScratch()
{
m_opaqueRenderList.reset();
m_alphaRenderList.reset();
for (int i=0; i<m_opaqueBatches.size(); ++i)
invalidateAndRecycleBatch(m_opaqueBatches.at(i));
for (int i=0; i<m_alphaBatches.size(); ++i)
invalidateAndRecycleBatch(m_alphaBatches.at(i));
m_opaqueBatches.reset();
m_alphaBatches.reset();
m_nextRenderOrder = 0;
buildRenderLists(rootNode());
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
void Renderer::invalidateBatchAndOverlappingRenderOrders(Batch *batch)
Fix rendering bug with batched translucent elements. When one item in a batch of other translucent items would change opacity, we need to rebuild batches under the current root as all items in a batch are expected to have the same opacity. Task-number: QTBUG-34311 Change-Id: I2b9db19f05bd3a82be65cfa8a91e9398e8d58d0f Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-31 21:14:12 +00:00
{
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
Q_ASSERT(batch);
Q_ASSERT(batch->first);
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#if defined(QSGBATCHRENDERER_INVALIDATE_WEDGED_NODES)
Invalidate all batches potentially affected by a change. When two separate changes have occurred, we need to not only invalidate the batches directly overlapping those, but also any batch which has render orders between the two. So, keep track of the range of invalidated render orders and invalidate everything in between. Task-number: QTBUG-37422 Change-Id: Ie5a289d5c569b84917ec9ac52671173c566e69b3 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-03-19 10:58:04 +00:00
if (m_renderOrderRebuildLower < 0 || batch->first->order < m_renderOrderRebuildLower)
m_renderOrderRebuildLower = batch->first->order;
if (m_renderOrderRebuildUpper < 0 || batch->lastOrderInBatch > m_renderOrderRebuildUpper)
m_renderOrderRebuildUpper = batch->lastOrderInBatch;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
int first = m_renderOrderRebuildLower;
int last = m_renderOrderRebuildUpper;
#else
int first = batch->first->order;
int last = batch->lastOrderInBatch;
#endif
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
batch->invalidate();
Fix rendering bug with batched translucent elements. When one item in a batch of other translucent items would change opacity, we need to rebuild batches under the current root as all items in a batch are expected to have the same opacity. Task-number: QTBUG-34311 Change-Id: I2b9db19f05bd3a82be65cfa8a91e9398e8d58d0f Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-31 21:14:12 +00:00
for (int i=0; i<m_alphaBatches.size(); ++i) {
Batch *b = m_alphaBatches.at(i);
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
if (b->first) {
int bf = b->first->order;
int bl = b->lastOrderInBatch;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
if (bl > first && bf < last)
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
b->invalidate();
}
Fix rendering bug with batched translucent elements. When one item in a batch of other translucent items would change opacity, we need to rebuild batches under the current root as all items in a batch are expected to have the same opacity. Task-number: QTBUG-34311 Change-Id: I2b9db19f05bd3a82be65cfa8a91e9398e8d58d0f Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-31 21:14:12 +00:00
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
m_rebuild |= BuildBatches;
Fix rendering bug with batched translucent elements. When one item in a batch of other translucent items would change opacity, we need to rebuild batches under the current root as all items in a batch are expected to have the same opacity. Task-number: QTBUG-34311 Change-Id: I2b9db19f05bd3a82be65cfa8a91e9398e8d58d0f Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-10-31 21:14:12 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
/* Clean up batches by making it a consecutive list of "valid"
* batches and moving all invalidated batches to the batches pool.
*/
void Renderer::cleanupBatches(QDataBuffer<Batch *> *batches) {
if (batches->size()) {
Use stable sort when cleaning batches. Ensure valid batches do not change order. This was causing rendering issues when m_rebuild was 0, as we would not re-sort the list in correct render order after cleanup. Change-Id: I912fb313d4029f96e263fad24d68462f252003df Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-15 04:27:06 +00:00
std::stable_sort(&batches->first(), &batches->last() + 1, qsg_sort_batch_is_valid);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
int count = 0;
while (count < batches->size() && batches->at(count)->first)
++count;
Off-by-one error in batch recylcing lead to leaks and no recycling Change-Id: Ic6b126bbc929c2062fd3e77253ad8bba60376a50 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-04 06:26:06 +00:00
for (int i=count; i<batches->size(); ++i)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
invalidateAndRecycleBatch(batches->at(i));
batches->resize(count);
}
}
void Renderer::prepareOpaqueBatches()
{
for (int i=m_opaqueRenderList.size() - 1; i >= 0; --i) {
Element *ei = m_opaqueRenderList.at(i);
Skip nodes with no vertices when preparing batches. Nodes with no veritces end up overlapping with everything so they tend to lead to poor batching. In my specific case, the empty nodes came from the QQuickTextNode, but it is a valid usecase so better to handle it gracefully in the renderer. Change-Id: Ic09c202a2675f806f2124cd436027afcd2654452 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-26 09:05:21 +00:00
if (!ei || ei->batch || ei->node->geometry()->vertexCount() == 0)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
continue;
Batch *batch = newBatch();
batch->first = ei;
batch->root = ei->root;
batch->isOpaque = true;
batch->needsUpload = true;
batch->positionAttribute = qsg_positionAttribute(ei->node->geometry());
m_opaqueBatches.add(batch);
ei->batch = batch;
Element *next = ei;
QSGGeometryNode *gni = ei->node;
for (int j = i - 1; j >= 0; --j) {
Element *ej = m_opaqueRenderList.at(j);
if (!ej)
continue;
if (ej->root != ei->root)
break;
Skip nodes with no vertices when preparing batches. Nodes with no veritces end up overlapping with everything so they tend to lead to poor batching. In my specific case, the empty nodes came from the QQuickTextNode, but it is a valid usecase so better to handle it gracefully in the renderer. Change-Id: Ic09c202a2675f806f2124cd436027afcd2654452 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-26 09:05:21 +00:00
if (ej->batch || ej->node->geometry()->vertexCount() == 0)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
continue;
QSGGeometryNode *gnj = ej->node;
if (gni->clipList() == gnj->clipList()
&& gni->geometry()->drawingMode() == gnj->geometry()->drawingMode()
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
&& (gni->geometry()->drawingMode() != QSGGeometry::DrawLines || gni->geometry()->lineWidth() == gnj->geometry()->lineWidth())
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
&& gni->geometry()->attributes() == gnj->geometry()->attributes()
&& gni->inheritedOpacity() == gnj->inheritedOpacity()
&& gni->activeMaterial()->type() == gnj->activeMaterial()->type()
&& gni->activeMaterial()->compare(gnj->activeMaterial()) == 0) {
ej->batch = batch;
next->nextInBatch = ej;
next = ej;
}
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
batch->lastOrderInBatch = next->order;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
bool Renderer::checkOverlap(int first, int last, const Rect &bounds)
{
for (int i=first; i<=last; ++i) {
Element *e = m_alphaRenderList.at(i);
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#if defined(QSGBATCHRENDERER_INVALIDATE_WEDGED_NODES)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (!e || e->batch)
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#else
if (!e)
#endif
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
continue;
Q_ASSERT(e->boundsComputed);
if (e->bounds.intersects(bounds))
return true;
}
return false;
}
/*
*
* To avoid the O(n^2) checkOverlap check in most cases, we have the
* overlapBounds which is the union of all bounding rects to check overlap
* for. We know that if it does not overlap, then none of the individual
* ones will either. For the typical list case, this results in no calls
* to checkOverlap what-so-ever. This also ensures that when all consecutive
* items are matching (such as a table of text), we don't build up an
* overlap bounds and thus do not require full overlap checks.
*/
void Renderer::prepareAlphaBatches()
{
for (int i=0; i<m_alphaRenderList.size(); ++i) {
Element *e = m_alphaRenderList.at(i);
if (!e || e->isRenderNode)
continue;
Q_ASSERT(!e->removed);
e->ensureBoundsValid();
}
for (int i=0; i<m_alphaRenderList.size(); ++i) {
Element *ei = m_alphaRenderList.at(i);
if (!ei || ei->batch)
continue;
if (ei->isRenderNode) {
Batch *rnb = newBatch();
rnb->first = ei;
rnb->root = ei->root;
rnb->isOpaque = false;
rnb->isRenderNode = true;
ei->batch = rnb;
m_alphaBatches.add(rnb);
continue;
}
Skip nodes with no vertices when preparing batches. Nodes with no veritces end up overlapping with everything so they tend to lead to poor batching. In my specific case, the empty nodes came from the QQuickTextNode, but it is a valid usecase so better to handle it gracefully in the renderer. Change-Id: Ic09c202a2675f806f2124cd436027afcd2654452 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-26 09:05:21 +00:00
if (ei->node->geometry()->vertexCount() == 0)
continue;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Batch *batch = newBatch();
batch->first = ei;
batch->root = ei->root;
batch->isOpaque = false;
batch->needsUpload = true;
m_alphaBatches.add(batch);
ei->batch = batch;
QSGGeometryNode *gni = ei->node;
batch->positionAttribute = qsg_positionAttribute(gni->geometry());
Rect overlapBounds;
overlapBounds.set(FLT_MAX, FLT_MAX, -FLT_MAX, -FLT_MAX);
Element *next = ei;
for (int j = i + 1; j < m_alphaRenderList.size(); ++j) {
Element *ej = m_alphaRenderList.at(j);
if (!ej)
continue;
if (ej->root != ei->root || ej->isRenderNode)
break;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
if (ej->batch) {
#if !defined(QSGBATCHRENDERER_INVALIDATE_WEDGED_NODES)
overlapBounds |= ej->bounds;
#endif
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
continue;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QSGGeometryNode *gnj = ej->node;
Skip nodes with no vertices when preparing batches. Nodes with no veritces end up overlapping with everything so they tend to lead to poor batching. In my specific case, the empty nodes came from the QQuickTextNode, but it is a valid usecase so better to handle it gracefully in the renderer. Change-Id: Ic09c202a2675f806f2124cd436027afcd2654452 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-26 09:05:21 +00:00
if (gnj->geometry()->vertexCount() == 0)
continue;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (gni->clipList() == gnj->clipList()
&& gni->geometry()->drawingMode() == gnj->geometry()->drawingMode()
Do not batch lines with > 1 width in alpha pass Cannot possibly do reasonable overlap checks when we have no idea how such lines are rasterized, meaning we do not know the real bounds of the geometry. Pick-to: 6.1 6.0 5.15 Fixes: QTBUG-91749 Change-Id: Ia444232330da2f1d29841589f0e65bb52822c4ae Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
2021-03-29 11:36:27 +00:00
&& (gni->geometry()->drawingMode() != QSGGeometry::DrawLines
|| (gni->geometry()->lineWidth() == gnj->geometry()->lineWidth()
// Must not do overlap checks when the line width is not 1,
// we have no knowledge how such lines are rasterized.
&& gni->geometry()->lineWidth() == 1.0f))
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
&& gni->geometry()->attributes() == gnj->geometry()->attributes()
&& gni->inheritedOpacity() == gnj->inheritedOpacity()
&& gni->activeMaterial()->type() == gnj->activeMaterial()->type()
&& gni->activeMaterial()->compare(gnj->activeMaterial()) == 0) {
if (!overlapBounds.intersects(ej->bounds) || !checkOverlap(i+1, j - 1, ej->bounds)) {
ej->batch = batch;
next->nextInBatch = ej;
next = ej;
Fix stacking order bug in the renderer Since we are sorting batches based on the zorder of the first element it is crucial that we don't continue adding to batches once an overlap with a compatible element is found. Task-number: QTBUG-34864 Change-Id: Ic2194c5c17bba0bc9874a14e8a69c81bff75bd1c Reviewed-by: Sean Harmer <sean.harmer@kdab.com>
2013-11-15 06:23:04 +00:00
} else {
/* When we come across a compatible element which hits an overlap, we
* need to stop the batch right away. We cannot add more elements
* to the current batch as they will be rendered before the batch that the
* current 'ej' will be added to.
*/
break;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
} else {
overlapBounds |= ej->bounds;
}
}
Avoid renderlist rebuilds in the scene graph renderer. Transform, material, opacity and geometry changes all used to trigger full rebuilds, which meant that very little geometry could be retained between frames. For instance, a rotating spinner on top of a gridview this would cause a full rebuild where nothing is retained. This change introduces new concept to the renderer: partial rebuilding based on render order ranges. Since the render order of nodes is strictly defined by their position in the tree and nothing else, we should use that for the majority of rebuilds. When a change comes in for a node, we invalidate its batch and all batches which it has overlapping render orders with. Render order rebuilds only happen when nodes are added and removed. Change-Id: Ib4cb284164892b409e3fff5c492a54d60a5de2d7 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-01-28 19:53:01 +00:00
batch->lastOrderInBatch = next->order;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
static inline int qsg_fixIndexCount(int iCount, int drawMode)
{
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
switch (drawMode) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
case QSGGeometry::DrawTriangleStrip:
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
// Merged triangle strips need to contain degenerate triangles at the beginning and end.
// One could save 2 uploaded ushorts here by ditching the padding for the front of the
// first and the end of the last, but for simplicity, we simply don't care.
// Those extra triangles will be skipped while drawing to preserve the strip's parity
// anyhow.
return iCount + 2;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
case QSGGeometry::DrawLines:
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
// For lines we drop the last vertex if the number of vertices is uneven.
return iCount - (iCount % 2);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
case QSGGeometry::DrawTriangles:
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
// For triangles we drop trailing vertices until the result is divisible by 3.
return iCount - (iCount % 3);
default:
return iCount;
}
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
/* These parameters warrant some explanation...
*
* vaOffset: The byte offset into the vertex data to the location of the
* 2D float point vertex attributes.
*
* vertexData: destination where the geometry's vertex data should go
*
* zData: destination of geometries injected Z positioning
*
* indexData: destination of the indices for this element
*
* iBase: The starting index for this element in the batch
*/
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
void Renderer::uploadMergedElement(Element *e, int vaOffset, char **vertexData, char **zData, char **indexData, void *iBasePtr, int *indexCount)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_upload())) qDebug() << " - uploading element:" << e << e->node << (void *) *vertexData << (qintptr) (*zData - *vertexData) << (qintptr) (*indexData - *vertexData);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QSGGeometry *g = e->node->geometry();
const QMatrix4x4 &localx = *e->node->matrix();
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
const float *localxdata = localx.constData();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
const int vCount = g->vertexCount();
const int vSize = g->sizeOfVertex();
memcpy(*vertexData, g->vertexData(), vSize * vCount);
// apply vertex transform..
char *vdata = *vertexData + vaOffset;
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
if (localx.flags() == QMatrix4x4::Translation) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<vCount; ++i) {
Pt *p = (Pt *) vdata;
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
p->x += localxdata[12];
p->y += localxdata[13];
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
vdata += vSize;
}
Remove QMatrix4x4_Accessor hack Relies on QMatrix4x4 exposing the flags via a \internal public function. The m[a][b] access can be replaced with constData()[4*a+b]. Fixes: QTBUG-82670 Change-Id: I39145b202cf133ad5a712cab2796ac97feddb6a6 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-28 11:02:17 +00:00
} else if (localx.flags() > QMatrix4x4::Translation) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<vCount; ++i) {
((Pt *) vdata)->map(localx);
vdata += vSize;
}
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (useDepthBuffer()) {
Make it possible to render without a depth buffer. Some GL implementations (especially on embedded) will give us an OpenGL context without a depth buffer. In low memory scenarios, it might also be feasible to request a non-depth buffer context to save the depth buffer memory. The renderer deals with this by treating all nodes as translucent, by not adjusting the shaders and by not creating the extra z-order vertex attribute for merged nodes. Change-Id: I8edc92d530daa3e2628df2ba52901b47d87eaf26 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-01-21 12:28:53 +00:00
float *vzorder = (float *) *zData;
float zorder = 1.0f - e->order * m_zRange;
for (int i=0; i<vCount; ++i)
vzorder[i] = zorder;
*zData += vCount * sizeof(float);
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
int iCount = g->indexCount();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (m_uint32IndexForRhi) {
// can only happen when using the rhi
quint32 *iBase = (quint32 *) iBasePtr;
quint32 *indices = (quint32 *) *indexData;
if (iCount == 0) {
iCount = vCount;
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip)
*indices++ = *iBase;
else
iCount = qsg_fixIndexCount(iCount, g->drawingMode());
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i=0; i<iCount; ++i)
indices[i] = *iBase + i;
} else {
// source index data in QSGGeometry is always ushort (we would not merge otherwise)
const quint16 *srcIndices = g->indexDataAsUShort();
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip)
*indices++ = *iBase + srcIndices[0];
else
iCount = qsg_fixIndexCount(iCount, g->drawingMode());
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i=0; i<iCount; ++i)
indices[i] = *iBase + srcIndices[i];
}
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip) {
indices[iCount] = indices[iCount - 1];
iCount += 2;
}
*iBase += vCount;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
} else {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// normally batching is only done for ushort index data
quint16 *iBase = (quint16 *) iBasePtr;
quint16 *indices = (quint16 *) *indexData;
if (iCount == 0) {
iCount = vCount;
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip)
*indices++ = *iBase;
else
iCount = qsg_fixIndexCount(iCount, g->drawingMode());
Drop trailing vertices in GL_LINES and GL_TRIANGLES drawing modes. This results in more correct behavior if you create nodes with a number of vertices that doesn't match the drawing mode. Change-Id: Ic0f59a4019a6b4087b527b7c9b38c35a9e02ece8 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-12 12:54:45 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i=0; i<iCount; ++i)
indices[i] = *iBase + i;
} else {
const quint16 *srcIndices = g->indexDataAsUShort();
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip)
*indices++ = *iBase + srcIndices[0];
else
iCount = qsg_fixIndexCount(iCount, g->drawingMode());
for (int i=0; i<iCount; ++i)
indices[i] = *iBase + srcIndices[i];
}
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip) {
indices[iCount] = indices[iCount - 1];
iCount += 2;
}
*iBase += vCount;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
*vertexData += vCount * vSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
*indexData += iCount * mergedIndexElemSize();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
*indexCount += iCount;
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
QMatrix4x4 qsg_matrixForRoot(Node *node)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
if (node->type() == QSGNode::TransformNodeType)
return static_cast<QSGTransformNode *>(node->sgNode)->combinedMatrix();
Q_ASSERT(node->type() == QSGNode::ClipNodeType);
QSGClipNode *c = static_cast<QSGClipNode *>(node->sgNode);
return *c->matrix();
}
void Renderer::uploadBatch(Batch *b)
{
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// Early out if nothing has changed in this batch..
if (!b->needsUpload) {
if (Q_UNLIKELY(debug_upload())) qDebug() << " Batch:" << b << "already uploaded...";
return;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!b->first) {
if (Q_UNLIKELY(debug_upload())) qDebug() << " Batch:" << b << "is invalid...";
return;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (b->isRenderNode) {
if (Q_UNLIKELY(debug_upload())) qDebug() << " Batch: " << b << "is a render node...";
return;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// Figure out if we can merge or not, if not, then just render the batch as is..
Q_ASSERT(b->first);
Q_ASSERT(b->first->node);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QSGGeometryNode *gn = b->first->node;
QSGGeometry *g = gn->geometry();
QSGMaterial::Flags flags = gn->activeMaterial()->flags();
bool canMerge = (g->drawingMode() == QSGGeometry::DrawTriangles || g->drawingMode() == QSGGeometry::DrawTriangleStrip ||
g->drawingMode() == QSGGeometry::DrawLines || g->drawingMode() == QSGGeometry::DrawPoints)
&& b->positionAttribute >= 0
&& g->indexType() == QSGGeometry::UnsignedShortType
Repurpose CustomCompileStep as NoBatching in QSGMaterial Qt 5's CustomCompileStep has limited use in Qt 6: as there are no virtual compile() type of functions to override in the API anymore, its only effect now is disabling batching for nodes using materials that have the flag set. Coincidentally it turns out that some views in Creator's QML Profiler rely on some quite advanced manual alteration of gl_Position.z in the materials' vertex shader. This is pretty bad if batching is involved, although in Qt 5 they could get away by setting the internal undocumented qt_zRange uniform to a magic value (1.0) to alter the behavior of the final gl_Position override statement inserted by the shader rewriter to batched materials' vertex shaders. In Qt 6 this approach is not available, so the Profiler's rendering becomes incorrect due to the vertex shader's own gl_Position.z alterations being lost when batching is active. Instead, Creator 5 (that uses Qt 6) will set CustomCompileStep on its QSGMaterial subclasses where relevant in order to never batch nodes with these materials. All in all this implies that there is a need for a better-named flag. Therefore, add a NoBatching flag in place of CustomCompileStep, while still keeping the latter as an alias until Qt 7. Change-Id: Ib806fbfa55132fdd02765adece366f0175129ae8 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
2021-08-11 07:59:59 +00:00
&& (flags & (QSGMaterial::NoBatching | QSGMaterial_FullMatrix)) == 0
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
&& ((flags & QSGMaterial::RequiresFullMatrixExceptTranslate) == 0 || b->isTranslateOnlyToRoot())
&& b->isSafeToBatch();
b->merged = canMerge;
// Figure out how much memory we need...
b->vertexCount = 0;
b->indexCount = 0;
int unmergedIndexSize = 0;
Element *e = b->first;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
while (e) {
QSGGeometry *eg = e->node->geometry();
b->vertexCount += eg->vertexCount();
int iCount = eg->indexCount();
if (b->merged) {
if (iCount == 0)
iCount = eg->vertexCount();
iCount = qsg_fixIndexCount(iCount, g->drawingMode());
} else {
const int effectiveIndexSize = m_uint32IndexForRhi ? sizeof(quint32) : eg->sizeOfIndex();
unmergedIndexSize += iCount * effectiveIndexSize;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
b->indexCount += iCount;
e = e->nextInBatch;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// Abort if there are no vertices in this batch.. We abort this late as
// this is a broken usecase which we do not care to optimize for...
if (b->vertexCount == 0 || (b->merged && b->indexCount == 0))
return;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
/* Allocate memory for this batch. Merged batches are divided into three separate blocks
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
1. Vertex data for all elements, as they were in the QSGGeometry object, but
with the tranform relative to this batch's root applied. The vertex data
is otherwise unmodified.
2. Z data for all elements, derived from each elements "render order".
This is present for merged data only.
3. Indices for all elements, as they were in the QSGGeometry object, but
adjusted so that each index matches its.
And for TRIANGLE_STRIPs, we need to insert degenerate between each
primitive. These are unsigned shorts for merged and arbitrary for
non-merged.
*/
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
int bufferSize = b->vertexCount * g->sizeOfVertex();
int ibufferSize = 0;
if (b->merged) {
ibufferSize = b->indexCount * mergedIndexElemSize();
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (useDepthBuffer())
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
bufferSize += b->vertexCount * sizeof(float);
} else {
ibufferSize = unmergedIndexSize;
}
Add support for a separate index buffer The renderer binds same buffer both for vertex and index data. This is allowed on desktop & ES but is forbidden in WebGL. Add a compile-time flag to disable this optimization(?) and force using a separate buffer for the index data. Change-Id: I57c17c883a55e02513a8e4427efb202cafaaf37e Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-01-05 19:36:13 +00:00
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
map(&b->ibo, ibufferSize, true);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
map(&b->vbo, bufferSize);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (Q_UNLIKELY(debug_upload())) qDebug() << " - batch" << b << " first:" << b->first << " root:"
<< b->root << " merged:" << b->merged << " positionAttribute" << b->positionAttribute
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
<< " vbo:" << b->vbo.buf << ":" << b->vbo.size;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (b->merged) {
char *vertexData = b->vbo.data;
char *zData = vertexData + b->vertexCount * g->sizeOfVertex();
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
char *indexData = b->ibo.data;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
quint16 iOffset16 = 0;
quint32 iOffset32 = 0;
e = b->first;
uint verticesInSet = 0;
// Start a new set already after 65534 vertices because 0xFFFF may be
// used for an always-on primitive restart with some apis (adapt for
// uint32 indices as appropriate).
const uint verticesInSetLimit = m_uint32IndexForRhi ? 0xfffffffe : 0xfffe;
int indicesInSet = 0;
b->drawSets.reset();
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
int drawSetIndices = 0;
const char *indexBase = b->ibo.data;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
b->drawSets << DrawSet(0, zData - vertexData, drawSetIndices);
while (e) {
verticesInSet += e->node->geometry()->vertexCount();
if (verticesInSet > verticesInSetLimit) {
b->drawSets.last().indexCount = indicesInSet;
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip) {
b->drawSets.last().indices += 1 * mergedIndexElemSize();
b->drawSets.last().indexCount -= 2;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
drawSetIndices = indexData - indexBase;
b->drawSets << DrawSet(vertexData - b->vbo.data,
zData - b->vbo.data,
drawSetIndices);
iOffset16 = 0;
iOffset32 = 0;
verticesInSet = e->node->geometry()->vertexCount();
indicesInSet = 0;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
void *iBasePtr = &iOffset16;
if (m_uint32IndexForRhi)
iBasePtr = &iOffset32;
uploadMergedElement(e, b->positionAttribute, &vertexData, &zData, &indexData, iBasePtr, &indicesInSet);
e = e->nextInBatch;
}
b->drawSets.last().indexCount = indicesInSet;
// We skip the very first and very last degenerate triangles since they aren't needed
// and the first one would reverse the vertex ordering of the merged strips.
if (g->drawingMode() == QSGGeometry::DrawTriangleStrip) {
b->drawSets.last().indices += 1 * mergedIndexElemSize();
b->drawSets.last().indexCount -= 2;
}
} else {
char *vboData = b->vbo.data;
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
char *iboData = b->ibo.data;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Element *e = b->first;
while (e) {
QSGGeometry *g = e->node->geometry();
int vbs = g->vertexCount() * g->sizeOfVertex();
memcpy(vboData, g->vertexData(), vbs);
vboData = vboData + vbs;
const int indexCount = g->indexCount();
if (indexCount) {
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
const int effectiveIndexSize = m_uint32IndexForRhi ? sizeof(quint32) : g->sizeOfIndex();
const int ibs = indexCount * effectiveIndexSize;
if (g->sizeOfIndex() == effectiveIndexSize) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
memcpy(iboData, g->indexData(), ibs);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
} else {
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
if (g->sizeOfIndex() == sizeof(quint16) && effectiveIndexSize == sizeof(quint32)) {
quint16 *src = g->indexDataAsUShort();
quint32 *dst = (quint32 *) iboData;
for (int i = 0; i < indexCount; ++i)
dst[i] = src[i];
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
} else {
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
Q_ASSERT_X(false, "uploadBatch (unmerged)", "uint index with ushort effective index - cannot happen");
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
iboData += ibs;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
e = e->nextInBatch;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#ifndef QT_NO_DEBUG_OUTPUT
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (Q_UNLIKELY(debug_upload())) {
const char *vd = b->vbo.data;
qDebug() << " -- Vertex Data, count:" << b->vertexCount << " - " << g->sizeOfVertex() << "bytes/vertex";
for (int i=0; i<b->vertexCount; ++i) {
QDebug dump = qDebug().nospace();
dump << " --- " << i << ": ";
int offset = 0;
for (int a=0; a<g->attributeCount(); ++a) {
const QSGGeometry::Attribute &attr = g->attributes()[a];
dump << attr.position << ":(" << attr.tupleSize << ",";
if (attr.type == QSGGeometry::FloatType) {
dump << "float ";
if (attr.isVertexCoordinate)
dump << "* ";
for (int t=0; t<attr.tupleSize; ++t)
dump << *(const float *)(vd + offset + t * sizeof(float)) << " ";
} else if (attr.type == QSGGeometry::UnsignedByteType) {
dump << "ubyte ";
for (int t=0; t<attr.tupleSize; ++t)
dump << *(const unsigned char *)(vd + offset + t * sizeof(unsigned char)) << " ";
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
dump << ") ";
offset += attr.tupleSize * size_of_type(attr.type);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (b->merged && useDepthBuffer()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
float zorder = ((float*)(b->vbo.data + b->vertexCount * g->sizeOfVertex()))[i];
dump << " Z:(" << zorder << ")";
}
vd += g->sizeOfVertex();
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!b->drawSets.isEmpty()) {
if (m_uint32IndexForRhi) {
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
const quint32 *id = (const quint32 *) b->ibo.data;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
QDebug iDump = qDebug();
iDump << " -- Index Data, count:" << b->indexCount;
for (int i=0; i<b->indexCount; ++i) {
if ((i % 24) == 0)
Fix Qt6 builds after dev -> wip/qt6 merge Change-Id: I56b9d3abdbc6663a2d514f12aa20f2f574042bc1 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-07-08 11:01:56 +00:00
iDump << Qt::endl << " --- ";
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
iDump << id[i];
}
}
} else {
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
const quint16 *id = (const quint16 *) b->ibo.data;
Fixed assertion failure when using QSG_RENDERER_DEBUG=upload. Added a check that Batch::drawSets is not empty. Task-number: QTBUG-48439 Change-Id: Ica76363be8c770240dc69c669815a60904e26988 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-09-24 17:55:39 +00:00
{
QDebug iDump = qDebug();
iDump << " -- Index Data, count:" << b->indexCount;
for (int i=0; i<b->indexCount; ++i) {
if ((i % 24) == 0)
Merge remote-tracking branch 'origin/dev' into wip/qt6 Change-Id: Ifc24fbd99ee216e528a213fdbfd2892b3df419fe
2019-07-08 09:36:14 +00:00
iDump << Qt::endl << " --- ";
Fixed assertion failure when using QSG_RENDERER_DEBUG=upload. Added a check that Batch::drawSets is not empty. Task-number: QTBUG-48439 Change-Id: Ica76363be8c770240dc69c669815a60904e26988 Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-09-24 17:55:39 +00:00
iDump << id[i];
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i=0; i<b->drawSets.size(); ++i) {
const DrawSet &s = b->drawSets.at(i);
qDebug() << " -- DrawSet: indexCount:" << s.indexCount << " vertices:" << s.vertices << " z:" << s.zorders << " indices:" << s.indices;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Fix build with QT_NO_DEBUG_OUTPUT defined The use of the qDebug() macro to construct a QDebug object fails when QT_NO_DEBUG_OUTPUT is defined when building Qt. This patch aims to fix this. [ChangeLog][General][Build] Can now build with QT_NO_DEBUG_OUTPUT defined Change-Id: If807ee3439db2a98b4d146f75860a98f40c247ec Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-10-22 22:34:09 +00:00
#endif // QT_NO_DEBUG_OUTPUT
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
unmap(&b->vbo);
scenegraph: Remove unused separateIndexBuffer logic The flag has been unconditionally set to true since Qt 6.0. Change-Id: Ie6ad91f00b5c7ac7d6a7745035175f23c9641a42 Reviewed-by: Hatem ElKharashy <hatem.elkharashy@qt.io> Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-02-07 11:52:33 +00:00
unmap(&b->ibo, true);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (Q_UNLIKELY(debug_upload())) qDebug() << " --- vertex/index buffers unmapped, batch upload completed...";
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
b->needsUpload = false;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (Q_UNLIKELY(debug_render()))
b->uploadedThisFrame = true;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
void Renderer::applyClipStateToGraphicsState()
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_gstate.usesScissor = (m_currentClipState.type & ClipState::ScissorClip);
m_gstate.stencilTest = (m_currentClipState.type & ClipState::StencilClip);
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QRhiGraphicsPipeline *Renderer::buildStencilPipeline(const Batch *batch, bool firstStencilClipInBatch)
{
QRhiGraphicsPipeline *ps = m_rhi->newGraphicsPipeline();
ps->setFlags(QRhiGraphicsPipeline::UsesStencilRef);
QRhiGraphicsPipeline::TargetBlend blend;
Avoid initializing QFlags with 0 or nullptr in further cases Amends 744e77b841878fb017c0f2d60607090008f28180. Change-Id: I16e37aaf503eb62f67fca0e48be4c92c4a72ae46 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-11-25 10:49:14 +00:00
blend.colorWrite = {};
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setTargetBlends({ blend });
scenegraph: Remove beginNext[Rhi]Frame differentiation One set of functions is enough, no need for a separate set of "Rhi" ones. Change-Id: I58600c539734d5f8a767926eb9649d9968bab08a Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2022-04-19 11:01:42 +00:00
ps->setSampleCount(renderTarget().rt->sampleCount());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setStencilTest(true);
QRhiGraphicsPipeline::StencilOpState stencilOp;
if (firstStencilClipInBatch) {
stencilOp.compareOp = QRhiGraphicsPipeline::Always;
stencilOp.failOp = QRhiGraphicsPipeline::Keep;
stencilOp.depthFailOp = QRhiGraphicsPipeline::Keep;
stencilOp.passOp = QRhiGraphicsPipeline::Replace;
} else {
stencilOp.compareOp = QRhiGraphicsPipeline::Equal;
stencilOp.failOp = QRhiGraphicsPipeline::Keep;
stencilOp.depthFailOp = QRhiGraphicsPipeline::Keep;
stencilOp.passOp = QRhiGraphicsPipeline::IncrementAndClamp;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setStencilFront(stencilOp);
ps->setStencilBack(stencilOp);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setTopology(m_stencilClipCommon.topology);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setShaderStages({ QRhiGraphicsShaderStage(QRhiGraphicsShaderStage::Vertex, m_stencilClipCommon.vs),
QRhiGraphicsShaderStage(QRhiGraphicsShaderStage::Fragment, m_stencilClipCommon.fs) });
ps->setVertexInputLayout(m_stencilClipCommon.inputLayout);
ps->setShaderResourceBindings(batch->stencilClipState.srb); // use something, it just needs to be layout-compatible
ps->setRenderPassDescriptor(renderPassDescriptor());
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!ps->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build stencil clip pipeline");
delete ps;
return nullptr;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return ps;
}
Work around Nouveau driver bugs Change-Id: I25311a2bd88f41087352e0a43ba505f4e27b7e85 Reviewed-by: Jørgen Lind <jorgen.lind@digia.com>
2013-10-30 13:09:18 +00:00
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
void Renderer::updateClipState(const QSGClipNode *clipList, Batch *batch)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
// Note: No use of the clip-related speparate m_current* vars is allowed
// here. All stored in batch->clipState instead. To collect state during
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
// the prepare steps, m_currentClipState is used. It should not be used in
// the render steps afterwards.
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
// The stenciling logic is slightly different from Qt 5's direct OpenGL version
// as we cannot just randomly clear the stencil buffer. We now put all clip
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// shapes into the stencil buffer for all batches in the frame. This means
// that the number of total clips in a scene is reduced (since the stencil
// value cannot exceed 255) but we do not need any clears inbetween.
Q_ASSERT(m_rhi);
batch->stencilClipState.updateStencilBuffer = false;
if (clipList == m_currentClipState.clipList || Q_UNLIKELY(debug_noclip())) {
applyClipStateToGraphicsState();
batch->clipState = m_currentClipState;
return;
}
ClipState::ClipType clipType = ClipState::NoClip;
QRect scissorRect;
QVarLengthArray<const QSGClipNode *, 4> stencilClipNodes;
const QSGClipNode *clip = clipList;
batch->stencilClipState.drawCalls.reset();
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 totalVSize = 0;
quint32 totalISize = 0;
quint32 totalUSize = 0;
const quint32 StencilClipUbufSize = 64;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
while (clip) {
QMatrix4x4 m = m_current_projection_matrix_native_ndc;
if (clip->matrix())
m *= *clip->matrix();
bool isRectangleWithNoPerspective = clip->isRectangular()
&& qFuzzyIsNull(m(3, 0)) && qFuzzyIsNull(m(3, 1));
bool noRotate = qFuzzyIsNull(m(0, 1)) && qFuzzyIsNull(m(1, 0));
bool isRotate90 = qFuzzyIsNull(m(0, 0)) && qFuzzyIsNull(m(1, 1));
if (isRectangleWithNoPerspective && (noRotate || isRotate90)) {
QRectF bbox = clip->clipRect();
qreal invW = 1 / m(3, 3);
qreal fx1, fy1, fx2, fy2;
if (noRotate) {
fx1 = (bbox.left() * m(0, 0) + m(0, 3)) * invW;
fy1 = (bbox.bottom() * m(1, 1) + m(1, 3)) * invW;
fx2 = (bbox.right() * m(0, 0) + m(0, 3)) * invW;
fy2 = (bbox.top() * m(1, 1) + m(1, 3)) * invW;
} else {
Q_ASSERT(isRotate90);
fx1 = (bbox.bottom() * m(0, 1) + m(0, 3)) * invW;
fy1 = (bbox.left() * m(1, 0) + m(1, 3)) * invW;
fx2 = (bbox.top() * m(0, 1) + m(0, 3)) * invW;
fy2 = (bbox.right() * m(1, 0) + m(1, 3)) * invW;
}
if (fx1 > fx2)
qSwap(fx1, fx2);
if (fy1 > fy2)
qSwap(fy1, fy2);
QRect deviceRect = this->deviceRect();
Clean up QT_CONFIG(opengl) Accelerated graphics is now possible without OpenGL support. With this change, a Qt build with -no-opengl can still run Qt Quick with a Vulkan, Metal, or Direct3D backend. Fixes: QTBUG-84027 Change-Id: Ib63c733d28cfdf7de16b138df136fa7628e1747b Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-16 15:03:47 +00:00
qint32 ix1 = qRound((fx1 + 1) * deviceRect.width() * qreal(0.5));
qint32 iy1 = qRound((fy1 + 1) * deviceRect.height() * qreal(0.5));
qint32 ix2 = qRound((fx2 + 1) * deviceRect.width() * qreal(0.5));
qint32 iy2 = qRound((fy2 + 1) * deviceRect.height() * qreal(0.5));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!(clipType & ClipState::ScissorClip)) {
clipType |= ClipState::ScissorClip;
scissorRect = QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
} else {
scissorRect &= QRect(ix1, iy1, ix2 - ix1, iy2 - iy1);
}
} else {
clipType |= ClipState::StencilClip;
const QSGGeometry *g = clip->geometry();
Q_ASSERT(g->attributeCount() > 0);
const int vertexByteSize = g->sizeOfVertex() * g->vertexCount();
// the 4 byte alignment may not actually be needed here
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
totalVSize = aligned(totalVSize, 4u) + vertexByteSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (g->indexCount()) {
const int indexByteSize = g->sizeOfIndex() * g->indexCount();
// so no need to worry about NonFourAlignedEffectiveIndexBufferOffset
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
totalISize = aligned(totalISize, 4u) + indexByteSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
// ubuf start offsets must be aligned (typically to 256 bytes)
totalUSize = aligned(totalUSize, m_ubufAlignment) + StencilClipUbufSize;
stencilClipNodes.append(clip);
}
clip = clip->clipList();
}
if (clipType & ClipState::StencilClip) {
bool rebuildVBuf = false;
if (!batch->stencilClipState.vbuf) {
batch->stencilClipState.vbuf = m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::VertexBuffer, totalVSize);
rebuildVBuf = true;
} else if (batch->stencilClipState.vbuf->size() < totalVSize) {
batch->stencilClipState.vbuf->setSize(totalVSize);
rebuildVBuf = true;
}
if (rebuildVBuf) {
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->stencilClipState.vbuf->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build stencil clip vertex buffer");
delete batch->stencilClipState.vbuf;
batch->stencilClipState.vbuf = nullptr;
return;
}
}
if (totalISize) {
bool rebuildIBuf = false;
if (!batch->stencilClipState.ibuf) {
batch->stencilClipState.ibuf = m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::IndexBuffer, totalISize);
rebuildIBuf = true;
} else if (batch->stencilClipState.ibuf->size() < totalISize) {
batch->stencilClipState.ibuf->setSize(totalISize);
rebuildIBuf = true;
}
if (rebuildIBuf) {
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->stencilClipState.ibuf->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build stencil clip index buffer");
delete batch->stencilClipState.ibuf;
batch->stencilClipState.ibuf = nullptr;
return;
}
}
}
bool rebuildUBuf = false;
if (!batch->stencilClipState.ubuf) {
batch->stencilClipState.ubuf = m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, totalUSize);
rebuildUBuf = true;
} else if (batch->stencilClipState.ubuf->size() < totalUSize) {
batch->stencilClipState.ubuf->setSize(totalUSize);
rebuildUBuf = true;
}
if (rebuildUBuf) {
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->stencilClipState.ubuf->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build stencil clip uniform buffer");
delete batch->stencilClipState.ubuf;
batch->stencilClipState.ubuf = nullptr;
return;
}
}
if (!batch->stencilClipState.srb) {
batch->stencilClipState.srb = m_rhi->newShaderResourceBindings();
const QRhiShaderResourceBinding ubufBinding = QRhiShaderResourceBinding::uniformBufferWithDynamicOffset(
0, QRhiShaderResourceBinding::VertexStage, batch->stencilClipState.ubuf, StencilClipUbufSize);
batch->stencilClipState.srb->setBindings({ ubufBinding });
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->stencilClipState.srb->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build stencil clip srb");
delete batch->stencilClipState.srb;
batch->stencilClipState.srb = nullptr;
return;
}
}
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 vOffset = 0;
quint32 iOffset = 0;
quint32 uOffset = 0;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (const QSGClipNode *clip : stencilClipNodes) {
const QSGGeometry *g = clip->geometry();
const QSGGeometry::Attribute *a = g->attributes();
StencilClipState::StencilDrawCall drawCall;
const bool firstStencilClipInBatch = batch->stencilClipState.drawCalls.isEmpty();
if (firstStencilClipInBatch) {
m_stencilClipCommon.inputLayout.setBindings({ QRhiVertexInputBinding(g->sizeOfVertex()) });
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
m_stencilClipCommon.inputLayout.setAttributes({ QRhiVertexInputAttribute(0, 0, qsg_vertexInputFormat(*a), 0) });
m_stencilClipCommon.topology = qsg_topology(g->drawingMode());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
#ifndef QT_NO_DEBUG
else {
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
if (qsg_topology(g->drawingMode()) != m_stencilClipCommon.topology)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("updateClipState: Clip list entries have different primitive topologies, this is not currently supported.");
Revert "Temporarily drop a debug mode check in rhi-based stenciling" The qt5 submodule update is now done in qtbase, so the code here can now be migrated to follow the QRhi (private) API changes. This reverts commit 7661b142a130df54af3a5430a29e3c82da086c7b. Task-number: QTBUG-78995 Change-Id: I6995cd5e14b75622a51c9e95fb3178485d67d63d Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2019-10-07 07:33:50 +00:00
if (qsg_vertexInputFormat(*a) != m_stencilClipCommon.inputLayout.cbeginAttributes()->format())
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("updateClipState: Clip list entries have different vertex input layouts, this is must not happen.");
}
#endif
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
drawCall.vbufOffset = aligned(vOffset, 4u);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const int vertexByteSize = g->sizeOfVertex() * g->vertexCount();
Fix 3+ level stencil clips on the rhi path Change-Id: Id1e0b904ba7273e63fb63ea53c513bde20dc9759 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-08-01 20:02:06 +00:00
vOffset = drawCall.vbufOffset + vertexByteSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
int indexByteSize = 0;
if (g->indexCount()) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
drawCall.ibufOffset = aligned(iOffset, 4u);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
indexByteSize = g->sizeOfIndex() * g->indexCount();
Fix 3+ level stencil clips on the rhi path Change-Id: Id1e0b904ba7273e63fb63ea53c513bde20dc9759 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-08-01 20:02:06 +00:00
iOffset = drawCall.ibufOffset + indexByteSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
drawCall.ubufOffset = aligned(uOffset, m_ubufAlignment);
Fix 3+ level stencil clips on the rhi path Change-Id: Id1e0b904ba7273e63fb63ea53c513bde20dc9759 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-08-01 20:02:06 +00:00
uOffset = drawCall.ubufOffset + StencilClipUbufSize;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QMatrix4x4 matrixYUpNDC = m_current_projection_matrix;
if (clip->matrix())
matrixYUpNDC *= *clip->matrix();
m_resourceUpdates->updateDynamicBuffer(batch->stencilClipState.ubuf, drawCall.ubufOffset, 64, matrixYUpNDC.constData());
m_resourceUpdates->updateDynamicBuffer(batch->stencilClipState.vbuf, drawCall.vbufOffset, vertexByteSize, g->vertexData());
if (indexByteSize)
m_resourceUpdates->updateDynamicBuffer(batch->stencilClipState.ibuf, drawCall.ibufOffset, indexByteSize, g->indexData());
// stencil ref goes 1, 1, 2, 3, 4, ..., N for the clips in the first batch,
// then N+1, N+1, N+2, N+3, ... for the next batch,
// and so on.
// Note the different stencilOp for the first and the subsequent clips.
drawCall.stencilRef = firstStencilClipInBatch ? m_currentClipState.stencilRef + 1 : m_currentClipState.stencilRef;
m_currentClipState.stencilRef += 1;
drawCall.vertexCount = g->vertexCount();
drawCall.indexCount = g->indexCount();
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
drawCall.indexFormat = qsg_indexFormat(g);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
batch->stencilClipState.drawCalls.add(drawCall);
}
if (!m_stencilClipCommon.vs.isValid())
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
m_stencilClipCommon.vs = QSGMaterialShaderPrivate::loadShader(QLatin1String(":/qt-project.org/scenegraph/shaders_ng/stencilclip.vert.qsb"));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!m_stencilClipCommon.fs.isValid())
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
m_stencilClipCommon.fs = QSGMaterialShaderPrivate::loadShader(QLatin1String(":/qt-project.org/scenegraph/shaders_ng/stencilclip.frag.qsb"));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!m_stencilClipCommon.replacePs)
m_stencilClipCommon.replacePs = buildStencilPipeline(batch, true);
if (!m_stencilClipCommon.incrPs)
m_stencilClipCommon.incrPs = buildStencilPipeline(batch, false);
batch->stencilClipState.updateStencilBuffer = true;
}
m_currentClipState.clipList = clipList;
m_currentClipState.type = clipType;
m_currentClipState.scissor = QRhiScissor(scissorRect.x(), scissorRect.y(),
scissorRect.width(), scissorRect.height());
applyClipStateToGraphicsState();
batch->clipState = m_currentClipState;
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
void Renderer::enqueueStencilDraw(const Batch *batch)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
// cliptype stencil + updateStencilBuffer==false means the batch uses
// stenciling but relies on the stencil data generated by a previous batch
// (due to the having the same clip node). Do not enqueue draw calls for
// stencil in this case as the stencil buffer is already up-to-date.
if (!batch->stencilClipState.updateStencilBuffer)
return;
QRhiCommandBuffer *cb = commandBuffer();
const int count = batch->stencilClipState.drawCalls.size();
for (int i = 0; i < count; ++i) {
const StencilClipState::StencilDrawCall &drawCall(batch->stencilClipState.drawCalls.at(i));
QRhiShaderResourceBindings *srb = batch->stencilClipState.srb;
QRhiCommandBuffer::DynamicOffset ubufOffset(0, drawCall.ubufOffset);
if (i == 0) {
cb->setGraphicsPipeline(m_stencilClipCommon.replacePs);
cb->setViewport(m_pstate.viewport);
} else if (i == 1) {
cb->setGraphicsPipeline(m_stencilClipCommon.incrPs);
cb->setViewport(m_pstate.viewport);
}
Fix 3+ level stencil clips on the rhi path Change-Id: Id1e0b904ba7273e63fb63ea53c513bde20dc9759 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-08-01 20:02:06 +00:00
// else incrPs is already bound
cb->setShaderResources(srb, 1, &ubufOffset);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
cb->setStencilRef(drawCall.stencilRef);
const QRhiCommandBuffer::VertexInput vbufBinding(batch->stencilClipState.vbuf, drawCall.vbufOffset);
if (drawCall.indexCount) {
cb->setVertexInput(0, 1, &vbufBinding,
batch->stencilClipState.ibuf, drawCall.ibufOffset, drawCall.indexFormat);
cb->drawIndexed(drawCall.indexCount);
} else {
cb->setVertexInput(0, 1, &vbufBinding);
cb->draw(drawCall.vertexCount);
}
}
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
void Renderer::setActiveRhiShader(QSGMaterialShader *program, ShaderManager::Shader *shader)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
Q_ASSERT(m_rhi);
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
m_currentProgram = program;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_currentShader = shader;
m_currentMaterial = nullptr;
}
static inline bool needsBlendConstant(QRhiGraphicsPipeline::BlendFactor f)
{
return f == QRhiGraphicsPipeline::ConstantColor
|| f == QRhiGraphicsPipeline::OneMinusConstantColor
|| f == QRhiGraphicsPipeline::ConstantAlpha
|| f == QRhiGraphicsPipeline::OneMinusConstantAlpha;
}
// With QRhi renderBatches() is split to two steps: prepare and render.
//
// Prepare goes through the batches and elements, and set up a graphics
// pipeline, srb, uniform buffer, calculates clipping, based on m_gstate, the
// material (shaders), and the batches. This step does not touch the command
// buffer or renderpass-related state (m_pstate).
//
// The render step then starts a renderpass, and goes through all
// batches/elements again and records setGraphicsPipeline, drawIndexed, etc. on
// the command buffer. The prepare step's accumulated global state like
// m_gstate must not be used here. Rather, all data needed for rendering is
// available from Batch/Element at this stage. Bookkeeping of state in the
// renderpass is done via m_pstate.
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
bool Renderer::ensurePipelineState(Element *e, const ShaderManager::Shader *sms, bool depthPostPass)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
Get rid of renderpass descriptor objects from the pipeline cache keys Follow what we did to the srb: instead of storing an object reference, store an opaque blob to test for compatibility. This works even if the object is destroyed in the meantime. Thus, the annoying and error-prone invalidatePipelineCacheDependency() goes away, finally. All this works because creating a QRhiGraphicsPipeline with a given QRhiRenderPassDescriptor only needs the renderpass object for building (as in create()). Afterwards the object can be destroyed, even. The pipeline is still usable with any render targets that have a _compatible_ rp descriptor. Therefore, it is ideal if there is a way to test for this compatibility without having to have the original object around for ever. Relies on enablers (most importantly, QRhiRenderPassDescriptor::serializedFormat()) added to QRhi in qtbase. While not necessarily obvious, the real benefit here is significant performance gains in certain situations: consider rendering a scene to a given render target, then to another one, then yet another one, for example via QQuickRenderControl. We no longer have to do aggressive purging of the pipelines just because a QRhiRenderPassDescriptor some of the recently created pipelines may be associated with is going to disappear. Rather, everything can stay as-is, there are no crashes due to dangling pointers in the pipeline cache keys. The majority of cases involve highly compatible render targets (e.g. rendering into textures of the same format), so reuse is highly beneficial. Pick-to: 6.2 Change-Id: I8ad4bfcb3c7e66c7364c91a749e2a2e6837b4f1a Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-09-15 12:07:15 +00:00
// Note the key's == and qHash implementations: the renderpass descriptor
// and srb are tested for compatibility, not pointer equality.
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
//
// We do not store the srb pointer itself because the ownership stays with
// the Element and that can go away more often that we would like it
// to. (think scrolling a list view, constantly dropping and creating new
// nodes) Rather, use an opaque blob of a few uints and store and compare
// that. This works because once the pipeline is built, we will always call
// setShaderResources with an explicitly specified srb which is fine even if
// e->srb we used here to bake the pipeline is already gone by that point.
//
// A typical QSGMaterial's serialized srb layout is 8 uints. (uniform buffer
// + texture, 4 fields each) Regardless, using an implicitly shared
// container is essential here. (won't detach so no more allocs and copies
// are done, unless the Element decides to rebake the srb with a different
// layout - but then the detach is exactly what we need)
Get rid of renderpass descriptor objects from the pipeline cache keys Follow what we did to the srb: instead of storing an object reference, store an opaque blob to test for compatibility. This works even if the object is destroyed in the meantime. Thus, the annoying and error-prone invalidatePipelineCacheDependency() goes away, finally. All this works because creating a QRhiGraphicsPipeline with a given QRhiRenderPassDescriptor only needs the renderpass object for building (as in create()). Afterwards the object can be destroyed, even. The pipeline is still usable with any render targets that have a _compatible_ rp descriptor. Therefore, it is ideal if there is a way to test for this compatibility without having to have the original object around for ever. Relies on enablers (most importantly, QRhiRenderPassDescriptor::serializedFormat()) added to QRhi in qtbase. While not necessarily obvious, the real benefit here is significant performance gains in certain situations: consider rendering a scene to a given render target, then to another one, then yet another one, for example via QQuickRenderControl. We no longer have to do aggressive purging of the pipelines just because a QRhiRenderPassDescriptor some of the recently created pipelines may be associated with is going to disappear. Rather, everything can stay as-is, there are no crashes due to dangling pointers in the pipeline cache keys. The majority of cases involve highly compatible render targets (e.g. rendering into textures of the same format), so reuse is highly beneficial. Pick-to: 6.2 Change-Id: I8ad4bfcb3c7e66c7364c91a749e2a2e6837b4f1a Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-09-15 12:07:15 +00:00
//
// Same story for the renderpass descriptor: the object can go away but
// that's fine because that has no effect on an already built pipeline, and
// for comparison we only rely on the serialized blob in order decide if the
// render target is compatible with the pipeline.
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
Get rid of renderpass descriptor objects from the pipeline cache keys Follow what we did to the srb: instead of storing an object reference, store an opaque blob to test for compatibility. This works even if the object is destroyed in the meantime. Thus, the annoying and error-prone invalidatePipelineCacheDependency() goes away, finally. All this works because creating a QRhiGraphicsPipeline with a given QRhiRenderPassDescriptor only needs the renderpass object for building (as in create()). Afterwards the object can be destroyed, even. The pipeline is still usable with any render targets that have a _compatible_ rp descriptor. Therefore, it is ideal if there is a way to test for this compatibility without having to have the original object around for ever. Relies on enablers (most importantly, QRhiRenderPassDescriptor::serializedFormat()) added to QRhi in qtbase. While not necessarily obvious, the real benefit here is significant performance gains in certain situations: consider rendering a scene to a given render target, then to another one, then yet another one, for example via QQuickRenderControl. We no longer have to do aggressive purging of the pipelines just because a QRhiRenderPassDescriptor some of the recently created pipelines may be associated with is going to disappear. Rather, everything can stay as-is, there are no crashes due to dangling pointers in the pipeline cache keys. The majority of cases involve highly compatible render targets (e.g. rendering into textures of the same format), so reuse is highly beneficial. Pick-to: 6.2 Change-Id: I8ad4bfcb3c7e66c7364c91a749e2a2e6837b4f1a Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-09-15 12:07:15 +00:00
const GraphicsPipelineStateKey k = GraphicsPipelineStateKey::create(m_gstate, sms, renderPassDescriptor(), e->srb);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// Note: dynamic state (viewport rect, scissor rect, stencil ref, blend
// constant) is never a part of GraphicsState/QRhiGraphicsPipeline.
// See if there is an existing, matching pipeline state object.
Share pipeline state objects between layer renderers ...as long as the renderpass descriptors are compatible. Relies on the new QRhiRenderPassDescriptor::isCompatible() function. In the nodetypes_ng manual test this brings down the number of pipelines created from 16 to 8 in the layer test scene (because most layers use the same materials there, so many pipelines can be reused between them - previously this was prevented by the comparison-by-pointer for the QRhiRenderPassDescriptors). Additionally, any application with more than one layer (Item.layer enabled or ShaderEffect) in the scene will benefit from this. Task-number: QTBUG-80318 Change-Id: Id7437a3baac31891a231643d4787da7186ac107e Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2019-11-25 20:36:23 +00:00
auto it = m_shaderManager->pipelineCache.constFind(k);
if (it != m_shaderManager->pipelineCache.constEnd()) {
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (depthPostPass)
e->depthPostPassPs = *it;
else
e->ps = *it;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return true;
}
// Build a new one. This is potentially expensive.
QRhiGraphicsPipeline *ps = m_rhi->newGraphicsPipeline();
Drop QVector for srb and shader stage descriptions Follow the QRhi changes that move away from QVector in QRhiShaderResourceBindings and QRhiGraphicsPipeline. This, together with QRhi's de-d-pointering of QRhiShaderResourceBinding, is bringing significant performance improvements for scenes with a lot (thousands) of unbatched items, since a large number of allocations are now avoided due to not having to create a QVector of d-pointered classes just to do a lookup in the srb cache. Change-Id: I612ab2d9449a9e0ce79f7169b942b95d55af61ff Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-09-28 15:21:03 +00:00
ps->setShaderStages(sms->programRhi.shaderStages.cbegin(), sms->programRhi.shaderStages.cend());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setVertexInputLayout(sms->programRhi.inputLayout);
ps->setShaderResourceBindings(e->srb);
ps->setRenderPassDescriptor(renderPassDescriptor());
Avoid initializing QFlags with 0 or nullptr It is being deprecated. Change-Id: I844bd92af85bc53a8fc0371408d05277bd49f511 Reviewed-by: Simon Hausmann <simon.hausmann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2019-11-21 12:10:02 +00:00
QRhiGraphicsPipeline::Flags flags;
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
if (needsBlendConstant(m_gstate.srcColor) || needsBlendConstant(m_gstate.dstColor)
|| needsBlendConstant(m_gstate.srcAlpha) || needsBlendConstant(m_gstate.dstAlpha))
{
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
flags |= QRhiGraphicsPipeline::UsesBlendConstants;
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (m_gstate.usesScissor)
flags |= QRhiGraphicsPipeline::UsesScissor;
if (m_gstate.stencilTest)
flags |= QRhiGraphicsPipeline::UsesStencilRef;
ps->setFlags(flags);
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
ps->setTopology(qsg_topology(m_gstate.drawMode));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setCullMode(m_gstate.cullMode);
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
ps->setPolygonMode(m_gstate.polygonMode);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QRhiGraphicsPipeline::TargetBlend blend;
blend.colorWrite = m_gstate.colorWrite;
blend.enable = m_gstate.blending;
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
blend.srcColor = m_gstate.srcColor;
blend.dstColor = m_gstate.dstColor;
blend.srcAlpha = m_gstate.srcAlpha;
blend.dstAlpha = m_gstate.dstAlpha;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ps->setTargetBlends({ blend });
ps->setDepthTest(m_gstate.depthTest);
ps->setDepthWrite(m_gstate.depthWrite);
ps->setDepthOp(m_gstate.depthFunc);
if (m_gstate.stencilTest) {
ps->setStencilTest(true);
QRhiGraphicsPipeline::StencilOpState stencilOp;
stencilOp.compareOp = QRhiGraphicsPipeline::Equal;
stencilOp.failOp = QRhiGraphicsPipeline::Keep;
stencilOp.depthFailOp = QRhiGraphicsPipeline::Keep;
stencilOp.passOp = QRhiGraphicsPipeline::Keep;
ps->setStencilFront(stencilOp);
ps->setStencilBack(stencilOp);
}
ps->setSampleCount(m_gstate.sampleCount);
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
ps->setLineWidth(m_gstate.lineWidth);
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!ps->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("Failed to build graphics pipeline state");
delete ps;
return false;
}
Share pipeline state objects between layer renderers ...as long as the renderpass descriptors are compatible. Relies on the new QRhiRenderPassDescriptor::isCompatible() function. In the nodetypes_ng manual test this brings down the number of pipelines created from 16 to 8 in the layer test scene (because most layers use the same materials there, so many pipelines can be reused between them - previously this was prevented by the comparison-by-pointer for the QRhiRenderPassDescriptors). Additionally, any application with more than one layer (Item.layer enabled or ShaderEffect) in the scene will benefit from this. Task-number: QTBUG-80318 Change-Id: Id7437a3baac31891a231643d4787da7186ac107e Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
2019-11-25 20:36:23 +00:00
m_shaderManager->pipelineCache.insert(k, ps);
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (depthPostPass)
e->depthPostPassPs = ps;
else
e->ps = ps;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return true;
}
static QRhiSampler *newSampler(QRhi *rhi, const QSGSamplerDescription &desc)
{
QRhiSampler::Filter magFilter;
QRhiSampler::Filter minFilter;
QRhiSampler::Filter mipmapMode;
QRhiSampler::AddressMode u;
QRhiSampler::AddressMode v;
switch (desc.filtering) {
case QSGTexture::None:
Q_FALLTHROUGH();
case QSGTexture::Nearest:
magFilter = minFilter = QRhiSampler::Nearest;
break;
case QSGTexture::Linear:
magFilter = minFilter = QRhiSampler::Linear;
break;
default:
Q_UNREACHABLE();
magFilter = minFilter = QRhiSampler::Nearest;
break;
}
switch (desc.mipmapFiltering) {
case QSGTexture::None:
mipmapMode = QRhiSampler::None;
break;
case QSGTexture::Nearest:
mipmapMode = QRhiSampler::Nearest;
break;
case QSGTexture::Linear:
mipmapMode = QRhiSampler::Linear;
break;
default:
Q_UNREACHABLE();
mipmapMode = QRhiSampler::None;
break;
}
switch (desc.horizontalWrap) {
case QSGTexture::Repeat:
u = QRhiSampler::Repeat;
break;
case QSGTexture::ClampToEdge:
u = QRhiSampler::ClampToEdge;
break;
case QSGTexture::MirroredRepeat:
u = QRhiSampler::Mirror;
break;
default:
Q_UNREACHABLE();
u = QRhiSampler::ClampToEdge;
break;
}
switch (desc.verticalWrap) {
case QSGTexture::Repeat:
v = QRhiSampler::Repeat;
break;
case QSGTexture::ClampToEdge:
v = QRhiSampler::ClampToEdge;
break;
case QSGTexture::MirroredRepeat:
v = QRhiSampler::Mirror;
break;
default:
Q_UNREACHABLE();
v = QRhiSampler::ClampToEdge;
break;
}
return rhi->newSampler(magFilter, minFilter, mipmapMode, u, v);
}
QRhiTexture *Renderer::dummyTexture()
{
if (!m_dummyTexture) {
m_dummyTexture = m_rhi->newTexture(QRhiTexture::RGBA8, QSize(64, 64));
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (m_dummyTexture->create()) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (m_resourceUpdates) {
QImage img(m_dummyTexture->pixelSize(), QImage::Format_RGBA8888_Premultiplied);
img.fill(0);
m_resourceUpdates->uploadTexture(m_dummyTexture, img);
}
}
}
return m_dummyTexture;
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
static void rendererToMaterialGraphicsState(QSGMaterialShader::GraphicsPipelineState *dst,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
GraphicsState *src)
{
dst->blendEnable = src->blending;
// the enum values should match, sanity check it
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
Q_ASSERT(int(QSGMaterialShader::GraphicsPipelineState::OneMinusSrc1Alpha) == int(QRhiGraphicsPipeline::OneMinusSrc1Alpha));
Q_ASSERT(int(QSGMaterialShader::GraphicsPipelineState::A) == int(QRhiGraphicsPipeline::A));
Q_ASSERT(int(QSGMaterialShader::GraphicsPipelineState::CullBack) == int(QRhiGraphicsPipeline::Back));
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
Q_ASSERT(int(QSGMaterialShader::GraphicsPipelineState::Line) == int(QRhiGraphicsPipeline::Line));
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
dst->srcColor = QSGMaterialShader::GraphicsPipelineState::BlendFactor(src->srcColor);
dst->dstColor = QSGMaterialShader::GraphicsPipelineState::BlendFactor(src->dstColor);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
// For compatibility with any existing code, separateBlendFactors defaults
// to _false_ which means that materials that do not touch srcAlpha and
// dstAlpha will continue to use srcColor and dstColor as the alpha
// blending factors. New code that needs different values for color/alpha,
// can explicitly set separateBlendFactors to true and then set srcAlpha
// and dstAlpha as well.
dst->separateBlendFactors = false;
dst->srcAlpha = QSGMaterialShader::GraphicsPipelineState::BlendFactor(src->srcAlpha);
dst->dstAlpha = QSGMaterialShader::GraphicsPipelineState::BlendFactor(src->dstAlpha);
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
dst->colorWrite = QSGMaterialShader::GraphicsPipelineState::ColorMask(int(src->colorWrite));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
dst->cullMode = QSGMaterialShader::GraphicsPipelineState::CullMode(src->cullMode);
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
dst->polygonMode = QSGMaterialShader::GraphicsPipelineState::PolygonMode(src->polygonMode);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
static void materialToRendererGraphicsState(GraphicsState *dst,
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::GraphicsPipelineState *src)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
dst->blending = src->blendEnable;
dst->srcColor = QRhiGraphicsPipeline::BlendFactor(src->srcColor);
dst->dstColor = QRhiGraphicsPipeline::BlendFactor(src->dstColor);
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
if (src->separateBlendFactors) {
dst->srcAlpha = QRhiGraphicsPipeline::BlendFactor(src->srcAlpha);
dst->dstAlpha = QRhiGraphicsPipeline::BlendFactor(src->dstAlpha);
} else {
dst->srcAlpha = dst->srcColor;
dst->dstAlpha = dst->dstColor;
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
dst->colorWrite = QRhiGraphicsPipeline::ColorMask(int(src->colorWrite));
dst->cullMode = QRhiGraphicsPipeline::CullMode(src->cullMode);
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
dst->polygonMode = QRhiGraphicsPipeline::PolygonMode(src->polygonMode);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
void Renderer::updateMaterialDynamicData(ShaderManager::Shader *sms,
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::RenderState &renderState,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QSGMaterial *material,
const Batch *batch,
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
Element *e,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
int ubufOffset,
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
int ubufRegionSize)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
m_current_resource_update_batch = m_resourceUpdates;
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader *shader = sms->programRhi.program;
QSGMaterialShaderPrivate *pd = QSGMaterialShaderPrivate::get(shader);
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
QVarLengthArray<QRhiShaderResourceBinding, 8> bindings;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (pd->ubufBinding >= 0) {
m_current_uniform_data = &pd->masterUniformData;
const bool changed = shader->updateUniformData(renderState, material, m_currentMaterial);
Change const ref to ref in QSGMaterialRhiShader as per API review Change-Id: I7783ed26a66f03ebe3b26bcba2f42f9fff45a417 Reviewed-by: Lars Knoll <lars.knoll@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-09-16 15:44:16 +00:00
m_current_uniform_data = nullptr;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (changed || !batch->ubufDataValid)
m_resourceUpdates->updateDynamicBuffer(batch->ubuf, ubufOffset, ubufRegionSize, pd->masterUniformData.constData());
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
bindings.append(QRhiShaderResourceBinding::uniformBuffer(pd->ubufBinding,
pd->ubufStages,
batch->ubuf,
ubufOffset,
ubufRegionSize));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
for (int binding = 0; binding < QSGMaterialShaderPrivate::MAX_SHADER_RESOURCE_BINDINGS; ++binding) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const QRhiShaderResourceBinding::StageFlags stages = pd->combinedImageSamplerBindings[binding];
if (!stages)
continue;
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
QVarLengthArray<QSGTexture *, 4> prevTex = pd->textureBindingTable[binding];
QVarLengthArray<QSGTexture *, 4> nextTex = prevTex;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
const int count = pd->combinedImageSamplerCount[binding];
nextTex.resize(count);
shader->updateSampledImage(renderState, binding, nextTex.data(), material,
m_currentMaterial);
if (nextTex.contains(nullptr)) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("No QSGTexture provided from updateSampledImage(). This is wrong.");
continue;
}
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
bool hasDirtySamplerOptions = false;
bool isAnisotropic = false;
for (QSGTexture *t : nextTex) {
QSGTexturePrivate *td = QSGTexturePrivate::get(t);
hasDirtySamplerOptions |= td->hasDirtySamplerOptions();
isAnisotropic |= t->anisotropyLevel() != QSGTexture::AnisotropyNone;
td->resetDirtySamplerOptions();
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// prevTex may be invalid at this point, avoid dereferencing it
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
if (nextTex != prevTex || hasDirtySamplerOptions) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// The QSGTexture, and so the sampler parameters, may have changed.
// The rhiTexture is not relevant here.
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
pd->textureBindingTable[binding] = nextTex; // does not own
pd->samplerBindingTable[binding].clear();
if (isAnisotropic) // ###
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("QSGTexture anisotropy levels are not currently supported");
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
QVarLengthArray<QRhiSampler *, 4> samplers;
for (QSGTexture *t : nextTex) {
const QSGSamplerDescription samplerDesc = QSGSamplerDescription::fromTexture(t);
QRhiSampler *sampler = m_samplers[samplerDesc];
if (!sampler) {
sampler = newSampler(m_rhi, samplerDesc);
if (!sampler->create()) {
qWarning("Failed to build sampler");
delete sampler;
continue;
}
m_samplers[samplerDesc] = sampler;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
samplers.append(sampler);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
pd->samplerBindingTable[binding] = samplers; // does not own
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
scenegraph: Enable arrays of combined image samplers The current scenegraph implementation only allows a single texture per combined image sampler binding. Shaders may specify arrays of combined image samplers. This change allows an array of textures to be provided per binding. [ChangeLog][QtQuick][QSGMaterialShader] Added support for arrays of combined image samplers per binding. Change-Id: I37b6f38c60d23cfe5f04388a4f0bf42fb1a73837 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-01-24 22:47:47 +00:00
if (pd->textureBindingTable[binding].count() == pd->samplerBindingTable[binding].count()) {
QVarLengthArray<QRhiShaderResourceBinding::TextureAndSampler, 4> textureSamplers;
for (int i = 0; i < pd->textureBindingTable[binding].count(); ++i) {
QRhiTexture *texture = pd->textureBindingTable[binding].at(i)->rhiTexture();
// texture may be null if the update above failed for any reason,
// or if the QSGTexture chose to return null intentionally. This is
// valid and we still need to provide something to the shader.
if (!texture)
texture = dummyTexture();
QRhiSampler *sampler = pd->samplerBindingTable[binding].at(i);
textureSamplers.append(
QRhiShaderResourceBinding::TextureAndSampler { texture, sampler });
}
if (!textureSamplers.isEmpty())
bindings.append(QRhiShaderResourceBinding::sampledTextures(
binding, stages, count, textureSamplers.constData()));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
}
#ifndef QT_NO_DEBUG
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
if (bindings.isEmpty())
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
qWarning("No shader resources for material %p, this is odd.", material);
#endif
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
enum class SrbAction {
Unknown,
DoNothing,
UpdateResources,
Rebake
} srbAction = SrbAction::Unknown;
// First, if the Element has no srb created at all, then try to find an existing,
// currently unused srb that is layout-compatible with our binding list.
if (!e->srb) {
// reuse a QVector as our work area, thus possibly reusing the underlying allocation too
QVector<quint32> &layoutDesc(m_shaderManager->srbLayoutDescSerializeWorkspace);
layoutDesc.clear();
QRhiShaderResourceBinding::serializeLayoutDescription(bindings.cbegin(), bindings.cend(), std::back_inserter(layoutDesc));
e->srb = m_shaderManager->srbPool.take(layoutDesc);
if (e->srb) {
// Here we know layout compatibility is satisfied, but do not spend time on full
// comparison. The chance of getting an srb that refers to the same resources
// (buffer, textures) is low in practice. So reuse, but write new resources.
srbAction = SrbAction::UpdateResources;
}
}
// If the Element had an existing srb, investigate:
// - It may be used as-is (when nothing changed in the scene regarding this node compared to the previous frame).
// - Otherwise it may be able to go with a lightweight update (replace resources, binding list layout is the same).
// - If all else fails rebake the full thing, meaning we reuse the memory allocation but will recreate everything underneath.
if (srbAction == SrbAction::Unknown && e->srb) {
if (std::equal(e->srb->cbeginBindings(), e->srb->cendBindings(), bindings.cbegin(), bindings.cend())) {
srbAction = SrbAction::DoNothing;
} else if (std::equal(e->srb->cbeginBindings(), e->srb->cendBindings(), bindings.cbegin(), bindings.cend(),
[](const auto &a, const auto &b) { return a.isLayoutCompatible(b); }))
{
srbAction = SrbAction::UpdateResources;
} else {
srbAction = SrbAction::Rebake;
}
}
// If the Element had no srb associated at all and could not find a layout-compatible
// one from the pool, then create a whole new object.
if (!e->srb) {
e->srb = m_rhi->newShaderResourceBindings();
srbAction = SrbAction::Rebake;
}
Q_ASSERT(srbAction != SrbAction::Unknown && e->srb);
switch (srbAction) {
case SrbAction::DoNothing:
break;
case SrbAction::UpdateResources:
{
e->srb->setBindings(bindings.cbegin(), bindings.cend());
QRhiShaderResourceBindings::UpdateFlags flags;
// Due to the way the binding list is built up above, if we have a uniform buffer
// at binding point 0 (or none at all) then the sampledTexture bindings are added
// with increasing binding points afterwards, so the list is already sorted based
// on the binding points, thus we can save some time by telling the QRhi backend
// not to sort again.
if (pd->ubufBinding <= 0 || bindings.count() <= 1)
flags |= QRhiShaderResourceBindings::BindingsAreSorted;
e->srb->updateResources(flags);
}
break;
case SrbAction::Rebake:
e->srb->setBindings(bindings.cbegin(), bindings.cend());
if (!e->srb->create())
qWarning("Failed to build srb");
break;
default:
Q_ASSERT_X(false, "updateMaterialDynamicData", "No srb action set, this cannot happen");
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
void Renderer::updateMaterialStaticData(ShaderManager::Shader *sms,
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::RenderState &renderState,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QSGMaterial *material,
Batch *batch,
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
bool *gstateChanged)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader *shader = sms->programRhi.program;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
*gstateChanged = false;
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
if (shader->flags().testFlag(QSGMaterialShader::UpdatesGraphicsPipelineState)) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// generate the public mini-state from m_gstate, invoke the material,
// write the changes, if any, back to m_gstate, together with a way to
// roll those back.
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::GraphicsPipelineState shaderPs;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
rendererToMaterialGraphicsState(&shaderPs, &m_gstate);
const bool changed = shader->updateGraphicsPipelineState(renderState, &shaderPs, material, m_currentMaterial);
if (changed) {
m_gstateStack.push(m_gstate);
materialToRendererGraphicsState(&m_gstate, &shaderPs);
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
if (needsBlendConstant(m_gstate.srcColor) || needsBlendConstant(m_gstate.dstColor)
|| needsBlendConstant(m_gstate.srcAlpha) || needsBlendConstant(m_gstate.dstAlpha))
{
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
batch->blendConstant = shaderPs.blendConstant;
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
*gstateChanged = true;
}
}
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
bool Renderer::prepareRenderMergedBatch(Batch *batch, PreparedRenderBatch *renderBatch)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
if (batch->vertexCount == 0 || batch->indexCount == 0)
return false;
Element *e = batch->first;
Q_ASSERT(e);
#ifndef QT_NO_DEBUG_OUTPUT
if (Q_UNLIKELY(debug_render())) {
QDebug debug = qDebug();
debug << " -"
<< batch
<< (batch->uploadedThisFrame ? "[ upload]" : "[retained]")
<< (e->node->clipList() ? "[ clip]" : "[noclip]")
<< (batch->isOpaque ? "[opaque]" : "[ alpha]")
<< "[ merged]"
<< " Nodes:" << QString::fromLatin1("%1").arg(qsg_countNodesInBatch(batch), 4).toLatin1().constData()
<< " Vertices:" << QString::fromLatin1("%1").arg(batch->vertexCount, 5).toLatin1().constData()
<< " Indices:" << QString::fromLatin1("%1").arg(batch->indexCount, 5).toLatin1().constData()
<< " root:" << batch->root;
if (batch->drawSets.size() > 1)
debug << "sets:" << batch->drawSets.size();
if (!batch->isOpaque)
debug << "opacity:" << e->node->inheritedOpacity();
batch->uploadedThisFrame = false;
}
#endif
QSGGeometryNode *gn = e->node;
// We always have dirty matrix as all batches are at a unique z range.
QSGMaterialShader::RenderState::DirtyStates dirty = QSGMaterialShader::RenderState::DirtyMatrix;
if (batch->root)
m_current_model_view_matrix = qsg_matrixForRoot(batch->root);
else
m_current_model_view_matrix.setToIdentity();
m_current_determinant = m_current_model_view_matrix.determinant();
m_current_projection_matrix = projectionMatrix();
m_current_projection_matrix_native_ndc = projectionMatrixWithNativeNDC();
QSGMaterial *material = gn->activeMaterial();
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode != QSGRendererInterface::RenderMode3D)
Skip all clipping when render mode is 3D The current assumption is that setting clip: true will have no effect in a scene rendered with RenderMode3D. (2D item tree under a 3D node) Change-Id: I81ca1fcc04c7f4af37a03fd48dc95ea307989e98 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-09 15:06:02 +00:00
updateClipState(gn->clipList(), batch);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const QSGGeometry *g = gn->geometry();
Anisotropic antialiasing for distance field text For perspective transforms, we need to find the sample range in the glyph cache per pixel. We can do this by getting the gradient of the distance field at the specific pixel. This will ensure proper antialiasing with any projection, but has the limitation that when glyph contours become thinner than a pixel, they may disappear or become too emphasized, because the hardware-gradient - based on neighbouring fragments - is not reliable at that scale. So we should only default to this when we detect that the text is child of a 3D scene. To make this smooth, we need to know the mode of the renderer when creating the shader. So QSGMaterial::createShader() now takes a render mode that we can use to customize behavior based on whether it is rendering into a 2D or 3D scene. [ChangeLog][QtQuick] The QSGMaterial::createShader() virtual function has been extended to take a render mode argument, which can be used for any customizations needed in the case where the shader will be used in combination with 3D perspective transformations. Fixes: QTBUG-84695 Change-Id: I5a18a4edbdfa07e8f9d506c42bb20e8eb580927d Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-09 08:57:35 +00:00
ShaderManager::Shader *sms = useDepthBuffer() ? m_shaderManager->prepareMaterial(material, g, m_renderMode)
: m_shaderManager->prepareMaterialNoRewrite(material, g, m_renderMode);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!sms)
return false;
Q_ASSERT(sms->programRhi.program);
if (m_currentShader != sms)
setActiveRhiShader(sms->programRhi.program, sms);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_current_opacity = gn->inheritedOpacity();
Avoid setting DirtyOpacity flag if it has not been changed Since it compares floating point values DirtyOpacity flag could be set every time when rendering is requested. Change-Id: If4f28a196952172c2d66d7a2978f600c61acac72 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2017-12-18 15:13:40 +00:00
if (!qFuzzyCompare(sms->lastOpacity, float(m_current_opacity))) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
dirty |= QSGMaterialShader::RenderState::DirtyOpacity;
sms->lastOpacity = m_current_opacity;
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShaderPrivate *pd = QSGMaterialShaderPrivate::get(sms->programRhi.program);
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
const quint32 ubufSize = quint32(pd->masterUniformData.size());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (pd->ubufBinding >= 0) {
bool ubufRebuild = false;
if (!batch->ubuf) {
batch->ubuf = m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);
ubufRebuild = true;
} else {
if (batch->ubuf->size() < ubufSize) {
batch->ubuf->setSize(ubufSize);
ubufRebuild = true;
}
}
if (ubufRebuild) {
batch->ubufDataValid = false;
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->ubuf->create()) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
qWarning("Failed to build uniform buffer of size %u bytes", ubufSize);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
delete batch->ubuf;
batch->ubuf = nullptr;
return false;
}
}
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::RenderState renderState = state(QSGMaterialShader::RenderState::DirtyStates(int(dirty)));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
bool pendingGStatePop = false;
updateMaterialStaticData(sms, renderState, material, batch, &pendingGStatePop);
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
updateMaterialDynamicData(sms, renderState, material, batch, e, 0, ubufSize);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Verbose fatal instead of crash when the scene graph state is invalid. Change-Id: I9a55bcbf9e94084c0cadac561e4707d47f5f8744 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-07-03 10:15:46 +00:00
#ifndef QT_NO_DEBUG
if (qsg_test_and_clear_material_failure()) {
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("QSGMaterial::updateState triggered an error (merged), batch will be skipped:");
Verbose fatal instead of crash when the scene graph state is invalid. Change-Id: I9a55bcbf9e94084c0cadac561e4707d47f5f8744 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-07-03 10:15:46 +00:00
Element *ee = e;
while (ee) {
qDebug() << " -" << ee->node;
ee = ee->nextInBatch;
}
QSGNodeDumper::dump(rootNode());
qFatal("Aborting: scene graph is invalid...");
}
#endif
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_gstate.drawMode = QSGGeometry::DrawingMode(g->drawingMode());
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
m_gstate.lineWidth = g->lineWidth();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const bool hasPipeline = ensurePipelineState(e, sms);
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (pendingGStatePop)
m_gstate = m_gstateStack.pop();
if (!hasPipeline)
return false;
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode == QSGRendererInterface::RenderMode3D) {
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
m_gstateStack.push(m_gstate);
setStateForDepthPostPass();
ensurePipelineState(e, sms, true);
m_gstate = m_gstateStack.pop();
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
batch->ubufDataValid = true;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_currentMaterial = material;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
renderBatch->batch = batch;
renderBatch->sms = sms;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return true;
}
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
void Renderer::checkLineWidth(QSGGeometry *g)
{
if (g->drawingMode() == QSGGeometry::DrawLines || g->drawingMode() == QSGGeometry::DrawLineLoop
|| g->drawingMode() == QSGGeometry::DrawLineStrip)
{
if (g->lineWidth() != 1.0f) {
static bool checkedWideLineSupport = false;
if (!checkedWideLineSupport) {
checkedWideLineSupport = true;
if (!m_rhi->isFeatureSupported(QRhi::WideLines))
qWarning("Line widths other than 1 are not supported by the graphics API");
}
}
} else if (g->drawingMode() == QSGGeometry::DrawPoints) {
if (g->lineWidth() != 1.0f) {
static bool warnedPointSize = false;
if (!warnedPointSize) {
warnedPointSize = true;
qWarning("Point size is not controllable by QSGGeometry. "
"Set gl_PointSize from the vertex shader instead.");
}
}
}
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
void Renderer::renderMergedBatch(PreparedRenderBatch *renderBatch, bool depthPostPass)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
const Batch *batch = renderBatch->batch;
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (!batch->vbo.buf || !batch->ibo.buf)
return;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Element *e = batch->first;
QSGGeometryNode *gn = e->node;
QSGGeometry *g = gn->geometry();
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
checkLineWidth(g);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (batch->clipState.type & ClipState::StencilClip)
enqueueStencilDraw(batch);
Verbose fatal instead of crash when the scene graph state is invalid. Change-Id: I9a55bcbf9e94084c0cadac561e4707d47f5f8744 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-07-03 10:15:46 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QRhiCommandBuffer *cb = commandBuffer();
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
setGraphicsPipeline(cb, batch, e, depthPostPass);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
for (int i = 0, ie = batch->drawSets.size(); i != ie; ++i) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
const DrawSet &draw = batch->drawSets.at(i);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const QRhiCommandBuffer::VertexInput vbufBindings[] = {
{ batch->vbo.buf, quint32(draw.vertices) },
{ batch->vbo.buf, quint32(draw.zorders) }
};
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
cb->setVertexInput(VERTEX_BUFFER_BINDING, useDepthBuffer() ? 2 : 1, vbufBindings,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
batch->ibo.buf, draw.indices,
m_uint32IndexForRhi ? QRhiCommandBuffer::IndexUInt32 : QRhiCommandBuffer::IndexUInt16);
cb->drawIndexed(draw.indexCount);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
bool Renderer::prepareRenderUnmergedBatch(Batch *batch, PreparedRenderBatch *renderBatch)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
{
if (batch->vertexCount == 0)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return false;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Element *e = batch->first;
Q_ASSERT(e);
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_render())) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
qDebug() << " -"
Fix partial rebuilds and geometry changes. When we do partial rebuilds, we need to update the render order for the entire subtree unconditionally. The previous logic was to reuse existing render orders beneath batch roots, which caused overlapping orders to be used. When geometry of an alpha batch changes, we need to rebuild everything under the current root. Otherwise, we might end up with previously batched content which incorrectly overlaps the changed geometry. Change-Id: I7b6de5ce34a02434294ac5ae29ae1b87eb3c4464 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-09-05 12:12:53 +00:00
<< batch
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
<< (batch->uploadedThisFrame ? "[ upload]" : "[retained]")
<< (e->node->clipList() ? "[ clip]" : "[noclip]")
<< (batch->isOpaque ? "[opaque]" : "[ alpha]")
<< "[unmerged]"
<< " Nodes:" << QString::fromLatin1("%1").arg(qsg_countNodesInBatch(batch), 4).toLatin1().constData()
<< " Vertices:" << QString::fromLatin1("%1").arg(batch->vertexCount, 5).toLatin1().constData()
<< " Indices:" << QString::fromLatin1("%1").arg(batch->indexCount, 5).toLatin1().constData()
<< " root:" << batch->root;
batch->uploadedThisFrame = false;
}
m_current_projection_matrix = projectionMatrix();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_current_projection_matrix_native_ndc = projectionMatrixWithNativeNDC();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QSGGeometryNode *gn = e->node;
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode != QSGRendererInterface::RenderMode3D)
Skip all clipping when render mode is 3D The current assumption is that setting clip: true will have no effect in a scene rendered with RenderMode3D. (2D item tree under a 3D node) Change-Id: I81ca1fcc04c7f4af37a03fd48dc95ea307989e98 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-09 15:06:02 +00:00
updateClipState(gn->clipList(), batch);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
// We always have dirty matrix as all batches are at a unique z range.
QSGMaterialShader::RenderState::DirtyStates dirty = QSGMaterialShader::RenderState::DirtyMatrix;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// The vertex attributes are assumed to be the same for all elements in the
// unmerged batch since the material (and so the shaders) is the same.
QSGGeometry *g = gn->geometry();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QSGMaterial *material = gn->activeMaterial();
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
ShaderManager::Shader *sms = m_shaderManager->prepareMaterialNoRewrite(material, g);
QSGBatchRenderer: return when a shader is not returned by the manager If a shader can't be found from the manager (e.g., if it failed to link), return from rendering. This prevents the renderer from crashing on a null pointer. Task-number: QTBUG-37290 Change-Id: I44d0bbb721854c0bc6da681ff55f71140a5cb0bc Reviewed-by: Gunnar Sletta <gunnar.sletta@jollamobile.com>
2014-03-06 12:59:42 +00:00
if (!sms)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
return false;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Q_ASSERT(sms->programRhi.program);
if (m_currentShader != sms)
setActiveRhiShader(sms->programRhi.program, sms);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_current_opacity = gn->inheritedOpacity();
if (sms->lastOpacity != m_current_opacity) {
dirty |= QSGMaterialShader::RenderState::DirtyOpacity;
sms->lastOpacity = m_current_opacity;
}
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
QMatrix4x4 rootMatrix = batch->root ? qsg_matrixForRoot(batch->root) : QMatrix4x4();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShaderPrivate *pd = QSGMaterialShaderPrivate::get(sms->programRhi.program);
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
const quint32 ubufSize = quint32(pd->masterUniformData.size());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (pd->ubufBinding >= 0) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 totalUBufSize = 0;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
while (e) {
totalUBufSize += aligned(ubufSize, m_ubufAlignment);
e = e->nextInBatch;
}
bool ubufRebuild = false;
if (!batch->ubuf) {
batch->ubuf = m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, totalUBufSize);
ubufRebuild = true;
} else {
if (batch->ubuf->size() < totalUBufSize) {
batch->ubuf->setSize(totalUBufSize);
ubufRebuild = true;
}
}
if (ubufRebuild) {
batch->ubufDataValid = false;
Follow QRhi create-destroy API update Change-Id: I0bc2cbce373febcb9073f15067eebbc1723462ba Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-27 15:54:41 +00:00
if (!batch->ubuf->create()) {
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
qWarning("Failed to build uniform buffer of size %u bytes", totalUBufSize);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
delete batch->ubuf;
batch->ubuf = nullptr;
return false;
}
}
}
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::RenderState renderState = state(QSGMaterialShader::RenderState::DirtyStates(int(dirty)));
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
bool pendingGStatePop = false;
Change const ref to ref in QSGMaterialRhiShader as per API review Change-Id: I7783ed26a66f03ebe3b26bcba2f42f9fff45a417 Reviewed-by: Lars Knoll <lars.knoll@qt.io> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-09-16 15:44:16 +00:00
updateMaterialStaticData(sms, renderState,
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
material, batch, &pendingGStatePop);
int ubufOffset = 0;
QRhiGraphicsPipeline *ps = nullptr;
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
QRhiGraphicsPipeline *depthPostPassPs = nullptr;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
e = batch->first;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
while (e) {
gn = e->node;
m_current_model_view_matrix = rootMatrix * *gn->matrix();
m_current_determinant = m_current_model_view_matrix.determinant();
m_current_projection_matrix = projectionMatrix();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_current_projection_matrix_native_ndc = projectionMatrixWithNativeNDC();
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (useDepthBuffer()) {
Make it possible to render without a depth buffer. Some GL implementations (especially on embedded) will give us an OpenGL context without a depth buffer. In low memory scenarios, it might also be feasible to request a non-depth buffer context to save the depth buffer memory. The renderer deals with this by treating all nodes as translucent, by not adjusting the shaders and by not creating the extra z-order vertex attribute for merged nodes. Change-Id: I8edc92d530daa3e2628df2ba52901b47d87eaf26 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-01-21 12:28:53 +00:00
m_current_projection_matrix(2, 2) = m_zRange;
m_current_projection_matrix(2, 3) = 1.0f - e->order * m_zRange;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Make QSGMaterialRhiShader become QSGMaterialShader After a symbiotic relationship in Qt 5.14 and 5.15, it is time for QSGMaterialRhiShader to devour its older sibling and take its place. This makes the direct OpenGL rendering path disfunctional. All QSGMaterial Qt 6 TODOs are solved, the API is clean and straightforward again: a QSGMaterial creates a QSGMaterialShader, no special flags and options needed. (it's just that QSGMaterialShader now has a slightly different API) Task-number: QTBUG-79268 Task-number: QTBUG-82997 Change-Id: I545ca8d796c5535e81957c706e7832133be15b7d Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-02 12:27:13 +00:00
QSGMaterialShader::RenderState renderState = state(QSGMaterialShader::RenderState::DirtyStates(int(dirty)));
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
updateMaterialDynamicData(sms, renderState, material, batch, e, ubufOffset, ubufSize);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Verbose fatal instead of crash when the scene graph state is invalid. Change-Id: I9a55bcbf9e94084c0cadac561e4707d47f5f8744 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-07-03 10:15:46 +00:00
#ifndef QT_NO_DEBUG
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (qsg_test_and_clear_material_failure()) {
qDebug("QSGMaterial::updateState() triggered an error (unmerged), batch will be skipped:");
qDebug() << " - offending node is" << e->node;
QSGNodeDumper::dump(rootNode());
qFatal("Aborting: scene graph is invalid...");
return false;
}
Verbose fatal instead of crash when the scene graph state is invalid. Change-Id: I9a55bcbf9e94084c0cadac561e4707d47f5f8744 Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-07-03 10:15:46 +00:00
#endif
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
ubufOffset += aligned(ubufSize, m_ubufAlignment);
const QSGGeometry::DrawingMode prevDrawMode = m_gstate.drawMode;
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
const float prevLineWidth = m_gstate.lineWidth;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
m_gstate.drawMode = QSGGeometry::DrawingMode(g->drawingMode());
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
m_gstate.lineWidth = g->lineWidth();
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// Do not bother even looking up the ps if the topology has not changed
// since everything else is the same for all elements in the batch.
// (except if the material modified blend state)
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
if (!ps || m_gstate.drawMode != prevDrawMode || m_gstate.lineWidth != prevLineWidth || pendingGStatePop) {
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!ensurePipelineState(e, sms)) {
if (pendingGStatePop)
m_gstate = m_gstateStack.pop();
return false;
}
ps = e->ps;
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode == QSGRendererInterface::RenderMode3D) {
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
m_gstateStack.push(m_gstate);
setStateForDepthPostPass();
ensurePipelineState(e, sms, true);
m_gstate = m_gstateStack.pop();
depthPostPassPs = e->depthPostPassPs;
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
} else {
e->ps = ps;
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode == QSGRendererInterface::RenderMode3D)
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
e->depthPostPassPs = depthPostPassPs;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Fix assert with native text rendering. The renderer only passed the very first node's material to updateState() as "new", yet pass the following node's materials to updateState() as "old". This triggered an assert in the QSGTextMaskMaterial's updateState as the native text nodes are invalid until they get called with their own material as "new". This goes against how the scene graph is supposed to be used, but update the code in the renderer regardless as this used to work and the fix there is not wrong. Every node in a batch has identical material, so pass the same instance for both "new" and "old" except for the first node in the batch which gets old==0. Change-Id: Ie8ae6fcd63adde08d80e9083e910836ede6694ee Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-11-06 11:08:42 +00:00
// We don't need to bother with asking each node for its material as they
// are all identical (compare==0) since they are in the same batch.
m_currentMaterial = material;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
// We only need to push this on the very first iteration...
dirty &= ~QSGMaterialShader::RenderState::DirtyOpacity;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
e = e->nextInBatch;
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (pendingGStatePop)
m_gstate = m_gstateStack.pop();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
batch->ubufDataValid = true;
renderBatch->batch = batch;
renderBatch->sms = sms;
return true;
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
void Renderer::renderUnmergedBatch(PreparedRenderBatch *renderBatch, bool depthPostPass)
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
const Batch *batch = renderBatch->batch;
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (!batch->vbo.buf)
return;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
Element *e = batch->first;
if (batch->clipState.type & ClipState::StencilClip)
enqueueStencilDraw(batch);
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 vOffset = 0;
quint32 iOffset = 0;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
QRhiCommandBuffer *cb = commandBuffer();
while (e) {
Fix warning "value assigned to gn is never read" A loop-local variable is often more efficient than a variable at function scope; and avoiding it altogether is more compact. Pick-to: 6.2 Change-Id: Iac88bc433ce640a52a6bd909c708711e294ecc59 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2021-08-17 11:00:21 +00:00
QSGGeometry *g = e->node->geometry();
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
checkLineWidth(g);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const int effectiveIndexSize = m_uint32IndexForRhi ? sizeof(quint32) : g->sizeOfIndex();
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
setGraphicsPipeline(cb, batch, e, depthPostPass);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
const QRhiCommandBuffer::VertexInput vbufBinding(batch->vbo.buf, vOffset);
if (g->indexCount()) {
scenegraph: Make the vertex/index buffer logic more robust Be consistent in handling a failing create(). Do not try to enqueue resource updates if we did not successfully built the buffer. Do not try to render either. With just a few checks we can now fully survive failing all vertex/index buffer creation (i.e. warnings will be printed and nothing will be rendered by Quick, but the application will continue to work). This matches the behavior one gets when the uniform buffer creation fails, that is already robust enough. Pick-to: 6.3 6.2 Fixes: QTBUG-99477 Change-Id: I2ca0f3ada8a7449c5ac1346216a58b06658b5cd5 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-01-03 16:51:34 +00:00
if (batch->ibo.buf) {
cb->setVertexInput(VERTEX_BUFFER_BINDING, 1, &vbufBinding,
batch->ibo.buf, iOffset,
effectiveIndexSize == sizeof(quint32) ? QRhiCommandBuffer::IndexUInt32
: QRhiCommandBuffer::IndexUInt16);
cb->drawIndexed(g->indexCount());
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
} else {
cb->setVertexInput(VERTEX_BUFFER_BINDING, 1, &vbufBinding);
cb->draw(g->vertexCount());
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
vOffset += g->sizeOfVertex() * g->vertexCount();
iOffset += g->indexCount() * effectiveIndexSize;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
e = e->nextInBatch;
}
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
void Renderer::setGraphicsPipeline(QRhiCommandBuffer *cb, const Batch *batch, Element *e, bool depthPostPass)
Support QSGGeometry::lineWidth also in the batched code path. Change-Id: Ifc664b9c718744b9549953e42ac3450a88403dea Task-number: QTBUG-47090 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-08-11 16:33:01 +00:00
{
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
cb->setGraphicsPipeline(depthPostPass ? e->depthPostPassPs : e->ps);
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (!m_pstate.viewportSet) {
m_pstate.viewportSet = true;
cb->setViewport(m_pstate.viewport);
}
if (batch->clipState.type & ClipState::ScissorClip) {
Q_ASSERT(e->ps->flags().testFlag(QRhiGraphicsPipeline::UsesScissor));
m_pstate.scissorSet = true;
cb->setScissor(batch->clipState.scissor);
} else {
Q_ASSERT(!e->ps->flags().testFlag(QRhiGraphicsPipeline::UsesScissor));
// Regardless of the ps not using scissor, the scissor may need to be
// reset, depending on the backend. So set the viewport again, which in
// turn also sets the scissor on backends where a scissor rect is
// always-on (Vulkan).
if (m_pstate.scissorSet) {
m_pstate.scissorSet = false;
cb->setViewport(m_pstate.viewport);
Use the GL context shared in the render context .. instead of calling QOpenGLContext::currentContext(), which in turn accesses the thread-local storage. Change-Id: I773686deb2a745e066b0878a6ccb087afb81774d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io> Reviewed-by: Tuukka Turunen <tuukka.turunen@qt.io>
2018-01-18 13:42:41 +00:00
}
Support QSGGeometry::lineWidth also in the batched code path. Change-Id: Ifc664b9c718744b9549953e42ac3450a88403dea Task-number: QTBUG-47090 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-08-11 16:33:01 +00:00
}
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
if (batch->clipState.type & ClipState::StencilClip) {
Q_ASSERT(e->ps->flags().testFlag(QRhiGraphicsPipeline::UsesStencilRef));
cb->setStencilRef(batch->clipState.stencilRef);
}
Prevent Vulkan validation warning in 3D mode with text Setting a dynamic state on the command buffer is an error if the pipeline was not created with the appropriate flag. In the depth post pass the pipeline's flags do not reflect the modifications from the materials' updateGraphicsPipeline(). So we should not set the appropriate dynamic state either. (blending has no relevance for the depth output anyway) Change-Id: Ifedae1f5175ac4f1905dec4b7a5c305417234808 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-09 17:51:12 +00:00
if (!depthPostPass && e->ps->flags().testFlag(QRhiGraphicsPipeline::UsesBlendConstants))
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
cb->setBlendConstants(batch->blendConstant);
cb->setShaderResources(e->srb);
Support QSGGeometry::lineWidth also in the batched code path. Change-Id: Ifc664b9c718744b9549953e42ac3450a88403dea Task-number: QTBUG-47090 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-08-11 16:33:01 +00:00
}
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
void Renderer::releaseElement(Element *e, bool inDestructor)
{
if (e->isRenderNode) {
delete static_cast<RenderNodeElement *>(e);
} else {
if (e->srb) {
if (!inDestructor) {
if (m_shaderManager->srbPool.count() < m_srbPoolThreshold)
m_shaderManager->srbPool.insert(e->srb->serializedLayoutDescription(), e->srb);
else
delete e->srb;
} else {
delete e->srb;
}
e->srb = nullptr;
}
m_elementAllocator.release(e);
}
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
void Renderer::deleteRemovedElements()
{
if (!m_elementsToDelete.size())
return;
for (int i=0; i<m_opaqueRenderList.size(); ++i) {
Element **e = m_opaqueRenderList.data() + i;
if (*e && (*e)->removed)
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
*e = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
for (int i=0; i<m_alphaRenderList.size(); ++i) {
Element **e = m_alphaRenderList.data() + i;
if (*e && (*e)->removed)
use nullptr consistently (clang-tidy) From now on we prefer nullptr instead of 0 to clarify cases where we are assigning or testing a pointer rather than a numeric zero. Also, replaced cases where 0 was passed as Qt::KeyboardModifiers with Qt::NoModifier (clang-tidy replaced them with nullptr, which waas wrong, so it was just as well to make the tests more readable rather than to revert those lines). Change-Id: I4735d35e4d9f42db5216862ce091429eadc6e65d Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2018-02-21 09:41:54 +00:00
*e = nullptr;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
for (int i=0; i<m_elementsToDelete.size(); ++i)
releaseElement(m_elementsToDelete.at(i));
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_elementsToDelete.reset();
}
void Renderer::render()
{
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
// Gracefully handle the lack of a render target - some autotests may rely
// on this in odd cases.
scenegraph: Remove beginNext[Rhi]Frame differentiation One set of functions is enough, no need for a separate set of "Rhi" ones. Change-Id: I58600c539734d5f8a767926eb9649d9968bab08a Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2022-04-19 11:01:42 +00:00
if (!renderTarget().rt)
Remove OpenGL FBO references in QQuickWindow and the renderer API setRenderTarget(GLuint), setRenderTarget(QQuickFramebufferObject*), renderScene(uint fboId), QSGBindable, etc. are now removed. This leads to a simpler and cleaner interface in QSGAbstractRenderer and QSGRenderer because the somewhat weird renderScene() overloading (where one version is virtual, while the other isn't) is now avoided, with just a single renderScene() virtual now. Task-number: QTBUG-84040 Change-Id: I0ce5a159a557688bdfcb7cacf8a9d12d6fd970d1 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 16:25:23 +00:00
return;
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
prepareRenderPass(&m_mainRenderPassContext);
beginRenderPass(&m_mainRenderPassContext);
recordRenderPass(&m_mainRenderPassContext);
endRenderPass(&m_mainRenderPassContext);
}
// An alternative to render() is to call prepareInline() and renderInline() at
// the appropriate times (i.e. outside of a QRhi::beginPass() and then inside,
// respectively) These allow rendering within a render pass that is started by
// another component. In contrast, render() records a full render pass on its
// own.
void Renderer::prepareInline()
{
prepareRenderPass(&m_mainRenderPassContext);
}
void Renderer::renderInline()
{
recordRenderPass(&m_mainRenderPassContext);
}
void Renderer::prepareRenderPass(RenderPassContext *ctx)
{
if (ctx->valid)
qWarning("prepareRenderPass() called with an already prepared render pass context");
ctx->valid = true;
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_dump())) {
Use qDebug for all debug under src/quick/scenegraph. Mixing printf and qDebug can make the output come out of sync. Change-Id: Ia71e71b09cb3bf651010eb2eb652db7899b07f0d Reviewed-by: Robin Burchell <robin+qt@viroteck.net>
2014-01-07 10:10:59 +00:00
qDebug("\n");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QSGNodeDumper::dump(rootNode());
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
ctx->timeRenderLists = 0;
ctx->timePrepareOpaque = 0;
ctx->timePrepareAlpha = 0;
ctx->timeSorting = 0;
ctx->timeUploadOpaque = 0;
ctx->timeUploadAlpha = 0;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
if (Q_UNLIKELY(debug_render() || debug_build())) {
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
QByteArray type("rebuild:");
if (m_rebuild == 0)
type += " none";
if (m_rebuild == FullRebuild)
type += " full";
else {
if (m_rebuild & BuildRenderLists)
type += " renderlists";
else if (m_rebuild & BuildRenderListsForTaggedRoots)
type += " partial";
else if (m_rebuild & BuildBatches)
type += " batches";
}
qDebug() << "Renderer::render()" << this << type;
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
ctx->timer.start();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
m_resourceUpdates = m_rhi->nextResourceUpdateBatch();
Move VAO binding to Renderer::render() Amongst other things, QSGRenderer::preprocess() triggers the rendering of QQuickShaderEffectSource items into framebuffer objects. The renderers responsible for these QQuickShaderEffectSource items bind and unbind their own VAOs, which messes up the VAO state set in QSGRenderer::preprocess(). Scenegraph nodes must not depend on the vao state set by the renderer anyway as the binding has to be considered as an implementation detail. Change-Id: Idec34c65397394e12e7f8419a1c9633d5f70a22e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2015-01-29 16:18:49 +00:00
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
if (m_rebuild & (BuildRenderLists | BuildRenderListsForTaggedRoots)) {
bool complete = (m_rebuild & BuildRenderLists) != 0;
if (complete)
buildRenderListsFromScratch();
else
buildRenderListsForTaggedRoots();
m_rebuild |= BuildBatches;
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_build())) {
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("Opaque render lists %s:", (complete ? "(complete)" : "(partial)"));
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<m_opaqueRenderList.size(); ++i) {
Element *e = m_opaqueRenderList.at(i);
qDebug() << " - element:" << e << " batch:" << e->batch << " node:" << e->node << " order:" << e->order;
}
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("Alpha render list %s:", complete ? "(complete)" : "(partial)");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<m_alphaRenderList.size(); ++i) {
Element *e = m_alphaRenderList.at(i);
qDebug() << " - element:" << e << " batch:" << e->batch << " node:" << e->node << " order:" << e->order;
}
}
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timeRenderLists = ctx->timer.restart();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<m_opaqueBatches.size(); ++i)
m_opaqueBatches.at(i)->cleanupRemovedElements();
for (int i=0; i<m_alphaBatches.size(); ++i)
m_alphaBatches.at(i)->cleanupRemovedElements();
deleteRemovedElements();
cleanupBatches(&m_opaqueBatches);
cleanupBatches(&m_alphaBatches);
if (m_rebuild & BuildBatches) {
prepareOpaqueBatches();
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timePrepareOpaque = ctx->timer.restart();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
prepareAlphaBatches();
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timePrepareAlpha = ctx->timer.restart();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Don't do qgetenv on library load Bad for two reasons: first, it increases the load time of the application and second, it makes it impossible to to setenv/putenv from main(). The latter is useful if you need to work on an embedded device that doesn't allow setting environment variables. Change-Id: Id543f77336d7ac2e4ea820b51f55ce5a40a33b4e Reviewed-by: Gunnar Sletta <gunnar@sletta.org>
2014-09-16 22:20:53 +00:00
if (Q_UNLIKELY(debug_build())) {
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("Opaque Batches:");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<m_opaqueBatches.size(); ++i) {
Batch *b = m_opaqueBatches.at(i);
qDebug() << " - Batch " << i << b << (b->needsUpload ? "upload" : "") << " root:" << b->root;
for (Element *e = b->first; e; e = e->nextInBatch) {
qDebug() << " - element:" << e << " node:" << e->node << e->order;
}
}
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
qDebug("Alpha Batches:");
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
for (int i=0; i<m_alphaBatches.size(); ++i) {
Batch *b = m_alphaBatches.at(i);
qDebug() << " - Batch " << i << b << (b->needsUpload ? "upload" : "") << " root:" << b->root;
for (Element *e = b->first; e; e = e->nextInBatch) {
qDebug() << " - element:" << e << e->bounds << " node:" << e->node << " order:" << e->order;
}
}
}
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
} else {
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timePrepareOpaque = ctx->timePrepareAlpha = ctx->timer.restart();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
deleteRemovedElements();
Don't sort batches when there are no changes. On node removal we change the batch, but don't set rebuild as everything else should be drawn as is. A sort after such a removal could result on the order of batches being changed without the other nodes being updated. This would then result in incorrect ordering and nodes could be obscured. Task-number: QTBUG-37222 Change-Id: I57dd2fbc945e8c10c949743f59315b3372a4b6f4 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-04 14:30:29 +00:00
if (m_rebuild != 0) {
// Then sort opaque batches so that we're drawing the batches with the highest
// order first, maximizing the benefit of front-to-back z-ordering.
if (m_opaqueBatches.size())
std::sort(&m_opaqueBatches.first(), &m_opaqueBatches.last() + 1, qsg_sort_batch_decreasing_order);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Don't sort batches when there are no changes. On node removal we change the batch, but don't set rebuild as everything else should be drawn as is. A sort after such a removal could result on the order of batches being changed without the other nodes being updated. This would then result in incorrect ordering and nodes could be obscured. Task-number: QTBUG-37222 Change-Id: I57dd2fbc945e8c10c949743f59315b3372a4b6f4 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-04 14:30:29 +00:00
// Sort alpha batches back to front so that they render correctly.
if (m_alphaBatches.size())
std::sort(&m_alphaBatches.first(), &m_alphaBatches.last() + 1, qsg_sort_batch_increasing_order);
Avoid div-by-zero when nothing is rendered. Change-Id: I3eb57baf1812f831335429cc7d2b4424f3cfa785 Task-number: QTBUG-50929 Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2016-02-15 07:02:50 +00:00
m_zRange = m_nextRenderOrder != 0
? 1.0 / (m_nextRenderOrder)
: 0;
Don't sort batches when there are no changes. On node removal we change the batch, but don't set rebuild as everything else should be drawn as is. A sort after such a removal could result on the order of batches being changed without the other nodes being updated. This would then result in incorrect ordering and nodes could be obscured. Task-number: QTBUG-37222 Change-Id: I57dd2fbc945e8c10c949743f59315b3372a4b6f4 Reviewed-by: Michael Brasser <michael.brasser@live.com>
2014-03-04 14:30:29 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timeSorting = ctx->timer.restart();
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
quint32 largestVBO = 0;
quint32 largestIBO = 0;
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
if (Q_UNLIKELY(debug_upload())) qDebug("Uploading Opaque Batches:");
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
for (int i=0; i<m_opaqueBatches.size(); ++i) {
Batch *b = m_opaqueBatches.at(i);
largestVBO = qMax(b->vbo.size, largestVBO);
largestIBO = qMax(b->ibo.size, largestIBO);
uploadBatch(b);
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timeUploadOpaque = ctx->timer.restart();
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
ScenGraph: Prefer printf style logging This generates more compact code, saving 20480 bytes on disk (Linux 64 bit, release build). Change-Id: I73d6d88b7b61b87a5d714e131fcf86ee80c83f38 Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
2018-02-13 08:57:29 +00:00
if (Q_UNLIKELY(debug_upload())) qDebug("Uploading Alpha Batches:");
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
for (int i=0; i<m_alphaBatches.size(); ++i) {
Batch *b = m_alphaBatches.at(i);
uploadBatch(b);
largestVBO = qMax(b->vbo.size, largestVBO);
largestIBO = qMax(b->ibo.size, largestIBO);
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (Q_UNLIKELY(debug_render())) ctx->timeUploadAlpha = ctx->timer.restart();
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
if (largestVBO * 2 < quint32(m_vertexUploadPool.size()))
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
m_vertexUploadPool.resize(largestVBO * 2);
Follow QRhi API cleanups int was used a bit too liberally, even in places where the QRhi API already took a quint32. More importantly, eliminate some signed-unsigned mismatches that occur now that the QRhi API is fixed up to consistently use the correct types. Change-Id: I02773d005c8fe6d9e6d1cfebb617d40447d7ef6c Reviewed-by: Ulf Hermann <ulf.hermann@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-07-08 08:15:58 +00:00
if (largestIBO * 2 < quint32(m_indexUploadPool.size()))
Reuse the memory we use for vertex uploads. Every batch would have its own buffer with its own memory and the original idea was that it would stabilize so that the same batch would be used over and over, so the memory allocatd for each batch's buffer would be reused. In practice batches get discarded and recycled in somewhat arbitrary order so we always end up reallocating. Instead, use a single buffer for all uploads. This saves us several reallocations per frame, and also prevents pooling of several potentially large allocated blocks inside the renderer. The exception is when using visualization or for drivers which have broken index buffer support (nouveau only currently), where we keep the existing behavior as the buffer data is needed during rendering and visualization. Change-Id: Id29095e00128ec1ee6d4ac3caa8f2c17cc7bbd27 Reviewed-by: Robin Burchell <robin.burchell@viroteck.net>
2015-01-06 07:40:21 +00:00
m_indexUploadPool.resize(largestIBO * 2);
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
if (Q_UNLIKELY(debug_render())) {
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
qDebug().nospace() << "Rendering:" << Qt::endl
<< " -> Opaque: " << qsg_countNodesInBatches(m_opaqueBatches) << " nodes in " << m_opaqueBatches.size() << " batches..." << Qt::endl
<< " -> Alpha: " << qsg_countNodesInBatches(m_alphaBatches) << " nodes in " << m_alphaBatches.size() << " batches...";
}
m_current_opacity = 1;
m_currentMaterial = nullptr;
m_currentShader = nullptr;
m_currentProgram = nullptr;
m_currentClipState.reset();
const QRect viewport = viewportRect();
bool renderOpaque = !debug_noopaque();
bool renderAlpha = !debug_noalpha();
m_pstate.viewport = QRhiViewport(viewport.x(), deviceRect().bottom() - viewport.bottom(), viewport.width(), viewport.height());
m_pstate.clearColor = clearColor();
m_pstate.dsClear = QRhiDepthStencilClearValue(1.0f, 0);
m_pstate.viewportSet = false;
m_pstate.scissorSet = false;
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
m_gstate.depthTest = useDepthBuffer();
m_gstate.depthWrite = useDepthBuffer();
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
m_gstate.depthFunc = QRhiGraphicsPipeline::Less;
m_gstate.blending = false;
m_gstate.cullMode = QRhiGraphicsPipeline::None;
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
m_gstate.polygonMode = QRhiGraphicsPipeline::Fill;
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
m_gstate.colorWrite = QRhiGraphicsPipeline::R
| QRhiGraphicsPipeline::G
| QRhiGraphicsPipeline::B
| QRhiGraphicsPipeline::A;
m_gstate.usesScissor = false;
m_gstate.stencilTest = false;
scenegraph: Remove beginNext[Rhi]Frame differentiation One set of functions is enough, no need for a separate set of "Rhi" ones. Change-Id: I58600c539734d5f8a767926eb9649d9968bab08a Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2022-04-19 11:01:42 +00:00
m_gstate.sampleCount = renderTarget().rt->sampleCount();
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
ctx->opaqueRenderBatches.clear();
if (Q_LIKELY(renderOpaque)) {
for (int i = 0, ie = m_opaqueBatches.size(); i != ie; ++i) {
Batch *b = m_opaqueBatches.at(i);
PreparedRenderBatch renderBatch;
bool ok;
if (b->merged)
ok = prepareRenderMergedBatch(b, &renderBatch);
else
ok = prepareRenderUnmergedBatch(b, &renderBatch);
if (ok)
ctx->opaqueRenderBatches.append(renderBatch);
}
}
m_gstate.blending = true;
// factors never change, always set for premultiplied alpha based blending
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
// depth test stays enabled (if useDepthBuffer(), that is) but no need
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
// to write out depth from the transparent (back-to-front) pass
m_gstate.depthWrite = false;
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
// special case: the 3D plane mode tests against the depth buffer, but does
// not write (and all batches are alpha because this render mode evaluates
// to useDepthBuffer()==false)
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode == QSGRendererInterface::RenderMode3D) {
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
Q_ASSERT(m_opaqueBatches.isEmpty());
m_gstate.depthTest = true;
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
ctx->alphaRenderBatches.clear();
if (Q_LIKELY(renderAlpha)) {
for (int i = 0, ie = m_alphaBatches.size(); i != ie; ++i) {
Batch *b = m_alphaBatches.at(i);
PreparedRenderBatch renderBatch;
bool ok;
if (b->merged)
ok = prepareRenderMergedBatch(b, &renderBatch);
else if (b->isRenderNode)
ok = prepareRhiRenderNode(b, &renderBatch);
else
ok = prepareRenderUnmergedBatch(b, &renderBatch);
if (ok)
ctx->alphaRenderBatches.append(renderBatch);
}
Add some timing breakdown to QSG_RENDERER_DEBUG=render Change-Id: Ic7ffb48c1a148036bdb14a912d3407e9a1b3b4fd Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
2015-04-23 12:00:04 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
m_rebuild = 0;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#if defined(QSGBATCHRENDERER_INVALIDATE_WEDGED_NODES)
Invalidate all batches potentially affected by a change. When two separate changes have occurred, we need to not only invalidate the batches directly overlapping those, but also any batch which has render orders between the two. So, keep track of the range of invalidated render orders and invalidate everything in between. Task-number: QTBUG-37422 Change-Id: Ie5a289d5c569b84917ec9ac52671173c566e69b3 Reviewed-by: Laszlo Agocs <laszlo.agocs@digia.com>
2014-03-19 10:58:04 +00:00
m_renderOrderRebuildLower = -1;
m_renderOrderRebuildUpper = -1;
Don't invalidate unaffected render orders If you have a list of render orders A, B, C, then A and C changes, we also invalidated B. This was to avoid the situation where B was ignored by the batching algorithm and A and C would end up being batched together. This has a performance impact for some scenes though, where you might have top level and bottom level items that constantly change, causing all geometry in the scene to be uploaded every frame. Instead of doing this, we skip invalidation of B, but include its bounding rect when checking for overlaps, so that we still avoid batching A and C together but without the need to re-upload B. Fixes: QTBUG-90632 Pick-to: 6.1 Change-Id: I462cf1938360643ca9fa1425ae8c8e08b534fd76 Reviewed-by: Andy Nichols <andy.nichols@qt.io> Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io> Reviewed-by: Michael Brasser <michael.brasser@live.com>
2021-02-12 06:43:22 +00:00
#endif
Adapt Qt Quick 2 renderer to work with OpenGL Core Profile The basic approach is to have the batched renderer create and bind a vertex array object if it detects we are using an OpenGL Core profile context. The VAO is bound for the duration of the QQ2 renderer's work cycle and unbound at the end so as to not interfere with any other VAO's a user may wish to use. All shaders have been copied and ported to be compliant with the GLSL 150 core specification which is the minimum for a Core profile context (OpenGL 3.2 Core). We are not using any newer features as yet so this will work anywhere we can get a Core profile context. The QSGShaderSourceBuilder class has been extended to resolve any requests for shaders to the same basefilename with "_core" appended prior to any file extension. This could be extended in the future to allow version, or GPU or platform specific shaders. The QSGShaderSourceBuilder has also been extended to allow it to insert #define definitions in the prologue of a shader. Any such definition is inserted: * After the last #extension directive (if any are found) * Otherwise after the #version directive (if found) * Otherwise at the start of the shader source This is required by the custom particle shaders which make extensive use of such #defines. In addition the mechanism used by the distance field glyph cache to extend the cache with new glyphs has been modified to work (and work more efficiently) when using a Core profile context. Rather than using a shader program and a buffer filling quad to blit the old texture into the new cache texture, we instead use the technique of framebuffer blitting. The existing fallback implementation using glTexSubImage2D() is still available if needed. The DECLARATIVE_EXAMPLE_MAIN macro has been extended to allow easy testing of any of the QtDeclarative examples with a core profile context. Just run the example with QT_QUICK_CORE_PROFILE=1 ./text for e.g. The only ones that may not work out of the box are those that provide GLSL shader source e.g. the customparticles or shader effect examples. These work fine if the shader source is adapted to GLSL 150 core. In the future it may be a good idea to expose some context property to QML that the user can use to determine what shader source variation to provide to Qt Quick. Along these lines it would also be very nice to allow the provision of shader source to ShaderEffect or CustomParticle from a separate source file just as we now do within Qt Quick. Task-number: QTBUG-32050 Change-Id: Ia6e9f06dbb8508af9ae03c6b60fb418b4cc9e41f Reviewed-by: Lars Knoll <lars.knoll@digia.com>
2013-11-06 13:07:58 +00:00
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
if (m_visualizer->mode() != Visualizer::VisualizeNothing)
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
m_visualizer->prepareVisualize();
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
commandBuffer()->resourceUpdate(m_resourceUpdates);
m_resourceUpdates = nullptr;
}
void Renderer::beginRenderPass(RenderPassContext *)
{
scenegraph: Remove beginNext[Rhi]Frame differentiation One set of functions is enough, no need for a separate set of "Rhi" ones. Change-Id: I58600c539734d5f8a767926eb9649d9968bab08a Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2022-04-19 11:01:42 +00:00
commandBuffer()->beginPass(renderTarget().rt, m_pstate.clearColor, m_pstate.dsClear, nullptr,
Follow rhi per-frame to per-pass flag change Change-Id: I728cecd85807eb835703a0bb8bb4acdb1f2068ae Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-09-30 13:44:49 +00:00
// we cannot tell if the application will have
// native rendering thrown in to this pass
// (QQuickWindow::beginExternalCommands()), so
// we have no choice but to set the flag always
// (thus triggering using secondary command
// buffers with Vulkan)
QRhiCommandBuffer::ExternalContent);
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (m_renderPassRecordingCallbacks.start)
m_renderPassRecordingCallbacks.start(m_renderPassRecordingCallbacks.userData);
}
void Renderer::recordRenderPass(RenderPassContext *ctx)
{
// prepareRenderPass and recordRenderPass must always be called together.
// They are separate because beginRenderPass and endRenderPass are optional.
//
// The valid call sequence are therefore:
// prepare, begin, record, end
// or
// prepare, record
if (!ctx->valid)
qWarning("recordRenderPass() called without a prepared render pass context");
ctx->valid = false;
QRhiCommandBuffer *cb = commandBuffer();
cb->debugMarkBegin(QByteArrayLiteral("Qt Quick scene render"));
for (int i = 0, ie = ctx->opaqueRenderBatches.count(); i != ie; ++i) {
PreparedRenderBatch *renderBatch = &ctx->opaqueRenderBatches[i];
if (renderBatch->batch->merged)
renderMergedBatch(renderBatch);
else
renderUnmergedBatch(renderBatch);
}
for (int i = 0, ie = ctx->alphaRenderBatches.count(); i != ie; ++i) {
PreparedRenderBatch *renderBatch = &ctx->alphaRenderBatches[i];
if (renderBatch->batch->merged)
renderMergedBatch(renderBatch);
else if (renderBatch->batch->isRenderNode)
renderRhiRenderNode(renderBatch->batch);
else
renderUnmergedBatch(renderBatch);
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode == QSGRendererInterface::RenderMode3D) {
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
// depth post-pass
for (int i = 0, ie = ctx->alphaRenderBatches.count(); i != ie; ++i) {
PreparedRenderBatch *renderBatch = &ctx->alphaRenderBatches[i];
if (renderBatch->batch->merged)
renderMergedBatch(renderBatch, true);
else if (!renderBatch->batch->isRenderNode) // rendernodes are skipped here for now
renderUnmergedBatch(renderBatch, true);
}
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
if (m_currentShader)
setActiveRhiShader(nullptr, nullptr);
cb->debugMarkEnd();
if (Q_UNLIKELY(debug_render())) {
qDebug(" -> times: build: %d, prepare(opaque/alpha): %d/%d, sorting: %d, upload(opaque/alpha): %d/%d, record rendering: %d",
(int) ctx->timeRenderLists,
(int) ctx->timePrepareOpaque, (int) ctx->timePrepareAlpha,
(int) ctx->timeSorting,
(int) ctx->timeUploadOpaque, (int) ctx->timeUploadAlpha,
(int) ctx->timer.elapsed());
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Enable invoking the scenegraph rendering without a full render pass Split the monolithic render() and renderBatches() into four steps (prepare, begin-pass, render, end-pass), of which two are optional. The behavior of the batch renderer's render() (the entry point when rendering a Qt Quick scene normally) remains unchanged: it just calls prepare, beginPass, render, endPass which together should boil down to exactly what the monolithic implementation was doing before. However, we can now also support recording rendering of the 2D scene as part of a render pass that is started by something else (e.g. the 3D scene). To enable this, the renderer interface gets prepareInline() and renderInline() virtuals that are only implemented by the batch renderer (and are no-ops by default). These are complemented by prepareSceneLine() and renderSceneInline() which are public (as in the class, not API-wise), like renderScene(). The former does preprocess() and triggers the internal prepareInline(), whereas renderSceneLine() is where renderInline() is called from. The rendercontext has no corresponding wrappers since one can just directly call these on the QSGRenderer. Change-Id: Iddfcec6970bad2bc73e6e8af19fe95d16c6ac9e5 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-22 12:14:13 +00:00
void Renderer::endRenderPass(RenderPassContext *)
{
if (m_renderPassRecordingCallbacks.end)
m_renderPassRecordingCallbacks.end(m_renderPassRecordingCallbacks.userData);
if (m_visualizer->mode() != Visualizer::VisualizeNothing)
m_visualizer->visualize();
commandBuffer()->endPass();
}
Make rendernode suitable for public consumption For non-OpenGL APIs the primary (and likely the only) way to add custom rendering into the Qt Quick scene is via the render node. Other approaches,like the before/afterRendering signals, QQuickFramebufferObject, remain OpenGL-only. (although QQuickFramebufferObject may get a multi-API replacement based on QSGRenderNode at a later time) Note that this is not a generic 3D content integration enabler. It targets creating 2D and 2.5D Quick items with custom rendering via the graphics API in use. Make QSGRenderNode public, enhance the docs a bit and add a releaseResources(). Add a QSGRendererInterface with a query function in QQuickWindow and QSGEngine. The scenegraph adaptation can then return a custom implementation of the interface. This will be necessary to query API-specific values, f.ex. the ID3D12Device and ID3D12CommandList when running with the d3d12 backend. The interface allows querying the API and void* resources. Resources that we know about in advance are enum-based to prevent the QPlatformNativeInterface-like ugliness of string keys. Support is there in the batch renderer already, fix this up according to the new public API, and implement the corresponding bits for the D3D12 renderer. For D3D12, fix also an issue with QSGNode destruction where graphics resources in use were attempted to be final-released without a proper wait. The semantics of changedStates() in QSGRenderNode is changed so that it can be called at any time, including before render(). This is very useful since we can implement some state restoring in a more efficient manner. Added a new example as well. Documentation for QSGRenderNode is heavily expanded. Change-Id: I4c4a261c55791d0e38743a784bc4c05a53b3462d Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-04-13 10:33:00 +00:00
struct RenderNodeState : public QSGRenderNode::RenderState
{
const QMatrix4x4 *projectionMatrix() const override { return m_projectionMatrix; }
Fix "inconsistent use of override" warnings If one overriding virtual method is marked as such, all of them should be marked. Change-Id: I29a19d2196a7f1afbb31fba8a4a6f2b345489e3c Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2016-07-05 08:27:19 +00:00
QRect scissorRect() const override { return m_scissorRect; }
bool scissorEnabled() const override { return m_scissorEnabled; }
int stencilValue() const override { return m_stencilValue; }
bool stencilEnabled() const override { return m_stencilEnabled; }
software: Add support for QSGRenderNode Have to change getResource() a bit since it turns out it is not suitable currently for backends that do not have a per-window rendercontext and do not implement the interface on the rendercontext. Pass in the window to make sure it can always figure out which window we want the resources for. (we do not want rendererInterface() to return window-specific instances created on the fly, with ownership issues, so stick with the simple model where backends implement the interface on one of their existing classes) To support clipping, QSGRenderNode::RenderState is extended accordingly. Also updated the docs since some claims in the rendernode docs are not true since Qt 5.3. Change-Id: I34779c83926f5231b888fcab7131e873ae97964f Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-07-15 11:43:08 +00:00
const QRegion *clipRegion() const override { return nullptr; }
Make rendernode suitable for public consumption For non-OpenGL APIs the primary (and likely the only) way to add custom rendering into the Qt Quick scene is via the render node. Other approaches,like the before/afterRendering signals, QQuickFramebufferObject, remain OpenGL-only. (although QQuickFramebufferObject may get a multi-API replacement based on QSGRenderNode at a later time) Note that this is not a generic 3D content integration enabler. It targets creating 2D and 2.5D Quick items with custom rendering via the graphics API in use. Make QSGRenderNode public, enhance the docs a bit and add a releaseResources(). Add a QSGRendererInterface with a query function in QQuickWindow and QSGEngine. The scenegraph adaptation can then return a custom implementation of the interface. This will be necessary to query API-specific values, f.ex. the ID3D12Device and ID3D12CommandList when running with the d3d12 backend. The interface allows querying the API and void* resources. Resources that we know about in advance are enum-based to prevent the QPlatformNativeInterface-like ugliness of string keys. Support is there in the batch renderer already, fix this up according to the new public API, and implement the corresponding bits for the D3D12 renderer. For D3D12, fix also an issue with QSGNode destruction where graphics resources in use were attempted to be final-released without a proper wait. The semantics of changedStates() in QSGRenderNode is changed so that it can be called at any time, including before render(). This is very useful since we can implement some state restoring in a more efficient manner. Added a new example as well. Documentation for QSGRenderNode is heavily expanded. Change-Id: I4c4a261c55791d0e38743a784bc4c05a53b3462d Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-04-13 10:33:00 +00:00
const QMatrix4x4 *m_projectionMatrix;
QRect m_scissorRect;
int m_stencilValue;
QSG: prevent in-struct padding This also shrinks the class by a tiny bit, because the second bool fits inside the padding that was added to the first bool. Change-Id: Ifb3f3f165c5e1666e2787118de5b5fb579a573b9 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2016-07-05 08:30:01 +00:00
bool m_scissorEnabled;
Make rendernode suitable for public consumption For non-OpenGL APIs the primary (and likely the only) way to add custom rendering into the Qt Quick scene is via the render node. Other approaches,like the before/afterRendering signals, QQuickFramebufferObject, remain OpenGL-only. (although QQuickFramebufferObject may get a multi-API replacement based on QSGRenderNode at a later time) Note that this is not a generic 3D content integration enabler. It targets creating 2D and 2.5D Quick items with custom rendering via the graphics API in use. Make QSGRenderNode public, enhance the docs a bit and add a releaseResources(). Add a QSGRendererInterface with a query function in QQuickWindow and QSGEngine. The scenegraph adaptation can then return a custom implementation of the interface. This will be necessary to query API-specific values, f.ex. the ID3D12Device and ID3D12CommandList when running with the d3d12 backend. The interface allows querying the API and void* resources. Resources that we know about in advance are enum-based to prevent the QPlatformNativeInterface-like ugliness of string keys. Support is there in the batch renderer already, fix this up according to the new public API, and implement the corresponding bits for the D3D12 renderer. For D3D12, fix also an issue with QSGNode destruction where graphics resources in use were attempted to be final-released without a proper wait. The semantics of changedStates() in QSGRenderNode is changed so that it can be called at any time, including before render(). This is very useful since we can implement some state restoring in a more efficient manner. Added a new example as well. Documentation for QSGRenderNode is heavily expanded. Change-Id: I4c4a261c55791d0e38743a784bc4c05a53b3462d Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2016-04-13 10:33:00 +00:00
bool m_stencilEnabled;
};
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
bool Renderer::prepareRhiRenderNode(Batch *batch, PreparedRenderBatch *renderBatch)
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
{
if (Q_UNLIKELY(debug_render()))
qDebug() << " -" << batch << "rendernode";
Q_ASSERT(batch->first->isRenderNode);
RenderNodeElement *e = static_cast<RenderNodeElement *>(batch->first);
setActiveRhiShader(nullptr, nullptr);
QSGRenderNodePrivate *rd = QSGRenderNodePrivate::get(e->renderNode);
rd->m_clip_list = nullptr;
Move QSGRenderContext::RenderMode to QSGRendererInterface We want to be able to use this enum from the public API, so we move it out to a suitable public class. Task-number: QTBUG-84695 Change-Id: I8a3860ecfd0da7990941540bcf39fb0c2bf0ff83 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2020-06-11 10:35:04 +00:00
if (m_renderMode != QSGRendererInterface::RenderMode3D) {
Skip all clipping when render mode is 3D The current assumption is that setting clip: true will have no effect in a scene rendered with RenderMode3D. (2D item tree under a 3D node) Change-Id: I81ca1fcc04c7f4af37a03fd48dc95ea307989e98 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-09 15:06:02 +00:00
QSGNode *clip = e->renderNode->parent();
while (clip != rootNode()) {
if (clip->type() == QSGNode::ClipNodeType) {
rd->m_clip_list = static_cast<QSGClipNode *>(clip);
break;
}
clip = clip->parent();
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
}
Skip all clipping when render mode is 3D The current assumption is that setting clip: true will have no effect in a scene rendered with RenderMode3D. (2D item tree under a 3D node) Change-Id: I81ca1fcc04c7f4af37a03fd48dc95ea307989e98 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-09 15:06:02 +00:00
updateClipState(rd->m_clip_list, batch);
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
}
rhi: Make QSGRenderNode usable in Quick3D Cannot just rely on a render() function, need a point where the "prepare" step can be performed, outside the main renderpass. Also enables proper m_useDepthBuffer handling for the RHI code path. Task-number: QTBUG-82797 Task-number: QTBUG-82793 Change-Id: I525228e53acefad9f2e6a33d446260a1521d8ae1 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-03-10 14:34:13 +00:00
QSGNode *xform = e->renderNode->parent();
QMatrix4x4 matrix;
QSGNode *root = rootNode();
if (e->root) {
matrix = qsg_matrixForRoot(e->root);
root = e->root->sgNode;
}
while (xform != root) {
if (xform->type() == QSGNode::TransformNodeType) {
matrix = matrix * static_cast<QSGTransformNode *>(xform)->combinedMatrix();
break;
}
xform = xform->parent();
}
rd->m_matrix = &matrix;
QSGNode *opacity = e->renderNode->parent();
rd->m_opacity = 1.0;
while (opacity != rootNode()) {
if (opacity->type() == QSGNode::OpacityNodeType) {
rd->m_opacity = static_cast<QSGOpacityNode *>(opacity)->combinedOpacity();
break;
}
opacity = opacity->parent();
}
Move some QSGRenderNodePrivate members Task-number: QTBUG-82997 Change-Id: Icea5ebe2f76cd5714435f17374388c73a5efda6d Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-02 11:05:29 +00:00
e->renderNode->prepare();
rhi: Make QSGRenderNode usable in Quick3D Cannot just rely on a render() function, need a point where the "prepare" step can be performed, outside the main renderpass. Also enables proper m_useDepthBuffer handling for the RHI code path. Task-number: QTBUG-82797 Task-number: QTBUG-82793 Change-Id: I525228e53acefad9f2e6a33d446260a1521d8ae1 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-03-10 14:34:13 +00:00
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
renderBatch->batch = batch;
renderBatch->sms = nullptr;
return true;
}
Remove the direct OpenGL code from the batch renderer Task-number: QTBUG-84026 Task-number: QTBUG-79268 Change-Id: Ie2e738891843d8d4e368fbf5e4aa07cc03236724 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-05-06 12:16:05 +00:00
void Renderer::renderRhiRenderNode(const Batch *batch)
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
{
if (batch->clipState.type & ClipState::StencilClip)
enqueueStencilDraw(batch);
RenderNodeElement *e = static_cast<RenderNodeElement *>(batch->first);
QSGRenderNodePrivate *rd = QSGRenderNodePrivate::get(e->renderNode);
QMatrix4x4 pm = projectionMatrix();
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
if (useDepthBuffer()) {
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
pm(2, 2) = m_zRange;
pm(2, 3) = 1.0f - e->order * m_zRange;
}
RenderNodeState state;
state.m_projectionMatrix = &pm;
const std::array<int, 4> scissor = batch->clipState.scissor.scissor();
state.m_scissorRect = QRect(scissor[0], scissor[1], scissor[2], scissor[3]);
state.m_stencilValue = batch->clipState.stencilRef;
state.m_scissorEnabled = batch->clipState.type & ClipState::ScissorClip;
state.m_stencilEnabled = batch->clipState.type & ClipState::StencilClip;
const QSGRenderNode::StateFlags changes = e->renderNode->changedStates();
QRhiCommandBuffer *cb = commandBuffer();
Move some QSGRenderNodePrivate members Task-number: QTBUG-82997 Change-Id: Icea5ebe2f76cd5714435f17374388c73a5efda6d Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-05-02 11:05:29 +00:00
const bool needsExternal = !e->renderNode->flags().testFlag(QSGRenderNode::NoExternalRendering);
rhi: Make QSGRenderNode usable in Quick3D Cannot just rely on a render() function, need a point where the "prepare" step can be performed, outside the main renderpass. Also enables proper m_useDepthBuffer handling for the RHI code path. Task-number: QTBUG-82797 Task-number: QTBUG-82793 Change-Id: I525228e53acefad9f2e6a33d446260a1521d8ae1 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-03-10 14:34:13 +00:00
if (needsExternal)
cb->beginExternal();
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
e->renderNode->render(&state);
rhi: Make QSGRenderNode usable in Quick3D Cannot just rely on a render() function, need a point where the "prepare" step can be performed, outside the main renderpass. Also enables proper m_useDepthBuffer handling for the RHI code path. Task-number: QTBUG-82797 Task-number: QTBUG-82793 Change-Id: I525228e53acefad9f2e6a33d446260a1521d8ae1 Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>
2020-03-10 14:34:13 +00:00
if (needsExternal)
cb->endExternal();
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
rd->m_matrix = nullptr;
rd->m_clip_list = nullptr;
rendernode example: Add support for Metal Plus clarify QQuickWindow::begin/endExternalCommands() in combination with QSGRenderNode in the docs. As the example demonstrates, calling these functions is not necessary within render() of a render node. Also fix an issue with resetting the scissor in the renderer after calling render() of a QSGRenderNode. Change-Id: If8c2dab38d62aa444266d37901f062a51e767f68 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-16 12:21:15 +00:00
if ((changes & QSGRenderNode::ViewportState)
|| (changes & QSGRenderNode::ScissorState))
{
// Reset both flags if either is reported as changed, since with the rhi
// it could be setViewport() that will record the resetting of the scissor.
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
m_pstate.viewportSet = false;
m_pstate.scissorSet = false;
rendernode example: Add support for Metal Plus clarify QQuickWindow::begin/endExternalCommands() in combination with QSGRenderNode in the docs. As the example demonstrates, calling these functions is not necessary within render() of a render node. Also fix an issue with resetting the scissor in the renderer after calling render() of a QSGRenderNode. Change-Id: If8c2dab38d62aa444266d37901f062a51e767f68 Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-16 12:21:15 +00:00
}
Implement QSGRenderNode for the rhi path The documentation is also refined and extended. Revise the rendernode example as well: make it possible to test and demonstrate both scissor and stencil based clipping. An implementation of the triangle for another graphics API should follow in a separate patch at a later point. For now only OpenGL is supported in combination with the RHI. Change-Id: I7ef9f6c6e0b44f1bdf44c9266ea3fa4736367a5d Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2019-08-07 13:27:24 +00:00
// Do not bother with RenderTargetState. Where applicable, endExternal()
// ensures the correct target is rebound. For others (like Vulkan) it makes
// no sense since render() could not possibly do that on our command buffer
// which is in renderpass recording state.
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
void Renderer::setVisualizationMode(const QByteArray &mode)
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
{
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
if (mode.isEmpty())
m_visualizer->setMode(Visualizer::VisualizeNothing);
else if (mode == "clip")
m_visualizer->setMode(Visualizer::VisualizeClipping);
else if (mode == "overdraw")
m_visualizer->setMode(Visualizer::VisualizeOverdraw);
else if (mode == "batches")
m_visualizer->setMode(Visualizer::VisualizeBatches);
else if (mode == "changes")
m_visualizer->setMode(Visualizer::VisualizeChanges);
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
}
Add perspective 3D plane render mode One can now do rc->createRenderer(QSGRenderContext::RenderMode3D) in Quick3D. By default nothing changes, both QQuickWindow and QSGRhiLayer default to either RenderMode2D or RenderMode2DNoDepthBuffer, depending on QSG_NO_DEPTH_BUFFER. (the environment variable handling is moved out of qsgbatchrenderer.cpp however, leaving it up to whoever is creating the renderer to passing the appropriate flag) The RenderMode3D mode is a modified version of the QSG_NO_DEPTH_BUFFER case: only alpha batches are used, which are then rendered back to front. The difference is that this is done with depth test on (no write), so the 2D content gets depth tested against whatever is already in the depth buffer. Then, there's an additional depth "post pass" to fill the depth buffer with the 2D content. This must be separate from the color-write enabled stage because otherwise unavoidable Z fighting would occur. By filling the depth buffer, other 3D or 2D content, that is rendered afterwards, can depth test correctly against the 2D elements rendered here. customRenderMode and related functions are renamed to visualization (because that's what it is about), in order to prevent confusing name clashes. Change-Id: I0d43b273e0a8020af05a652a236c0ad5fb150685 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2020-06-05 16:10:30 +00:00
bool Renderer::hasVisualizationModeWithContinuousUpdate() const
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
{
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
return m_visualizer->mode() == Visualizer::VisualizeOverdraw;
Visualization modes for rendering. There are two ways of setting this right now. One is to set it on startup using an environment varible. QSG_VISUALIZE= "batches" - Visualize batchtes in the renderer. Merged batches are drawn with solid color and Unmerged batches are drawn with a diagonal line pattern. Few unique colors means good batching. Unmerged batches are bad if they contain many individual nodes. "clip" - Visualize clipping as red areas on top of the scene. "overdraw" - Visualize all items in 3D to highlight overdraws. This mode can also be used to detect geometry outside the viewport to some extent. Opaque items are rendered with a green tint while translucent items are rendered with a red tint. The bounding box for the viewport is rendered in blue. Opaque content is easier for the scenegraph to process and it can also be faster to render on some hardware. "changes" - Changes in the scenegraph are visualized with a flashing overlay with a random color. Changes on a primitive is visualized with a solid color while changes in an ancestor, such as a matrix or opacity changes is visualized with a pattern. The second way to set the visualization mode is to set it at runtime through QString QQuickWindowPrivate::customRenderMode. This "API" is string based so it is not tied to the batch renderer and in theory can support other custom renderers. The visualized elements do not respect clipping and rendering order is arbitrary. Change-Id: I31efbe53fc905145bf48080ede3e36945cb60dcf Reviewed-by: Michael Brasser <michael.brasser@live.com>
2013-12-07 08:41:44 +00:00
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
bool operator==(const GraphicsState &a, const GraphicsState &b) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
return a.depthTest == b.depthTest
&& a.depthWrite == b.depthWrite
&& a.depthFunc == b.depthFunc
&& a.blending == b.blending
&& a.srcColor == b.srcColor
&& a.dstColor == b.dstColor
Add support for separate blending factors in QSGMaterialShader This needs to also have an opt-in flag, because existing code must continue to work as-is (i.e. when it does not touch the new srcAlpha/dstAlpha fields at all, the color blending factors should be used for alpha too). Therefore, by default there is no change in behavior, no matter if one touches the alpha blending factors or not. The renderer will continue to use the color factors for everything. Only when the flag is flipped will srcAlpha and dstAlpha have an effect. Inspired by a recent text node bug which, while solved differently in the end, shows that the ability to specify separate factors is useful in practice occasionally. [ChangeLog][QtQuick] When a custom material declares its own blending factors, it is now possible to specify the source/destination alpha blending factors separate from the color blending factors. This is done by first setting the separateBlendFactors to true in QSGMaterialShader::GraphicsPipelineState, and then writing the desired values to srcAlpha and dstAlpha, in addition to srcColor and dstColor. Change-Id: I83826a68b80d76500ee195db73b29d393a7d0381 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2022-06-15 11:17:11 +00:00
&& a.srcAlpha == b.srcAlpha
&& a.dstAlpha == b.dstAlpha
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
&& a.colorWrite == b.colorWrite
&& a.cullMode == b.cullMode
&& a.usesScissor == b.usesScissor
&& a.stencilTest == b.stencilTest
&& a.sampleCount == b.sampleCount
Enable line width on the rhi code path So examples like customgeometry show up as they should now, at least with OpenGL and Vulkan (when wide lines are supported). This way applications drawing lines on Qt Quick on OpenGL can continue functioning on Qt Quick on RHI on OpenGL as well. Those relying on drawing points with a size set from C++ and not from the vertex shader will need to migrate, but this has not been supported on OpenGL ES in Qt 5 either. Those wishing full cross-platform, cross-graphics-API compatibility should avoid relying on wide lines and points completely. The unsupported cases get a helpful warning now. Change-Id: If4255ccc46ad5d91a3a10d69d1c90260055037cc Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-06-24 14:53:46 +00:00
&& a.drawMode == b.drawMode
scenegraph: Add support for polygon fill mode The qtbase RHI graphics pipeline recently gained support for Polygon Mode (Triangle Fill Mode in Metal, Fill Mode in D3D). This patch extends support to the scenegraph. Note - glPolygonMode not supported on OpenGL ES [ChangeLog][QtQuick][QSGMaterialShader] Added support for polygon rasterization mode to graphics pipeline state. Change-Id: I6fc05bc4d38446e573687ca651d6d13a76b3e667 Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
2022-02-01 05:22:26 +00:00
&& a.lineWidth == b.lineWidth
&& a.polygonMode == b.polygonMode;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
bool operator!=(const GraphicsState &a, const GraphicsState &b) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
return !(a == b);
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
size_t qHash(const GraphicsState &s, size_t seed) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
// do not bother with all fields
return seed
+ s.depthTest * 1000
+ s.depthWrite * 100
+ s.depthFunc
+ s.blending * 10
+ s.srcColor
+ s.cullMode
+ s.usesScissor
+ s.stencilTest
+ s.sampleCount;
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
bool operator==(const GraphicsPipelineStateKey &a, const GraphicsPipelineStateKey &b) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
return a.state == b.state
&& a.sms->programRhi.program == b.sms->programRhi.program
Get rid of renderpass descriptor objects from the pipeline cache keys Follow what we did to the srb: instead of storing an object reference, store an opaque blob to test for compatibility. This works even if the object is destroyed in the meantime. Thus, the annoying and error-prone invalidatePipelineCacheDependency() goes away, finally. All this works because creating a QRhiGraphicsPipeline with a given QRhiRenderPassDescriptor only needs the renderpass object for building (as in create()). Afterwards the object can be destroyed, even. The pipeline is still usable with any render targets that have a _compatible_ rp descriptor. Therefore, it is ideal if there is a way to test for this compatibility without having to have the original object around for ever. Relies on enablers (most importantly, QRhiRenderPassDescriptor::serializedFormat()) added to QRhi in qtbase. While not necessarily obvious, the real benefit here is significant performance gains in certain situations: consider rendering a scene to a given render target, then to another one, then yet another one, for example via QQuickRenderControl. We no longer have to do aggressive purging of the pipelines just because a QRhiRenderPassDescriptor some of the recently created pipelines may be associated with is going to disappear. Rather, everything can stay as-is, there are no crashes due to dangling pointers in the pipeline cache keys. The majority of cases involve highly compatible render targets (e.g. rendering into textures of the same format), so reuse is highly beneficial. Pick-to: 6.2 Change-Id: I8ad4bfcb3c7e66c7364c91a749e2a2e6837b4f1a Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-09-15 12:07:15 +00:00
&& a.renderTargetDescription == b.renderTargetDescription
Remove the per-rendercontext srb cache Remove the srbCache which is effectively a map of unbounded size. Depending on scene structure and changes to the scene that trigger rebuilding the batching structures of the scenegraph, it can grow unexpectedly large, potentially growing continuously on every frame, with animated scenes that manage to trigger the "right" kind of changes to the scene. Other similar structures, such as the graphics pipeline or the sampler tables have a known maximum size, because we know that there can only be a certain number of combinations in the values that form the keys to the map. Whereas with QRhiShaderResourceBindings objects the key is the full binding list, including the QRhiBuffer/Texture/Sampler pointers. This becomes complex pretty quickly when combined with the internal mechanisms of the scenegraph's batching system and the lifecycle of these QRhiResource objects. For instance, uniform buffers live in Batch, which is a pooled, (semi-)transient object: changes to the scene that lead to full or partial rebuild will generate a new set of Batches, meaning a QSGGeometryNode can be associated with a different QRhiBuffer afterwards (not that we create new buffers all the time, they are reused, but they can be associated with different nodes over their lifetime). Which then means that to render the node, we now need a different srb as well (that references the correct QRhiBuffer). Depending on the scene and how it changes over time, this may lead to an explosive number of combinations, thus a "continuously" growing srbCache map, inserting more and more new entries, while leaving perhaps-unused entries in there for ever. Trimming is far from trivial as the costs of managing the purging of unused entries is likely more expensive than not having the "cache" in the first place. Thus, drop the whole data structure and give ownership of the srb to Element (which is the object in the shadow tree for each QSGGeometryNode). To not completely degrade performance, this needs some new enablers in QRhi, namely the ability to have a fast path for replacing the QRhiResources (buffers, textures, samplers) in the binding list of an already baked srb without having to go through full rebaking. (e.g. with Vulkan, we want to reuse all the existing descriptor set layouts and the descriptor sets themselves, it's just the descriptors themselves that need new values written) So now, instead of looking up in a QHash, we first compare the full binding list (this is what one gets with the QHash when there's a hit anyway: at minimum the binding list is hashed and then compared). If this matches then fine (and we saved the time spent on hashing even). Then, if there's a mismatch, we now do a layout-only comparison. If this matches, then we use the new enablers in QRhi to do a "light update" (different resources, but same binding points, types, etc.) to the srb. Finally, if there was a mismatch here too, we go through create() to do a full rebuild. Therefore, the performance effects of this patch depend heavily on the scene. Scenes that do not do changes that trigger re-batching often may see improvements even. Others are assumed to have small or negligible consequences with regards to performance (due to now spending time on a layout-compatible comparison of binding lists which was not there before). In return, we do not need to have the srbCache QHash at all, leading to, with scenes exhibiting the relevant patterns, significantly reduced memory usage. Once srbCache is gone, the following issues need to be handled: First, now that the srb ownership stays with the shadow node (Element), instead of guaranteed to stay around for ever in an srb cache data structure, throwing references into the keys used to look up pipelines is problematic (and was never nice to begin with). Get rid of this, building on the new QRhi API that gives us a list of uints that can be used to test for layout compatibility. The container is implicitly shared, which makes the switch quite simple and efficient. Second, all this does not mean that some sort of reuse of srb objects is not needed. Consider scrolling a list view. Nodes (and so shadow nodes, i.e. Element objects) come and go in this case. Creating full new srb objects for the Elements for the list items becoming visible is not ideal. (even if only really dubious with Vulkan, where there are true Vulkan API objects underneath) To facilitate reuse, reintroduce an srb pool in ShaderManager, but this time with different semantics: this stores unused srb objects, with the serialized layout description as the key. When a new Element needs an srb, we try to pick a (layout compatible) srb from this pool. If there is a match, the Element gets the srb with ownership, and the srb is removed from the pool. When an Element is about to go away, its srb may be "moved" to the pool when the pool is not too large already. The threshold for being too large is currently simply 1024 elements (in the QMultiHash). This can be overridden with an environment variable, although that should pretty much be never needed in practice. Pick-to: 6.2 Fixes: QTBUG-96130 Change-Id: Ie5a49beeb6dea0db6a81fdceebf39374ad192b0e Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Christian Strømme <christian.stromme@qt.io>
2021-08-31 16:27:50 +00:00
&& a.srbLayoutDescription == b.srbLayoutDescription;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
bool operator!=(const GraphicsPipelineStateKey &a, const GraphicsPipelineStateKey &b) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
return !(a == b);
}
Replace old Q_DECL statements with modern C++ Since we depend on C++17 now, all of these can go. Change-Id: I0484fd4bb99e4367ec211c29146c316453729959 Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
2020-10-30 15:00:24 +00:00
size_t qHash(const GraphicsPipelineStateKey &k, size_t seed) noexcept
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
{
Get rid of renderpass descriptor objects from the pipeline cache keys Follow what we did to the srb: instead of storing an object reference, store an opaque blob to test for compatibility. This works even if the object is destroyed in the meantime. Thus, the annoying and error-prone invalidatePipelineCacheDependency() goes away, finally. All this works because creating a QRhiGraphicsPipeline with a given QRhiRenderPassDescriptor only needs the renderpass object for building (as in create()). Afterwards the object can be destroyed, even. The pipeline is still usable with any render targets that have a _compatible_ rp descriptor. Therefore, it is ideal if there is a way to test for this compatibility without having to have the original object around for ever. Relies on enablers (most importantly, QRhiRenderPassDescriptor::serializedFormat()) added to QRhi in qtbase. While not necessarily obvious, the real benefit here is significant performance gains in certain situations: consider rendering a scene to a given render target, then to another one, then yet another one, for example via QQuickRenderControl. We no longer have to do aggressive purging of the pipelines just because a QRhiRenderPassDescriptor some of the recently created pipelines may be associated with is going to disappear. Rather, everything can stay as-is, there are no crashes due to dangling pointers in the pipeline cache keys. The majority of cases involve highly compatible render targets (e.g. rendering into textures of the same format), so reuse is highly beneficial. Pick-to: 6.2 Change-Id: I8ad4bfcb3c7e66c7364c91a749e2a2e6837b4f1a Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2021-09-15 12:07:15 +00:00
return qHash(k.state, seed)
^ qHash(k.sms->programRhi.program)
^ k.extra.renderTargetDescriptionHash
^ k.extra.srbLayoutDescriptionHash;
Add the graphics api independent scenegraph port Opt in via environment variables: QSG_RHI=1 -> enable using QRhi instead of GL QSG_RHI_BACKEND -> set to vulkan, metal, d3d11, gl to override the default (the default is d3d11 on Windows, metal on Mac, gl elsewhere) Or force a given rhi backend via the existing QQuickWindow::setSceneGraphBackend(). Otherwise the default behavior is the same as before, the rhi code path is never active by default. -no-opengl builds are supported in the sense that they work and default to the software backend. However, the rhi code path cannot currently be used in such builds, even though QRhi from qtbase is fully functional with Vulkan, D3D, or Metal even when qtbase was configured with -no-opengl. This cannot be utilized by Quick atm due to OpenGL usage being all over the place in the sources corresponding to the default backend, and those host the rhi code path as well. This will be cleaned up hopefully in Qt 6, with the removal all direct OpenGL usage. Other env.vars.: QSG_RHI_DEBUG_LAYER=1 -> enable D3D debug or Vulkan validation layer (assuming the system is set up for this) QSG_RHI_SHADEREFFECT_DEBUG=1 -> print stuff from ShaderEffect QSG_SAMPLES=1,2,4,... -> MSAA sample count (but QSurfaceFormat works too) QT_D3D_ADAPTER_INDEX=0,1,... -> D3D adapter index QT_VK_PHYSICAL_DEVICE_INDEX=0,1,... -> Vulkan physical device index QSG_RHI_UINT32_INDEX=1 -> always use uint index data (both merged/unmerged, convert when needed - with some rhi backends this is implicit) QSG_RENDER_LOOP -> to override the render loop as usual. The default with RHI is threaded for Metal, threaded for Vulkan on Windows, basic for Vulkan on Linux and Android (to be checked later), while the existing rules apply for OpenGL. Not supported when running with QRhi: - particles - compressed atlases (though this is transparent to the apps) - QSGRenderNode - QQuickRenderControl - QQuickFramebufferObject - certain QQuickWindow functionality that depends directly on OpenGL - anisotropic filtering for textures - native text may lack some gamma correction - QSGEngine applicability unclear - some QML profiler logs may be incorrect or irrelevant Change-Id: I7822e99ad79e342e4166275da6e9e66498d76521 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2019-04-23 07:40:59 +00:00
}
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
Visualizer::Visualizer(Renderer *renderer)
: m_renderer(renderer),
m_visualizeMode(VisualizeNothing)
{
}
Visualizer::~Visualizer()
{
}
#define QSGNODE_DIRTY_PARENT (QSGNode::DirtyNodeAdded \
| QSGNode::DirtyOpacity \
| QSGNode::DirtyMatrix \
| QSGNode::DirtyNodeRemoved)
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
void Visualizer::visualizeChangesPrepare(Node *n, uint parentChanges)
{
uint childDirty = (parentChanges | n->dirtyState) & QSGNODE_DIRTY_PARENT;
uint selfDirty = n->dirtyState | parentChanges;
if (n->type() == QSGNode::GeometryNodeType && selfDirty != 0)
m_visualizeChangeSet.insert(n, selfDirty);
SHADOWNODE_TRAVERSE(n) {
visualizeChangesPrepare(child, childDirty);
}
New scenegraph renderer and atlas textures. The renderer tries to batch primitives together where possible, isolate non-changing subparts of the scene from changing subparts and retain vertexdata on the GPU as much as possible. Atlas textures are crucial in enabling batching. The renderer and atlas texture are described in detail in the doc page "Qt Quick Scene Graph Renderer". Change-Id: Ia476c7f0f42e1fc57a2cef528e93ee88cf8f7055 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com>
2013-08-14 05:27:07 +00:00
}
Run includemocs in qtdeclarative Change-Id: I84e363d735b443cb9beefffd14b8c023a37aa489 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-04-25 21:08:46 +00:00
Implement QSG_VISUALIZE for RHI Change-Id: I6343f316e2ecff4e4d7454fb450a1bd0c5a917b8 Reviewed-by: Andy Nichols <andy.nichols@qt.io>
2019-07-31 13:17:52 +00:00
} // namespace QSGBatchRenderer
QT_END_NAMESPACE
Run includemocs in qtdeclarative Change-Id: I84e363d735b443cb9beefffd14b8c023a37aa489 Reviewed-by: Lars Knoll <lars.knoll@qt.io>
2017-04-25 21:08:46 +00:00
#include "moc_qsgbatchrenderer_p.cpp"