qssgrendercamera_p.h

Go to the documentation of this file.

// 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_RENDER_CAMERA_H
#define QSSG_RENDER_CAMERA_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 <QtQuick3DRuntimeRender/private/qtquick3druntimerenderglobal_p.h>
 
#include <QtQuick3DRuntimeRender/private/qssgrendernode_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderray_p.h>
 
#include <QtQuick3DUtils/private/qssgrenderbasetypes_p.h>
 
QT_BEGIN_NAMESPACE
 
struct QSSGCameraGlobalCalculationResult
{
    bool m_wasDirty;
    bool m_computeFrustumSucceeded /* = true */;
};
 
struct QSSGRenderCameraConfiguration
{
    float dpr = 1.0f;
    float ssaaMultiplier = 1.0f;
};
 
class QSSGRenderCameraFieldOfView
{
public:
    enum class Orientation
    {
        Vertical,
        Horizontal,
    };
 
    explicit constexpr QSSGRenderCameraFieldOfView(Orientation orientation = Orientation::Vertical) : fovOrientation(orientation) {}
    QSSGRenderCameraFieldOfView(const QSSGRenderCameraFieldOfView &) = default;
    QSSGRenderCameraFieldOfView(QSSGRenderCameraFieldOfView &&) = default;
 
    QSSGRenderCameraFieldOfView &operator=(const QSSGRenderCameraFieldOfView &other) = default;
 
    template <Orientation Type = Orientation::Vertical>
    static QSSGRenderCameraFieldOfView fromDegrees(float fov)
    {
        return QSSGRenderCameraFieldOfView(fov, FovValue::Degrees, Type);
    }
    template <Orientation Type = Orientation::Vertical>
    static QSSGRenderCameraFieldOfView fromRadians(float fov)
    {
        return QSSGRenderCameraFieldOfView(fov, FovValue::Radians, Type);
    }
 
    constexpr Orientation orientation() const { return fovOrientation; }
 
    float degrees() const { return fovDegrees; }
    float radians() const { return fovRadians; }
 
    void setDegrees(float fov)
    {
        fovDegrees = fov;
        fovRadians = qDegreesToRadians(fov);
    }
 
    QSSGRenderCameraFieldOfView asVerticalFov(float aspectRatio) const
    {
        if (fovOrientation == Orientation::Vertical)
            return *this;
 
        const float fovV = float(2.0 * qAtan(qTan(qreal(fovRadians) / 2.0) / qreal(aspectRatio)));
        return fromRadians<Orientation::Vertical>(fovV);
    }
 
    void setRadians(float fov)
    {
        fovRadians = fov;
        fovDegrees = qRadiansToDegrees(fov);
    }
private:
    enum class FovValue
    {
        Degrees,
        Radians,
    };
    constexpr explicit QSSGRenderCameraFieldOfView(float fov, FovValue value, Orientation angleOfView)
        : fovDegrees(value == FovValue::Degrees ? fov : qRadiansToDegrees(fov))
        , fovRadians(value == FovValue::Radians ? fov : qDegreesToRadians(fov))
        , fovOrientation(angleOfView)
    {
    }
 
    float fovDegrees = 60.0f;
    float fovRadians = qDegreesToRadians(fovDegrees);
    Orientation fovOrientation;
};
 
class Q_QUICK3DRUNTIMERENDER_EXPORT QSSGRenderCamera : public QSSGRenderNode
{
public:
    using Configuration = QSSGRenderCameraConfiguration;
    using FieldOfView = QSSGRenderCameraFieldOfView;
 
    explicit QSSGRenderCamera(QSSGRenderGraphObject::Type type);
 
    enum class DirtyFlag : quint8
    {
        CameraDirty = 0x1,
        LayerMaskDirty = 0x2,
    };
    using FlagT = std::underlying_type_t<DirtyFlag>;
 
    static constexpr DirtyFlag DirtyMask { std::numeric_limits<FlagT>::max() };
 
    static constexpr quint32 ReservedLayerMask = 0xFF000000; // The upper 8 bits are reserved for internal use.
    static constexpr quint32 LayerMaskUserAll = 0x00FFFFFF; // The lower 24 bits are available for user layers.
    // Default to all layers (user + reserved).
    static constexpr quint32 LayerMaskAll = LayerMaskUserAll | ReservedLayerMask;
 
    class ClipPlanes : public QVector2D
    {
    public:
        constexpr inline ClipPlanes() : QVector2D(0.0f, 10000.0f) {}
        constexpr inline ClipPlanes(float n, float f) : QVector2D(n, f) {}
        constexpr float clipNear() const noexcept { return x(); }
        constexpr float clipFar() const noexcept { return y(); }
 
        constexpr inline void setClipNear(float n) noexcept { setX(n); }
        constexpr inline void setClipFar(float f) noexcept { setY(f); }
    };
 
    class Magnification : public QVector2D
    {
    public:
        constexpr inline Magnification() : QVector2D(1.0f, 1.0f) {}
        constexpr inline Magnification(float h, float v) : QVector2D(h, v) {}
        constexpr float horizontal() const noexcept { return x(); }
        constexpr float vertical() const noexcept { return y(); }
 
        constexpr inline void setHorizontal(float h) noexcept { setX(h); }
        constexpr inline void setVertical(float v) noexcept { setY(v); }
    };
 
    // Used by the custom frustum camera
    struct Frustum
    {
        float top = 0.0f;
        float bottom = 0.0f;
        float left = 0.0f;
        float right = 0.0f;
    };
 
    // Set our position, rotation member variables based on the lookat target
    // Marks this object as dirty.
    // Need to test this when the camera's local transform is null.
    // Assumes parent's local transform is the identity, meaning our local transform is
    // our global transform.
    void lookAt(const QVector3D &inCameraPos, const QVector3D &inUpDir, const QVector3D &inTargetPos, const QVector3D &pivot);
 
    /*!
     * Convenience function intended for use with internal cameras that's not part of the scene graph!
     * This function will NOT ensure that the camera's global transform, projection matrix, or state
     * is updated!.
     */
    static bool calculateProjectionInternal(QSSGRenderCamera &camera,
                                            const QRectF &inViewport,
                                            Configuration config = {});
 
    /*!
     * \brief calculateProjection
     * \param inViewport
     * \param config
     * \return true if the projection was successfully calculated, false otherwise.
     *
     * This function will calculate the projection matrix for the camera.
     *
     * NOTE: This function will not update the camera's global transform. It is the caller's
     * responsibility to ensure that the camera's global transform has been calculated prior
     * to calling this function.
     */
    bool calculateProjection(const QRectF &inViewport, Configuration config = {});
 
    void setCustomProjection(const QMatrix4x4 &proj);
 
    static bool computeFrustumOrtho(QRectF inViewport,
                                    QSSGRenderCamera::ClipPlanes clipPlanes,
                                    QSSGRenderCamera::Magnification magnification,
                                    Configuration config,
                                    QMatrix4x4 &outProjection);
    static bool computeFrustumPerspective(QRectF inViewport,
                                          FieldOfView fov,
                                          QSSGRenderCamera::ClipPlanes clipPlanes,
                                          QMatrix4x4 &outProjection);
    static bool computeCustomFrustum(QSSGRenderCamera::Frustum frustum,
                                     QSSGRenderCamera::ClipPlanes clipPlanes,
                                     QMatrix4x4 &outProjection);
 
    static void calculateViewProjectionMatrix(const QMatrix4x4 &globalTransform,
                                              const QMatrix4x4 &projection,
                                              QMatrix4x4 &outMatrix);
 
    void calculateViewProjectionMatrix(const QMatrix4x4 &globalTransform, QMatrix4x4 &outMatrix) const;
    void calculateViewProjectionWithoutTranslation(const QMatrix4x4 &globalTransform, float near, float far, QMatrix4x4 &outMatrix) const;
 
    // Unproject a point (x,y) in viewport relative coordinates meaning
    // left, bottom is 0,0 and values are increasing right,up respectively.
    QSSGRenderRay unproject(const QMatrix4x4 &globalTransform, const QVector2D &inLayerRelativeMouseCoords, const QRectF &inViewport) const;
 
    [[nodiscard]] inline bool isDirty(DirtyFlag dirtyFlag = DirtyMask) const
    {
        return ((cameraDirtyFlags & FlagT(dirtyFlag)) != 0)
               || ((dirtyFlag == DirtyMask) && QSSGRenderNode::isDirty());
    }
    void markDirty(DirtyFlag dirtyFlag);
    void clearDirty(DirtyFlag dirtyFlag);
 
    float getLevelOfDetailMultiplier() const;
 
    float getDpr() const { return dpr; }
 
    // Setting these variables should be followed by marking the camera dirty!
    ClipPlanes clipPlanes;
    FieldOfView fov;
    Frustum customFrustum;
    Magnification magnification;
    QMatrix4x4 projection;
    float levelOfDetailPixelThreshold = 1.0;
    quint32 layerMask = LayerMaskAll;
    bool enableFrustumClipping = true;
 
private:
    // Record some values from creating the projection matrix
    // to use during mouse picking.
    QVector2D frustumScale;
 
    QRectF previousInViewport;
    float dpr = 1.0f;
    FlagT cameraDirtyFlags = 0;
};
 
[[nodiscard]] constexpr bool qFuzzyCompare(const QSSGRenderCamera::FieldOfView &fov1, const QSSGRenderCamera::FieldOfView &fov2) noexcept
{
    return fov1.orientation() == fov2.orientation() && qFuzzyCompare(fov1.degrees(), fov2.degrees());
}
 
[[nodiscard]] constexpr bool qFuzzyCompare(QSSGRenderCamera::Frustum f1, QSSGRenderCamera::Frustum f2) noexcept
{
    return qFuzzyCompare(f1.top, f2.top) && qFuzzyCompare(f1.bottom, f2.bottom) && qFuzzyCompare(f1.left, f2.left) && qFuzzyCompare(f1.right, f2.right);
}
 
QT_END_NAMESPACE
 
#endif