387 lines
11 KiB
C++
387 lines
11 KiB
C++
#include "Camera.h"
|
|
#include "ViewportWidget.h"
|
|
#include <QApplication>
|
|
#include <QWheelEvent>
|
|
#include <QPropertyAnimation>
|
|
#include <QParallelAnimationGroup>
|
|
#include <QtMath>
|
|
|
|
Camera::Camera(QObject *parent) : QObject(parent)
|
|
{
|
|
m_lastPos = QPoint();
|
|
// Set initial view to an isometric angle on the XY plane
|
|
m_xRot = 30 * 16;
|
|
m_yRot = -45 * 16;
|
|
m_zoom = -20.0f;
|
|
m_panX = 0.0f;
|
|
m_panY = 0.0f;
|
|
}
|
|
|
|
void Camera::mousePressEvent(QMouseEvent* event)
|
|
{
|
|
m_lastPos = event->pos();
|
|
}
|
|
|
|
void Camera::mouseMoveEvent(QMouseEvent* event, int viewportHeight)
|
|
{
|
|
int dx = event->pos().x() - m_lastPos.x();
|
|
int dy = event->pos().y() - m_lastPos.y();
|
|
|
|
if (event->buttons() & Qt::MiddleButton) {
|
|
if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
|
|
// Pan
|
|
if (viewportHeight == 0) viewportHeight = 1;
|
|
|
|
// This logic is based on a 45-degree field of view.
|
|
float fov = 45.0f;
|
|
float dist = -m_zoom;
|
|
|
|
float world_height = 2.0f * dist * tan(qDegreesToRadians(fov / 2.0f));
|
|
float pixels_to_world = world_height / viewportHeight;
|
|
|
|
setPanX(m_panX + dx * pixels_to_world);
|
|
setPanY(m_panY - dy * pixels_to_world);
|
|
} else {
|
|
// Rotate
|
|
setXRotation(m_xRot + 8 * dy);
|
|
setYRotation(m_yRot + 8 * dx);
|
|
}
|
|
}
|
|
m_lastPos = event->pos();
|
|
}
|
|
|
|
void Camera::wheelEvent(QWheelEvent* event, const QVector3D& worldPos)
|
|
{
|
|
QPoint numDegrees = event->angleDelta() / 8;
|
|
if (!numDegrees.isNull()) {
|
|
// Make zoom speed proportional to distance, with a minimum speed and a cap.
|
|
// The factors are chosen to match the original zoom speed at the default zoom level.
|
|
float dist = -m_zoom;
|
|
dist = qMin(dist, 200.0f); // Cap distance to avoid crazy fast zoom out.
|
|
float zoomFactor = dist * 0.009f + 0.02f;
|
|
float zoomAmount = numDegrees.y() * zoomFactor;
|
|
|
|
float oldZoom = m_zoom;
|
|
float newZoom = oldZoom + zoomAmount;
|
|
|
|
QMatrix4x4 rotation;
|
|
rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
|
|
rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
|
|
QVector3D p_camera = rotation.map(worldPos);
|
|
|
|
if (std::abs(p_camera.z() + oldZoom) < 1e-6) {
|
|
setZoom(newZoom);
|
|
return;
|
|
}
|
|
|
|
float ratio = (p_camera.z() + newZoom) / (p_camera.z() + oldZoom);
|
|
|
|
float newPanX = (p_camera.x() + m_panX) * ratio - p_camera.x();
|
|
float newPanY = (p_camera.y() + m_panY) * ratio - p_camera.y();
|
|
|
|
setZoom(newZoom);
|
|
setPanX(newPanX);
|
|
setPanY(newPanY);
|
|
}
|
|
}
|
|
|
|
QMatrix4x4 Camera::modelViewMatrix() const
|
|
{
|
|
QMatrix4x4 model;
|
|
model.translate(m_panX, m_panY, m_zoom);
|
|
|
|
if (m_isRotating) {
|
|
model.translate(m_rotationPivot);
|
|
}
|
|
model.rotate(m_xRot / 16.0f, 1, 0, 0);
|
|
model.rotate(m_yRot / 16.0f, 0, 1, 0);
|
|
if (m_isRotating) {
|
|
model.translate(-m_rotationPivot);
|
|
}
|
|
return model;
|
|
}
|
|
|
|
float Camera::xRotation() const { return m_xRot; }
|
|
void Camera::setXRotation(float angle)
|
|
{
|
|
if (angle != m_xRot) {
|
|
m_xRot = angle;
|
|
emit cameraChanged();
|
|
}
|
|
}
|
|
|
|
float Camera::yRotation() const { return m_yRot; }
|
|
void Camera::setYRotation(float angle)
|
|
{
|
|
if (angle != m_yRot) {
|
|
m_yRot = angle;
|
|
emit cameraChanged();
|
|
}
|
|
}
|
|
|
|
float Camera::zoom() const { return m_zoom; }
|
|
void Camera::setZoom(float value)
|
|
{
|
|
const float max_dist = 5000.0f;
|
|
float remaining_dist_sq = max_dist * max_dist - m_panX * m_panX - m_panY * m_panY;
|
|
if (remaining_dist_sq < 0) {
|
|
remaining_dist_sq = 0;
|
|
}
|
|
float max_val = qSqrt(remaining_dist_sq);
|
|
value = qBound(-max_val, value, 0.0f); // Zoom is negative or zero
|
|
|
|
if (value != m_zoom) {
|
|
m_zoom = value;
|
|
emit cameraChanged();
|
|
}
|
|
}
|
|
|
|
float Camera::panX() const { return m_panX; }
|
|
void Camera::setPanX(float value)
|
|
{
|
|
const float max_dist = 5000.0f;
|
|
float remaining_dist_sq = max_dist * max_dist - m_panY * m_panY - m_zoom * m_zoom;
|
|
if (remaining_dist_sq < 0) {
|
|
remaining_dist_sq = 0;
|
|
}
|
|
float max_val = qSqrt(remaining_dist_sq);
|
|
value = qBound(-max_val, value, max_val);
|
|
|
|
if (value != m_panX) {
|
|
m_panX = value;
|
|
emit cameraChanged();
|
|
}
|
|
}
|
|
|
|
float Camera::panY() const { return m_panY; }
|
|
void Camera::setPanY(float value)
|
|
{
|
|
const float max_dist = 5000.0f;
|
|
float remaining_dist_sq = max_dist * max_dist - m_panX * m_panX - m_zoom * m_zoom;
|
|
if (remaining_dist_sq < 0) {
|
|
remaining_dist_sq = 0;
|
|
}
|
|
float max_val = qSqrt(remaining_dist_sq);
|
|
value = qBound(-max_val, value, max_val);
|
|
|
|
if (value != m_panY) {
|
|
m_panY = value;
|
|
emit cameraChanged();
|
|
}
|
|
}
|
|
|
|
void Camera::saveState()
|
|
{
|
|
m_savedXRot = m_xRot;
|
|
m_savedYRot = m_yRot;
|
|
m_savedPanX = m_panX;
|
|
m_savedPanY = m_panY;
|
|
m_savedZoom = m_zoom;
|
|
}
|
|
|
|
void Camera::restoreState()
|
|
{
|
|
setXRotation(m_savedXRot);
|
|
setYRotation(m_savedYRot);
|
|
setPanX(m_savedPanX);
|
|
setPanY(m_savedPanY);
|
|
setZoom(m_savedZoom);
|
|
}
|
|
|
|
void Camera::animateToPlaneView(int plane)
|
|
{
|
|
float targetXRot = xRotation();
|
|
float targetYRot = yRotation();
|
|
switch (static_cast<ViewportWidget::SketchPlane>(plane)) {
|
|
case ViewportWidget::SketchPlane::XY: // Top view
|
|
targetXRot = 90 * 16;
|
|
targetYRot = 0;
|
|
break;
|
|
case ViewportWidget::SketchPlane::XZ: // Front view
|
|
targetXRot = 0;
|
|
targetYRot = 0;
|
|
break;
|
|
case ViewportWidget::SketchPlane::YZ: // Right view
|
|
targetXRot = 0;
|
|
targetYRot = -90 * 16;
|
|
break;
|
|
case ViewportWidget::SketchPlane::NONE:
|
|
break;
|
|
}
|
|
|
|
auto* animGroup = new QParallelAnimationGroup(this);
|
|
|
|
const float full_circle = 360.0f * 16.0f;
|
|
|
|
float currentXRot = xRotation();
|
|
float diffX = targetXRot - currentXRot;
|
|
diffX = fmod(diffX, full_circle);
|
|
if (diffX > full_circle / 2.0f) {
|
|
diffX -= full_circle;
|
|
} else if (diffX < -full_circle / 2.0f) {
|
|
diffX += full_circle;
|
|
}
|
|
|
|
auto* xRotAnim = new QPropertyAnimation(this, "xRotation");
|
|
xRotAnim->setDuration(300);
|
|
xRotAnim->setStartValue(currentXRot);
|
|
xRotAnim->setEndValue(currentXRot + diffX);
|
|
xRotAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(xRotAnim);
|
|
|
|
float currentYRot = yRotation();
|
|
float diffY = targetYRot - currentYRot;
|
|
diffY = fmod(diffY, full_circle);
|
|
if (diffY > full_circle / 2.0f) {
|
|
diffY -= full_circle;
|
|
} else if (diffY < -full_circle / 2.0f) {
|
|
diffY += full_circle;
|
|
}
|
|
|
|
auto* yRotAnim = new QPropertyAnimation(this, "yRotation");
|
|
yRotAnim->setDuration(300);
|
|
yRotAnim->setStartValue(currentYRot);
|
|
yRotAnim->setEndValue(currentYRot + diffY);
|
|
yRotAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(yRotAnim);
|
|
|
|
auto* panXAnim = new QPropertyAnimation(this, "panX");
|
|
panXAnim->setDuration(300);
|
|
panXAnim->setStartValue(panX());
|
|
panXAnim->setEndValue(0.0f);
|
|
panXAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(panXAnim);
|
|
|
|
auto* panYAnim = new QPropertyAnimation(this, "panY");
|
|
panYAnim->setDuration(300);
|
|
panYAnim->setStartValue(panY());
|
|
panYAnim->setEndValue(0.0f);
|
|
panYAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(panYAnim);
|
|
|
|
auto* zoomAnim = new QPropertyAnimation(this, "zoom");
|
|
zoomAnim->setDuration(300);
|
|
zoomAnim->setStartValue(zoom());
|
|
zoomAnim->setEndValue(-20.0f);
|
|
zoomAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(zoomAnim);
|
|
|
|
animGroup->start(QAbstractAnimation::DeleteWhenStopped);
|
|
}
|
|
|
|
void Camera::startRotation(const QVector3D& pivot)
|
|
{
|
|
m_rotationPivot = pivot;
|
|
if (m_rotationPivot.length() > 1000.0f) {
|
|
m_rotationPivot = m_rotationPivot.normalized() * 1000.0f;
|
|
}
|
|
m_stableZoom = m_zoom;
|
|
|
|
QMatrix4x4 rotation;
|
|
rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
|
|
rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
|
|
|
|
QVector3D p_rotated = rotation.map(m_rotationPivot);
|
|
QVector3D p_diff = p_rotated - m_rotationPivot;
|
|
|
|
setPanX(m_panX + p_diff.x());
|
|
setPanY(m_panY + p_diff.y());
|
|
setZoom(m_zoom + p_diff.z());
|
|
|
|
m_isRotating = true;
|
|
}
|
|
|
|
void Camera::stopRotation()
|
|
{
|
|
if (!m_isRotating) {
|
|
return;
|
|
}
|
|
|
|
QMatrix4x4 rotation;
|
|
rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
|
|
rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
|
|
|
|
QVector3D p_rotated = rotation.map(m_rotationPivot);
|
|
QVector3D p_diff = p_rotated - m_rotationPivot;
|
|
|
|
setPanX(m_panX - p_diff.x());
|
|
setPanY(m_panY - p_diff.y());
|
|
setZoom(m_zoom - p_diff.z());
|
|
|
|
m_isRotating = false;
|
|
}
|
|
|
|
void Camera::animateRestoreState()
|
|
{
|
|
auto* animGroup = new QParallelAnimationGroup(this);
|
|
|
|
const float full_circle = 360.0f * 16.0f;
|
|
|
|
float currentXRot = xRotation();
|
|
float targetXRot = savedXRot();
|
|
float diffX = targetXRot - currentXRot;
|
|
diffX = fmod(diffX, full_circle);
|
|
if (diffX > full_circle / 2.0f) {
|
|
diffX -= full_circle;
|
|
} else if (diffX < -full_circle / 2.0f) {
|
|
diffX += full_circle;
|
|
}
|
|
|
|
auto* xRotAnim = new QPropertyAnimation(this, "xRotation");
|
|
xRotAnim->setDuration(300);
|
|
xRotAnim->setStartValue(currentXRot);
|
|
xRotAnim->setEndValue(currentXRot + diffX);
|
|
xRotAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(xRotAnim);
|
|
|
|
float currentYRot = yRotation();
|
|
float targetYRot = savedYRot();
|
|
float diffY = targetYRot - currentYRot;
|
|
diffY = fmod(diffY, full_circle);
|
|
if (diffY > full_circle / 2.0f) {
|
|
diffY -= full_circle;
|
|
} else if (diffY < -full_circle / 2.0f) {
|
|
diffY += full_circle;
|
|
}
|
|
|
|
auto* yRotAnim = new QPropertyAnimation(this, "yRotation");
|
|
yRotAnim->setDuration(300);
|
|
yRotAnim->setStartValue(currentYRot);
|
|
yRotAnim->setEndValue(currentYRot + diffY);
|
|
yRotAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(yRotAnim);
|
|
|
|
auto* panXAnim = new QPropertyAnimation(this, "panX");
|
|
panXAnim->setDuration(300);
|
|
panXAnim->setStartValue(panX());
|
|
panXAnim->setEndValue(savedPanX());
|
|
panXAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(panXAnim);
|
|
|
|
auto* panYAnim = new QPropertyAnimation(this, "panY");
|
|
panYAnim->setDuration(300);
|
|
panYAnim->setStartValue(panY());
|
|
panYAnim->setEndValue(savedPanY());
|
|
panYAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(panYAnim);
|
|
|
|
auto* zoomAnim = new QPropertyAnimation(this, "zoom");
|
|
zoomAnim->setDuration(300);
|
|
zoomAnim->setStartValue(zoom());
|
|
zoomAnim->setEndValue(savedZoom());
|
|
zoomAnim->setEasingCurve(QEasingCurve::InOutQuad);
|
|
animGroup->addAnimation(zoomAnim);
|
|
|
|
connect(animGroup, &QParallelAnimationGroup::finished, this, &Camera::restoreStateAnimationFinished);
|
|
|
|
animGroup->start(QAbstractAnimation::DeleteWhenStopped);
|
|
}
|
|
|
|
float Camera::uiCameraDistance() const
|
|
{
|
|
if (m_isRotating) {
|
|
return m_stableZoom;
|
|
}
|
|
return m_zoom;
|
|
}
|