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/qsgdefaultcontext.cpp

369 lines
14 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtQuick module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qsgdefaultcontext_p.h"
#include <QtQuick/private/qsgdefaultinternalrectanglenode_p.h>
#include <QtQuick/private/qsgdefaultinternalimagenode_p.h>
#include <QtQuick/private/qsgdefaultpainternode_p.h>
#include <QtQuick/private/qsgdefaultglyphnode_p.h>
#include <QtQuick/private/qsgdistancefieldglyphnode_p.h>
#include <QtQuick/private/qsgdistancefieldglyphnode_p_p.h>
#include <QtQuick/private/qsgopengllayer_p.h>
#include <QtQuick/private/qsgrhisupport_p.h>
#include <QtQuick/private/qsgrhilayer_p.h>
#include <QtQuick/private/qsgdefaultrendercontext_p.h>
#include <QtQuick/private/qsgdefaultrectanglenode_p.h>
#include <QtQuick/private/qsgdefaultimagenode_p.h>
#include <QtQuick/private/qsgdefaultninepatchnode_p.h>
#if QT_CONFIG(quick_sprite)
#include <QtQuick/private/qsgdefaultspritenode_p.h>
#endif
#include <QtQuick/private/qsgrhishadereffectnode_p.h>
#include <QOpenGLContext>
#include <QOpenGLFramebufferObject>
#include <QtQuick/private/qquickwindow_p.h>
#include <QtQuick/private/qquickitem_p.h>
#include <private/qqmlglobal_p.h>
#include <algorithm>
#include <QtGui/private/qrhi_p.h>
#include <QtGui/private/qrhigles2_p.h>
QT_BEGIN_NAMESPACE
namespace QSGMultisampleAntialiasing {
class ImageNode : public QSGDefaultInternalImageNode {
public:
ImageNode(QSGDefaultRenderContext *rc) : QSGDefaultInternalImageNode(rc) { }
void setAntialiasing(bool) override { }
};
class RectangleNode : public QSGDefaultInternalRectangleNode {
public:
void setAntialiasing(bool) override { }
};
}
DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD)
QSGDefaultContext::QSGDefaultContext(QObject *parent)
: QSGContext (parent)
, m_antialiasingMethod(QSGContext::UndecidedAntialiasing)
, m_distanceFieldDisabled(qmlDisableDistanceField())
, m_distanceFieldAntialiasing(QSGGlyphNode::HighQualitySubPixelAntialiasing)
, m_distanceFieldAntialiasingDecided(false)
{
if (Q_UNLIKELY(!qEnvironmentVariableIsEmpty("QSG_DISTANCEFIELD_ANTIALIASING"))) {
const QByteArray mode = qgetenv("QSG_DISTANCEFIELD_ANTIALIASING");
m_distanceFieldAntialiasingDecided = true;
if (mode == "subpixel")
m_distanceFieldAntialiasing = QSGGlyphNode::HighQualitySubPixelAntialiasing;
else if (mode == "subpixel-lowq")
m_distanceFieldAntialiasing = QSGGlyphNode::LowQualitySubPixelAntialiasing;
else if (mode == "gray")
m_distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing;
}
// Adds compatibility with Qt 5.3 and earlier's QSG_RENDER_TIMING
if (qEnvironmentVariableIsSet("QSG_RENDER_TIMING")) {
const_cast<QLoggingCategory &>(QSG_LOG_TIME_GLYPH()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_TEXTURE()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_RENDERER()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_RENDERLOOP()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_COMPILATION()).setEnabled(QtDebugMsg, true);
}
}
QSGDefaultContext::~QSGDefaultContext()
{
}
void QSGDefaultContext::renderContextInitialized(QSGRenderContext *renderContext)
{
m_mutex.lock();
auto rc = static_cast<const QSGDefaultRenderContext *>(renderContext);
if (m_antialiasingMethod == UndecidedAntialiasing) {
if (Q_UNLIKELY(qEnvironmentVariableIsSet("QSG_ANTIALIASING_METHOD"))) {
const QByteArray aaType = qgetenv("QSG_ANTIALIASING_METHOD");
if (aaType == "msaa")
m_antialiasingMethod = MsaaAntialiasing;
else if (aaType == "vertex")
m_antialiasingMethod = VertexAntialiasing;
}
if (m_antialiasingMethod == UndecidedAntialiasing)
m_antialiasingMethod = rc->msaaSampleCount() > 1 ? MsaaAntialiasing : VertexAntialiasing;
}
// With OpenGL ES, except for Angle on Windows, use GrayAntialiasing, unless
// some value had been requested explicitly. This could not be decided
// before without a context. Now the context is ready.
if (!m_distanceFieldAntialiasingDecided) {
m_distanceFieldAntialiasingDecided = true;
#ifndef Q_OS_WIN32
if (rc->rhi()) {
if (rc->rhi()->backend() == QRhi::OpenGLES2
&& static_cast<const QRhiGles2NativeHandles *>(rc->rhi()->nativeHandles())->context->isOpenGLES())
{
m_distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing;
}
} else {
if (rc->openglContext()->isOpenGLES())
m_distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing;
}
#endif
}
static bool dumped = false;
if (!dumped && QSG_LOG_INFO().isDebugEnabled() && !rc->rhi()) {
dumped = true;
QSurfaceFormat format = rc->openglContext()->format();
QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions();
qCDebug(QSG_LOG_INFO, "R/G/B/A Buffers: %d %d %d %d", format.redBufferSize(),
format.greenBufferSize(), format.blueBufferSize(), format.alphaBufferSize());
qCDebug(QSG_LOG_INFO, "Depth Buffer: %d", format.depthBufferSize());
qCDebug(QSG_LOG_INFO, "Stencil Buffer: %d", format.stencilBufferSize());
qCDebug(QSG_LOG_INFO, "Samples: %d", format.samples());
qCDebug(QSG_LOG_INFO, "GL_VENDOR: %s", (const char*)funcs->glGetString(GL_VENDOR));
qCDebug(QSG_LOG_INFO, "GL_RENDERER: %s",
(const char*)funcs->glGetString(GL_RENDERER));
qCDebug(QSG_LOG_INFO, "GL_VERSION: %s", (const char*)funcs->glGetString(GL_VERSION));
QByteArrayList exts = rc->openglContext()->extensions().values();
std::sort(exts.begin(), exts.end());
qCDebug(QSG_LOG_INFO, "GL_EXTENSIONS: %s", exts.join(' ').constData());
qCDebug(QSG_LOG_INFO, "Max Texture Size: %d", rc->maxTextureSize());
qCDebug(QSG_LOG_INFO, "Debug context: %s",
format.testOption(QSurfaceFormat::DebugContext) ? "true" : "false");
}
m_mutex.unlock();
}
void QSGDefaultContext::renderContextInvalidated(QSGRenderContext *)
{
}
QSGRenderContext *QSGDefaultContext::createRenderContext()
{
return new QSGDefaultRenderContext(this);
}
QSGInternalRectangleNode *QSGDefaultContext::createInternalRectangleNode()
{
return m_antialiasingMethod == MsaaAntialiasing
? new QSGMultisampleAntialiasing::RectangleNode
: new QSGDefaultInternalRectangleNode;
}
QSGInternalImageNode *QSGDefaultContext::createInternalImageNode(QSGRenderContext *renderContext)
{
return m_antialiasingMethod == MsaaAntialiasing
? new QSGMultisampleAntialiasing::ImageNode(static_cast<QSGDefaultRenderContext *>(renderContext))
: new QSGDefaultInternalImageNode(static_cast<QSGDefaultRenderContext *>(renderContext));
}
QSGPainterNode *QSGDefaultContext::createPainterNode(QQuickPaintedItem *item)
{
return new QSGDefaultPainterNode(item);
}
QSGGlyphNode *QSGDefaultContext::createGlyphNode(QSGRenderContext *rc, bool preferNativeGlyphNode)
{
if (m_distanceFieldDisabled || preferNativeGlyphNode) {
return new QSGDefaultGlyphNode(rc);
} else {
QSGDistanceFieldGlyphNode *node = new QSGDistanceFieldGlyphNode(rc);
node->setPreferredAntialiasingMode(m_distanceFieldAntialiasing);
return node;
}
}
QSGLayer *QSGDefaultContext::createLayer(QSGRenderContext *renderContext)
{
auto rc = static_cast<const QSGDefaultRenderContext *>(renderContext);
if (rc->rhi())
return new QSGRhiLayer(renderContext);
else
return new QSGOpenGLLayer(renderContext);
}
QSurfaceFormat QSGDefaultContext::defaultSurfaceFormat() const
{
QSurfaceFormat format = QSurfaceFormat::defaultFormat();
static bool useDepth = qEnvironmentVariableIsEmpty("QSG_NO_DEPTH_BUFFER");
static bool useStencil = qEnvironmentVariableIsEmpty("QSG_NO_STENCIL_BUFFER");
static bool enableDebug = qEnvironmentVariableIsSet("QSG_OPENGL_DEBUG");
if (useDepth && format.depthBufferSize() == -1)
format.setDepthBufferSize(24);
else if (!useDepth)
format.setDepthBufferSize(0);
if (useStencil && format.stencilBufferSize() == -1)
format.setStencilBufferSize(8);
else if (!useStencil)
format.setStencilBufferSize(0);
if (enableDebug)
format.setOption(QSurfaceFormat::DebugContext);
if (QQuickWindow::hasDefaultAlphaBuffer())
format.setAlphaBufferSize(8);
format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
return format;
}
void QSGDefaultContext::setDistanceFieldEnabled(bool enabled)
{
m_distanceFieldDisabled = !enabled;
}
bool QSGDefaultContext::isDistanceFieldEnabled() const
{
return !m_distanceFieldDisabled;
}
QSGRendererInterface *QSGDefaultContext::rendererInterface(QSGRenderContext *renderContext)
{
Q_UNUSED(renderContext);
return this;
}
QSGRectangleNode *QSGDefaultContext::createRectangleNode()
{
return new QSGDefaultRectangleNode;
}
QSGImageNode *QSGDefaultContext::createImageNode()
{
return new QSGDefaultImageNode;
}
QSGNinePatchNode *QSGDefaultContext::createNinePatchNode()
{
return new QSGDefaultNinePatchNode;
}
#if QT_CONFIG(quick_sprite)
QSGSpriteNode *QSGDefaultContext::createSpriteNode()
{
return new QSGDefaultSpriteNode;
}
#endif
QSGGuiThreadShaderEffectManager *QSGDefaultContext::createGuiThreadShaderEffectManager()
{
if (QSGRhiSupport::instance()->isRhiEnabled())
return new QSGRhiGuiThreadShaderEffectManager;
return nullptr;
}
QSGShaderEffectNode *QSGDefaultContext::createShaderEffectNode(QSGRenderContext *renderContext,
QSGGuiThreadShaderEffectManager *mgr)
{
if (QSGRhiSupport::instance()->isRhiEnabled()) {
return new QSGRhiShaderEffectNode(static_cast<QSGDefaultRenderContext *>(renderContext),
static_cast<QSGRhiGuiThreadShaderEffectManager *>(mgr));
}
return nullptr;
}
QSGRendererInterface::GraphicsApi QSGDefaultContext::graphicsApi() const
{
return QSGRhiSupport::instance()->graphicsApi();
}
void *QSGDefaultContext::getResource(QQuickWindow *window, Resource resource) const
{
if (!window)
return nullptr;
// Unlike the graphicsApi and shaderType and similar queries, getting a
// native resource is only possible when there is an initialized
// rendercontext, or rather, only within rendering a frame, as per
// QSGRendererInterface docs. This is good since getting some things is
// only possible within a beginFrame - endFrame with the RHI.
const QSGDefaultRenderContext *rc = static_cast<const QSGDefaultRenderContext *>(
QQuickWindowPrivate::get(window)->context);
QSGRhiSupport *rhiSupport = QSGRhiSupport::instance();
switch (resource) {
case OpenGLContextResource:
if (rhiSupport->graphicsApi() == OpenGL)
return rc->openglContext();
else
return const_cast<void *>(rhiSupport->rifResource(resource, rc));
#if QT_CONFIG(vulkan)
case VulkanInstanceResource:
return window->vulkanInstance();
#endif
default:
return const_cast<void *>(rhiSupport->rifResource(resource, rc));
}
}
QSGRendererInterface::ShaderType QSGDefaultContext::shaderType() const
{
return QSGRhiSupport::instance()->isRhiEnabled() ? RhiShader : GLSL;
}
QSGRendererInterface::ShaderCompilationTypes QSGDefaultContext::shaderCompilationType() const
{
return QSGRhiSupport::instance()->isRhiEnabled() ? OfflineCompilation : RuntimeCompilation;
}
QSGRendererInterface::ShaderSourceTypes QSGDefaultContext::shaderSourceType() const
{
return QSGRhiSupport::instance()->isRhiEnabled() ? ShaderSourceFile : (ShaderSourceString | ShaderSourceFile);
}
QT_END_NAMESPACE
static void initResources()
{
Q_INIT_RESOURCE(scenegraph);
}
Q_CONSTRUCTOR_FUNCTION(initResources)
Reference in New Issue View Git Blame Copy Permalink