qsgabstractrenderer.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsgabstractrenderer_p_p.h"
 
QT_BEGIN_NAMESPACE
 
QSGAbstractRendererPrivate::QSGAbstractRendererPrivate()
    : m_root_node(nullptr)
    , m_clear_color(Qt::transparent)
{
    m_projection_matrix.resize(1);
    m_projection_matrix_native_ndc.resize(1);
}
 
QSGAbstractRenderer::QSGAbstractRenderer(QObject *parent)
    : QObject(*new QSGAbstractRendererPrivate, parent)
{
}
 
QSGAbstractRenderer::~QSGAbstractRenderer()
{
}
 
void QSGAbstractRenderer::setRootNode(QSGRootNode *node)
{
    Q_D(QSGAbstractRenderer);
    if (d->m_root_node == node)
        return;
    if (d->m_root_node) {
        d->m_root_node->m_renderers.removeOne(this);
        nodeChanged(d->m_root_node, QSGNode::DirtyNodeRemoved);
    }
    d->m_root_node = node;
    if (d->m_root_node) {
        Q_ASSERT(!d->m_root_node->m_renderers.contains(this));
        d->m_root_node->m_renderers << this;
        nodeChanged(d->m_root_node, QSGNode::DirtyNodeAdded);
    }
}
 
QSGRootNode *QSGAbstractRenderer::rootNode() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_root_node;
}
 
 
void QSGAbstractRenderer::setDeviceRect(const QRect &rect)
{
    Q_D(QSGAbstractRenderer);
    d->m_device_rect = rect;
}
 
QRect QSGAbstractRenderer::deviceRect() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_device_rect;
}
 
void QSGAbstractRenderer::setViewportRect(const QRect &rect)
{
    Q_D(QSGAbstractRenderer);
    d->m_viewport_rect = rect;
}
 
QRect QSGAbstractRenderer::viewportRect() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_viewport_rect;
}
 
void QSGAbstractRenderer::setProjectionMatrixToRect(const QRectF &rect)
{
    setProjectionMatrixToRect(rect, {}, false);
}
 
void QSGAbstractRenderer::setProjectionMatrixToRect(const QRectF &rect, MatrixTransformFlags flags)
{
    setProjectionMatrixToRect(rect, flags, flags.testFlag(MatrixTransformFlipY));
}
 
void QSGAbstractRenderer::setProjectionMatrixToRect(const QRectF &rect, MatrixTransformFlags flags,
                                                    bool nativeNDCFlipY)
{
    const bool flipY = flags.testFlag(MatrixTransformFlipY);
 
    const float left = rect.x();
    const float right = rect.x() + rect.width();
    float bottom = rect.y() + rect.height();
    float top = rect.y();
 
    if (flipY)
        std::swap(top, bottom);
 
    QMatrix4x4 matrix;
    matrix.ortho(left, right, bottom, top, 1, -1);
    setProjectionMatrix(matrix, 0);
 
    if (nativeNDCFlipY) {
        std::swap(top, bottom);
 
        matrix.setToIdentity();
        matrix.ortho(left, right, bottom, top, 1, -1);
    }
    setProjectionMatrixWithNativeNDC(matrix, 0);
}
 
void QSGAbstractRenderer::setProjectionMatrix(const QMatrix4x4 &matrix, int index)
{
    Q_D(QSGAbstractRenderer);
    if (d->m_projection_matrix.count() <= index)
        d->m_projection_matrix.resize(index + 1);
    d->m_projection_matrix[index] = matrix;
}
 
void QSGAbstractRenderer::setProjectionMatrixWithNativeNDC(const QMatrix4x4 &matrix, int index)
{
    Q_D(QSGAbstractRenderer);
    if (d->m_projection_matrix_native_ndc.count() <= index)
        d->m_projection_matrix_native_ndc.resize(index + 1);
    d->m_projection_matrix_native_ndc[index] = matrix;
}
 
QMatrix4x4 QSGAbstractRenderer::projectionMatrix(int index) const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_projection_matrix[index];
}
 
int QSGAbstractRenderer::projectionMatrixCount() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_projection_matrix.count();
}
 
int QSGAbstractRenderer::projectionMatrixWithNativeNDCCount() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_projection_matrix_native_ndc.count();
}
 
QMatrix4x4 QSGAbstractRenderer::projectionMatrixWithNativeNDC(int index) const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_projection_matrix_native_ndc[index];
}
 
void QSGAbstractRenderer::setClearColor(const QColor &color)
{
    Q_D(QSGAbstractRenderer);
    d->m_clear_color = color;
}
 
QColor QSGAbstractRenderer::clearColor() const
{
    Q_D(const QSGAbstractRenderer);
    return d->m_clear_color;
}
 
void QSGAbstractRenderer::prepareSceneInline()
{
}
 
void QSGAbstractRenderer::renderSceneInline()
{
}
 
QT_END_NAMESPACE
 
#include "moc_qsgabstractrenderer_p.cpp"