qquick3dcamera.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dcamera_p.h"
 
#include <QtQuick3DRuntimeRender/private/qssgrendercamera_p.h>
 
#include "qquick3dquaternionutils_p.h"
#include "qquick3dnode_p_p.h"
 
#include <QtMath>
#include <QtQuick3DUtils/private/qssgutils_p.h>
 
#include "qquick3dutils_p.h"
 
QT_BEGIN_NAMESPACE
 
QQuick3DCamera::QQuick3DCamera(QQuick3DNodePrivate &dd, QQuick3DNode *parent)
    : QQuick3DNode(dd, parent) {}
 
bool QQuick3DCamera::frustumCullingEnabled() const
{
    return m_frustumCullingEnabled;
}
 
void QQuick3DCamera::setFrustumCullingEnabled(bool frustumCullingEnabled)
{
    if (m_frustumCullingEnabled == frustumCullingEnabled)
        return;
 
    m_frustumCullingEnabled = frustumCullingEnabled;
    emit frustumCullingEnabledChanged();
    update();
}
 
QQuick3DNode *QQuick3DCamera::lookAtNode() const
{
    return m_lookAtNode;
}
 
void QQuick3DCamera::setLookAtNode(QQuick3DNode *node)
{
    if (m_lookAtNode == node)
        return;
 
    if (m_lookAtNode) {
        disconnect(m_lookAtNode, &QQuick3DNode::scenePositionChanged, this, &QQuick3DCamera::updateLookAt);
        disconnect(this, &QQuick3DNode::scenePositionChanged, this, &QQuick3DCamera::updateLookAt);
    }
 
    m_lookAtNode = node;
 
    if (m_lookAtNode) {
        connect(m_lookAtNode, &QQuick3DNode::scenePositionChanged, this, &QQuick3DCamera::updateLookAt);
        connect(this, &QQuick3DNode::scenePositionChanged, this, &QQuick3DCamera::updateLookAt);
    }
 
    emit lookAtNodeChanged();
    updateLookAt();
}
 
QVector3D QQuick3DCamera::mapToViewport(const QVector3D &scenePos) const
{
    QSSGRenderCamera *cameraNode = static_cast<QSSGRenderCamera *>(QQuick3DObjectPrivate::get(this)->spatialNode);
    if (!cameraNode)
        return QVector3D(0, 0, 0);
 
    QVector4D scenePosRightHand(scenePos, 1);
 
    // Transform position
    const QMatrix4x4 sceneToCamera = sceneTransform().inverted();
    const QMatrix4x4 projectionViewMatrix = cameraNode->projection * sceneToCamera;
    const QVector4D transformedScenePos = mat44::transform(projectionViewMatrix, scenePosRightHand);
 
    if (qFuzzyIsNull(transformedScenePos.w()) || qIsNaN(transformedScenePos.w()))
        return QVector3D(0, 0, 0);
 
    // Normalize scenePosView between [-1, 1]
    QVector3D scenePosView = transformedScenePos.toVector3D() / transformedScenePos.w();
 
    // Set z to be the scene distance from clipNear so that the return value
    // can be used as argument to viewportToscene() to reverse the call.
    const QVector4D clipNearPos(scenePosView.x(), scenePosView.y(), -1, 1);
    auto invProj = projectionViewMatrix.inverted();
    const QVector4D clipNearPosTransformed = mat44::transform(invProj, clipNearPos);
    if (qFuzzyIsNull(clipNearPosTransformed.w()) || qIsNaN(clipNearPosTransformed.w()))
        return QVector3D(0, 0, 0);
    const QVector4D clipNearPosScene = clipNearPosTransformed / clipNearPosTransformed.w();
    QVector4D clipFarPos = clipNearPos;
    clipFarPos.setZ(0);
    const QVector4D clipFarPosTransformed = mat44::transform(invProj, clipFarPos);
    if (qFuzzyIsNull(clipFarPosTransformed.w()) || qIsNaN(clipFarPosTransformed.w()))
        return QVector3D(0, 0, 0);
    const QVector4D clipFarPosScene = clipFarPosTransformed / clipFarPosTransformed.w();
    const QVector3D direction = (clipFarPosScene - clipNearPosScene).toVector3D();
    const QVector3D scenePosVec = (scenePosRightHand - clipNearPosScene).toVector3D();
 
    const float distanceToScenePos = scenePosVec.length()
            * (QVector3D::dotProduct(direction, scenePosVec) > 0.f ? 1 : -1);
 
    scenePosView.setZ(distanceToScenePos);
 
    // Convert x and y to be between [0, 1]
    scenePosView.setX((scenePosView.x() / 2) + 0.5f);
    scenePosView.setY((scenePosView.y() / 2) + 0.5f);
    // And convert origin from bottom-left to top-left
    scenePosView.setY(1 - scenePosView.y());
    return scenePosView;
}
 
QVector3D QQuick3DCamera::mapFromViewport(const QVector3D &viewportPos) const
{
    QSSGRenderCamera *cameraNode = static_cast<QSSGRenderCamera *>(QQuick3DObjectPrivate::get(this)->spatialNode);
    if (!cameraNode)
        return QVector3D(0, 0, 0);
 
    // Pick two positions in the frustum
    QVector4D clipNearPos(viewportPos, 1);
    // Convert origin from top-left to bottom-left
    clipNearPos.setY(1 - clipNearPos.y());
    // Convert to homogenous position between [-1, 1]
    clipNearPos.setX((clipNearPos.x() * 2.0f) - 1.0f);
    clipNearPos.setY((clipNearPos.y() * 2.0f) - 1.0f);
    QVector4D clipFarPos = clipNearPos;
    // clipNear: z = -1, clipFar: z = 1. It's recommended to use 0 as
    // far pos instead of clipFar because of infinite projection issues.
    clipNearPos.setZ(-1);
    clipFarPos.setZ(0);
 
    // Transform position to scene
    const QMatrix4x4 sceneToCamera = sceneTransform().inverted();
    const QMatrix4x4 projectionViewMatrixInv = (cameraNode->projection * sceneToCamera).inverted();
    const QVector4D transformedClipNearPos = mat44::transform(projectionViewMatrixInv, clipNearPos);
    const QVector4D transformedClipFarPos = mat44::transform(projectionViewMatrixInv, clipFarPos);
 
    if (qFuzzyIsNull(transformedClipNearPos.w()) || qIsNaN(transformedClipNearPos.w()) ||
        qFuzzyIsNull(transformedClipFarPos.w()) || qIsNaN(transformedClipFarPos.w()))
        return QVector3D(0, 0, 0);
 
    // Reverse the projection
    const QVector3D clipNearPosScene = transformedClipNearPos.toVector3D()
            / transformedClipNearPos.w();
    const QVector3D clipFarPosScene = transformedClipFarPos.toVector3D()
            / transformedClipFarPos.w();
 
    // Calculate the position in the scene
    const QVector3D direction = (clipFarPosScene - clipNearPosScene).normalized();
    const float distanceFromClipNear = viewportPos.z();
    QVector3D scenePos = clipNearPosScene + (direction * distanceFromClipNear);
 
    return scenePos;
}
 
QVector3D QQuick3DCamera::mapToViewport(const QVector3D &scenePos,
                                        qreal width,
                                        qreal height)
{
    // We can be called before a spatial node is created, if that is the case, create the node now.
    if (QSSGRenderCamera *cameraNode = static_cast<QSSGRenderCamera *>(updateSpatialNode(QQuick3DObjectPrivate::get(this)->spatialNode))) {
        QQuick3DObjectPrivate::get(this)->spatialNode = cameraNode;
        cameraNode->calculateGlobalVariables(QRect(0, 0, width * cameraNode->dpr, height * cameraNode->dpr));
    }
 
    return QQuick3DCamera::mapToViewport(scenePos);
}
 
QVector3D QQuick3DCamera::mapFromViewport(const QVector3D &viewportPos,
                                          qreal width,
                                          qreal height)
{
    // We can be called before a spatial node is created, if that is the case, create the node now.
    if (QSSGRenderCamera *cameraNode = static_cast<QSSGRenderCamera *>(updateSpatialNode(QQuick3DObjectPrivate::get(this)->spatialNode))) {
        QQuick3DObjectPrivate::get(this)->spatialNode = cameraNode;
        cameraNode->calculateGlobalVariables(QRect(0, 0, width * cameraNode->dpr, height * cameraNode->dpr));
    }
 
    return QQuick3DCamera::mapFromViewport(viewportPos);
}
 
void QQuick3DCamera::lookAt(const QVector3D &scenePos)
{
    // Assumption: we never want the camera to roll.
    // We use Euler angles here to avoid roll to sneak in through numerical instability.
 
    const auto &targetPosition = scenePos;
    auto sourcePosition = scenePosition();
 
    QVector3D targetVector = sourcePosition - targetPosition;
 
    float yaw = qRadiansToDegrees(atan2(targetVector.x(), targetVector.z()));
 
    QVector2D p(targetVector.x(), targetVector.z()); // yaw vector projected to horizontal plane
    float pitch = qRadiansToDegrees(atan2(p.length(), targetVector.y())) - 90;
 
    const float previousRoll = eulerRotation().z();
    setEulerRotation(QVector3D(pitch, yaw, previousRoll));
}
 
void QQuick3DCamera::lookAt(QQuick3DNode *node)
{
    if (!node)
        return;
    lookAt(node->scenePosition());
}
 
void QQuick3DCamera::updateGlobalVariables(const QRectF &inViewport)
{
    QSSGRenderCamera *node = static_cast<QSSGRenderCamera *>(QQuick3DObjectPrivate::get(this)->spatialNode);
    if (node)
        node->calculateGlobalVariables(inViewport);
}
 
QSSGRenderGraphObject *QQuick3DCamera::updateSpatialNode(QSSGRenderGraphObject *node)
{
    if (!node) {
        markAllDirty();
        node = new QSSGRenderCamera(QQuick3DObjectPrivate::get(this)->type);
    }
 
    QQuick3DNode::updateSpatialNode(node);
 
    QSSGRenderCamera *camera = static_cast<QSSGRenderCamera *>(node);
    if (qUpdateIfNeeded(camera->enableFrustumClipping, m_frustumCullingEnabled))
        camera->markDirty(QSSGRenderCamera::DirtyFlag::CameraDirty);
    if (qUpdateIfNeeded(camera->levelOfDetailPixelThreshold, m_levelOfDetailBias))
        camera->markDirty(QSSGRenderCamera::DirtyFlag::CameraDirty);
 
    return node;
}
 
void QQuick3DCamera::updateLookAt()
{
    if (m_lookAtNode)
        lookAt(m_lookAtNode);
}
 
float QQuick3DCamera::levelOfDetailBias() const
{
    return m_levelOfDetailBias;
}
 
void QQuick3DCamera::setLevelOfDetailBias(float newLevelOfDetailBias)
{
    if (qFuzzyCompare(m_levelOfDetailBias, newLevelOfDetailBias))
        return;
    m_levelOfDetailBias = newLevelOfDetailBias;
    emit levelOfDetailBiasChanged();
    update();
}
 
QT_END_NAMESPACE