sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-12-15 00:07:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

feat(3d/renderview): extract forward render view to dedicated renderview class

Browse Source
This commit is contained in:
bdm-oslandia 2025-03-04 15:44:11 +01:00 committed by Jean Felder
parent 47965755ee
commit e69c09eb29
11 changed files with 572 additions and 347 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/3d/CMakeLists.txt
View File

@ -81,6 +81,7 @@ set(QGIS_3D_SRCS
framegraph/qgs3daxisrenderview.cpp
framegraph/qgsambientocclusionrenderentity.cpp
framegraph/qgsambientocclusionblurentity.cpp
framegraph/qgsforwardrenderview.cpp
framegraph/qgspostprocessingentity.cpp
framegraph/qgspreviewquad.cpp
framegraph/qgsrenderpassquad.cpp
@ -190,6 +191,7 @@ set(QGIS_3D_HDRS
framegraph/qgs3daxisrenderview.h
framegraph/qgsambientocclusionrenderentity.h
framegraph/qgsambientocclusionblurentity.h
framegraph/qgsforwardrenderview.h
framegraph/qgsframegraph.h
framegraph/qgsframegraphutils.h
framegraph/qgspostprocessingentity.h

292
src/3d/framegraph/qgsforwardrenderview.cpp Normal file
View File

@ -0,0 +1,292 @@
/***************************************************************************
qgsforwardrenderview.cpp
--------------------------------------
Date : June 2024
Copyright : (C) 2024 by Benoit De Mezzo and (C) 2020 by Belgacem Nedjima
Email : benoit dot de dot mezzo at oslandia dot com
***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "qgsforwardrenderview.h"
#include "moc_qgsforwardrenderview.cpp"
#include <Qt3DRender/QCamera>
#include <Qt3DRender/QViewport>
#include <Qt3DRender/QCameraSelector>
#include <Qt3DRender/QLayerFilter>
#include <Qt3DRender/QLayer>
#include <Qt3DRender/QRenderTargetSelector>
#include <Qt3DRender/QRenderTarget>
#include <Qt3DRender/QTexture>
#include <Qt3DRender/QClearBuffers>
#include <Qt3DRender/QParameter>
#include <Qt3DRender/QFrustumCulling>
#include <Qt3DRender/QRenderStateSet>
#include <Qt3DRender/QDepthTest>
#include <Qt3DRender/QCullFace>
#include <Qt3DRender/QPolygonOffset>
#include <Qt3DRender/qsubtreeenabler.h>
#include <Qt3DRender/QBlendEquation>
#include <Qt3DRender/QColorMask>
#include <Qt3DRender/QSortPolicy>
#include <Qt3DRender/QNoDepthMask>
#include <Qt3DRender/QBlendEquationArguments>
#include <Qt3DRender/QClipPlane>
#if QT_VERSION >= QT_VERSION_CHECK( 5, 15, 0 )
#include <Qt3DRender/QDebugOverlay>
#endif
QgsForwardRenderView::QgsForwardRenderView( QObject *parent, Qt3DRender::QCamera *mainCamera )
: QgsAbstractRenderView( parent, "forward" )
, mMainCamera( mainCamera )
{
mRenderLayer = new Qt3DRender::QLayer;
mRenderLayer->setRecursive( true );
mRenderLayer->setObjectName( objectName() + "::Layer" );
mTransparentObjectsLayer = new Qt3DRender::QLayer;
mTransparentObjectsLayer->setRecursive( true );
mTransparentObjectsLayer->setObjectName( objectName() + "::TransparentLayer" );
// forward rendering pass
buildRenderPasses();
}
Qt3DRender::QRenderTarget *QgsForwardRenderView::buildTextures()
{
mColorTexture = new Qt3DRender::QTexture2D;
mColorTexture->setFormat( Qt3DRender::QAbstractTexture::RGB8_UNorm );
mColorTexture->setGenerateMipMaps( false );
mColorTexture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
mColorTexture->setMinificationFilter( Qt3DRender::QTexture2D::Linear );
mColorTexture->wrapMode()->setX( Qt3DRender::QTextureWrapMode::ClampToEdge );
mColorTexture->wrapMode()->setY( Qt3DRender::QTextureWrapMode::ClampToEdge );
mDepthTexture = new Qt3DRender::QTexture2D;
mDepthTexture->setFormat( Qt3DRender::QTexture2D::TextureFormat::DepthFormat );
mDepthTexture->setGenerateMipMaps( false );
mDepthTexture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
mDepthTexture->setMinificationFilter( Qt3DRender::QTexture2D::Linear );
mDepthTexture->wrapMode()->setX( Qt3DRender::QTextureWrapMode::ClampToEdge );
mDepthTexture->wrapMode()->setY( Qt3DRender::QTextureWrapMode::ClampToEdge );
Qt3DRender::QRenderTarget *renderTarget = new Qt3DRender::QRenderTarget;
Qt3DRender::QRenderTargetOutput *renderTargetDepthOutput = new Qt3DRender::QRenderTargetOutput;
renderTargetDepthOutput->setAttachmentPoint( Qt3DRender::QRenderTargetOutput::Depth );
renderTargetDepthOutput->setTexture( mDepthTexture );
renderTarget->addOutput( renderTargetDepthOutput );
Qt3DRender::QRenderTargetOutput *renderTargetColorOutput = new Qt3DRender::QRenderTargetOutput;
renderTargetColorOutput->setAttachmentPoint( Qt3DRender::QRenderTargetOutput::Color0 );
renderTargetColorOutput->setTexture( mColorTexture );
renderTarget->addOutput( renderTargetColorOutput );
return renderTarget;
}
/*
* We define three forward passes: one for solid objects, followed by two for transparent objects (one to write colors but no depths, one to write depths) :
*
* |
* +-----------------+
* | QCameraSelector | (using the main camera)
* +-----------------+
* |
* +-----------------+
* | QLayerFilter | (using mForwardRenderLayer)
* +-----------------+
* |
* +-----------------+
* | QRenderStateSet | define clip planes
* +-----------------+
* |
* +-----------------------+
* | QRenderTargetSelector | (write mForwardColorTexture + mForwardDepthTexture)
* +-----------------------+
* |
* +------------------------+---------------------+
* | |
* +-----------------+ discard +-----------------+ accept
* | QLayerFilter | transparent | QLayerFilter | transparent
* +-----------------+ objects +-----------------+ objects
* | |
* +-----------------+ use depth test +-----------------+ sort entities
* | QRenderStateSet | cull back faces | QSortPolicy | back to front
* +-----------------+ +-----------------+
* | |
* +-----------------+ +--------------------+--------------------+
* | QFrustumCulling | | |
* +-----------------+ +-----------------+ use depth tests +-----------------+ use depth tests
* | | QRenderStateSet | don't write depths | QRenderStateSet | write depths
* | +-----------------+ write colors +-----------------+ don't write colors
* +-----------------+ use alpha blending don't use alpha blending
* | QClearBuffers | color and depth no culling no culling
* +-----------------+
* |
* +-----------------+
* | QDebugOverlay |
* +-----------------+
*
*/
void QgsForwardRenderView::buildRenderPasses()
{
mMainCameraSelector = new Qt3DRender::QCameraSelector( mRendererEnabler );
mMainCameraSelector->setObjectName( objectName() + "::CameraSelector" );
mMainCameraSelector->setCamera( mMainCamera );
mLayerFilter = new Qt3DRender::QLayerFilter( mMainCameraSelector );
mLayerFilter->addLayer( mRenderLayer );
mClipRenderStateSet = new Qt3DRender::QRenderStateSet( mLayerFilter );
mClipRenderStateSet->setObjectName( objectName() + "::Clip Plane RenderStateSet" );
Qt3DRender::QRenderTarget *renderTarget = buildTextures();
mRenderTargetSelector = new Qt3DRender::QRenderTargetSelector( mClipRenderStateSet );
mRenderTargetSelector->setTarget( renderTarget );
// first branch: opaque layer filter
Qt3DRender::QLayerFilter *opaqueObjectsFilter = new Qt3DRender::QLayerFilter( mRenderTargetSelector );
opaqueObjectsFilter->addLayer( mTransparentObjectsLayer );
opaqueObjectsFilter->setFilterMode( Qt3DRender::QLayerFilter::DiscardAnyMatchingLayers );
Qt3DRender::QRenderStateSet *renderStateSet = new Qt3DRender::QRenderStateSet( opaqueObjectsFilter );
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
renderStateSet->addRenderState( depthTest );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::Back );
renderStateSet->addRenderState( cullFace );
mFrustumCulling = new Qt3DRender::QFrustumCulling( renderStateSet );
mClearBuffers = new Qt3DRender::QClearBuffers( mFrustumCulling );
mClearBuffers->setClearColor( QColor::fromRgbF( 0.0, 0.0, 1.0, 1.0 ) );
mClearBuffers->setBuffers( Qt3DRender::QClearBuffers::ColorDepthBuffer );
mClearBuffers->setClearDepthValue( 1.0f );
// second branch: transparent layer filter - color
Qt3DRender::QLayerFilter *transparentObjectsLayerFilter = new Qt3DRender::QLayerFilter( mRenderTargetSelector );
transparentObjectsLayerFilter->addLayer( mTransparentObjectsLayer );
transparentObjectsLayerFilter->setFilterMode( Qt3DRender::QLayerFilter::AcceptAnyMatchingLayers );
Qt3DRender::QSortPolicy *sortPolicy = new Qt3DRender::QSortPolicy( transparentObjectsLayerFilter );
QVector<Qt3DRender::QSortPolicy::SortType> sortTypes;
sortTypes.push_back( Qt3DRender::QSortPolicy::BackToFront );
sortPolicy->setSortTypes( sortTypes );
Qt3DRender::QRenderStateSet *transparentObjectsRenderStateSetColor = new Qt3DRender::QRenderStateSet( sortPolicy );
{
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
transparentObjectsRenderStateSetColor->addRenderState( depthTest );
Qt3DRender::QNoDepthMask *noDepthMask = new Qt3DRender::QNoDepthMask;
transparentObjectsRenderStateSetColor->addRenderState( noDepthMask );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::NoCulling );
transparentObjectsRenderStateSetColor->addRenderState( cullFace );
Qt3DRender::QBlendEquation *blendEquation = new Qt3DRender::QBlendEquation;
blendEquation->setBlendFunction( Qt3DRender::QBlendEquation::Add );
transparentObjectsRenderStateSetColor->addRenderState( blendEquation );
Qt3DRender::QBlendEquationArguments *blendEquationArgs = new Qt3DRender::QBlendEquationArguments;
blendEquationArgs->setSourceRgb( Qt3DRender::QBlendEquationArguments::Blending::SourceAlpha );
blendEquationArgs->setDestinationRgb( Qt3DRender::QBlendEquationArguments::Blending::OneMinusSourceAlpha );
transparentObjectsRenderStateSetColor->addRenderState( blendEquationArgs );
}
// third branch: transparent layer filter - depth
Qt3DRender::QRenderStateSet *transparentObjectsRenderStateSetDepth = new Qt3DRender::QRenderStateSet( sortPolicy );
{
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
transparentObjectsRenderStateSetDepth->addRenderState( depthTest );
Qt3DRender::QColorMask *noColorMask = new Qt3DRender::QColorMask;
noColorMask->setAlphaMasked( false );
noColorMask->setRedMasked( false );
noColorMask->setGreenMasked( false );
noColorMask->setBlueMasked( false );
transparentObjectsRenderStateSetDepth->addRenderState( noColorMask );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::NoCulling );
transparentObjectsRenderStateSetDepth->addRenderState( cullFace );
}
mDebugOverlay = new Qt3DRender::QDebugOverlay( mClearBuffers );
mDebugOverlay->setEnabled( false );
}
void QgsForwardRenderView::updateWindowResize( int width, int height )
{
mColorTexture->setSize( width, height );
mDepthTexture->setSize( width, height );
}
void QgsForwardRenderView::setClearColor( const QColor &clearColor )
{
mClearBuffers->setClearColor( clearColor );
}
void QgsForwardRenderView::setFrustumCullingEnabled( bool enabled )
{
if ( enabled == mFrustumCullingEnabled )
return;
mFrustumCullingEnabled = enabled;
mFrustumCulling->setEnabled( enabled );
}
void QgsForwardRenderView::setDebugOverlayEnabled( bool enabled )
{
mDebugOverlay->setEnabled( enabled );
}
Qt3DRender::QTexture2D *QgsForwardRenderView::depthTexture() const
{
return mDepthTexture;
}
Qt3DRender::QTexture2D *QgsForwardRenderView::colorTexture() const
{
return mColorTexture;
}
void QgsForwardRenderView::removeClipPlanes()
{
for ( Qt3DRender::QRenderState *state : mClipRenderStateSet->renderStates() )
{
if ( qobject_cast<Qt3DRender::QClipPlane *>( state ) )
{
mClipRenderStateSet->removeRenderState( state );
}
}
}
void QgsForwardRenderView::addClipPlanes( int nrClipPlanes )
{
// remove existing QClipPlane
removeClipPlanes();
// create new QClipPlane
for ( int i = 0; i < nrClipPlanes; ++i )
{
Qt3DRender::QClipPlane *clipPlane = new Qt3DRender::QClipPlane;
clipPlane->setPlaneIndex( i );
mClipRenderStateSet->addRenderState( clipPlane );
}
}

133
src/3d/framegraph/qgsforwardrenderview.h Normal file
View File

@ -0,0 +1,133 @@
/***************************************************************************
qgsforwardrenderview.h
--------------------------------------
Date : June 2024
Copyright : (C) 2024 by Benoit De Mezzo and (C) 2020 by Belgacem Nedjima
Email : benoit dot de dot mezzo at oslandia dot com
***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSFORWARDRENDERVIEW_H
#define QGSFORWARDRENDERVIEW_H
#include "qgsabstractrenderview.h"
namespace Qt3DRender
{
class QRenderSettings;
class QLayer;
class QSubtreeEnabler;
class QTexture2D;
class QCamera;
class QCameraSelector;
class QLayerFilter;
class QRenderTargetSelector;
class QRenderTarget;
class QClearBuffers;
class QFrustumCulling;
class QRenderStateSet;
class QDebugOverlay;
} // namespace Qt3DRender
#define SIP_NO_FILE
/**
* \ingroup 3d
* \brief Container class that holds different objects related to forward rendering
* \note Not available in Python bindings
*
* \since QGIS 3.44
*/
class QgsForwardRenderView : public QgsAbstractRenderView
{
Q_OBJECT
public:
//! Constructor with 3D scene camera
QgsForwardRenderView( QObject *parent, Qt3DRender::QCamera *mainCamera );
//! Returns a layer object used to indicate that the object is transparent
Qt3DRender::QLayer *renderLayer() { return mRenderLayer; }
//! Returns a layer object used to indicate that the object is transparent
Qt3DRender::QLayer *transparentObjectLayer() { return mTransparentObjectsLayer; }
//! Sets the clear color of the scene (background color)
void setClearColor( const QColor &clearColor );
//! Returns whether frustum culling is enabled
bool isFrustumCullingEnabled() const { return mFrustumCullingEnabled; }
//! Sets whether frustum culling is enabled
void setFrustumCullingEnabled( bool enabled );
//! Sets whether debug overlay is enabled
void setDebugOverlayEnabled( bool enabled );
//! Returns current render target selector
Qt3DRender::QRenderTargetSelector *renderTargetSelector() { return mRenderTargetSelector; }
virtual void updateWindowResize( int width, int height ) override;
//! Returns forward depth texture
Qt3DRender::QTexture2D *depthTexture() const;
//! Returns forward color texture
Qt3DRender::QTexture2D *colorTexture() const;
/**
* Setups \a nrClipPlanes clip planes in the forward pass to enable OpenGL clipping.
* If \a nrClipPlanes is equal to 0, the clipping is disabled.
*
* \see removeClipPlanes()
* \since QGIS 3.40
*/
void addClipPlanes( int nrClipPlanes );
/**
* Disables OpenGL clipping
*
* \see addClipPlanes()
* \since QGIS 3.40
*/
void removeClipPlanes();
private:
Qt3DRender::QCamera *mMainCamera = nullptr;
Qt3DRender::QCameraSelector *mMainCameraSelector = nullptr;
Qt3DRender::QLayerFilter *mLayerFilter = nullptr;
Qt3DRender::QRenderTargetSelector *mRenderTargetSelector = nullptr;
// clip planes render state
Qt3DRender::QRenderStateSet *mClipRenderStateSet = nullptr;
Qt3DRender::QLayer *mRenderLayer = nullptr;
Qt3DRender::QLayer *mTransparentObjectsLayer = nullptr;
Qt3DRender::QClearBuffers *mClearBuffers = nullptr;
bool mFrustumCullingEnabled = true;
Qt3DRender::QFrustumCulling *mFrustumCulling = nullptr;
// Forward rendering pass texture related objects:
Qt3DRender::QTexture2D *mColorTexture = nullptr;
Qt3DRender::QTexture2D *mDepthTexture = nullptr;
// QDebugOverlay added in the forward pass
#if QT_VERSION >= QT_VERSION_CHECK( 5, 15, 0 )
Qt3DRender::QDebugOverlay *mDebugOverlay = nullptr;
#endif
/**
* Builds the three forward passes needed by forward: one for solid objects, followed by two for transparent objects
*/
void buildRenderPasses();
/**
* Build color and depth textures and add then to a new rendertarget
*/
Qt3DRender::QRenderTarget *buildTextures();
};
#endif // QGSFORWARDRENDERVIEW_H

229
src/3d/framegraph/qgsframegraph.cpp
View File

@ -54,178 +54,20 @@ typedef Qt3DCore::QGeometry Qt3DQGeometry;
#include <Qt3DRender/QBlendEquationArguments>
#include <Qt3DRender/QAbstractTexture>
#include <Qt3DRender/QNoDraw>
#include <Qt3DRender/QClipPlane>
#include "qgsshadowrenderview.h"
#include "qgsforwardrenderview.h"
const QString QgsFrameGraph::FORWARD_RENDERVIEW = "forward";
const QString QgsFrameGraph::SHADOW_RENDERVIEW = "shadow";
const QString QgsFrameGraph::AXIS3D_RENDERVIEW = "3daxis";
Qt3DRender::QFrameGraphNode *QgsFrameGraph::constructForwardRenderPass()
void QgsFrameGraph::constructForwardRenderPass()
{
// This is where rendering of the 3D scene actually happens.
// We define two forward passes: one for solid objects, followed by one for transparent objects.
//
// |
// +-----------------+
// | QCameraSelector | (using the main camera)
// +-----------------+
// |
// +-----------------+
// | QLayerFilter | (using mForwardRenderLayer)
// +-----------------+
// |
// +-----------------+
// | QRenderStateSet | define clip planes
// +-----------------+
// |
// +-----------------------+
// | QRenderTargetSelector | (write mForwardColorTexture + mForwardDepthTexture)
// +-----------------------+
// |
// +------------------------+---------------------+
// | |
// +-----------------+ discard +-----------------+ accept
// | QLayerFilter | transparent | QLayerFilter | transparent
// +-----------------+ objects +-----------------+ objects
// | |
// +-----------------+ use depth test +-----------------+ sort entities
// | QRenderStateSet | cull back faces | QSortPolicy | back to front
// +-----------------+ +-----------------+
// | |
// +-----------------+ +--------------------+--------------------+
// | QFrustumCulling | | |
// +-----------------+ +-----------------+ use depth tests +-----------------+ use depth tests
// | | QRenderStateSet | don't write depths | QRenderStateSet | write depths
// | +-----------------+ write colors +-----------------+ don't write colors
// +-----------------+ use alpha blending don't use alpha blending
// | QClearBuffers | color and depth no culling no culling
// +-----------------+
mMainCameraSelector = new Qt3DRender::QCameraSelector;
mMainCameraSelector->setObjectName( "Forward render pass CameraSelector" );
mMainCameraSelector->setCamera( mMainCamera );
mForwardRenderLayerFilter = new Qt3DRender::QLayerFilter( mMainCameraSelector );
mForwardRenderLayerFilter->addLayer( mForwardRenderLayer );
mClipRenderStateSet = new Qt3DRender::QRenderStateSet( mForwardRenderLayerFilter );
mClipRenderStateSet->setObjectName( "Forward render pass Clip Plane RenderStateSet" );
mForwardColorTexture = new Qt3DRender::QTexture2D;
mForwardColorTexture->setWidth( mSize.width() );
mForwardColorTexture->setHeight( mSize.height() );
mForwardColorTexture->setFormat( Qt3DRender::QAbstractTexture::RGB8_UNorm );
mForwardColorTexture->setGenerateMipMaps( false );
mForwardColorTexture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
mForwardColorTexture->setMinificationFilter( Qt3DRender::QTexture2D::Linear );
mForwardColorTexture->wrapMode()->setX( Qt3DRender::QTextureWrapMode::ClampToEdge );
mForwardColorTexture->wrapMode()->setY( Qt3DRender::QTextureWrapMode::ClampToEdge );
mForwardDepthTexture = new Qt3DRender::QTexture2D;
mForwardDepthTexture->setWidth( mSize.width() );
mForwardDepthTexture->setHeight( mSize.height() );
mForwardDepthTexture->setFormat( Qt3DRender::QTexture2D::TextureFormat::DepthFormat );
mForwardDepthTexture->setGenerateMipMaps( false );
mForwardDepthTexture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
mForwardDepthTexture->setMinificationFilter( Qt3DRender::QTexture2D::Linear );
mForwardDepthTexture->wrapMode()->setX( Qt3DRender::QTextureWrapMode::ClampToEdge );
mForwardDepthTexture->wrapMode()->setY( Qt3DRender::QTextureWrapMode::ClampToEdge );
Qt3DRender::QRenderTarget *forwardRenderTarget = new Qt3DRender::QRenderTarget;
Qt3DRender::QRenderTargetOutput *forwardRenderTargetDepthOutput = new Qt3DRender::QRenderTargetOutput;
forwardRenderTargetDepthOutput->setAttachmentPoint( Qt3DRender::QRenderTargetOutput::Depth );
forwardRenderTargetDepthOutput->setTexture( mForwardDepthTexture );
forwardRenderTarget->addOutput( forwardRenderTargetDepthOutput );
Qt3DRender::QRenderTargetOutput *forwardRenderTargetColorOutput = new Qt3DRender::QRenderTargetOutput;
forwardRenderTargetColorOutput->setAttachmentPoint( Qt3DRender::QRenderTargetOutput::Color0 );
forwardRenderTargetColorOutput->setTexture( mForwardColorTexture );
forwardRenderTarget->addOutput( forwardRenderTargetColorOutput );
mForwardRenderTargetSelector = new Qt3DRender::QRenderTargetSelector( mClipRenderStateSet );
mForwardRenderTargetSelector->setTarget( forwardRenderTarget );
// first branch: opaque layer filter
Qt3DRender::QLayerFilter *opaqueObjectsFilter = new Qt3DRender::QLayerFilter( mForwardRenderTargetSelector );
opaqueObjectsFilter->addLayer( mTransparentObjectsPassLayer );
opaqueObjectsFilter->setFilterMode( Qt3DRender::QLayerFilter::DiscardAnyMatchingLayers );
Qt3DRender::QRenderStateSet *forwardedRenderStateSet = new Qt3DRender::QRenderStateSet( opaqueObjectsFilter );
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
forwardedRenderStateSet->addRenderState( depthTest );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::Back );
forwardedRenderStateSet->addRenderState( cullFace );
mFrustumCulling = new Qt3DRender::QFrustumCulling( forwardedRenderStateSet );
mForwardClearBuffers = new Qt3DRender::QClearBuffers( mFrustumCulling );
mForwardClearBuffers->setClearColor( QColor::fromRgbF( 0.0, 0.0, 1.0, 1.0 ) );
mForwardClearBuffers->setBuffers( Qt3DRender::QClearBuffers::ColorDepthBuffer );
mForwardClearBuffers->setClearDepthValue( 1.0f );
// second branch: transparent layer filter - color
Qt3DRender::QLayerFilter *transparentObjectsLayerFilter = new Qt3DRender::QLayerFilter( mForwardRenderTargetSelector );
transparentObjectsLayerFilter->addLayer( mTransparentObjectsPassLayer );
transparentObjectsLayerFilter->setFilterMode( Qt3DRender::QLayerFilter::AcceptAnyMatchingLayers );
Qt3DRender::QSortPolicy *sortPolicy = new Qt3DRender::QSortPolicy( transparentObjectsLayerFilter );
QVector<Qt3DRender::QSortPolicy::SortType> sortTypes;
sortTypes.push_back( Qt3DRender::QSortPolicy::BackToFront );
sortPolicy->setSortTypes( sortTypes );
Qt3DRender::QRenderStateSet *transparentObjectsRenderStateSetColor = new Qt3DRender::QRenderStateSet( sortPolicy );
{
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
transparentObjectsRenderStateSetColor->addRenderState( depthTest );
Qt3DRender::QNoDepthMask *noDepthMask = new Qt3DRender::QNoDepthMask;
transparentObjectsRenderStateSetColor->addRenderState( noDepthMask );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::NoCulling );
transparentObjectsRenderStateSetColor->addRenderState( cullFace );
Qt3DRender::QBlendEquation *blendEquation = new Qt3DRender::QBlendEquation;
blendEquation->setBlendFunction( Qt3DRender::QBlendEquation::Add );
transparentObjectsRenderStateSetColor->addRenderState( blendEquation );
Qt3DRender::QBlendEquationArguments *blendEquationArgs = new Qt3DRender::QBlendEquationArguments;
blendEquationArgs->setSourceRgb( Qt3DRender::QBlendEquationArguments::Blending::SourceAlpha );
blendEquationArgs->setDestinationRgb( Qt3DRender::QBlendEquationArguments::Blending::OneMinusSourceAlpha );
transparentObjectsRenderStateSetColor->addRenderState( blendEquationArgs );
}
// third branch: transparent layer filter - depth
Qt3DRender::QRenderStateSet *transparentObjectsRenderStateSetDepth = new Qt3DRender::QRenderStateSet( sortPolicy );
{
Qt3DRender::QDepthTest *depthTest = new Qt3DRender::QDepthTest;
depthTest->setDepthFunction( Qt3DRender::QDepthTest::Less );
transparentObjectsRenderStateSetDepth->addRenderState( depthTest );
Qt3DRender::QColorMask *noColorMask = new Qt3DRender::QColorMask;
noColorMask->setAlphaMasked( false );
noColorMask->setRedMasked( false );
noColorMask->setGreenMasked( false );
noColorMask->setBlueMasked( false );
transparentObjectsRenderStateSetDepth->addRenderState( noColorMask );
Qt3DRender::QCullFace *cullFace = new Qt3DRender::QCullFace;
cullFace->setMode( Qt3DRender::QCullFace::CullingMode::NoCulling );
transparentObjectsRenderStateSetDepth->addRenderState( cullFace );
}
mDebugOverlay = new Qt3DRender::QDebugOverlay( mForwardClearBuffers );
mDebugOverlay->setEnabled( false );
// cppcheck wrongly believes transparentObjectsRenderStateSetColor and transparentObjectsRenderStateSetDepth will leak
// cppcheck-suppress memleak
return mMainCameraSelector;
QgsForwardRenderView *forwardRenderView = new QgsForwardRenderView( this, mMainCamera );
registerRenderView( forwardRenderView, FORWARD_RENDERVIEW );
}
void QgsFrameGraph::constructShadowRenderPass()
{
QgsShadowRenderView *shadowRenderView = new QgsShadowRenderView( this, SHADOW_RENDERVIEW );
@ -373,7 +215,8 @@ Qt3DRender::QFrameGraphNode *QgsFrameGraph::constructAmbientOcclusionRenderPass(
mAmbientOcclusionRenderCaptureTargetSelector->setTarget( colorRenderTarget );
Qt3DRender::QLayer *ambientOcclusionRenderLayer = new Qt3DRender::QLayer();
mAmbientOcclusionRenderEntity = new QgsAmbientOcclusionRenderEntity( mForwardDepthTexture, ambientOcclusionRenderLayer, mMainCamera, mRootEntity );
Qt3DRender::QTexture2D *forwardDepthTexture = forwardRenderView()->depthTexture();
mAmbientOcclusionRenderEntity = new QgsAmbientOcclusionRenderEntity( forwardDepthTexture, ambientOcclusionRenderLayer, mMainCamera, mRootEntity );
mAmbientOcclusionRenderLayerFilter->addLayer( ambientOcclusionRenderLayer );
return mAmbientOcclusionRenderCameraSelector;
@ -456,7 +299,7 @@ Qt3DRender::QFrameGraphNode *QgsFrameGraph::constructRubberBandsPass()
// This is kind of okay, but as a result, post-processing effects get applied
// to rubber bands too. Ideally we would want them on top of everything.
mRubberBandsRenderTargetSelector = new Qt3DRender::QRenderTargetSelector( mRubberBandsStateSet );
mRubberBandsRenderTargetSelector->setTarget( mForwardRenderTargetSelector->target() );
mRubberBandsRenderTargetSelector->setTarget( forwardRenderView()->renderTargetSelector()->target() );
return mRubberBandsCameraSelector;
}
@ -564,7 +407,8 @@ Qt3DCore::QEntity *QgsFrameGraph::constructDepthRenderQuad()
// construct material
Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial;
Qt3DRender::QParameter *textureParameter = new Qt3DRender::QParameter( "depthTexture", mForwardDepthTexture );
Qt3DRender::QTexture2D *forwardDepthTexture = forwardRenderView()->depthTexture();
Qt3DRender::QParameter *textureParameter = new Qt3DRender::QParameter( "depthTexture", forwardDepthTexture );
Qt3DRender::QParameter *textureTransformParameter = new Qt3DRender::QParameter( "modelMatrix", QVariant::fromValue( modelMatrix ) );
material->addParameter( textureParameter );
material->addParameter( textureTransformParameter );
@ -632,17 +476,13 @@ QgsFrameGraph::QgsFrameGraph( QSurface *surface, QSize s, Qt3DRender::QCamera *m
mMainCamera = mainCamera;
mPreviewLayer = new Qt3DRender::QLayer;
mForwardRenderLayer = new Qt3DRender::QLayer;
mDepthRenderPassLayer = new Qt3DRender::QLayer;
mTransparentObjectsPassLayer = new Qt3DRender::QLayer;
mRubberBandsLayer = new Qt3DRender::QLayer;
mRubberBandsLayer->setObjectName( "mRubberBandsLayer" );
mPreviewLayer->setRecursive( true );
mForwardRenderLayer->setRecursive( true );
mDepthRenderPassLayer->setRecursive( true );
mTransparentObjectsPassLayer->setRecursive( true );
mRubberBandsLayer->setRecursive( true );
mRenderSurfaceSelector = new Qt3DRender::QRenderSurfaceSelector;
@ -657,8 +497,7 @@ QgsFrameGraph::QgsFrameGraph( QSurface *surface, QSize s, Qt3DRender::QCamera *m
mMainViewPort->setNormalizedRect( QRectF( 0.0f, 0.0f, 1.0f, 1.0f ) );
// Forward render
Qt3DRender::QFrameGraphNode *forwardRenderPass = constructForwardRenderPass();
forwardRenderPass->setParent( mMainViewPort );
constructForwardRenderPass();
// rubber bands (they should be always on top)
Qt3DRender::QFrameGraphNode *rubberBandsPass = constructRubberBandsPass();
@ -691,7 +530,8 @@ QgsFrameGraph::QgsFrameGraph( QSurface *surface, QSize s, Qt3DRender::QCamera *m
Qt3DRender::QParameter *depthMapIsDepthParam = new Qt3DRender::QParameter( "isDepth", true );
Qt3DRender::QParameter *shadowMapIsDepthParam = new Qt3DRender::QParameter( "isDepth", true );
mDebugDepthMapPreviewQuad = this->addTexturePreviewOverlay( mForwardDepthTexture, QPointF( 0.9f, 0.9f ), QSizeF( 0.1, 0.1 ), QVector<Qt3DRender::QParameter *> { depthMapIsDepthParam } );
Qt3DRender::QTexture2D *forwardDepthTexture = forwardRenderView()->depthTexture();
mDebugDepthMapPreviewQuad = this->addTexturePreviewOverlay( forwardDepthTexture, QPointF( 0.9f, 0.9f ), QSizeF( 0.1, 0.1 ), QVector<Qt3DRender::QParameter *> { depthMapIsDepthParam } );
Qt3DRender::QTexture2D *shadowMapTexture = shadowRenderView()->mapTexture();
mDebugShadowMapPreviewQuad = this->addTexturePreviewOverlay( shadowMapTexture, QPointF( 0.9f, 0.9f ), QSizeF( 0.1, 0.1 ), QVector<Qt3DRender::QParameter *> { shadowMapIsDepthParam } );
@ -810,7 +650,9 @@ QString QgsFrameGraph::dumpSceneGraph() const
void QgsFrameGraph::setClearColor( const QColor &clearColor )
{
mForwardClearBuffers->setClearColor( clearColor );
QgsForwardRenderView *rv = forwardRenderView();
if ( rv )
rv->setClearColor( clearColor );
}
void QgsFrameGraph::setAmbientOcclusionEnabled( bool enabled )
@ -840,13 +682,7 @@ void QgsFrameGraph::setAmbientOcclusionThreshold( float threshold )
void QgsFrameGraph::setFrustumCullingEnabled( bool enabled )
{
if ( enabled == mFrustumCullingEnabled )
return;
mFrustumCullingEnabled = enabled;
if ( mFrustumCullingEnabled )
mFrustumCulling->setParent( mForwardClearBuffers );
else
mFrustumCulling->setParent( ( Qt3DCore::QNode * ) nullptr );
forwardRenderView()->setFrustumCullingEnabled( enabled );
}
void QgsFrameGraph::setupEyeDomeLighting( bool enabled, double strength, int distance )
@ -935,32 +771,15 @@ void QgsFrameGraph::setRenderCaptureEnabled( bool enabled )
void QgsFrameGraph::setDebugOverlayEnabled( bool enabled )
{
mDebugOverlay->setEnabled( enabled );
forwardRenderView()->setDebugOverlayEnabled( enabled );
}
void QgsFrameGraph::removeClipPlanes()
QgsForwardRenderView *QgsFrameGraph::forwardRenderView() const
{
for ( Qt3DRender::QRenderState *state : mClipRenderStateSet->renderStates() )
{
if ( qobject_cast<Qt3DRender::QClipPlane *>( state ) )
{
mClipRenderStateSet->removeRenderState( state );
}
}
}
void QgsFrameGraph::addClipPlanes( int nrClipPlanes )
{
// remove existing QClipPlane
removeClipPlanes();
// create new QClipPlane
for ( int i = 0; i < nrClipPlanes; ++i )
{
Qt3DRender::QClipPlane *clipPlane = new Qt3DRender::QClipPlane;
clipPlane->setPlaneIndex( i );
mClipRenderStateSet->addRenderState( clipPlane );
}
QgsAbstractRenderView *rv = mRenderViewMap[QgsFrameGraph::FORWARD_RENDERVIEW].get();
if ( rv )
return qobject_cast<QgsForwardRenderView *>( rv );
return nullptr;
}
QgsShadowRenderView *QgsFrameGraph::shadowRenderView() const

47
src/3d/framegraph/qgsframegraph.h
View File

@ -73,11 +73,6 @@ class QgsFrameGraph : public Qt3DCore::QEntity
//! Returns the root of the frame graph object
Qt3DRender::QFrameGraphNode *frameGraphRoot() { return mRenderSurfaceSelector; }
//! Returns the color texture of the forward rendering pass
Qt3DRender::QTexture2D *forwardRenderColorTexture() { return mForwardColorTexture; }
//! Returns the depth texture of the forward rendering pass
Qt3DRender::QTexture2D *forwardRenderDepthTexture() { return mForwardDepthTexture; }
/**
* Returns blurred ambient occlusion factor values texture
* \since QGIS 3.28
@ -86,21 +81,11 @@ class QgsFrameGraph : public Qt3DCore::QEntity
//! Returns a layer object used to indicate that an entity is to be rendered during the preview textures rendering pass
Qt3DRender::QLayer *previewLayer() { return mPreviewLayer; }
//! Returns a layer object used to indicate that an entity will be rendered during the forward rendering pass
Qt3DRender::QLayer *forwardRenderLayer() { return mForwardRenderLayer; }
/**
* Returns a layer object used to indicate that the object is transparent
* \since QGIS 3.26
*/
Qt3DRender::QLayer *transparentObjectLayer() { return mTransparentObjectsPassLayer; }
//! Returns the main camera
Qt3DRender::QCamera *mainCamera() { return mMainCamera; }
//! Returns the postprocessing entity
QgsPostprocessingEntity *postprocessingEntity() { return mPostprocessingEntity; }
//! Returns the root entity of the entities related to the frame graph (like the post processing entity and preview entity)
Qt3DCore::QEntity *rootEntity() { return mRootEntity; }
//! Returns entity for all rubber bands (to show them always on top)
Qt3DCore::QEntity *rubberBandsRootEntity() { return mRubberBandsRootEntity; }
@ -111,13 +96,9 @@ class QgsFrameGraph : public Qt3DCore::QEntity
//! Returns the render capture object used to take an image of the depth buffer of the scene
Qt3DRender::QRenderCapture *depthRenderCapture() { return mDepthRenderCapture; }
//! Returns whether frustum culling is enabled
bool frustumCullingEnabled() const { return mFrustumCullingEnabled; }
//! Sets whether frustum culling is enabled
void setFrustumCullingEnabled( bool enabled );
/**
* Sets whether Screen Space Ambient Occlusion will be enabled
* \since QGIS 3.28
@ -259,34 +240,28 @@ class QgsFrameGraph : public Qt3DCore::QEntity
*/
QgsShadowRenderView *shadowRenderView() const;
/**
* Returns forward renderview or nullptr if not defined
* \since QGIS 3.44
*/
QgsForwardRenderView *forwardRenderView() const;
/**
* Updates shadow bias, light and texture size according to \a shadowSettings and \a lightSources
* \since QGIS 3.44
*/
void updateShadowSettings( const QgsShadowSettings &shadowSettings, const QList<QgsLightSource *> &lightSources );
static const QString FORWARD_RENDERVIEW;
static const QString SHADOW_RENDERVIEW;
static const QString AXIS3D_RENDERVIEW;
private:
Qt3DRender::QRenderSurfaceSelector *mRenderSurfaceSelector = nullptr;
Qt3DRender::QViewport *mMainViewPort = nullptr;
bool mFrustumCullingEnabled = true;
Qt3DRender::QCamera *mMainCamera = nullptr;
// Forward rendering pass branch nodes:
Qt3DRender::QCameraSelector *mMainCameraSelector = nullptr;
Qt3DRender::QLayerFilter *mForwardRenderLayerFilter = nullptr;
Qt3DRender::QRenderTargetSelector *mForwardRenderTargetSelector = nullptr;
Qt3DRender::QClearBuffers *mForwardClearBuffers = nullptr;
Qt3DRender::QFrustumCulling *mFrustumCulling = nullptr;
// Forward rendering pass texture related objects:
Qt3DRender::QTexture2D *mForwardColorTexture = nullptr;
Qt3DRender::QTexture2D *mForwardDepthTexture = nullptr;
// QDebugOverlay added in the forward pass
Qt3DRender::QDebugOverlay *mDebugOverlay = nullptr;
// - The depth buffer render pass is made to copy the depth buffer into
// an RGB texture that can be captured into a QImage and sent to the CPU for
// calculating real 3D points from mouse coordinates (for zoom, rotation, drag..)
@ -348,15 +323,10 @@ class QgsFrameGraph : public Qt3DCore::QEntity
QVector3D mLightDirection = QVector3D( 0.0, -1.0f, 0.0f );
// clip planes render state
Qt3DRender::QRenderStateSet *mClipRenderStateSet = nullptr;
Qt3DCore::QEntity *mRootEntity = nullptr;
Qt3DRender::QLayer *mPreviewLayer = nullptr;
Qt3DRender::QLayer *mForwardRenderLayer = nullptr;
Qt3DRender::QLayer *mDepthRenderPassLayer = nullptr;
Qt3DRender::QLayer *mTransparentObjectsPassLayer = nullptr;
Qt3DRender::QLayer *mRubberBandsLayer = nullptr;
QgsPostprocessingEntity *mPostprocessingEntity = nullptr;
@ -368,7 +338,8 @@ class QgsFrameGraph : public Qt3DCore::QEntity
QVector<QgsPreviewQuad *> mPreviewQuads;
void constructShadowRenderPass();
Qt3DRender::QFrameGraphNode *constructForwardRenderPass();
void constructForwardRenderPass();
Qt3DRender::QFrameGraphNode *constructTexturesPreviewPass();
Qt3DRender::QFrameGraphNode *constructPostprocessingPass();
Qt3DRender::QFrameGraphNode *constructDepthRenderPass();
Qt3DRender::QFrameGraphNode *constructAmbientOcclusionRenderPass();

6
src/3d/framegraph/qgspostprocessingentity.cpp
View File

@ -45,13 +45,15 @@ typedef Qt3DCore::QGeometry Qt3DQGeometry;
#include "qgsdirectionallightsettings.h"
#include "qgsframegraph.h"
#include "qgsshadowrenderview.h"
#include "qgsforwardrenderview.h"
QgsPostprocessingEntity::QgsPostprocessingEntity( QgsFrameGraph *frameGraph, Qt3DRender::QLayer *layer, QNode *parent )
: QgsRenderPassQuad( layer, parent )
{
QgsShadowRenderView *shadowRenderView = frameGraph->shadowRenderView();
mColorTextureParameter = new Qt3DRender::QParameter( QStringLiteral( "colorTexture" ), frameGraph->forwardRenderColorTexture() );
mDepthTextureParameter = new Qt3DRender::QParameter( QStringLiteral( "depthTexture" ), frameGraph->forwardRenderDepthTexture() );
QgsForwardRenderView *forwardRenderView = frameGraph->forwardRenderView();
mColorTextureParameter = new Qt3DRender::QParameter( QStringLiteral( "colorTexture" ), forwardRenderView->colorTexture() );
mDepthTextureParameter = new Qt3DRender::QParameter( QStringLiteral( "depthTexture" ), forwardRenderView->depthTexture() );
mShadowMapParameter = new Qt3DRender::QParameter( QStringLiteral( "shadowTexture" ), shadowRenderView->mapTexture() );
mAmbientOcclusionTextureParameter = new Qt3DRender::QParameter( QStringLiteral( "ssaoTexture" ), frameGraph->blurredAmbientOcclusionFactorMap() );
mMaterial->addParameter( mColorTextureParameter );

11
src/3d/qgs3dmapscene.cpp
View File

@ -84,6 +84,7 @@
#include "qgswindow3dengine.h"
#include "qgspointcloudlayer.h"
#include "qgsshadowrenderview.h"
#include "qgsforwardrenderview.h"
std::function<QMap<QString, Qgs3DMapScene *>()> Qgs3DMapScene::sOpenScenesFunction = [] { return QMap<QString, Qgs3DMapScene *>(); };
@ -834,7 +835,7 @@ void Qgs3DMapScene::finalizeNewEntity( Qt3DCore::QEntity *newEntity )
// Finalize adding the 3D transparent objects by adding the layer components to the entities
QgsFrameGraph *frameGraph = mEngine->frameGraph();
Qt3DRender::QLayer *transparentLayer = frameGraph->transparentObjectLayer();
Qt3DRender::QLayer *transparentLayer = frameGraph->forwardRenderView()->transparentObjectLayer();
const QList<Qt3DRender::QMaterial *> childMaterials = newEntity->findChildren<Qt3DRender::QMaterial *>();
for ( Qt3DRender::QMaterial *material : childMaterials )
{
@ -1276,8 +1277,8 @@ void Qgs3DMapScene::enableClipping( const QList<QVector4D> &clipPlaneEquations )
mClipPlanesEquations = clipPlaneEquations.mid( 0, mMaxClipPlanes );
// enable the clip planes on the framegraph
QgsFrameGraph *frameGraph = mEngine->frameGraph();
frameGraph->addClipPlanes( clipPlaneEquations.size() );
QgsForwardRenderView *forwardRenderView = mEngine->frameGraph()->forwardRenderView();
forwardRenderView->addClipPlanes( clipPlaneEquations.size() );
// Enable the clip planes for the material of each entity.
handleClippingOnAllEntities();
@ -1288,8 +1289,8 @@ void Qgs3DMapScene::disableClipping()
mClipPlanesEquations.clear();
// disable the clip planes on the framegraph
QgsFrameGraph *frameGraph = mEngine->frameGraph();
frameGraph->removeClipPlanes();
QgsForwardRenderView *forwardRenderView = mEngine->frameGraph()->forwardRenderView();
forwardRenderView->removeClipPlanes();
// Disable the clip planes for the material of each entity.
handleClippingOnAllEntities();

3
src/3d/qgsoffscreen3dengine.cpp
View File

@ -38,6 +38,7 @@
#include <Qt3DRender/QViewport>
#include "qgsabstractrenderview.h"
#include "qgsshadowrenderview.h"
#include "qgsforwardrenderview.h"
QgsOffscreen3DEngine::QgsOffscreen3DEngine()
{
@ -150,7 +151,7 @@ void QgsOffscreen3DEngine::setRootEntity( Qt3DCore::QEntity *root )
// Parent the incoming scene root to our current root entity.
mSceneRoot = root;
mSceneRoot->setParent( mRoot );
root->addComponent( mFrameGraph->forwardRenderLayer() );
root->addComponent( mFrameGraph->forwardRenderView()->renderLayer() );
root->addComponent( mFrameGraph->shadowRenderView()->entityCastingShadowsLayer() );
}

4
src/3d/qgswindow3dengine.cpp
View File

@ -20,11 +20,11 @@
#include <Qt3DRender/QRenderSettings>
#include "qgsabstractrenderview.h"
#include "qgspreviewquad.h"
#include "qgs3dmapcanvas.h"
#include "qgsframegraph.h"
#include "qgsshadowrenderview.h"
#include "qgsforwardrenderview.h"
QgsWindow3DEngine::QgsWindow3DEngine( Qgs3DMapCanvas *parent )
: QgsAbstract3DEngine( parent )
@ -66,7 +66,7 @@ void QgsWindow3DEngine::setRootEntity( Qt3DCore::QEntity *root )
{
mSceneRoot = root;
mSceneRoot->setParent( mRoot );
mSceneRoot->addComponent( mFrameGraph->forwardRenderLayer() );
mSceneRoot->addComponent( mFrameGraph->forwardRenderView()->renderLayer() );
mSceneRoot->addComponent( mFrameGraph->shadowRenderView()->entityCastingShadowsLayer() );
}

96
tests/testdata/control_files/3d/expected_ambient_occlusion_1/expected_framegraph.txt vendored
View File

@ -1,47 +1,49 @@
(Qt3DRender::QRenderSurfaceSelector{12/<no_name>})
(Qt3DRender::QViewport{13/<no_name>})
(Qt3DRender::QCameraSelector{14/Forward render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{15/<no_name>}) [ (AcceptAnyMatchingLayers:[ {8/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{16/Forward render pass Clip Plane RenderStateSet}) [ ]
(Qt3DRender::QRenderTargetSelector{22/<no_name>}) [ (outputs:[ (Depth:{18[DepthFormat]/<no_name>), (Color0:{17[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QLayerFilter{23/<no_name>}) [ (DiscardAnyMatchingLayers:[ {10/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{24/<no_name>}) [ (QDepthTest:Less), (QCullFace:Back) ]
(Qt3DRender::QFrustumCulling{27/<no_name>})
(Qt3DRender::QClearBuffers{28/<no_name>})
(Qt3DRender::QDebugOverlay{41/<no_name>}) [D]
(Qt3DRender::QLayerFilter{29/<no_name>}) [ (AcceptAnyMatchingLayers:[ {10/<no_name>} ]) ]
(Qt3DRender::QSortPolicy{30/<no_name>})
(Qt3DRender::QRenderStateSet{31/<no_name>}) [ (QDepthTest:Less), (QNoDepthMask), (QCullFace:NoCulling), (QBlendEquation:Add), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]) ]
(Qt3DRender::QRenderStateSet{37/<no_name>}) [ (QDepthTest:Less), (QColorMask:[ (red:false), (green:false), (blue:false), (alpha:false) ]), (QCullFace:NoCulling) ]
(Qt3DRender::QCameraSelector{42/rubberBandsPass}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{43/<no_name>}) [ (AcceptAnyMatchingLayers:[ {11/mRubberBandsLayer} ]) ]
(Qt3DRender::QRenderStateSet{46/<no_name>}) [ (QDepthTest:Always), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]), (QBlendEquation:Add) ]
(Qt3DRender::QRenderTargetSelector{48/<no_name>}) [ (outputs:[ (Depth:{18[DepthFormat]/<no_name>), (Color0:{17[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QNoDraw{49/shadow::NoDraw})
(Qt3DRender::QSubtreeEnabler{50/shadow::SubtreeEnabler}) [D]
(Qt3DRender::QCameraSelector{55/shadow::CameraSelector}) [ (Qt3DRender::QCamera:{51/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{56/<no_name>}) [D] [ (AcceptAnyMatchingLayers:[ {54/shadow::Layer} ]) ]
(Qt3DRender::QRenderTargetSelector{57/<no_name>}) [ (outputs:[ (Depth:{63[DepthFormat]/QgsShadowRenderView::DepthTarget) ]) ]
(Qt3DRender::QClearBuffers{58/<no_name>})
(Qt3DRender::QRenderStateSet{59/<no_name>}) [ (QDepthTest:Less), (QCullFace:Front), (QPolygonOffset:[ (scaleFactor:1.1), (depthSteps:4) ]) ]
(Qt3DRender::QCameraSelector{66/Depth render view CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{67/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{70/<no_name>}) [ (AcceptAnyMatchingLayers:[ {9/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{71/<no_name>}) [ (outputs:[ (Color0:{74[RGB8_UNorm]/<no_name>), (Depth:{76[DepthFormat]/<no_name>) ]) ]
(Qt3DRender::QRenderCapture{77/<no_name>})
(Qt3DRender::QCameraSelector{78/AmbientOcclusion render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{79/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{82/<no_name>}) [ (AcceptAnyMatchingLayers:[ {87/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{83/<no_name>}) [ (outputs:[ (Color0:{86[R32F]/<no_name>) ]) ]
(Qt3DRender::QCameraSelector{110/AmbientOcclusion blur pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{111/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{114/<no_name>}) [ (AcceptAnyMatchingLayers:[ {119/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{115/<no_name>}) [ (outputs:[ (Color0:{118[R32F]/<no_name>) ]) ]
(Qt3DRender::QRenderTargetSelector{132/PostProcessingPass}) [ (outputs:[ (Color0:{135[RGB8_UNorm]/PostProcessingPass::ColorTarget), (Depth:{137[DepthFormat]/PostProcessingPass::DepthTarget) ]) ]
(Qt3DRender::QCameraSelector{138/Sub pass Postprocessing}) [ (Qt3DRender::QCamera:{51/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{139/<no_name>}) [ (AcceptAnyMatchingLayers:[ {141/<no_name>} ]) ]
(Qt3DRender::QClearBuffers{140/<no_name>})
(Qt3DRender::QLayerFilter{175/Sub pass TexturesPreview}) [ (AcceptAnyMatchingLayers:[ {7/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{176/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QNoDraw{179/Sub pass RenderCapture})
(Qt3DRender::QRenderCapture{180/<no_name>})
(Qt3DRender::QRenderSurfaceSelector{10/<no_name>})
(Qt3DRender::QViewport{11/<no_name>})
(Qt3DRender::QNoDraw{12/forward::NoDraw}) [D]
(Qt3DRender::QSubtreeEnabler{13/forward::SubtreeEnabler})
(Qt3DRender::QCameraSelector{16/forward::CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{17/<no_name>}) [ (AcceptAnyMatchingLayers:[ {14/forward::Layer} ]) ]
(Qt3DRender::QRenderStateSet{18/forward::Clip Plane RenderStateSet}) [ ]
(Qt3DRender::QRenderTargetSelector{24/<no_name>}) [ (outputs:[ (Depth:{20[DepthFormat]/<no_name>), (Color0:{19[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QLayerFilter{25/<no_name>}) [ (DiscardAnyMatchingLayers:[ {15/forward::TransparentLayer} ]) ]
(Qt3DRender::QRenderStateSet{26/<no_name>}) [ (QDepthTest:Less), (QCullFace:Back) ]
(Qt3DRender::QFrustumCulling{29/<no_name>})
(Qt3DRender::QClearBuffers{30/<no_name>})
(Qt3DRender::QDebugOverlay{43/<no_name>}) [D]
(Qt3DRender::QLayerFilter{31/<no_name>}) [ (AcceptAnyMatchingLayers:[ {15/forward::TransparentLayer} ]) ]
(Qt3DRender::QSortPolicy{32/<no_name>})
(Qt3DRender::QRenderStateSet{33/<no_name>}) [ (QDepthTest:Less), (QNoDepthMask), (QCullFace:NoCulling), (QBlendEquation:Add), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]) ]
(Qt3DRender::QRenderStateSet{39/<no_name>}) [ (QDepthTest:Less), (QColorMask:[ (red:false), (green:false), (blue:false), (alpha:false) ]), (QCullFace:NoCulling) ]
(Qt3DRender::QCameraSelector{44/rubberBandsPass}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{45/<no_name>}) [ (AcceptAnyMatchingLayers:[ {9/mRubberBandsLayer} ]) ]
(Qt3DRender::QRenderStateSet{48/<no_name>}) [ (QDepthTest:Always), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]), (QBlendEquation:Add) ]
(Qt3DRender::QRenderTargetSelector{50/<no_name>}) [ (outputs:[ (Depth:{20[DepthFormat]/<no_name>), (Color0:{19[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QNoDraw{51/shadow::NoDraw})
(Qt3DRender::QSubtreeEnabler{52/shadow::SubtreeEnabler}) [D]
(Qt3DRender::QCameraSelector{57/shadow::CameraSelector}) [ (Qt3DRender::QCamera:{53/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{58/<no_name>}) [D] [ (AcceptAnyMatchingLayers:[ {56/shadow::Layer} ]) ]
(Qt3DRender::QRenderTargetSelector{59/<no_name>}) [ (outputs:[ (Depth:{65[DepthFormat]/QgsShadowRenderView::DepthTarget) ]) ]
(Qt3DRender::QClearBuffers{60/<no_name>})
(Qt3DRender::QRenderStateSet{61/<no_name>}) [ (QDepthTest:Less), (QCullFace:Front), (QPolygonOffset:[ (scaleFactor:1.1), (depthSteps:4) ]) ]
(Qt3DRender::QCameraSelector{68/Depth render view CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{69/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{72/<no_name>}) [ (AcceptAnyMatchingLayers:[ {8/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{73/<no_name>}) [ (outputs:[ (Color0:{76[RGB8_UNorm]/<no_name>), (Depth:{78[DepthFormat]/<no_name>) ]) ]
(Qt3DRender::QRenderCapture{79/<no_name>})
(Qt3DRender::QCameraSelector{80/AmbientOcclusion render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{81/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{84/<no_name>}) [ (AcceptAnyMatchingLayers:[ {89/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{85/<no_name>}) [ (outputs:[ (Color0:{88[R32F]/<no_name>) ]) ]
(Qt3DRender::QCameraSelector{112/AmbientOcclusion blur pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{113/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{116/<no_name>}) [ (AcceptAnyMatchingLayers:[ {121/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{117/<no_name>}) [ (outputs:[ (Color0:{120[R32F]/<no_name>) ]) ]
(Qt3DRender::QRenderTargetSelector{134/PostProcessingPass}) [ (outputs:[ (Color0:{137[RGB8_UNorm]/PostProcessingPass::ColorTarget), (Depth:{139[DepthFormat]/PostProcessingPass::DepthTarget) ]) ]
(Qt3DRender::QCameraSelector{140/Sub pass Postprocessing}) [ (Qt3DRender::QCamera:{53/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{141/<no_name>}) [ (AcceptAnyMatchingLayers:[ {143/<no_name>} ]) ]
(Qt3DRender::QClearBuffers{142/<no_name>})
(Qt3DRender::QLayerFilter{177/Sub pass TexturesPreview}) [ (AcceptAnyMatchingLayers:[ {7/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{178/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QNoDraw{181/Sub pass RenderCapture})
(Qt3DRender::QRenderCapture{182/<no_name>})

96
tests/testdata/control_files/3d/expected_ambient_occlusion_2/expected_framegraph.txt vendored
View File

@ -1,47 +1,49 @@
(Qt3DRender::QRenderSurfaceSelector{12/<no_name>})
(Qt3DRender::QViewport{13/<no_name>})
(Qt3DRender::QCameraSelector{14/Forward render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{15/<no_name>}) [ (AcceptAnyMatchingLayers:[ {8/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{16/Forward render pass Clip Plane RenderStateSet}) [ ]
(Qt3DRender::QRenderTargetSelector{22/<no_name>}) [ (outputs:[ (Depth:{18[DepthFormat]/<no_name>), (Color0:{17[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QLayerFilter{23/<no_name>}) [ (DiscardAnyMatchingLayers:[ {10/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{24/<no_name>}) [ (QDepthTest:Less), (QCullFace:Back) ]
(Qt3DRender::QFrustumCulling{27/<no_name>})
(Qt3DRender::QClearBuffers{28/<no_name>})
(Qt3DRender::QDebugOverlay{41/<no_name>}) [D]
(Qt3DRender::QLayerFilter{29/<no_name>}) [ (AcceptAnyMatchingLayers:[ {10/<no_name>} ]) ]
(Qt3DRender::QSortPolicy{30/<no_name>})
(Qt3DRender::QRenderStateSet{31/<no_name>}) [ (QDepthTest:Less), (QNoDepthMask), (QCullFace:NoCulling), (QBlendEquation:Add), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]) ]
(Qt3DRender::QRenderStateSet{37/<no_name>}) [ (QDepthTest:Less), (QColorMask:[ (red:false), (green:false), (blue:false), (alpha:false) ]), (QCullFace:NoCulling) ]
(Qt3DRender::QCameraSelector{42/rubberBandsPass}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{43/<no_name>}) [ (AcceptAnyMatchingLayers:[ {11/mRubberBandsLayer} ]) ]
(Qt3DRender::QRenderStateSet{46/<no_name>}) [ (QDepthTest:Always), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]), (QBlendEquation:Add) ]
(Qt3DRender::QRenderTargetSelector{48/<no_name>}) [ (outputs:[ (Depth:{18[DepthFormat]/<no_name>), (Color0:{17[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QNoDraw{49/shadow::NoDraw})
(Qt3DRender::QSubtreeEnabler{50/shadow::SubtreeEnabler}) [D]
(Qt3DRender::QCameraSelector{55/shadow::CameraSelector}) [ (Qt3DRender::QCamera:{51/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{56/<no_name>}) [D] [ (AcceptAnyMatchingLayers:[ {54/shadow::Layer} ]) ]
(Qt3DRender::QRenderTargetSelector{57/<no_name>}) [ (outputs:[ (Depth:{63[DepthFormat]/QgsShadowRenderView::DepthTarget) ]) ]
(Qt3DRender::QClearBuffers{58/<no_name>})
(Qt3DRender::QRenderStateSet{59/<no_name>}) [ (QDepthTest:Less), (QCullFace:Front), (QPolygonOffset:[ (scaleFactor:1.1), (depthSteps:4) ]) ]
(Qt3DRender::QCameraSelector{66/Depth render view CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{67/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{70/<no_name>}) [ (AcceptAnyMatchingLayers:[ {9/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{71/<no_name>}) [ (outputs:[ (Color0:{74[RGB8_UNorm]/<no_name>), (Depth:{76[DepthFormat]/<no_name>) ]) ]
(Qt3DRender::QRenderCapture{77/<no_name>})
(Qt3DRender::QCameraSelector{78/AmbientOcclusion render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{79/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{82/<no_name>}) [ (AcceptAnyMatchingLayers:[ {87/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{83/<no_name>}) [ (outputs:[ (Color0:{86[R32F]/<no_name>) ]) ]
(Qt3DRender::QCameraSelector{110/AmbientOcclusion blur pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{111/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{114/<no_name>}) [ (AcceptAnyMatchingLayers:[ {119/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{115/<no_name>}) [ (outputs:[ (Color0:{118[R32F]/<no_name>) ]) ]
(Qt3DRender::QRenderTargetSelector{132/PostProcessingPass}) [ (outputs:[ (Color0:{135[RGB8_UNorm]/PostProcessingPass::ColorTarget), (Depth:{137[DepthFormat]/PostProcessingPass::DepthTarget) ]) ]
(Qt3DRender::QCameraSelector{138/Sub pass Postprocessing}) [ (Qt3DRender::QCamera:{51/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{139/<no_name>}) [ (AcceptAnyMatchingLayers:[ {141/<no_name>} ]) ]
(Qt3DRender::QClearBuffers{140/<no_name>})
(Qt3DRender::QLayerFilter{175/Sub pass TexturesPreview}) [ (AcceptAnyMatchingLayers:[ {7/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{176/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QNoDraw{179/Sub pass RenderCapture})
(Qt3DRender::QRenderCapture{180/<no_name>})
(Qt3DRender::QRenderSurfaceSelector{10/<no_name>})
(Qt3DRender::QViewport{11/<no_name>})
(Qt3DRender::QNoDraw{12/forward::NoDraw}) [D]
(Qt3DRender::QSubtreeEnabler{13/forward::SubtreeEnabler})
(Qt3DRender::QCameraSelector{16/forward::CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{17/<no_name>}) [ (AcceptAnyMatchingLayers:[ {14/forward::Layer} ]) ]
(Qt3DRender::QRenderStateSet{18/forward::Clip Plane RenderStateSet}) [ ]
(Qt3DRender::QRenderTargetSelector{24/<no_name>}) [ (outputs:[ (Depth:{20[DepthFormat]/<no_name>), (Color0:{19[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QLayerFilter{25/<no_name>}) [ (DiscardAnyMatchingLayers:[ {15/forward::TransparentLayer} ]) ]
(Qt3DRender::QRenderStateSet{26/<no_name>}) [ (QDepthTest:Less), (QCullFace:Back) ]
(Qt3DRender::QFrustumCulling{29/<no_name>})
(Qt3DRender::QClearBuffers{30/<no_name>})
(Qt3DRender::QDebugOverlay{43/<no_name>}) [D]
(Qt3DRender::QLayerFilter{31/<no_name>}) [ (AcceptAnyMatchingLayers:[ {15/forward::TransparentLayer} ]) ]
(Qt3DRender::QSortPolicy{32/<no_name>})
(Qt3DRender::QRenderStateSet{33/<no_name>}) [ (QDepthTest:Less), (QNoDepthMask), (QCullFace:NoCulling), (QBlendEquation:Add), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]) ]
(Qt3DRender::QRenderStateSet{39/<no_name>}) [ (QDepthTest:Less), (QColorMask:[ (red:false), (green:false), (blue:false), (alpha:false) ]), (QCullFace:NoCulling) ]
(Qt3DRender::QCameraSelector{44/rubberBandsPass}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QLayerFilter{45/<no_name>}) [ (AcceptAnyMatchingLayers:[ {9/mRubberBandsLayer} ]) ]
(Qt3DRender::QRenderStateSet{48/<no_name>}) [ (QDepthTest:Always), (QBlendEquationArguments:[ (sourceRgb:SourceAlpha), (destinationRgb:Source1Alpha), (sourceAlpha:One), (destinationAlpha:Zero), (bufferIndex:-1) ]), (QBlendEquation:Add) ]
(Qt3DRender::QRenderTargetSelector{50/<no_name>}) [ (outputs:[ (Depth:{20[DepthFormat]/<no_name>), (Color0:{19[RGB8_UNorm]/<no_name>) ]) ]
(Qt3DRender::QNoDraw{51/shadow::NoDraw})
(Qt3DRender::QSubtreeEnabler{52/shadow::SubtreeEnabler}) [D]
(Qt3DRender::QCameraSelector{57/shadow::CameraSelector}) [ (Qt3DRender::QCamera:{53/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{58/<no_name>}) [D] [ (AcceptAnyMatchingLayers:[ {56/shadow::Layer} ]) ]
(Qt3DRender::QRenderTargetSelector{59/<no_name>}) [ (outputs:[ (Depth:{65[DepthFormat]/QgsShadowRenderView::DepthTarget) ]) ]
(Qt3DRender::QClearBuffers{60/<no_name>})
(Qt3DRender::QRenderStateSet{61/<no_name>}) [ (QDepthTest:Less), (QCullFace:Front), (QPolygonOffset:[ (scaleFactor:1.1), (depthSteps:4) ]) ]
(Qt3DRender::QCameraSelector{68/Depth render view CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{69/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{72/<no_name>}) [ (AcceptAnyMatchingLayers:[ {8/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{73/<no_name>}) [ (outputs:[ (Color0:{76[RGB8_UNorm]/<no_name>), (Depth:{78[DepthFormat]/<no_name>) ]) ]
(Qt3DRender::QRenderCapture{79/<no_name>})
(Qt3DRender::QCameraSelector{80/AmbientOcclusion render pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{81/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{84/<no_name>}) [ (AcceptAnyMatchingLayers:[ {89/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{85/<no_name>}) [ (outputs:[ (Color0:{88[R32F]/<no_name>) ]) ]
(Qt3DRender::QCameraSelector{112/AmbientOcclusion blur pass CameraSelector}) [ (Qt3DRender::QCamera:{0/<no_name>}) ]
(Qt3DRender::QRenderStateSet{113/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QLayerFilter{116/<no_name>}) [ (AcceptAnyMatchingLayers:[ {121/<no_name>} ]) ]
(Qt3DRender::QRenderTargetSelector{117/<no_name>}) [ (outputs:[ (Color0:{120[R32F]/<no_name>) ]) ]
(Qt3DRender::QRenderTargetSelector{134/PostProcessingPass}) [ (outputs:[ (Color0:{137[RGB8_UNorm]/PostProcessingPass::ColorTarget), (Depth:{139[DepthFormat]/PostProcessingPass::DepthTarget) ]) ]
(Qt3DRender::QCameraSelector{140/Sub pass Postprocessing}) [ (Qt3DRender::QCamera:{53/shadow::LightCamera}) ]
(Qt3DRender::QLayerFilter{141/<no_name>}) [ (AcceptAnyMatchingLayers:[ {143/<no_name>} ]) ]
(Qt3DRender::QClearBuffers{142/<no_name>})
(Qt3DRender::QLayerFilter{177/Sub pass TexturesPreview}) [ (AcceptAnyMatchingLayers:[ {7/<no_name>} ]) ]
(Qt3DRender::QRenderStateSet{178/<no_name>}) [ (QDepthTest:Always), (QCullFace:NoCulling) ]
(Qt3DRender::QNoDraw{181/Sub pass RenderCapture})
(Qt3DRender::QRenderCapture{182/<no_name>})