Revision control
Copy as Markdown
// 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
#include "qssgrendercamera_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrendererutil_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
#include <QtGui/qquaternion.h>
#include <QtGui/QVector2D>
#include <qmath.h>
QT_BEGIN_NAMESPACE
static inline float getAspectRatio(const QRectF &inViewport)
{
return inViewport.height() != 0 ? inViewport.width() / inViewport.height() : 0.0f;
}
QSSGRenderCamera::QSSGRenderCamera(QSSGRenderGraphObject::Type type)
: QSSGRenderNode(type)
{
Q_ASSERT(QSSGRenderCamera::isCamera(type));
markDirty(DirtyFlag::CameraDirty);
}
bool QSSGRenderCamera::calculateProjectionInternal(QSSGRenderCamera &camera,
const QRectF &inViewport,
Configuration config)
{
return camera.calculateProjection(inViewport, config);
}
bool QSSGRenderCamera::calculateProjection(const QRectF &inViewport, Configuration config)
{
bool retval = false;
// NOTE: We always update the dpr, under normal surcumstances it won't change, but we have at least
// one broken use-cases (front-end camera class) where we depend on the dpr being available from
// here...
dpr = config.dpr;
const bool argumentsChanged = inViewport != previousInViewport;
if (!argumentsChanged && !isDirty(DirtyFlag::CameraDirty))
return true;
previousInViewport = inViewport;
clearDirty(DirtyFlag::CameraDirty);
switch (type) {
case QSSGRenderGraphObject::Type::OrthographicCamera:
retval = computeFrustumOrtho(inViewport, clipPlanes, magnification, config, projection);
break;
case QSSGRenderGraphObject::Type::PerspectiveCamera:
retval = computeFrustumPerspective(inViewport, fov, clipPlanes, projection);
break;
case QSSGRenderGraphObject::Type::CustomCamera:
retval = true; // Do nothing
break;
case QSSGRenderGraphObject::Type::CustomFrustumCamera:
retval = computeCustomFrustum(customFrustum, clipPlanes, projection);
break;
default:
Q_UNREACHABLE();
}
if (retval) {
float *writePtr(projection.data());
frustumScale.setX(writePtr[0]);
frustumScale.setY(writePtr[5]);
}
return retval;
}
//==============================================================================
/**
* Compute the projection matrix for a perspective camera
* @return true if the computed projection matrix is valid
*/
bool QSSGRenderCamera::computeFrustumPerspective(QRectF inViewport,
QSSGRenderCamera::FieldOfView fov,
QSSGRenderCamera::ClipPlanes clipPlane,
QMatrix4x4 &outProjection)
{
outProjection.setToIdentity();
const float aspectRatio = getAspectRatio(inViewport);
const auto vfov = fov.asVerticalFov(aspectRatio);
outProjection.perspective(vfov.degrees(), aspectRatio, clipPlane.clipNear(), clipPlane.clipFar());
return true;
}
bool QSSGRenderCamera::computeCustomFrustum(QSSGRenderCamera::Frustum frustum,
QSSGRenderCamera::ClipPlanes clipPlanes,
QMatrix4x4 &outProjection)
{
outProjection.setToIdentity();
outProjection.frustum(frustum.left, frustum.right, frustum.bottom, frustum.top, clipPlanes.clipNear(), clipPlanes.clipFar());
return true;
}
void QSSGRenderCamera::calculateViewProjectionMatrix(const QMatrix4x4 &globalTransform,
const QMatrix4x4 &projection,
QMatrix4x4 &outMatrix)
{
QMatrix4x4 nonScaledGlobal(Qt::Uninitialized);
nonScaledGlobal.setColumn(0, globalTransform.column(0).normalized());
nonScaledGlobal.setColumn(1, globalTransform.column(1).normalized());
nonScaledGlobal.setColumn(2, globalTransform.column(2).normalized());
nonScaledGlobal.setColumn(3, globalTransform.column(3));
outMatrix = projection * nonScaledGlobal.inverted();
}
//==============================================================================
/**
* Compute the outProjection matrix for a orthographic camera
* @return true if the computed outProjection matrix is valid
*/
bool QSSGRenderCamera::computeFrustumOrtho(QRectF inViewport,
QSSGRenderCamera::ClipPlanes clipPlanes,
QSSGRenderCamera::Magnification magnification,
Configuration config,
QMatrix4x4 &outProjection)
{
outProjection.setToIdentity();
// When using ssaa we need to zoom with the ssaa multiplier since otherwise the
// orthographic camera will be zoomed out due to the bigger viewport. We therefore
// scale the magnification before calulating the projection.
// Since the same camera can be used in several View3Ds with or without ssaa we
// cannot store the magnification permanently.
magnification *= config.ssaaMultiplier;
const float halfWidth = inViewport.width() / 2.0f / magnification.horizontal() / config.dpr;
const float halfHeight = inViewport.height() / 2.0f / magnification.vertical() / config.dpr;
outProjection.ortho(-halfWidth, halfWidth, -halfHeight, halfHeight, clipPlanes.clipNear(), clipPlanes.clipFar());
return true;
}
static QQuaternion rotationQuaternionForLookAt(const QVector3D &sourcePosition,
const QVector3D &sourceDirection,
const QVector3D &targetPosition,
const QVector3D &upDirection)
{
QVector3D targetDirection = sourcePosition - targetPosition;
targetDirection.normalize();
QVector3D rotationAxis = QVector3D::crossProduct(sourceDirection, targetDirection);
const QVector3D normalizedAxis = rotationAxis.normalized();
if (qFuzzyIsNull(normalizedAxis.lengthSquared()))
rotationAxis = upDirection;
float dot = QVector3D::dotProduct(sourceDirection, targetDirection);
dot = qBound(-1.0f, dot, 1.0f);
float rotationAngle = float(qRadiansToDegrees(qAcos(qreal(dot))));
return QQuaternion::fromAxisAndAngle(rotationAxis, rotationAngle);
}
void QSSGRenderCamera::lookAt(const QVector3D &inCameraPos, const QVector3D &inUpDir, const QVector3D &inTargetPos, const QVector3D &pivot)
{
QQuaternion rotation = rotationQuaternionForLookAt(inCameraPos, getScalingCorrectDirection(localTransform), inTargetPos, inUpDir.normalized());
localTransform = QSSGRenderNode::calculateTransformMatrix(inCameraPos, QSSGRenderNode::initScale, pivot, rotation);
QSSGRenderNode::markDirty(QSSGRenderNode::DirtyFlag::TransformDirty);
}
void QSSGRenderCamera::calculateViewProjectionMatrix(const QMatrix4x4 &globalTransform, QMatrix4x4 &outMatrix) const
{
QMatrix4x4 nonScaledGlobal(Qt::Uninitialized);
nonScaledGlobal.setColumn(0, globalTransform.column(0).normalized());
nonScaledGlobal.setColumn(1, globalTransform.column(1).normalized());
nonScaledGlobal.setColumn(2, globalTransform.column(2).normalized());
nonScaledGlobal.setColumn(3, globalTransform.column(3));
outMatrix = projection * nonScaledGlobal.inverted();
}
void QSSGRenderCamera::calculateViewProjectionWithoutTranslation(const QMatrix4x4 &globalTransform, float clipNear, float clipFar, QMatrix4x4 &outMatrix) const
{
if (qFuzzyIsNull(clipFar - clipNear)) {
qWarning() << "QSSGRenderCamera::calculateViewProjection: far == near";
return;
}
QMatrix4x4 proj = projection;
proj(2, 2) = -(clipFar + clipNear) / (clipFar - clipNear);
proj(2, 3) = -2 * clipFar * clipNear / (clipFar - clipNear);
QMatrix4x4 nonScaledGlobal(Qt::Uninitialized);
nonScaledGlobal.setColumn(0, globalTransform.column(0).normalized());
nonScaledGlobal.setColumn(1, globalTransform.column(1).normalized());
nonScaledGlobal.setColumn(2, globalTransform.column(2).normalized());
nonScaledGlobal.setColumn(3, QVector4D(0, 0, 0, 1));
outMatrix = proj * nonScaledGlobal.inverted();
}
QSSGRenderRay QSSGRenderCamera::unproject(const QMatrix4x4 &globalTransform,
const QVector2D &inViewportRelativeCoords,
const QRectF &inViewport) const
{
QSSGRenderRay theRay;
QVector2D normalizedCoords = QSSGUtils::rect::relativeToNormalizedCoordinates(inViewport, inViewportRelativeCoords);
QVector3D &outOrigin(theRay.origin);
QVector3D &outDir(theRay.direction);
QVector2D inverseFrustumScale(1.0f / frustumScale.x(), 1.0f / frustumScale.y());
QVector2D scaledCoords(inverseFrustumScale.x() * normalizedCoords.x(), inverseFrustumScale.y() * normalizedCoords.y());
if (type == QSSGRenderCamera::Type::OrthographicCamera) {
outOrigin.setX(scaledCoords.x());
outOrigin.setY(scaledCoords.y());
outOrigin.setZ(0.0f);
outDir.setX(0.0f);
outDir.setY(0.0f);
outDir.setZ(-1.0f);
} else {
outOrigin.setX(0.0f);
outOrigin.setY(0.0f);
outOrigin.setZ(0.0f);
outDir.setX(scaledCoords.x());
outDir.setY(scaledCoords.y());
outDir.setZ(-1.0f);
}
outOrigin = QSSGUtils::mat44::transform(globalTransform, outOrigin);
QMatrix3x3 theNormalMatrix = globalTransform.normalMatrix();
outDir = QSSGUtils::mat33::transform(theNormalMatrix, outDir);
outDir.normalize();
return theRay;
}
void QSSGRenderCamera::markDirty(DirtyFlag dirtyFlag)
{
cameraDirtyFlags |= FlagT(dirtyFlag);
QSSGRenderNode::markDirty(QSSGRenderNode::DirtyFlag::SubNodeDirty);
}
void QSSGRenderCamera::clearDirty(DirtyFlag dirtyFlag)
{
cameraDirtyFlags &= ~FlagT(dirtyFlag);
QSSGRenderNode::clearDirty(QSSGRenderNode::DirtyFlag::SubNodeDirty);
}
static float getZNear(const QMatrix4x4 &projection)
{
const float *data = projection.constData();
QSSGPlane plane(QVector3D(data[3] + data[2], data[7] + data[6], data[11] + data[10]), -data[15] - data[14]);
plane.normalize();
return plane.d;
}
static QVector2D getViewportHalfExtents(const QMatrix4x4 &projection) {
const float *data = projection.constData();
QSSGPlane nearPlane(QVector3D(data[3] + data[2], data[7] + data[6], data[11] + data[10]), -data[15] - data[14]);
nearPlane.normalize();
QSSGPlane rightPlane(QVector3D(data[3] - data[0], data[7] - data[4], data[11] - data[8]), -data[15] + data[12]);
rightPlane.normalize();
QSSGPlane topPlane(QVector3D(data[3] - data[1], data[7] - data[5], data[11] - data[9]), -data[15] + data[13]);
topPlane.normalize();
// Get intersection the 3 planes
float denom = QVector3D::dotProduct(QVector3D::crossProduct(nearPlane.n, rightPlane.n), topPlane.n);
if (qFuzzyIsNull(denom))
return QVector2D();
QVector3D intersection = (QVector3D::crossProduct(rightPlane.n, topPlane.n) * nearPlane.d +
(QVector3D::crossProduct(topPlane.n, nearPlane.n) * rightPlane.d) +
(QVector3D::crossProduct(nearPlane.n, rightPlane.n) * topPlane.d)) / denom;
return QVector2D(intersection.x(), intersection.y());
}
float QSSGRenderCamera::getLevelOfDetailMultiplier() const
{
if (type == QSSGRenderGraphObject::Type::OrthographicCamera)
return getViewportHalfExtents(projection).x();
float zn = getZNear(projection);
float width = getViewportHalfExtents(projection).x() * 2.0;
return 1.0 / (zn / width);
}
QT_END_NAMESPACE