| /**************************************************************************** |
| ** |
| ** Copyright (C) 2008-2012 NVIDIA Corporation. |
| ** Copyright (C) 2019 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of Qt Quick 3D. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 or (at your option) any later version |
| ** approved by the KDE Free Qt Foundation. The licenses are as published by |
| ** the Free Software Foundation and appearing in the file LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QSSG_RENDERER_H |
| #define QSSG_RENDERER_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 <QtQuick3DUtils/private/qssgdataref_p.h> |
| #include <QtQuick3DRender/private/qssgrenderbasetypes_p.h> |
| #include <QtQuick3DRuntimeRender/private/qssgrendergraphobjectpickquery_p.h> |
| #include <QtQuick3DRuntimeRender/private/qssgrendercamera_p.h> |
| #include <QtQuick3DRuntimeRender/private/qssgrenderray_p.h> |
| #include <QtQuick3DRuntimeRender/private/qssgrendernode_p.h> |
| |
| #include <QtGui/QVector2D> |
| |
| QT_BEGIN_NAMESPACE |
| |
| typedef void *QSSGRenderInstanceId; |
| |
| class QSSGRenderNodeFilterInterface |
| { |
| protected: |
| virtual ~QSSGRenderNodeFilterInterface() {} |
| |
| public: |
| virtual bool includeNode(const QSSGRenderNode &inNode) = 0; |
| }; |
| struct QSSGLayerPickSetup |
| { |
| QMatrix4x4 projectionPreMultiply; |
| QMatrix4x4 viewProjection; |
| QRect scissorRect; |
| QSSGLayerPickSetup(const QMatrix4x4 &inProjPreMult, const QMatrix4x4 &inVP, const QRect &inScissor) |
| : projectionPreMultiply(inProjPreMult), viewProjection(inVP), scissorRect(inScissor) |
| { |
| } |
| QSSGLayerPickSetup() {} |
| }; |
| |
| struct QSSGScaleAndPosition |
| { |
| QVector3D position; |
| float scale; |
| QSSGScaleAndPosition(const QVector3D &inPos, float inScale) : position(inPos), scale(inScale) {} |
| QSSGScaleAndPosition() = default; |
| }; |
| |
| struct QSSGRenderLayer; |
| class QSSGRendererImpl; |
| class QSSGRenderContextInterface; |
| |
| class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRendererInterface |
| { |
| public: |
| QAtomicInt ref; |
| virtual ~QSSGRendererInterface() {} |
| virtual void enableLayerCaching(bool inEnabled) = 0; |
| virtual bool isLayerCachingEnabled() const = 0; |
| virtual void enableLayerGpuProfiling(bool inEnabled) = 0; |
| virtual bool isLayerGpuProfilingEnabled() const = 0; |
| |
| // Get the camera that rendered this node last render |
| virtual QSSGRenderCamera *cameraForNode(const QSSGRenderNode &inNode) const = 0; |
| virtual QSSGOption<QSSGCuboidRect> cameraBounds(const QSSGRenderGraphObject &inObject) = 0; |
| // Called when you have changed the number or order of children of a given node. |
| virtual void childrenUpdated(QSSGRenderNode &inParent) = 0; |
| |
| // The QSSGRenderContextInterface calls these, clients should not. |
| virtual void beginFrame() = 0; |
| virtual void endFrame() = 0; |
| |
| // Setup the vertex and index buffers (but not shader state) |
| // and render the quad. The quad is setup so that its edges |
| // go from -1,1 in x,y and its UV coordinates will map naturally |
| // to an image. |
| virtual void renderQuad() = 0; |
| |
| // Render a given texture to the scene using a given transform. |
| virtual void renderQuad(const QVector2D inDimensions, const QMatrix4x4 &inMVP, QSSGRenderTexture2D &inQuadTexture) = 0; |
| |
| // Returns true if this layer or a sibling was dirty. |
| virtual bool prepareLayerForRender(QSSGRenderLayer &inLayer, const QSize &surfaceSize) = 0; |
| virtual void renderLayer(QSSGRenderLayer &inLayer, |
| const QSize &surfaceSize, |
| bool clear, |
| const QColor &clearColor) = 0; |
| |
| // Studio option to disable picking against sub renderers. This allows better interaction |
| // in studio. |
| // In pick siblings measn pick the layer siblings; this is the normal behavior. |
| // InPickEverything means ignore the node's pick flags; this allows us to only pick things |
| // that have handlers |
| // in some cases and just pick everything in other things. |
| virtual void pickRenderPlugins(bool inPick) = 0; |
| virtual QSSGRenderPickResult pick(QSSGRenderLayer &inLayer, |
| const QVector2D &inViewportDimensions, |
| const QVector2D &inMouseCoords, |
| bool inPickSiblings = true, |
| bool inPickEverything = false) = 0; |
| virtual QSSGRenderPickResult syncPick(QSSGRenderLayer &inLayer, |
| const QVector2D &inViewportDimensions, |
| const QVector2D &inMouseCoords, |
| bool inPickSiblings = true, |
| bool inPickEverything = false) = 0; |
| |
| // Return the relative hit position, in UV space, of a mouse pick against this object. |
| // We need the node in order to figure out which layer rendered this object. |
| // We need mapper objects if this is a in a subpresentation because we have to know how |
| // to map the mouse coordinates into the subpresentation. So for instance if inNode is in |
| // a subpres then we need to know which image is displaying the subpres in order to map |
| // the mouse coordinates into the subpres's render space. |
| virtual QSSGOption<QVector2D> facePosition(QSSGRenderNode &inNode, |
| QSSGBounds3 inBounds, |
| const QMatrix4x4 &inGlobalTransform, |
| const QVector2D &inViewportDimensions, |
| const QVector2D &inMouseCoords, |
| QSSGDataView<QSSGRenderGraphObject *> inMapperObjects, |
| QSSGRenderBasisPlanes inIsectPlane) = 0; |
| |
| virtual QVector3D unprojectToPosition(QSSGRenderNode &inNode, QVector3D &inPosition, const QVector2D &inMouseVec) const = 0; |
| virtual QVector3D unprojectWithDepth(QSSGRenderNode &inNode, QVector3D &inPosition, const QVector3D &inMouseVec) const = 0; |
| virtual QVector3D projectPosition(QSSGRenderNode &inNode, const QVector3D &inPosition) const = 0; |
| |
| // Roughly equivalent of gluPickMatrix, allows users to setup a perspective transform that |
| // will draw some sub component |
| // of the layer. Used in combination with an expected viewport of 0,0,width,height the |
| // viewproj matrix returned will center |
| // around the center of the viewport and render just the part of the layer around this area. |
| // The return value is optional because if the mouse point is completely outside the layer |
| // obviously this method is irrelevant. |
| virtual QSSGOption<QSSGLayerPickSetup> getLayerPickSetup(QSSGRenderLayer &inLayer, |
| const QVector2D &inMouseCoords, |
| const QSize &inPickDims) = 0; |
| |
| // Return the layer's viewport rect after the layer's member variables have been applied. |
| // Uses the last rendered viewport rect. |
| virtual QSSGOption<QRectF> layerRect(QSSGRenderLayer &inLayer) = 0; |
| // Testing function to allow clients to render a layer using a custom view project instead |
| // of the one that would be setup |
| // using the layer's camera in conjunction with the layer's position,scale. |
| virtual void runLayerRender(QSSGRenderLayer &inLayer, const QMatrix4x4 &inViewProjection) = 0; |
| |
| // Render the layer's rect onscreen. Will only render one frame, you need to call this |
| // every frame |
| // for this to work and be persistent. |
| virtual void renderLayerRect(QSSGRenderLayer &inLayer, const QVector3D &inColor) = 0; |
| |
| // Called before a layer goes completely out of scope to release any rendering resources |
| // related to the layer. |
| virtual void releaseLayerRenderResources(QSSGRenderLayer &inLayer) = 0; |
| |
| // render Gpu profiler values |
| virtual void dumpGpuProfilerStats() = 0; |
| |
| // Get the mouse coordinates as they relate to a given layer |
| virtual QSSGOption<QVector2D> getLayerMouseCoords(QSSGRenderLayer &inLayer, |
| const QVector2D &inMouseCoords, |
| const QVector2D &inViewportDimensions, |
| bool forceImageIntersect = false) const = 0; |
| |
| // Returns true if the renderer expects new frame to be rendered |
| // Happens when progressive AA is enabled |
| virtual bool rendererRequestsFrames() const = 0; |
| |
| static bool isGlEsContext(const QSSGRenderContextType &inContextType); |
| static bool isGlEs3Context(const QSSGRenderContextType &inContextType); |
| static bool isGl2Context(const QSSGRenderContextType &inContextType); |
| static const char *getGlslVesionString(QSSGRenderContextType inContextType); |
| |
| static QSSGRef<QSSGRendererInterface> createRenderer(QSSGRenderContextInterface *inContext); |
| }; |
| QT_END_NAMESPACE |
| |
| #endif |