Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquick3drenderstats_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrendermesh_p.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuick/qquickitem.h>
QT_BEGIN_NAMESPACE
/*!
\qmltype RenderStats
\inqmlmodule QtQuick3D
\brief Provides information of the scene rendering.
The RenderStats type provides information about scene rendering statistics. This
cannot be created directly, but can be retrieved from a \l View3D.
Use the \l DebugView item to display the data on-screen.
*/
QQuick3DRenderStats::QQuick3DRenderStats(QObject *parent)
: QObject(parent)
{
m_frameTimer.start();
}
/*!
\qmlproperty int QtQuick3D::RenderStats::fps
\readonly
This property holds the number of frames rendered during the last second.
*/
int QQuick3DRenderStats::fps() const
{
return m_fps;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::frameTime
\readonly
This property holds the amount of time elapsed since the last frame, in
milliseconds.
*/
float QQuick3DRenderStats::frameTime() const
{
return m_results.frameTime;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::renderTime
\readonly
This property holds the amount of time spent on generating a new frame,
including both the preparation phase and the recording of draw calls. The
value is in milliseconds.
*/
float QQuick3DRenderStats::renderTime() const
{
return m_results.renderTime;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::renderPrepareTime
\readonly
This property holds the amount of time spent in the preparation phase of
rendering, in milliseconds. This is a subset of the total render time
reported in renderTime.
*/
float QQuick3DRenderStats::renderPrepareTime() const
{
return m_results.renderPrepareTime;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::syncTime
\readonly
This property holds the amount of time spent inside the sync function, in
milliseconds. The property values of the objects are updated during the
sync.
*/
float QQuick3DRenderStats::syncTime() const
{
return m_results.syncTime;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::maxFrameTime
\readonly
This property holds the maximum time spent rendering a single frame during
the last second.
*/
float QQuick3DRenderStats::maxFrameTime() const
{
return m_maxFrameTime;
}
float QQuick3DRenderStats::timestamp() const
{
return m_frameTimer.nsecsElapsed() / 1000000.0f;
}
void QQuick3DRenderStats::startSync()
{
m_syncStartTime = timestamp();
}
void QQuick3DRenderStats::endSync(bool dump)
{
m_results.syncTime = timestamp() - m_syncStartTime;
if (dump)
qDebug("Sync took: %f ms", m_results.syncTime);
}
void QQuick3DRenderStats::startRender()
{
m_renderStartTime = timestamp();
}
void QQuick3DRenderStats::startRenderPrepare()
{
m_renderPrepareStartTime = timestamp();
}
void QQuick3DRenderStats::endRenderPrepare()
{
m_results.renderPrepareTime = timestamp() - m_renderPrepareStartTime;
}
void QQuick3DRenderStats::endRender(bool dump)
{
// Threading-wise this and onFrameSwapped are not perfect. These are called
// on the render thread (if there is one) outside of the sync step, so
// writing the data in m_results, which then may be read by the properties
// on the main thread concurrently, is not ideal. But at least the data the
// results are generated from (the m_* timings and all the stuff from
// QSSGRhiContextStats) belong to the render thread, so that's good.
m_renderingThisFrame = true;
const float endTime = timestamp();
m_results.renderTime = endTime - m_renderStartTime;
if (dump)
qDebug("Render took: %f ms (of which prep: %f ms)", m_results.renderTime, m_results.renderPrepareTime);
}
void QQuick3DRenderStats::onFrameSwapped()
{
// NOTE: This is called on the render thread
// This is the real start and end of a frame
if (m_renderingThisFrame) {
++m_frameCount;
m_results.frameTime = timestamp();
m_internalMaxFrameTime = qMax(m_results.frameTime, m_internalMaxFrameTime);
m_secTimer += m_results.frameTime;
m_notifyTimer += m_results.frameTime;
m_results.renderTime = m_results.frameTime - m_renderStartTime;
processRhiContextStats();
if (m_window) {
QRhiSwapChain *sc = m_window->swapChain();
if (sc) {
QRhiCommandBuffer *cb = sc->currentFrameCommandBuffer();
if (cb) {
const float msecs = float(cb->lastCompletedGpuTime() * 1000.0);
if (!qFuzzyIsNull(msecs))
m_results.lastCompletedGpuTime = msecs;
}
}
}
const float notifyInterval = 200.0f;
if (m_notifyTimer >= notifyInterval) {
m_notifyTimer -= notifyInterval;
if (m_results.frameTime != m_notifiedResults.frameTime) {
m_notifiedResults.frameTime = m_results.frameTime;
emit frameTimeChanged();
}
if (m_results.syncTime != m_notifiedResults.syncTime) {
m_notifiedResults.syncTime = m_results.syncTime;
emit syncTimeChanged();
}
if (m_results.renderTime != m_notifiedResults.renderTime) {
m_notifiedResults.renderTime = m_results.renderTime;
m_notifiedResults.renderPrepareTime = m_results.renderPrepareTime;
emit renderTimeChanged();
}
if (m_results.lastCompletedGpuTime != m_notifiedResults.lastCompletedGpuTime) {
m_notifiedResults.lastCompletedGpuTime = m_results.lastCompletedGpuTime;
emit lastCompletedGpuTimeChanged();
}
notifyRhiContextStats();
}
const float fpsInterval = 1000.0f;
if (m_secTimer >= fpsInterval) {
m_secTimer -= fpsInterval;
m_fps = m_frameCount;
m_frameCount = 0;
emit fpsChanged();
m_maxFrameTime = m_internalMaxFrameTime;
m_internalMaxFrameTime = 0;
emit maxFrameTimeChanged();
}
m_renderingThisFrame = false; // reset for next frame
}
// Always reset the frame timer
m_frameTimer.start();
}
void QQuick3DRenderStats::setRhiContext(QSSGRhiContext *ctx, QSSGRenderLayer *layer)
{
// called from synchronize(), so on the render thread with gui blocked
m_layer = layer;
m_contextStats = &QSSGRhiContextStats::get(*ctx);
// setExtendedDataCollectionEnabled will likely get called at some point
// before this (so too early), sync the flag here as well now that we know
// all we need to know.
if (m_extendedDataCollectionEnabled)
m_contextStats->dynamicDataSources.insert(layer);
if (m_contextStats && m_contextStats->rhiCtx->rhi()) {
const QString backendName = QString::fromUtf8(m_contextStats->rhiCtx->rhi()->backendName());
if (m_graphicsApiName != backendName) {
m_graphicsApiName = backendName;
emit graphicsApiNameChanged();
}
}
}
void QQuick3DRenderStats::setWindow(QQuickWindow *window)
{
if (m_window == window)
return;
if (m_window)
disconnect(m_frameSwappedConnection);
m_window = window;
if (m_window) {
m_frameSwappedConnection = connect(m_window, &QQuickWindow::afterFrameEnd,
this, &QQuick3DRenderStats::onFrameSwapped,
Qt::DirectConnection);
}
}
/*!
\qmlproperty bool QtQuick3D::RenderStats::extendedDataCollectionEnabled
This property controls if render pass and draw call statistics are
processed and made available. This may incur a small performance cost and
is therefore optional.
Properties such as drawCallCount, drawVertexCount, or renderPassCount are
updated only when this property is set to true.
The default value is false.
\note Changing the visibility of a \l DebugView associated with the \l
View3D automatically toggles the value based on the DebugView's
\l{QQuickItem::visible}{visible} property.
\since 6.5
*/
bool QQuick3DRenderStats::extendedDataCollectionEnabled() const
{
return m_extendedDataCollectionEnabled;
}
void QQuick3DRenderStats::setExtendedDataCollectionEnabled(bool enable)
{
if (enable != m_extendedDataCollectionEnabled) {
m_extendedDataCollectionEnabled = enable;
emit extendedDataCollectionEnabledChanged();
}
if (m_contextStats) {
// This is what allows recognizing that there is at least one DebugView
// that is visible and wants all the data, and also helps in not
// performing all the processing if the set is empty (because then we
// know that no DebugView wants to display the data)
if (m_extendedDataCollectionEnabled)
m_contextStats->dynamicDataSources.insert(m_layer);
else
m_contextStats->dynamicDataSources.remove(m_layer);
}
}
static const char *textureFormatStr(QRhiTexture::Format format)
{
switch (format) {
case QRhiTexture::RGBA8:
return "RGBA8";
case QRhiTexture::BGRA8:
return "BGRA8";
case QRhiTexture::R8:
return "R8";
case QRhiTexture::RG8:
return "RG8";
case QRhiTexture::R16:
return "R16";
case QRhiTexture::RG16:
return "RG16";
case QRhiTexture::RED_OR_ALPHA8:
return "R8/A8";
case QRhiTexture::RGBA16F:
return "RGBA16F";
case QRhiTexture::RGBA32F:
return "RGBA32F";
case QRhiTexture::R16F:
return "R16F";
case QRhiTexture::R32F:
return "R32F";
case QRhiTexture::RGB10A2:
return "RGB10A2";
case QRhiTexture::D16:
return "D16";
case QRhiTexture::D24:
return "D24";
case QRhiTexture::D24S8:
return "D24S8";
case QRhiTexture::D32F:
return "D32F";
case QRhiTexture::BC1:
return "BC1";
case QRhiTexture::BC2:
return "BC2";
case QRhiTexture::BC3:
return "BC3";
case QRhiTexture::BC4:
return "BC4";
case QRhiTexture::BC5:
return "BC5";
case QRhiTexture::BC6H:
return "BC6H";
case QRhiTexture::BC7:
return "BC7";
case QRhiTexture::ETC2_RGB8:
return "ETC2_RGB8";
case QRhiTexture::ETC2_RGB8A1:
return "ETC2_RGB8A1";
case QRhiTexture::ETC2_RGBA8:
return "ETC2_RGBA8";
case QRhiTexture::ASTC_4x4:
return "ASTC_4x4";
case QRhiTexture::ASTC_5x4:
return "ASTC_5x4";
case QRhiTexture::ASTC_5x5:
return "ASTC_5x5";
case QRhiTexture::ASTC_6x5:
return "ASTC_6x5";
case QRhiTexture::ASTC_6x6:
return "ASTC_6x6";
case QRhiTexture::ASTC_8x5:
return "ASTC_8x5";
case QRhiTexture::ASTC_8x6:
return "ASTC_8x6";
case QRhiTexture::ASTC_8x8:
return "ASTC_8x8";
case QRhiTexture::ASTC_10x5:
return "ASTC_10x5";
case QRhiTexture::ASTC_10x6:
return "ASTC_10x6";
case QRhiTexture::ASTC_10x8:
return "ASTC_10x8";
case QRhiTexture::ASTC_10x10:
return "ASTC_10x10";
case QRhiTexture::ASTC_12x10:
return "ASTC_12x10";
case QRhiTexture::ASTC_12x12:
return "ASTC_12x12";
default:
break;
}
return "<unknown>";
}
static inline void printRenderPassDetails(QString *dst, const QSSGRhiContextStats::RenderPassInfo &rp)
{
*dst += QString::asprintf("| %s | %dx%d | %llu | %llu |\n",
rp.rtName.constData(),
rp.pixelSize.width(),
rp.pixelSize.height(),
QSSGRhiContextStats::totalVertexCountForPass(rp),
QSSGRhiContextStats::totalDrawCallCountForPass(rp));
}
static inline QByteArray nameForRenderMesh(const QSSGRenderMesh *mesh)
{
if (!mesh->subsets.isEmpty()) {
auto buf = mesh->subsets[0].rhi.vertexBuffer;
if (buf)
return buf->buffer()->name();
}
return {};
}
void QQuick3DRenderStats::processRhiContextStats()
{
if (!m_contextStats || !m_extendedDataCollectionEnabled)
return;
// the render pass list is per renderer, i.e. per View3D
const QSSGRhiContextStats::PerLayerInfo data = m_contextStats->perLayerInfo[m_layer];
const QSSGRhiContext *rhiCtx = m_contextStats->rhiCtx;
const QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
// textures and meshes include all assets registered to the per-QQuickWindow QSSGRhiContext
const QSSGRhiContextStats::GlobalInfo globalData = m_contextStats->globalInfo;
const auto textures = rhiCtxD->m_textures;
const auto meshes = rhiCtxD->m_meshes;
const auto pipelines = rhiCtxD->m_pipelines;
m_results.drawCallCount = 0;
m_results.drawVertexCount = 0;
for (const auto &pass : data.renderPasses) {
m_results.drawCallCount += QSSGRhiContextStats::totalDrawCallCountForPass(pass);
m_results.drawVertexCount += QSSGRhiContextStats::totalVertexCountForPass(pass);
}
m_results.drawCallCount += QSSGRhiContextStats::totalDrawCallCountForPass(data.externalRenderPass);
m_results.drawVertexCount += QSSGRhiContextStats::totalVertexCountForPass(data.externalRenderPass);
m_results.imageDataSize = globalData.imageDataSize;
m_results.meshDataSize = globalData.meshDataSize;
m_results.renderPassCount = data.renderPasses.size()
+ (data.externalRenderPass.pixelSize.isEmpty() ? 0 : 1);
QString renderPassDetails = QLatin1String(R"(
| Name | Size | Vertices | Draw calls |
| ---- | ---- | -------- | ---------- |
)");
if (!data.externalRenderPass.pixelSize.isEmpty())
printRenderPassDetails(&renderPassDetails, data.externalRenderPass);
for (const auto &pass : data.renderPasses) {
if (!pass.pixelSize.isEmpty())
printRenderPassDetails(&renderPassDetails, pass);
}
renderPassDetails += QString::asprintf("\nGenerated from QSSGRenderLayer %p", m_layer);
m_results.renderPassDetails = renderPassDetails;
if (m_results.activeTextures != textures) {
m_results.activeTextures = textures;
QString texDetails = QLatin1String(R"(
| Name | Size | Format | Mip | Flags |
| ---- | ---- | ------ | --- | ----- |
)");
QList<QRhiTexture *> textureList = textures.values();
std::sort(textureList.begin(), textureList.end(), [](QRhiTexture *a, QRhiTexture *b) {
return a->name() < b->name();
});
for (QRhiTexture *tex : textureList) {
int mipCount = 1;
const QRhiTexture::Flags flags = tex->flags();
if (flags.testFlag(QRhiTexture::MipMapped))
mipCount = m_contextStats->rhiCtx->rhi()->mipLevelsForSize(tex->pixelSize());
QByteArray flagMsg;
if (flags.testFlag(QRhiTexture::CubeMap))
flagMsg += QByteArrayLiteral("[cube]");
texDetails += QString::asprintf("| %s | %dx%d | %s | %d | %s |\n",
tex->name().constData(),
tex->pixelSize().width(),
tex->pixelSize().height(),
textureFormatStr(tex->format()),
mipCount,
flagMsg.constData());
}
texDetails += QString::asprintf("\nAsset textures registered with QSSGRhiContext %p", m_contextStats->rhiCtx);
m_results.textureDetails = texDetails;
}
if (m_results.activeMeshes != meshes) {
m_results.activeMeshes = meshes;
QString meshDetails = QLatin1String(R"(
| Name | Submeshes | Vertices | V.buf size | I.buf size |
| ---- | --------- | -------- | ---------- | ---------- |
)");
QList<QSSGRenderMesh *> meshList = meshes.values();
std::sort(meshList.begin(), meshList.end(), [](QSSGRenderMesh *a, QSSGRenderMesh *b) {
return nameForRenderMesh(a) < nameForRenderMesh(b);
});
for (QSSGRenderMesh *mesh : meshList) {
const QByteArray name = nameForRenderMesh(mesh);
const int subsetCount = int(mesh->subsets.size());
quint64 vertexCount = 0;
quint32 vbufSize = 0;
quint32 ibufSize = 0;
if (subsetCount > 0) {
for (const QSSGRenderSubset &subset : std::as_const(mesh->subsets))
vertexCount += subset.count;
// submeshes ref into the same vertex and index buffer
const QSSGRhiBuffer *vbuf = mesh->subsets[0].rhi.vertexBuffer.get();
if (vbuf)
vbufSize = vbuf->buffer()->size();
const QSSGRhiBuffer *ibuf = mesh->subsets[0].rhi.indexBuffer.get();
if (ibuf)
ibufSize = ibuf->buffer()->size();
}
meshDetails += QString::asprintf("| %s | %d | %llu | %u | %u |\n",
name.constData(),
subsetCount,
vertexCount,
vbufSize,
ibufSize);
}
meshDetails += QString::asprintf("\nAsset meshes registered with QSSGRhiContext %p", m_contextStats->rhiCtx);
m_results.meshDetails = meshDetails;
}
m_results.pipelineCount = pipelines.count();
m_results.materialGenerationTime = m_contextStats->globalInfo.materialGenerationTime;
m_results.effectGenerationTime = m_contextStats->globalInfo.effectGenerationTime;
m_results.rhiStats = m_contextStats->rhiCtx->rhi()->statistics();
}
void QQuick3DRenderStats::notifyRhiContextStats()
{
if (!m_contextStats || !m_extendedDataCollectionEnabled)
return;
if (m_results.drawCallCount != m_notifiedResults.drawCallCount) {
m_notifiedResults.drawCallCount = m_results.drawCallCount;
emit drawCallCountChanged();
}
if (m_results.drawVertexCount != m_notifiedResults.drawVertexCount) {
m_notifiedResults.drawVertexCount = m_results.drawVertexCount;
emit drawVertexCountChanged();
}
if (m_results.imageDataSize != m_notifiedResults.imageDataSize) {
m_notifiedResults.imageDataSize = m_results.imageDataSize;
emit imageDataSizeChanged();
}
if (m_results.meshDataSize != m_notifiedResults.meshDataSize) {
m_notifiedResults.meshDataSize = m_results.meshDataSize;
emit meshDataSizeChanged();
}
if (m_results.renderPassCount != m_notifiedResults.renderPassCount) {
m_notifiedResults.renderPassCount = m_results.renderPassCount;
emit renderPassCountChanged();
}
if (m_results.renderPassDetails != m_notifiedResults.renderPassDetails) {
m_notifiedResults.renderPassDetails = m_results.renderPassDetails;
emit renderPassDetailsChanged();
}
if (m_results.textureDetails != m_notifiedResults.textureDetails) {
m_notifiedResults.textureDetails = m_results.textureDetails;
emit textureDetailsChanged();
}
if (m_results.meshDetails != m_notifiedResults.meshDetails) {
m_notifiedResults.meshDetails = m_results.meshDetails;
emit meshDetailsChanged();
}
if (m_results.pipelineCount != m_notifiedResults.pipelineCount) {
m_notifiedResults.pipelineCount = m_results.pipelineCount;
emit pipelineCountChanged();
}
if (m_results.materialGenerationTime != m_notifiedResults.materialGenerationTime) {
m_notifiedResults.materialGenerationTime = m_results.materialGenerationTime;
emit materialGenerationTimeChanged();
}
if (m_results.effectGenerationTime != m_notifiedResults.effectGenerationTime) {
m_notifiedResults.effectGenerationTime = m_results.effectGenerationTime;
emit effectGenerationTimeChanged();
}
if (m_results.rhiStats.totalPipelineCreationTime != m_notifiedResults.rhiStats.totalPipelineCreationTime) {
m_notifiedResults.rhiStats.totalPipelineCreationTime = m_results.rhiStats.totalPipelineCreationTime;
emit pipelineCreationTimeChanged();
}
if (m_results.rhiStats.allocCount != m_notifiedResults.rhiStats.allocCount) {
m_notifiedResults.rhiStats.allocCount = m_results.rhiStats.allocCount;
emit vmemAllocCountChanged();
}
if (m_results.rhiStats.usedBytes != m_notifiedResults.rhiStats.usedBytes) {
m_notifiedResults.rhiStats.usedBytes = m_results.rhiStats.usedBytes;
emit vmemUsedBytesChanged();
}
}
/*!
\qmlproperty quint64 QtQuick3D::RenderStats::drawCallCount
\readonly
This property holds the total number of draw calls (including non-indexed,
indexed, instanced, and instanced indexed draw calls) that were registered
during the last render of the \l View3D.
The value is updated only when extendedDataCollectionEnabled is enabled.
\since 6.5
*/
quint64 QQuick3DRenderStats::drawCallCount() const
{
return m_results.drawCallCount;
}
/*!
\qmlproperty quint64 QtQuick3D::RenderStats::drawVertexCount
\readonly
This property holds the total number of vertices in draw calls that were
registered during the last render of the \l View3D.
The value includes the number of vertex and index count from draw calls
that were registered during the last render of the \l View3D. While the
number is not guaranteed to be totally accurate, it is expected to give a
good indication of the complexity of the scene rendering.
The value is updated only when extendedDataCollectionEnabled is enabled.
\since 6.5
*/
quint64 QQuick3DRenderStats::drawVertexCount() const
{
return m_results.drawVertexCount;
}
/*!
\qmlproperty quint64 QtQuick3D::RenderStats::imageDataSize
\readonly
This property holds the approximate size in bytes of the image data for
texture maps currently registered with the View3D's window. The value is
per-window, meaning if there are multiple View3D objects within the same
QQuickWindow, those will likely report the same value.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
quint64 QQuick3DRenderStats::imageDataSize() const
{
return m_results.imageDataSize;
}
/*!
\qmlproperty quint64 QtQuick3D::RenderStats::meshDataSize
\readonly
This property holds the approximate size in bytes of the mesh data
currently registered with the View3D's window. The value is per-window,
meaning if there are multiple View3D objects within the same QQuickWindow,
those will likely report the same value.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
quint64 QQuick3DRenderStats::meshDataSize() const
{
return m_results.meshDataSize;
}
/*!
\qmlproperty int QtQuick3D::RenderStats::renderPassCount
\readonly
This property holds the total number of render passes that were registered
during the last render of the \l View3D.
Many features, such as realtime shadow mapping, postprocessing effects, the
depth and screen textures, and certain antialiasing methods involve
multiple additional render passes. While the number is not guaranteed to
include absolutely all render passes, it is expected to give a good
indication of the complexity of the scene rendering.
The value is updated only when extendedDataCollectionEnabled is enabled.
\since 6.5
*/
int QQuick3DRenderStats::renderPassCount() const
{
return m_results.renderPassCount;
}
/*!
\qmlproperty string QtQuick3D::RenderStats::renderPassDetails
\readonly
\internal
\since 6.5
*/
QString QQuick3DRenderStats::renderPassDetails() const
{
return m_results.renderPassDetails;
}
/*!
\qmlproperty string QtQuick3D::RenderStats::textureDetails
\readonly
\internal
\since 6.5
*/
QString QQuick3DRenderStats::textureDetails() const
{
return m_results.textureDetails;
}
/*!
\qmlproperty string QtQuick3D::RenderStats::meshDetails
\readonly
\internal
\since 6.5
*/
QString QQuick3DRenderStats::meshDetails() const
{
return m_results.meshDetails;
}
/*!
\qmlproperty int QtQuick3D::RenderStats::pipelineCount
\readonly
This property holds the total number of cached graphics pipelines for the
window the \l View3D belongs to.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
int QQuick3DRenderStats::pipelineCount() const
{
return m_results.pipelineCount;
}
/*!
\qmlproperty qint64 QtQuick3D::RenderStats::materialGenerationTime
\readonly
This property holds the total number of milliseconds spent on generating
and processing shader code for \l DefaultMaterial, \l PrincipledMaterial,
and \l CustomMaterial in the window the \l View3D belongs to.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
qint64 QQuick3DRenderStats::materialGenerationTime() const
{
return m_results.materialGenerationTime;
}
/*!
\qmlproperty qint64 QtQuick3D::RenderStats::effectGenerationTime
\readonly
This property holds the total number of milliseconds spent on generating
and processing shader code for post-processing effects in the window the \l
View3D belongs to.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
qint64 QQuick3DRenderStats::effectGenerationTime() const
{
return m_results.effectGenerationTime;
}
/*!
\qmlproperty qint64 QtQuick3D::RenderStats::pipelineCreationTime
\readonly
This property holds the total number of milliseconds spent on creating
graphics pipelines on the rendering hardware interface level. This can
include, among other things: compilation times for compiling HLSL to an
intermediate format, compiling MSL, compiling GLSL code with
glCompileShader or linking using program binaries, and generating Vulkan
pipelines with all that entails (e.g. SPIR-V -> ISA compilation). The value
reflects all Qt Quick and Qt Quick 3D rendering in the window the \l View3D
belongs to.
\note The value includes operations that are under Qt's control. Depending
on the underlying graphics API, some pipeline (shader, graphics state)
related operations may happen asynchronously, and may be affected by
caching on various levels in the graphics stack. Releasing cached resource
by calling QQuickWindow::releaseResources() or clicking the corresponding
DebugView button may also have varying results, depending on the underlying
details (rhi backend, graphics API); it may or may not affect this counter
due to a varying number of factors.
This timing is provided as a general, high level indication. Combined with
\l materialGenerationTime, application developers can use these values to
confirm that the time spent on material and graphics pipeline processing is
reasonably low during the normal use of the application, once all caches
(both persistent and in-memory) are warm. Avoid drawing conclusions from
the first run of the application. (since that may not benefit from
persistent, disk-based caches yet)
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
qint64 QQuick3DRenderStats::pipelineCreationTime() const
{
return m_results.rhiStats.totalPipelineCreationTime;
}
/*!
\qmlproperty quint32 QtQuick3D::RenderStats::vmemAllocCount
\readonly
When applicable, the number of allocations made by the graphics memory
allocator library. This includes allocations from all Qt Quick and Qt Quick
3D rendering in the QQuickWindow to which the \l View3D belongs. The value
is zero with graphics APIs such as OpenGL, Direct3D, and Metal because
memory allocation is not under Qt's control then.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
quint32 QQuick3DRenderStats::vmemAllocCount() const
{
return m_results.rhiStats.allocCount;
}
/*!
\qmlproperty quint64 QtQuick3D::RenderStats::vmemUsedBytes
\readonly
When applicable, the number of bytes used by allocations made by the
graphics memory allocator library. This includes allocations from all Qt
Quick and Qt Quick 3D rendering in the QQuickWindow to which the \l View3D
belongs. The value is zero with graphics APIs such as OpenGL, Direct3D, and
Metal because memory allocation is not under Qt's control then.
The value is updated only when extendedDataCollectionEnabled is enabled.
\note The value is reported on a per-QQuickWindow basis. If there are
multiple View3D instances within the same window, the DebugView shows the
same value for all those View3Ds.
\since 6.5
*/
quint64 QQuick3DRenderStats::vmemUsedBytes() const
{
return m_results.rhiStats.usedBytes;
}
/*!
\qmlproperty string QtQuick3D::RenderStats::graphicsAPIName
\readonly
This property holds the name of the current graphics API (RHI) backend
currently in use.
\since 6.5
*/
QString QQuick3DRenderStats::graphicsApiName() const
{
return m_graphicsApiName;
}
/*!
\qmlproperty real QtQuick3D::RenderStats::lastCompletedGpuTime
\readonly
When GPU timing collection is
\l{QQuickGraphicsConfiguration::setTimestamps()}{enabled in Qt Quick}, and
the relevant features are supported by the underlying graphics API, this
property contains the last retrieved elapsed GPU time in milliseconds.
\note The value is retrieved asynchronously, and usually refers to a frame
older than the previous one, meaning that the value is not necessarily in
sync with the other, CPU-side timings.
\note The result is based on the rendering of the entire contents of the
QQuickWindow the View3D belongs to. It includes all the contents of Qt
Quick scene, including all 2D elements and all View3D items within that
window.
\since 6.6
\sa QQuickGraphicsConfiguration::setTimestamps()
*/
float QQuick3DRenderStats::lastCompletedGpuTime() const
{
return m_results.lastCompletedGpuTime;
}
/*!
\internal
*/
void QQuick3DRenderStats::releaseCachedResources()
{
if (m_window)
m_window->releaseResources();
else
qWarning("QQuick3DRenderStats: No window, cannot request releasing cached resources");
}
QT_END_NAMESPACE