490 lines
12 KiB
C++
490 lines
12 KiB
C++
/******************************************************************************
|
|
* QSkinny - Copyright (C) The authors
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*****************************************************************************/
|
|
|
|
#include "QskSceneTexture.h"
|
|
#include "QskTreeNode.h"
|
|
|
|
#include <qmath.h>
|
|
|
|
QSK_QT_PRIVATE_BEGIN
|
|
#include <private/qquickwindow_p.h>
|
|
#include <private/qsgtexture_p.h>
|
|
|
|
#define QT_BUILD_QUICK_LIB // suppress Qt5 warnings
|
|
#include <private/qsgbatchrenderer_p.h>
|
|
#undef QT_BUILD_QUICK_LIB
|
|
|
|
QSK_QT_PRIVATE_END
|
|
|
|
/*
|
|
With Qt 5.15 Rhi can optionally be enbled by setting "export QSG_RHI=1".
|
|
So we need to have a native QOpenGL implementation and one using
|
|
the Rhi abstraction layer. For Qt6 we can rely on Rhi.
|
|
Once Qt5 support has been dropped we can eliminate this #ifdef jungle
|
|
*/
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
#include <qopenglframebufferobject.h>
|
|
#endif
|
|
|
|
static int qskRenderOrderCompare( const QSGNode* rootNode,
|
|
const QSGNode* node1, const QSGNode* node2 )
|
|
{
|
|
if ( rootNode == node1 )
|
|
return 1;
|
|
|
|
if ( rootNode == node2 )
|
|
return -1;
|
|
|
|
for ( auto node = rootNode->firstChild();
|
|
node != nullptr; node = node->nextSibling() )
|
|
{
|
|
const auto ret = qskRenderOrderCompare( node, node1, node2 );
|
|
if ( ret )
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
#if QT_VERSION >= QT_VERSION_CHECK( 6, 0, 0 )
|
|
inline QSGRendererInterface::RenderMode contextRenderMode(
|
|
QSGDefaultRenderContext* context )
|
|
{
|
|
return context->useDepthBufferFor2D()
|
|
? QSGRendererInterface::RenderMode2D
|
|
: QSGRendererInterface::RenderMode2DNoDepthBuffer;
|
|
}
|
|
#endif
|
|
|
|
class Renderer final : public QSGBatchRenderer::Renderer
|
|
{
|
|
using Inherited = QSGBatchRenderer::Renderer;
|
|
|
|
public:
|
|
Renderer( QskSceneTexture*, QSGDefaultRenderContext* );
|
|
~Renderer() override;
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
inline int textureId() const { return m_fbo ? m_fbo->texture() : 0; }
|
|
|
|
inline void renderScene()
|
|
{
|
|
class Bindable : public QSGBindable
|
|
{
|
|
public:
|
|
Bindable( QOpenGLFramebufferObject* fbo ) : m_fbo( fbo ) {}
|
|
void bind() const override { m_fbo->bind(); }
|
|
private:
|
|
QOpenGLFramebufferObject* m_fbo;
|
|
};
|
|
|
|
Inherited::renderScene( Bindable( m_fbo ) );
|
|
}
|
|
#endif
|
|
|
|
inline QRhiTexture* rhiTexture() const { return m_rhiTexture; }
|
|
|
|
inline bool isDirty() const { return m_dirty; }
|
|
|
|
void setFinalNode( QSGTransformNode* );
|
|
|
|
void setProjection( const QRectF& );
|
|
void setTextureSize( const QSize& );
|
|
QSize textureSize() const;
|
|
|
|
protected:
|
|
void nodeChanged( QSGNode*, QSGNode::DirtyState ) override;
|
|
void render() override;
|
|
|
|
private:
|
|
void createTarget( const QSize& );
|
|
void clearTarget();
|
|
void markDirty();
|
|
|
|
QSGTransformNode* m_finalNode = nullptr;
|
|
QskSceneTexture* m_texture = nullptr;
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
QOpenGLFramebufferObject* m_fbo = nullptr;
|
|
#endif
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 4, 0 )
|
|
struct RenderTarget
|
|
{
|
|
QRhiRenderTarget* rt = nullptr;
|
|
QRhiRenderPassDescriptor* rpDesc = nullptr;
|
|
QRhiCommandBuffer* cb = nullptr;
|
|
} m_rt;
|
|
#endif
|
|
QRhiTexture* m_rhiTexture = nullptr;
|
|
|
|
bool m_dirty = true;
|
|
};
|
|
|
|
Renderer::Renderer( QskSceneTexture* texture, QSGDefaultRenderContext* context )
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
: Inherited( context )
|
|
#else
|
|
: Inherited( context, contextRenderMode( context ) )
|
|
#endif
|
|
, m_texture( texture )
|
|
{
|
|
setClearColor( Qt::transparent );
|
|
|
|
connect( this, &QSGRenderer::sceneGraphChanged,
|
|
this, &Renderer::markDirty );
|
|
}
|
|
|
|
Renderer::~Renderer()
|
|
{
|
|
clearTarget();
|
|
}
|
|
|
|
void Renderer::setFinalNode( QSGTransformNode* node )
|
|
{
|
|
if ( node != m_finalNode )
|
|
{
|
|
m_finalNode = node;
|
|
markDirty();
|
|
}
|
|
}
|
|
|
|
void Renderer::setProjection( const QRectF& rect )
|
|
{
|
|
bool flipFramebuffer = true;
|
|
bool flipMatrix = false;
|
|
|
|
if ( const auto rhi = context()->rhi() )
|
|
{
|
|
flipFramebuffer = rhi->isYUpInFramebuffer();
|
|
flipMatrix = !rhi->isYUpInNDC();
|
|
}
|
|
|
|
auto r = rect;
|
|
|
|
if ( flipFramebuffer )
|
|
{
|
|
r.moveTop( r.bottom() );
|
|
r.setHeight( -r.height() );
|
|
}
|
|
|
|
MatrixTransformFlags matrixFlags;
|
|
|
|
if ( flipMatrix )
|
|
matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;
|
|
|
|
setProjectionMatrixToRect( r, matrixFlags );
|
|
}
|
|
|
|
void Renderer::setTextureSize( const QSize& size )
|
|
{
|
|
if ( const auto rhi = context()->rhi() )
|
|
{
|
|
if ( m_rt.rt && m_rt.rt->pixelSize() != size )
|
|
clearTarget();
|
|
|
|
if ( m_rt.rt == nullptr )
|
|
createTarget( size );
|
|
}
|
|
else
|
|
{
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
if ( m_fbo && m_fbo->size() != size )
|
|
clearTarget();
|
|
|
|
if ( m_fbo == nullptr )
|
|
createTarget( size );
|
|
#endif
|
|
}
|
|
|
|
const QRect r( 0, 0, size.width(), size.height() );
|
|
|
|
setDeviceRect( r );
|
|
setViewportRect( r );
|
|
}
|
|
|
|
QSize Renderer::textureSize() const
|
|
{
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
if ( m_fbo ) return m_fbo->size();
|
|
#else
|
|
if( m_rt.rt ) return m_rt.rt->pixelSize();
|
|
#endif
|
|
return QSize();
|
|
}
|
|
|
|
void Renderer::render()
|
|
{
|
|
m_dirty = false;
|
|
|
|
qskTryBlockTrailingNodes( m_finalNode, rootNode(), true, false );
|
|
|
|
#if 0
|
|
static int counter = 0;
|
|
qDebug() << ++counter;
|
|
QSGNodeDumper::dump( rootNode() );
|
|
#endif
|
|
Inherited::render();
|
|
qskTryBlockTrailingNodes( m_finalNode, rootNode(), false, false );
|
|
}
|
|
|
|
void Renderer::nodeChanged( QSGNode* node, QSGNode::DirtyState state )
|
|
{
|
|
/*
|
|
No need to update the texture for changes of nodes behind
|
|
the final node.
|
|
|
|
Unfortunately QQuickWindow does not update the scene graph in
|
|
rendering order and we might be called for relevant nodes after
|
|
the texture has already been updated. In these situations we
|
|
update the texture twice. Not so good ...
|
|
*/
|
|
if ( qskRenderOrderCompare( rootNode(), node, m_finalNode ) > 0 )
|
|
{
|
|
// triggering QSGRenderer::sceneGraphChanged signals
|
|
Inherited::nodeChanged( node, state );
|
|
}
|
|
}
|
|
|
|
void Renderer::markDirty()
|
|
{
|
|
if ( !m_dirty )
|
|
{
|
|
m_dirty = true;
|
|
Q_EMIT m_texture->updateRequested();
|
|
}
|
|
}
|
|
|
|
void Renderer::createTarget( const QSize& size )
|
|
{
|
|
if ( const auto rhi = context()->rhi() )
|
|
{
|
|
auto flags = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
|
|
|
|
m_rhiTexture = rhi->newTexture( QRhiTexture::RGBA8, size, 1, flags );
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
m_rhiTexture->build();
|
|
#else
|
|
m_rhiTexture->create();
|
|
#endif
|
|
|
|
QRhiColorAttachment color0( m_rhiTexture );
|
|
auto target = rhi->newTextureRenderTarget( { color0 } );
|
|
|
|
target->setRenderPassDescriptor(
|
|
target->newCompatibleRenderPassDescriptor() );
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
target->build();
|
|
#else
|
|
target->create();
|
|
#endif
|
|
|
|
m_rt.rt = target;
|
|
m_rt.rpDesc = target->renderPassDescriptor();
|
|
|
|
auto defaultContext = qobject_cast< QSGDefaultRenderContext* >( context() );
|
|
m_rt.cb = defaultContext->currentFrameCommandBuffer();
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
setRenderTarget( m_rt.rt );
|
|
setCommandBuffer( m_rt.cb );
|
|
setRenderPassDescriptor( m_rt.rpDesc );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
QOpenGLFramebufferObjectFormat format;
|
|
format.setInternalTextureFormat( GL_RGBA8 );
|
|
format.setSamples( 0 );
|
|
format.setAttachment( QOpenGLFramebufferObject::CombinedDepthStencil );
|
|
|
|
m_fbo = new QOpenGLFramebufferObject( size, format );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
void Renderer::clearTarget()
|
|
{
|
|
if ( const auto rhi = context()->rhi() )
|
|
{
|
|
delete m_rt.rt;
|
|
m_rt.rt = nullptr;
|
|
|
|
delete m_rt.rpDesc;
|
|
m_rt.rpDesc = nullptr;
|
|
|
|
delete m_rhiTexture;
|
|
m_rhiTexture = nullptr;
|
|
}
|
|
else
|
|
{
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
delete m_fbo;
|
|
m_fbo = nullptr;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
class QskSceneTexturePrivate final : public QSGTexturePrivate
|
|
{
|
|
public:
|
|
QskSceneTexturePrivate( const QQuickWindow* window, QskSceneTexture* texture )
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
: QSGTexturePrivate()
|
|
#else
|
|
: QSGTexturePrivate( texture )
|
|
#endif
|
|
, devicePixelRatio( window->effectiveDevicePixelRatio() )
|
|
{
|
|
Q_UNUSED( texture );
|
|
|
|
// Qt5 needs the extra const_cast
|
|
auto dw = QQuickWindowPrivate::get( const_cast< QQuickWindow* >( window ) );
|
|
context = dynamic_cast< QSGDefaultRenderContext* >( dw->context );
|
|
}
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
int comparisonKey() const override
|
|
{
|
|
if ( renderer )
|
|
{
|
|
if ( renderer->textureId() )
|
|
return renderer->textureId();
|
|
|
|
if ( renderer->rhiTexture() )
|
|
return int( qintptr( renderer->rhiTexture() ) );
|
|
}
|
|
|
|
return int( qintptr( this ) );
|
|
}
|
|
|
|
QRhiTexture *rhiTexture() const override
|
|
{ return renderer ? renderer->rhiTexture() : nullptr; }
|
|
#endif
|
|
|
|
QSize pixelSize() const
|
|
{
|
|
QSize size( qCeil( rect.width() ), qCeil( rect.height() ) );
|
|
size *= devicePixelRatio;
|
|
|
|
const QSize minSize = context->sceneGraphContext()->minimumFBOSize();
|
|
|
|
while ( size.width() < minSize.width() )
|
|
size.rwidth() *= 2;
|
|
|
|
while ( size.height() < minSize.height() )
|
|
size.rheight() *= 2;
|
|
|
|
return size;
|
|
}
|
|
|
|
QRectF rect;
|
|
const qreal devicePixelRatio;
|
|
|
|
Renderer* renderer = nullptr;
|
|
QSGDefaultRenderContext* context = nullptr;
|
|
};
|
|
|
|
QskSceneTexture::QskSceneTexture( const QQuickWindow* window )
|
|
: Inherited( *new QskSceneTexturePrivate( window, this ) )
|
|
{
|
|
Q_ASSERT( d_func()->context );
|
|
}
|
|
|
|
QskSceneTexture::~QskSceneTexture()
|
|
{
|
|
delete d_func()->renderer;
|
|
}
|
|
|
|
QSize QskSceneTexture::textureSize() const
|
|
{
|
|
Q_D( const QskSceneTexture );
|
|
return d->renderer ? d->renderer->textureSize() : QSize();
|
|
}
|
|
|
|
void QskSceneTexture::render( const QSGRootNode* rootNode,
|
|
const QSGTransformNode* finalNode, const QRectF& rect )
|
|
{
|
|
Q_D( QskSceneTexture );
|
|
|
|
d->rect = rect;
|
|
|
|
if ( d->renderer == nullptr )
|
|
{
|
|
d->renderer = new Renderer( this, d->context );
|
|
d->renderer->setDevicePixelRatio( d->devicePixelRatio );
|
|
}
|
|
|
|
d->renderer->setRootNode( const_cast< QSGRootNode* >( rootNode ) );
|
|
d->renderer->setFinalNode( const_cast< QSGTransformNode* >( finalNode ) );
|
|
|
|
d->renderer->setProjection( d->rect );
|
|
d->renderer->setTextureSize( d->pixelSize() );
|
|
d->renderer->renderScene();
|
|
}
|
|
|
|
bool QskSceneTexture::isDirty() const
|
|
{
|
|
Q_D( const QskSceneTexture );
|
|
return d->renderer ? d->renderer->isDirty() : true;
|
|
}
|
|
|
|
QRectF QskSceneTexture::normalizedTextureSubRect() const
|
|
{
|
|
return QRectF( 0, 1, 1, -1 );
|
|
}
|
|
|
|
bool QskSceneTexture::hasAlphaChannel() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool QskSceneTexture::hasMipmaps() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
|
|
|
|
void QskSceneTexture::bind()
|
|
{
|
|
if ( d_func()->rhiTexture() == nullptr )
|
|
{
|
|
auto funcs = QOpenGLContext::currentContext()->functions();
|
|
funcs->glBindTexture( GL_TEXTURE_2D, textureId() );
|
|
|
|
updateBindOptions();
|
|
}
|
|
}
|
|
|
|
int QskSceneTexture::textureId() const
|
|
{
|
|
Q_D( const QskSceneTexture );
|
|
return d->renderer ? d->renderer->textureId() : 0;
|
|
}
|
|
|
|
#else
|
|
|
|
qint64 QskSceneTexture::comparisonKey() const
|
|
{
|
|
return qint64( rhiTexture() );
|
|
}
|
|
|
|
QRhiTexture* QskSceneTexture::rhiTexture() const
|
|
{
|
|
Q_D( const QskSceneTexture );
|
|
return d->renderer ? d->renderer->rhiTexture() : nullptr;
|
|
}
|
|
|
|
#endif
|
|
|
|
#include "moc_QskSceneTexture.cpp"
|