qssgrenderer_p.h - mozsearch

// Copyright (C) 2008-2012 NVIDIA Corporation.

// Copyright (C) 2019 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QSSG_RENDERER_P_H

#define QSSG_RENDERER_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <private/qssgrenderpickresult_p.h>

#include <private/qssgrhicontext_p.h>

#include <private/qssgrhiquadrenderer_p.h>

#include <QtCore/qpointer.h>

#include <vector>

QT_BEGIN_NAMESPACE

class QSSGShaderCache;

class QSSGProgramGenerator;

class QSSGShaderLibraryManager;

class QSSGBufferManager;

class QSSGLayerRenderData;

class QSSGRenderContextInterface;

struct QSSGRenderNode;

struct QSSGRenderItem2D;

struct QSSGRenderRay;

class QSSGSubsetRenderable;

struct QSSGShaderDefaultMaterialKeyProperties;

struct QSSGShaderFeatures;

class QSSGRenderItem2DData;

class QSGRenderContext;

class QSSGFrustum;

class QSSGUserShaderAugmentation;

class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRenderer

    Q_DISABLE_COPY(QSSGRenderer)

public:

    QSSGRenderer();

    ~QSSGRenderer();

    // Returns true if this layer or a sibling was dirty.

    bool prepareLayerForRender(QSSGRenderLayer &inLayer);

    void rhiPrepare(QSSGRenderLayer &inLayer);

    void rhiRender(QSSGRenderLayer &inLayer);

    // Clients need to call this every frame in order for various subsystems to release

    // temporary per-frame allocated objects.

    void beginFrame(QSSGRenderLayer &layer, bool allowRecursion = true);

    // When allowRecursion is true, the cleanup is only done when all

    // beginFrames got their corresponding endFrame. This is indicated by the

    // return value (false if nothing's been done due to pending "frames")

    bool endFrame(QSSGRenderLayer &layer, bool allowRecursion = true);

    // Get the number of times EndFrame has been called

    [[nodiscard]] constexpr quint32 frameCount() const { return m_frameCount; }

    void setViewport(QRect inViewport) { m_viewport = inViewport; }

    QRect viewport() const { return m_viewport; }

    void setDpr(float dpr) { m_dpr = dpr; }

    float dpr() const { return m_dpr; }

    void setScissorRect(QRect inScissorRect) { m_scissorRect = inScissorRect; }

    QRect scissorRect() const { return m_scissorRect; }

    quint32 frameDepth() const { return m_activeFrameRef; }

    const std::unique_ptr<QSSGRhiQuadRenderer> &rhiQuadRenderer() const;

    const std::unique_ptr<QSSGRhiCubeRenderer> &rhiCubeRenderer() const;

    QSSGRenderContextInterface *contextInterface() const { return m_contextInterface; }

    // Before we start rendering a sublayer(s), e.g., Item2D with View3Ds,

    // we need to inform the renderer about it, so we can restore the state as we

    // return from the sublayer(s) rendering. The state will be saved in the data set

    // for the layer.

    void beginSubLayerRender(QSSGLayerRenderData &inLayer);

    void endSubLayerRender(QSSGLayerRenderData &inLayer);

    void releaseItem2DData(const QSSGRenderItem2D &item2D);

protected:

    void cleanupResources(QList<QSSGRenderGraphObject*> &resources);

    void cleanupResources(QSet<QSSGRenderGraphObject*> &resources);

private:

    friend class QSSGRendererPrivate;

    friend class QSSGLayerRenderData;

    friend class QSSGRenderContextInterface;

    friend class QQuick3DSceneRenderer;

    friend class QQuick3DWindowAttachment;

    friend class QSSGCleanupObject;

    friend class QSSGParticleRenderer;

    QSSGLayerRenderData *getOrCreateLayerRenderData(QSSGRenderLayer &layer);

    void beginLayerRender(QSSGLayerRenderData &inLayer);

    void endLayerRender();

    void addMaterialDirtyClear(QSSGRenderGraphObject *material);

    void cleanupUnreferencedBuffers(QSSGRenderLayer *inLayer);

    void resetResourceCounters(QSSGRenderLayer *inLayer);

    void releaseCachedResources();

    void registerItem2DData(QSSGRenderItem2DData &data);

    void unregisterItem2DData(QSSGRenderItem2DData &data);

    QSSGRenderContextInterface *m_contextInterface = nullptr; //  We're own by the context interface

    bool m_globalPickingEnabled = false;

    // Temporary information stored only when rendering a particular layer.

    QSSGLayerRenderData *m_currentLayer = nullptr;

    QSet<QSSGRenderGraphObject *> m_materialClearDirty;

    QPointer<QSGRenderContext> m_qsgRenderContext;

    // Item2D data (per layer).

    // Note that the data is own by the layer.

    std::vector<QSSGRenderItem2DData *> m_item2DDatas;

    mutable std::unique_ptr<QSSGRhiQuadRenderer> m_rhiQuadRenderer;

    mutable std::unique_ptr<QSSGRhiCubeRenderer> m_rhiCubeRenderer;

    quint32 m_activeFrameRef = 0;

    quint32 m_frameCount = 0;

    // Viewport that this render context should use

    QRect m_viewport;

    float m_dpr = 1.0;

    QRect m_scissorRect;

};

class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRendererPrivate

    QSSGRendererPrivate() = default;

public:

    using PickResultList = QVarLengthArray<QSSGRenderPickResult, 20>; // Lets assume most items are filtered out already

    static QSSGRhiShaderPipelinePtr generateRhiShaderPipelineImpl(QSSGSubsetRenderable &renderable,

                                                                  QSSGShaderLibraryManager &shaderLibraryManager,

                                                                  QSSGShaderCache &shaderCache,

                                                                  QSSGProgramGenerator &shaderProgramGenerator,

                                                                  const QSSGShaderDefaultMaterialKeyProperties &shaderKeyProperties,

                                                                  const QSSGShaderFeatures &featureSet,

                                                                  const QSSGUserShaderAugmentation &shaderAugmentation,

                                                                  QByteArray &shaderString);

    static QSSGRhiShaderPipelinePtr generateRhiShaderPipeline(QSSGRenderer &renderer,

                                                              QSSGSubsetRenderable &inRenderable,

                                                              const QSSGShaderFeatures &inFeatureSet,

                                                              const QSSGUserShaderAugmentation &shaderAugmentation);

    static QSSGRhiShaderPipelinePtr getShaderPipelineForDefaultMaterial(QSSGRenderer &renderer,

                                                                        QSSGSubsetRenderable &inRenderable,

                                                                        const QSSGShaderFeatures &inFeatureSet,

                                                                        const QSSGUserShaderAugmentation &shaderAugmentation);

    static void getLayerHitObjectList(const QSSGRenderLayer &layer,

                                      QSSGBufferManager &bufferManager,

                                      const QSSGRenderRay &ray,

                                      bool inPickEverything,

                                      PickResultList &outIntersectionResult);

    static void intersectRayWithSubsetRenderable(const QSSGRenderLayer &layer, QSSGBufferManager &bufferManager,

                                                 const QSSGRenderRay &inRay,

                                                 const QSSGRenderNode &node,

                                                 PickResultList &outIntersectionResultList);

    static void intersectRayWithItem2D(const QSSGRenderLayer &layer, const QSSGRenderRay &inRay,

                                       const QSSGRenderItem2D &item2D,

                                       PickResultList &outIntersectionResultList);

    static std::optional<QSSGRenderPickResult> closestPointOnSubsetRenderable(const QSSGRenderLayer &layer,

                                                                              QSSGBufferManager &bufferManager,

                                                                              const QVector3D &center,

                                                                              float radiusSquared,

                                                                              const QSSGRenderNode &node);

    static PickResultList syncPickAll(const QSSGRenderContextInterface &ctx,

                                      const QSSGRenderLayer &layer,

                                      const QSSGRenderRay &ray);

    static PickResultList syncPick(const QSSGRenderContextInterface &ctx,

                                   const QSSGRenderLayer &layer,

                                   const QSSGRenderRay &ray,

                                   QSSGRenderNode *target = nullptr);

    static PickResultList syncPickSubset(const QSSGRenderLayer &layer,

                                         QSSGBufferManager &bufferManager,

                                         const QSSGRenderRay &ray,

                                         QVarLengthArray<QSSGRenderNode *> subset);

    static std::optional<QSSGRenderPickResult> syncPickClosestPoint(const QSSGRenderContextInterface &ctx,

                                                                    const QSSGRenderLayer &layer,

                                                                    const QVector3D &center,

                                                                    const float radiusSquared,

                                                                    QSSGRenderNode *target = nullptr);

    static QList<const QSSGRenderNode *> syncPickInFrustum(const QSSGRenderContextInterface &ctx,

                                                           const QSSGRenderLayer &layer,

                                                           const QSSGFrustum &frustum);

    // Setting this true enables picking for all the models, regardless of

    // the models pickable property.

    static bool isGlobalPickingEnabled(const QSSGRenderer &renderer) { return renderer.m_globalPickingEnabled; }

    static void setGlobalPickingEnabled(QSSGRenderer &renderer, bool isEnabled);

    static void setRenderContextInterface(QSSGRenderer &renderer, QSSGRenderContextInterface *ctx);

    static void setSgRenderContext(QSSGRenderer &renderer, QSGRenderContext *sgRenderCtx);

    static QSSGLayerRenderData *getCurrentRenderData(const QSSGRenderer &renderer) { return renderer.m_currentLayer; }

    static QSGRenderContext *getSgRenderContext(const QSSGRenderer &renderer);

    static constexpr float minimumRenderOpacity = .01f;

};

QT_END_NAMESPACE

#endif // QSSG_RENDERER_P_H

Revision control

Copy as Markdown