qgsframegraph.h

Go to the documentation of this file.

/***************************************************************************
  qgsframegraph.h
  --------------------------------------
  Date                 : August 2020
  Copyright            : (C) 2020 by Belgacem Nedjima
  Email                : gb underscore nedjima at esi dot dz
 ***************************************************************************
 *                                                                         *
 *   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 QGSFRAMEGRAPH_H
#define QGSFRAMEGRAPH_H
 
#include <map>
#include <QWindow>
#include <Qt3DRender/QCamera>
#include <Qt3DRender/QRenderSurfaceSelector>
#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/QRenderCapture>
#include <Qt3DRender/QDebugOverlay>
 
#include "qgspointlightsettings.h"
 
class QgsDirectionalLightSettings;
class QgsCameraController;
class QgsRectangle;
class QgsPostprocessingEntity;
class QgsAmbientOcclusionRenderEntity;
class QgsAmbientOcclusionBlurEntity;
class QgsAbstractRenderView;
class QgsForwardRenderView;
class QgsShadowRenderView;
class QgsDepthRenderView;
class QgsShadowSettings;
class QgsDebugTextureEntity;
 
#define SIP_NO_FILE
 
class QgsFrameGraph : public Qt3DCore::QEntity
{
    Q_OBJECT
 
  public:
    QgsFrameGraph( QSurface *surface, QSize s, Qt3DRender::QCamera *mainCamera, Qt3DCore::QEntity *root );
 
    Qt3DRender::QFrameGraphNode *frameGraphRoot() { return mRenderSurfaceSelector; }
 
    Qt3DRender::QTexture2D *blurredAmbientOcclusionFactorMap() { return mAmbientOcclusionBlurTexture; }
 
    Qt3DRender::QCamera *mainCamera() { return mMainCamera; }
 
    QgsPostprocessingEntity *postprocessingEntity() { return mPostprocessingEntity; }
 
    Qt3DCore::QEntity *rubberBandsRootEntity() { return mRubberBandsRootEntity; }
 
    Qt3DRender::QRenderCapture *renderCapture() { return mRenderCapture; }
 
    Qt3DRender::QRenderCapture *depthRenderCapture();
 
    void setFrustumCullingEnabled( bool enabled );
 
    void setAmbientOcclusionEnabled( bool enabled );
 
    bool ambientOcclusionEnabled() const { return mAmbientOcclusionEnabled; }
 
    void setAmbientOcclusionIntensity( float intensity );
 
    float ambientOcclusionIntensity() const { return mAmbientOcclusionIntensity; }
 
    void setAmbientOcclusionRadius( float radius );
 
    float ambientOcclusionRadius() const { return mAmbientOcclusionRadius; }
 
    void setAmbientOcclusionThreshold( float threshold );
 
    float ambientOcclusionThreshold() const { return mAmbientOcclusionThreshold; }
 
    void setClearColor( const QColor &clearColor );
 
    void setupEyeDomeLighting( bool enabled, double strength, int distance );
    void setSize( QSize s );
 
    void setRenderCaptureEnabled( bool enabled );
 
    bool renderCaptureEnabled() const { return mRenderCaptureEnabled; }
 
    void setDebugOverlayEnabled( bool enabled );
 
    QString dumpFrameGraph() const;
 
    QString dumpSceneGraph() const;
 
    void addClipPlanes( int nrClipPlanes );
 
    void removeClipPlanes();
 
    bool registerRenderView( std::unique_ptr<QgsAbstractRenderView> renderView, const QString &name, Qt3DRender::QFrameGraphNode *topNode = nullptr );
 
    void unregisterRenderView( const QString &name );
 
    void setRenderViewEnabled( const QString &name, bool enable );
 
    bool isRenderViewEnabled( const QString &name );
 
    QgsAbstractRenderView *renderView( const QString &name );
 
    QgsShadowRenderView &shadowRenderView();
 
    QgsForwardRenderView &forwardRenderView();
 
    QgsDepthRenderView &depthRenderView();
 
    void updateShadowSettings( const QgsShadowSettings &shadowSettings, const QList<QgsLightSource *> &lightSources );
 
    void updateDebugShadowMapSettings( const Qgs3DMapSettings &settings );
 
    void updateDebugDepthMapSettings( const Qgs3DMapSettings &settings );
 
    static const QString FORWARD_RENDERVIEW;
    static const QString SHADOW_RENDERVIEW;
    static const QString AXIS3D_RENDERVIEW;
    static const QString DEPTH_RENDERVIEW;
    static const QString DEBUG_RENDERVIEW;
 
  private:
    Qt3DRender::QRenderSurfaceSelector *mRenderSurfaceSelector = nullptr;
    Qt3DRender::QViewport *mMainViewPort = nullptr;
 
    Qt3DRender::QCamera *mMainCamera = nullptr;
 
    // Post processing pass branch nodes:
    Qt3DRender::QRenderTargetSelector *mRenderCaptureTargetSelector = nullptr;
    Qt3DRender::QRenderCapture *mRenderCapture = nullptr;
    // Post processing pass texture related objects:
    Qt3DRender::QTexture2D *mRenderCaptureColorTexture = nullptr;
    Qt3DRender::QTexture2D *mRenderCaptureDepthTexture = nullptr;
 
    // Ambient occlusion factor generation pass
    Qt3DRender::QCameraSelector *mAmbientOcclusionRenderCameraSelector = nullptr;
    Qt3DRender::QRenderStateSet *mAmbientOcclusionRenderStateSet = nullptr;
    Qt3DRender::QLayerFilter *mAmbientOcclusionRenderLayerFilter = nullptr;
    Qt3DRender::QRenderTargetSelector *mAmbientOcclusionRenderCaptureTargetSelector = nullptr;
    // Ambient occlusion factor generation pass texture related objects:
    Qt3DRender::QTexture2D *mAmbientOcclusionRenderTexture = nullptr;
 
    // Ambient occlusion factor blur pass
    Qt3DRender::QCameraSelector *mAmbientOcclusionBlurCameraSelector = nullptr;
    Qt3DRender::QRenderStateSet *mAmbientOcclusionBlurStateSet = nullptr;
    Qt3DRender::QLayerFilter *mAmbientOcclusionBlurLayerFilter = nullptr;
    Qt3DRender::QRenderTargetSelector *mAmbientOcclusionBlurRenderCaptureTargetSelector = nullptr;
    // Ambient occlusion factor blur pass texture related objects:
    Qt3DRender::QTexture2D *mAmbientOcclusionBlurTexture = nullptr;
 
    // Rubber bands pass
    Qt3DRender::QCameraSelector *mRubberBandsCameraSelector = nullptr;
    Qt3DRender::QLayerFilter *mRubberBandsLayerFilter = nullptr;
    Qt3DRender::QRenderStateSet *mRubberBandsStateSet = nullptr;
    Qt3DRender::QRenderTargetSelector *mRubberBandsRenderTargetSelector = nullptr;
 
    // Ambient occlusion related settings
    bool mAmbientOcclusionEnabled = false;
    float mAmbientOcclusionIntensity = 0.5f;
    float mAmbientOcclusionRadius = 25.f;
    float mAmbientOcclusionThreshold = 0.5f;
 
    QSize mSize = QSize( 1024, 768 );
 
    bool mEyeDomeLightingEnabled = false;
    double mEyeDomeLightingStrength = 1000.0;
    int mEyeDomeLightingDistance = 1;
 
    QVector3D mLightDirection = QVector3D( 0.0, -1.0f, 0.0f );
 
    Qt3DCore::QEntity *mRootEntity = nullptr;
 
    Qt3DRender::QLayer *mRubberBandsLayer = nullptr;
 
    QgsPostprocessingEntity *mPostprocessingEntity = nullptr;
    QgsAmbientOcclusionRenderEntity *mAmbientOcclusionRenderEntity = nullptr;
    QgsAmbientOcclusionBlurEntity *mAmbientOcclusionBlurEntity = nullptr;
 
    Qt3DCore::QEntity *mRubberBandsRootEntity = nullptr;
 
    QgsDebugTextureEntity *mShadowTextureDebugging = nullptr;
    QgsDebugTextureEntity *mDepthTextureDebugging = nullptr;
 
    void constructShadowRenderPass();
    void constructForwardRenderPass();
    void constructDebugTexturePass( Qt3DRender::QFrameGraphNode *topNode = nullptr );
    Qt3DRender::QFrameGraphNode *constructPostprocessingPass();
    void constructDepthRenderPass();
    Qt3DRender::QFrameGraphNode *constructAmbientOcclusionRenderPass();
    Qt3DRender::QFrameGraphNode *constructAmbientOcclusionBlurPass();
    Qt3DRender::QFrameGraphNode *constructRubberBandsPass();
 
    Qt3DRender::QFrameGraphNode *constructSubPostPassForProcessing();
    Qt3DRender::QFrameGraphNode *constructSubPostPassForRenderCapture();
    Qt3DRender::QFrameGraphNode *constructSubPostPassForTexturesPreview();
 
    bool mRenderCaptureEnabled = false;
 
    // holds renderviews according to their name
    std::map<QString, std::unique_ptr<QgsAbstractRenderView>> mRenderViewMap;
 
    Q_DISABLE_COPY( QgsFrameGraph )
};
class QgsFrameGraph : public Qt3DCore::QEntity {…};
 
#endif // QGSFRAMEGRAPH_H