168492376
/
qskinny
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

classes moved from parrot to src/nodes

This commit is contained in:
Uwe Rathmann 2023-12-16 12:27:09 +01:00
parent 3e32a14264
commit e0acd82619
8 changed files with 348 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
playground/parrots/CMakeLists.txt
View File

@ -6,7 +6,6 @@
set(SOURCES
Overlay.h Overlay.cpp
BlurringNode.h BlurringNode.cpp
SceneTexture.h SceneTexture.cpp
main.cpp)
qt_add_resources(SOURCES images.qrc shaders.qrc)

29
playground/parrots/Overlay.cpp
View File

@ -5,8 +5,8 @@
#include "Overlay.h"
#include "BlurringNode.h"
#include "SceneTexture.h"
#include <QskSceneTexture.h>
#include <QskTreeNode.h>
#include <private/qquickitem_p.h>
@ -112,9 +112,6 @@ QSGNode* Overlay::updatePaintNode( QSGNode* oldNode, UpdatePaintNodeData* )
auto grabbedNode = d->grabbedNode();
if ( grabbedNode == nullptr )
QMetaObject::invokeMethod( this, &QQuickItem::update );
if ( grabbedNode == nullptr || size().isEmpty() )
{
delete oldNode;
@ -127,26 +124,30 @@ QSGNode* Overlay::updatePaintNode( QSGNode* oldNode, UpdatePaintNodeData* )
{
node = new BlurringNode();
auto texture = new SceneTexture( d->sceneGraphRenderContext() );
auto texture = new QskSceneTexture( d->sceneGraphRenderContext() );
texture->setDevicePixelRatio( window()->effectiveDevicePixelRatio() );
connect( texture, &QskSceneTexture::updateRequested,
this, &QQuickItem::update );
node->setTexture( texture );
}
auto texture = static_cast< SceneTexture* >( node->texture() );
auto texture = qobject_cast< QskSceneTexture* >( node->texture() );
Q_ASSERT( texture );
if ( !texture->isRendering() )
{
texture->setFiltering( smooth() ? QSGTexture::Linear : QSGTexture::Nearest );
texture->setFiltering( smooth() ? QSGTexture::Linear : QSGTexture::Nearest );
texture->render( grabbedNode, d->itemNode(),
QRectF( x(), y(), width(), height() ) );
QMetaObject::invokeMethod( this, &QQuickItem::update );
}
texture->render( grabbedNode, d->itemNode(),
QRectF( x(), y(), width(), height() ) );
node->setRect( QRectF( 0, 0, width(), height() ) );
#if 0
// always updating ...
QMetaObject::invokeMethod( this, &QQuickItem::update );
#endif
return node;
}

263
playground/parrots/SceneTexture.cpp
View File

@ -1,263 +0,0 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* SPDX-License-Identifier: BSD-3-Clause
*****************************************************************************/
#include "SceneTexture.h"
#include <QskTreeNode.h>
#include <private/qsgbatchrenderer_p.h>
namespace
{
class Renderer : public QSGBatchRenderer::Renderer
{
using Inherited = QSGBatchRenderer::Renderer;
public:
Renderer( QSGDefaultRenderContext* context )
: Inherited( context, renderMode( context ) )
{
setClearColor( Qt::transparent );
}
~Renderer() override
{
clearTarget();
}
void setFinalNode( QSGTransformNode* node )
{
if ( node != m_finalNode )
{
m_finalNode = node;
}
}
QRhiTexture* texture() const { return m_rhiTexture; }
void setProjection( const QRectF& rect )
{
const auto rhi = context()->rhi();
auto r = rect;
if ( rhi->isYUpInFramebuffer() )
{
r.moveTop( r.bottom() );
r.setHeight( -r.height() );
}
MatrixTransformFlags matrixFlags;
if ( !rhi->isYUpInNDC() )
matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;
setProjectionMatrixToRect( r, matrixFlags );
}
void setTextureSize( const QSize& size )
{
if ( m_rt.rt && m_rt.rt->pixelSize() != size )
clearTarget();
if ( m_rt.rt == nullptr )
createTarget( size );
const QRect r( 0, 0, size.width(), size.height() );
setDeviceRect( r );
setViewportRect( r );
}
void render() override
{
setNodesBlocked( m_finalNode, true );
#if 0
qDebug() << "===================";
QSGNodeDumper::dump( rootNode() );
#endif
Inherited::render();
setNodesBlocked( m_finalNode, false );
}
private:
void setNodesBlocked( QSGNode* node, bool on )
{
setSubtreeBlocked( node, on );
for ( auto sibling = node->nextSibling();
sibling != nullptr; sibling = sibling->nextSibling() )
{
setSubtreeBlocked( sibling, on );
}
if ( node != rootNode() )
{
if ( auto upperNode = node->parent() )
{
upperNode = upperNode->nextSibling();
if ( upperNode )
setNodesBlocked( upperNode, on );
}
}
}
void setSubtreeBlocked( QSGNode* node, bool on )
{
if ( qskTrySubtreeBlocked( node, on, false ) )
return;
for ( auto child = node->firstChild();
child != nullptr; child = child->nextSibling() )
{
setSubtreeBlocked( child, on );
}
}
void createTarget( const QSize& size )
{
const auto rhi = context()->rhi();
auto flags = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
m_rhiTexture = rhi->newTexture( QRhiTexture::RGBA8, size, 1, flags );
m_rhiTexture->create();
QRhiColorAttachment color0( m_rhiTexture );
auto target = rhi->newTextureRenderTarget( { color0 } );
target->setRenderPassDescriptor(
target->newCompatibleRenderPassDescriptor() );
target->create();
m_rt.rt = target;
m_rt.rpDesc = target->renderPassDescriptor();
auto defaultContext = qobject_cast< QSGDefaultRenderContext* >( context() );
m_rt.cb = defaultContext->currentFrameCommandBuffer();
}
void clearTarget()
{
delete m_rt.rt;
m_rt.rt = nullptr;
delete m_rt.rpDesc;
m_rt.rpDesc = nullptr;
delete m_rhiTexture;
m_rhiTexture = nullptr;
}
private:
inline QSGRendererInterface::RenderMode renderMode(
QSGDefaultRenderContext* context ) const
{
return context->useDepthBufferFor2D()
? QSGRendererInterface::RenderMode2D
: QSGRendererInterface::RenderMode2DNoDepthBuffer;
}
QRhiTexture* m_rhiTexture = nullptr;
QSGTransformNode* m_finalNode = nullptr;
};
};
class SceneTexturePrivate final : public QSGTexturePrivate
{
public:
SceneTexturePrivate( SceneTexture* texture )
: QSGTexturePrivate( texture )
{
}
QRectF rect;
qreal devicePixelRatio = 1.0;
Renderer* renderer = nullptr;
QSGDefaultRenderContext* context = nullptr;
bool isRendering = false;
};
SceneTexture::SceneTexture( QSGRenderContext* context )
: Inherited(*( new SceneTexturePrivate(this) ) )
{
d_func()->context = static_cast< QSGDefaultRenderContext* >( context );
}
SceneTexture::~SceneTexture()
{
delete d_func()->renderer;
}
QSize SceneTexture::textureSize() const
{
Q_D( const SceneTexture );
QSize size( qCeil( d->rect.width() ), qCeil( d->rect.height() ) );
size *= d->devicePixelRatio;
const QSize minSize = d->context->sceneGraphContext()->minimumFBOSize();
while ( size.width() < minSize.width() )
size.rwidth() *= 2;
while ( size.height() < minSize.height() )
size.rheight() *= 2;
return size;
}
qint64 SceneTexture::comparisonKey() const
{
return qint64( rhiTexture() );
}
QRhiTexture* SceneTexture::rhiTexture() const
{
Q_D( const SceneTexture );
return d->renderer ? d->renderer->texture() : nullptr;
}
void SceneTexture::render( QSGRootNode* rootNode,
QSGTransformNode* finalNode, const QRectF& rect )
{
Q_D( SceneTexture );
d->rect = rect;
const auto pixelSize = textureSize();
if ( d->renderer == nullptr )
{
d->renderer = new Renderer( d->context );
d->renderer->setDevicePixelRatio( d->devicePixelRatio );
}
d->renderer->setRootNode( rootNode );
d->renderer->setFinalNode( finalNode );
d->renderer->setProjection( d->rect );
d->renderer->setTextureSize( pixelSize );
d->isRendering = true;
d->renderer->renderScene();
d->isRendering = false;
}
bool SceneTexture::isRendering() const
{
return d_func()->isRendering;
}
void SceneTexture::setDevicePixelRatio( qreal ratio )
{
d_func()->devicePixelRatio = ratio;
}
QRectF SceneTexture::normalizedTextureSubRect() const
{
return QRectF( 0, 1, 1, -1 );
}

2
src/CMakeLists.txt
View File

@ -120,6 +120,7 @@ list(APPEND HEADERS
nodes/QskPaintedNode.h
nodes/QskPlainTextRenderer.h
nodes/QskRichTextRenderer.h
nodes/QskSceneTexture.h
nodes/QskSGNode.h
nodes/QskStrokeNode.h
nodes/QskStippledLineRenderer.h
@ -158,6 +159,7 @@ list(APPEND SOURCES
nodes/QskPlainTextRenderer.cpp
nodes/QskRectangleNode.cpp
nodes/QskRichTextRenderer.cpp
nodes/QskSceneTexture.cpp
nodes/QskSGNode.cpp
nodes/QskStrokeNode.cpp
nodes/QskStippledLineRenderer.cpp

268
src/nodes/QskSceneTexture.cpp Normal file
View File

@ -0,0 +1,268 @@
/******************************************************************************
* QSkinny - Copyright (C) 2016 Uwe Rathmann
* SPDX-License-Identifier: BSD-3-Clause
*****************************************************************************/
#include "QskSceneTexture.h"
#include "QskTreeNode.h"
QSK_QT_PRIVATE_BEGIN
#include <private/qsgbatchrenderer_p.h>
QSK_QT_PRIVATE_END
namespace
{
inline QSGRendererInterface::RenderMode contextRenderMode(
QSGDefaultRenderContext* context )
{
return context->useDepthBufferFor2D()
? QSGRendererInterface::RenderMode2D
: QSGRendererInterface::RenderMode2DNoDepthBuffer;
}
class Renderer final : public QSGBatchRenderer::Renderer
{
using Inherited = QSGBatchRenderer::Renderer;
public:
Renderer( QskSceneTexture*, QSGDefaultRenderContext* );
~Renderer() override;
void setFinalNode( QSGTransformNode* );
QRhiTexture* texture() const { return m_rhiTexture; }
void setProjection( const QRectF& );
void setTextureSize( const QSize& );
protected:
void nodeChanged( QSGNode*, QSGNode::DirtyState ) override;
void render() override;
private:
void createTarget( const QSize& );
void clearTarget();
private:
QRhiTexture* m_rhiTexture = nullptr;
QSGTransformNode* m_finalNode = nullptr;
QskSceneTexture* m_texture = nullptr;
};
Renderer::Renderer( QskSceneTexture* texture, QSGDefaultRenderContext* context )
: Inherited( context, contextRenderMode( context ) )
, m_texture( texture )
{
setClearColor( Qt::transparent );
}
Renderer::~Renderer()
{
clearTarget();
}
void Renderer::setFinalNode( QSGTransformNode* node )
{
if ( node != m_finalNode )
{
m_finalNode = node;
}
}
void Renderer::setProjection( const QRectF& rect )
{
const auto rhi = context()->rhi();
auto r = rect;
if ( rhi->isYUpInFramebuffer() )
{
r.moveTop( r.bottom() );
r.setHeight( -r.height() );
}
MatrixTransformFlags matrixFlags;
if ( !rhi->isYUpInNDC() )
matrixFlags |= QSGAbstractRenderer::MatrixTransformFlipY;
setProjectionMatrixToRect( r, matrixFlags );
}
void Renderer::setTextureSize( const QSize& size )
{
if ( m_rt.rt && m_rt.rt->pixelSize() != size )
clearTarget();
if ( m_rt.rt == nullptr )
createTarget( size );
const QRect r( 0, 0, size.width(), size.height() );
setDeviceRect( r );
setViewportRect( r );
}
void Renderer::render()
{
qskTryBlockTrailingNodes( m_finalNode, rootNode(), true, false );
#if 0
QSGNodeDumper::dump( rootNode() );
#endif
Inherited::render();
qskTryBlockTrailingNodes( m_finalNode, rootNode(), false, false );
}
void Renderer::nodeChanged( QSGNode* node, QSGNode::DirtyState state )
{
// do not forward nodes that are blocked while rendering
const bool isTrailingNode = false; // TODO ...
if ( !isTrailingNode )
{
Inherited::nodeChanged( node, state );
Q_EMIT m_texture->updateRequested();
}
}
void Renderer::createTarget( const QSize& size )
{
const auto rhi = context()->rhi();
auto flags = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
m_rhiTexture = rhi->newTexture( QRhiTexture::RGBA8, size, 1, flags );
m_rhiTexture->create();
QRhiColorAttachment color0( m_rhiTexture );
auto target = rhi->newTextureRenderTarget( { color0 } );
target->setRenderPassDescriptor(
target->newCompatibleRenderPassDescriptor() );
target->create();
m_rt.rt = target;
m_rt.rpDesc = target->renderPassDescriptor();
auto defaultContext = qobject_cast< QSGDefaultRenderContext* >( context() );
m_rt.cb = defaultContext->currentFrameCommandBuffer();
}
void Renderer::clearTarget()
{
delete m_rt.rt;
m_rt.rt = nullptr;
delete m_rt.rpDesc;
m_rt.rpDesc = nullptr;
delete m_rhiTexture;
m_rhiTexture = nullptr;
}
}
class QskSceneTexturePrivate final : public QSGTexturePrivate
{
public:
QskSceneTexturePrivate( QskSceneTexture* texture )
: QSGTexturePrivate( texture )
{
}
QRectF rect;
qreal devicePixelRatio = 1.0;
Renderer* renderer = nullptr;
QSGDefaultRenderContext* context = nullptr;
};
QskSceneTexture::QskSceneTexture( QSGRenderContext* context )
: Inherited(*( new QskSceneTexturePrivate(this) ) )
{
d_func()->context = static_cast< QSGDefaultRenderContext* >( context );
}
QskSceneTexture::~QskSceneTexture()
{
delete d_func()->renderer;
}
QSize QskSceneTexture::textureSize() const
{
Q_D( const QskSceneTexture );
QSize size( qCeil( d->rect.width() ), qCeil( d->rect.height() ) );
size *= d->devicePixelRatio;
const QSize minSize = d->context->sceneGraphContext()->minimumFBOSize();
while ( size.width() < minSize.width() )
size.rwidth() *= 2;
while ( size.height() < minSize.height() )
size.rheight() *= 2;
return size;
}
qint64 QskSceneTexture::comparisonKey() const
{
return qint64( rhiTexture() );
}
QRhiTexture* QskSceneTexture::rhiTexture() const
{
Q_D( const QskSceneTexture );
return d->renderer ? d->renderer->texture() : nullptr;
}
void QskSceneTexture::render( QSGRootNode* rootNode,
QSGTransformNode* finalNode, const QRectF& rect )
{
Q_D( QskSceneTexture );
d->rect = rect;
const auto pixelSize = textureSize();
if ( d->renderer == nullptr )
{
d->renderer = new Renderer( this, d->context );
d->renderer->setDevicePixelRatio( d->devicePixelRatio );
}
d->renderer->setRootNode( rootNode );
d->renderer->setFinalNode( finalNode );
d->renderer->setProjection( d->rect );
d->renderer->setTextureSize( pixelSize );
d->renderer->renderScene();
}
void QskSceneTexture::setDevicePixelRatio( qreal ratio )
{
d_func()->devicePixelRatio = ratio;
}
QRectF QskSceneTexture::normalizedTextureSubRect() const
{
return QRectF( 0, 1, 1, -1 );
}
bool QskSceneTexture::hasAlphaChannel() const
{
return false;
}
bool QskSceneTexture::hasMipmaps() const
{
return false;
}
void QskSceneTexture::commitTextureOperations( QRhi*, QRhiResourceUpdateBatch* )
{
// what to do here ?
}
#include "moc_QskSceneTexture.cpp"

31
playground/parrots/SceneTexture.h → src/nodes/QskSceneTexture.h
View File

@ -3,23 +3,27 @@
* SPDX-License-Identifier: BSD-3-Clause
*****************************************************************************/
#pragma once
#ifndef QSK_SCENE_TEXTURE_H
#define QSK_SCENE_TEXTURE_H
#include "QskGlobal.h"
#include <qsgtexture.h>
class SceneTexturePrivate;
class QskSceneTexturePrivate;
class QSGRenderContext;
class QSGRootNode;
class QSGTransformNode;
class SceneTexture : public QSGTexture
class QSK_EXPORT QskSceneTexture : public QSGTexture // QSGDynamicTexture: TODO ...
{
Q_OBJECT
using Inherited = QSGTexture;
public:
SceneTexture( QSGRenderContext* );
~SceneTexture();
QskSceneTexture( QSGRenderContext* );
~QskSceneTexture();
void setDevicePixelRatio( qreal );
void render( QSGRootNode*, QSGTransformNode*, const QRectF& );
@ -31,13 +35,16 @@ class SceneTexture : public QSGTexture
QRectF normalizedTextureSubRect() const override;
bool isRendering() const;
// satisfy the QSGTexture API
bool hasAlphaChannel() const override;
bool hasMipmaps() const override;
void commitTextureOperations( QRhi*, QRhiResourceUpdateBatch* ) override;
Q_SIGNALS:
void updateRequested();
private:
// satisfy the QSGTexture API
bool hasAlphaChannel() const override { return false; }
bool hasMipmaps() const override { return false; }
void commitTextureOperations( QRhi*, QRhiResourceUpdateBatch* ) override {}
Q_DECLARE_PRIVATE( SceneTexture )
Q_DECLARE_PRIVATE( QskSceneTexture )
};
#endif

38
src/nodes/QskTreeNode.cpp
View File

@ -97,7 +97,7 @@ const QskItemNode* qskItemNodeCast( const QSGNode* node )
qskCheckedNode( node, QSGNode::TransformNodeType ) );
}
bool qskIsNodeBlockable( const QSGNode* node )
bool qskIsBlockableNode( const QSGNode* node )
{
switch( node->type() )
{
@ -110,7 +110,7 @@ bool qskIsNodeBlockable( const QSGNode* node )
}
}
bool qskTrySubtreeBlocked( QSGNode* node, bool on, bool notify )
bool qskTryBlockNode( QSGNode* node, bool on, bool notify )
{
if ( node && ( node->flags() & extraFlag ) )
{
@ -129,3 +129,37 @@ bool qskTrySubtreeBlocked( QSGNode* node, bool on, bool notify )
return false;
}
void qskTryBlockTree( QSGNode* node, bool on, bool notify )
{
if ( qskTryBlockNode( node, on, notify ) )
return;
for ( auto child = node->firstChild();
child != nullptr; child = child->nextSibling() )
{
qskTryBlockTree( child, on, notify );
}
}
void qskTryBlockTrailingNodes(
QSGNode* node, const QSGNode* ancestorNode, bool on, bool notify )
{
qskTryBlockTree( node, on, notify );
for ( auto sibling = node->nextSibling();
sibling != nullptr; sibling = sibling->nextSibling() )
{
qskTryBlockTree( sibling, on, notify );
}
if ( node != ancestorNode )
{
if ( auto upperNode = node->parent() )
{
upperNode = upperNode->nextSibling();
if ( upperNode )
qskTryBlockTrailingNodes( upperNode, ancestorNode, on, notify );
}
}
}

10
src/nodes/QskTreeNode.h
View File

@ -51,7 +51,13 @@ class QSK_EXPORT QskItemNode final : public QSGTransformNode
QSK_EXPORT QskItemNode* qskItemNodeCast( QSGNode* );
QSK_EXPORT const QskItemNode* qskItemNodeCast( const QSGNode* );
QSK_EXPORT bool qskIsNodeBlockable( const QSGNode* );
QSK_EXPORT bool qskTrySubtreeBlocked( QSGNode*, bool on, bool notify = true );
QSK_EXPORT bool qskIsBlockableNode( const QSGNode* );
QSK_EXPORT bool qskTryBlockNode( QSGNode*, bool on, bool notify = true );
QSK_EXPORT void qskTryBlockTree( QSGNode*, bool on, bool notify = true );
// un/block a node and all its successors in the rendering pipeline
QSK_EXPORT void qskTryBlockTrailingNodes(
QSGNode*, const QSGNode* ancestorNode, bool on, bool notify = true );
#endif