mirror of
https://github.com/overte-org/overte.git
synced 2025-04-26 07:16:25 +02:00
326 lines
10 KiB
C++
326 lines
10 KiB
C++
//
|
|
// Camera.cpp
|
|
// interface/src
|
|
//
|
|
// Copyright 2013 High Fidelity, Inc.
|
|
//
|
|
// Distributed under the Apache License, Version 2.0.
|
|
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
|
//
|
|
|
|
#include <glm/gtx/quaternion.hpp>
|
|
|
|
#include <SharedUtil.h>
|
|
#include <VoxelConstants.h>
|
|
#include <EventTypes.h>
|
|
|
|
#include "Application.h"
|
|
#include "Camera.h"
|
|
#include "Menu.h"
|
|
#include "Util.h"
|
|
#include "devices/OculusManager.h"
|
|
|
|
const float CAMERA_FIRST_PERSON_MODE_UP_SHIFT = 0.0f;
|
|
const float CAMERA_FIRST_PERSON_MODE_DISTANCE = 0.0f;
|
|
const float CAMERA_FIRST_PERSON_MODE_TIGHTNESS = 100.0f;
|
|
|
|
const float CAMERA_INDEPENDENT_MODE_UP_SHIFT = 0.0f;
|
|
const float CAMERA_INDEPENDENT_MODE_DISTANCE = 0.0f;
|
|
const float CAMERA_INDEPENDENT_MODE_TIGHTNESS = 100.0f;
|
|
|
|
const float CAMERA_THIRD_PERSON_MODE_UP_SHIFT = -0.2f;
|
|
const float CAMERA_THIRD_PERSON_MODE_DISTANCE = 1.5f;
|
|
const float CAMERA_THIRD_PERSON_MODE_TIGHTNESS = 8.0f;
|
|
|
|
const float CAMERA_MIRROR_MODE_UP_SHIFT = 0.0f;
|
|
const float CAMERA_MIRROR_MODE_DISTANCE = 0.17f;
|
|
const float CAMERA_MIRROR_MODE_TIGHTNESS = 100.0f;
|
|
|
|
|
|
Camera::Camera() :
|
|
_needsToInitialize(true),
|
|
_mode(CAMERA_MODE_THIRD_PERSON),
|
|
_prevMode(CAMERA_MODE_THIRD_PERSON),
|
|
_frustumNeedsReshape(true),
|
|
_position(0.0f, 0.0f, 0.0f),
|
|
_idealPosition(0.0f, 0.0f, 0.0f),
|
|
_targetPosition(0.0f, 0.0f, 0.0f),
|
|
_fieldOfView(DEFAULT_FIELD_OF_VIEW_DEGREES),
|
|
_aspectRatio(16.0f/9.0f),
|
|
_nearClip(0.08f), // default
|
|
_farClip(50.0f * TREE_SCALE), // default
|
|
_upShift(0.0f),
|
|
_distance(0.0f),
|
|
_tightness(10.0f), // default
|
|
_previousUpShift(0.0f),
|
|
_previousDistance(0.0f),
|
|
_previousTightness(0.0f),
|
|
_newUpShift(0.0f),
|
|
_newDistance(0.0f),
|
|
_newTightness(0.0f),
|
|
_modeShift(1.0f),
|
|
_linearModeShift(0.0f),
|
|
_modeShiftPeriod(1.0f),
|
|
_scale(1.0f),
|
|
_lookingAt(0.0f, 0.0f, 0.0f),
|
|
_isKeepLookingAt(false)
|
|
{
|
|
}
|
|
|
|
void Camera::update(float deltaTime) {
|
|
|
|
if (_mode != CAMERA_MODE_NULL) {
|
|
// use iterative forces to push the camera towards the target position and angle
|
|
updateFollowMode(deltaTime);
|
|
}
|
|
}
|
|
|
|
// use iterative forces to keep the camera at the desired position and angle
|
|
void Camera::updateFollowMode(float deltaTime) {
|
|
if (_linearModeShift < 1.0f) {
|
|
_linearModeShift += deltaTime / _modeShiftPeriod;
|
|
if (_needsToInitialize || _linearModeShift > 1.0f) {
|
|
_linearModeShift = 1.0f;
|
|
_modeShift = 1.0f;
|
|
_upShift = _newUpShift;
|
|
_distance = _newDistance;
|
|
_tightness = _newTightness;
|
|
} else {
|
|
_modeShift = ONE_HALF - ONE_HALF * cosf(_linearModeShift * PI );
|
|
_upShift = _previousUpShift * (1.0f - _modeShift) + _newUpShift * _modeShift;
|
|
_distance = _previousDistance * (1.0f - _modeShift) + _newDistance * _modeShift;
|
|
_tightness = _previousTightness * (1.0f - _modeShift) + _newTightness * _modeShift;
|
|
}
|
|
}
|
|
|
|
// derive t from tightness
|
|
float t = _tightness * _modeShift * deltaTime;
|
|
if (t > 1.0f) {
|
|
t = 1.0f;
|
|
}
|
|
|
|
// handle keepLookingAt
|
|
if (_isKeepLookingAt) {
|
|
lookAt(_lookingAt);
|
|
}
|
|
|
|
// Update position and rotation, setting directly if tightness is 0.0
|
|
if (_needsToInitialize || (_tightness == 0.0f)) {
|
|
_rotation = _targetRotation;
|
|
_idealPosition = _targetPosition + _scale * (_rotation * glm::vec3(0.0f, _upShift, _distance));
|
|
_position = _idealPosition;
|
|
_needsToInitialize = false;
|
|
} else {
|
|
// pull rotation towards ideal
|
|
_rotation = safeMix(_rotation, _targetRotation, t);
|
|
_idealPosition = _targetPosition + _scale * (_rotation * glm::vec3(0.0f, _upShift, _distance));
|
|
_position += (_idealPosition - _position) * t;
|
|
}
|
|
}
|
|
|
|
float Camera::getFarClip() const {
|
|
return (_scale * _farClip < std::numeric_limits<int16_t>::max())
|
|
? _scale * _farClip
|
|
: std::numeric_limits<int16_t>::max() - 1;
|
|
}
|
|
|
|
void Camera::setModeShiftPeriod (float period) {
|
|
const float MIN_PERIOD = 0.001f;
|
|
const float MAX_PERIOD = 3.0f;
|
|
_modeShiftPeriod = glm::clamp(period, MIN_PERIOD, MAX_PERIOD);
|
|
|
|
// if a zero period was requested, we clearly want to snap immediately to the target
|
|
if (period == 0.0f) {
|
|
update(MAX_PERIOD);
|
|
}
|
|
}
|
|
|
|
void Camera::setMode(CameraMode m) {
|
|
|
|
_prevMode = _mode;
|
|
_mode = m;
|
|
_modeShift = 0.0;
|
|
_linearModeShift = 0.0;
|
|
|
|
_previousUpShift = _upShift;
|
|
_previousDistance = _distance;
|
|
_previousTightness = _tightness;
|
|
|
|
if (_mode == CAMERA_MODE_THIRD_PERSON) {
|
|
_newUpShift = CAMERA_THIRD_PERSON_MODE_UP_SHIFT;
|
|
_newDistance = CAMERA_THIRD_PERSON_MODE_DISTANCE;
|
|
_newTightness = CAMERA_THIRD_PERSON_MODE_TIGHTNESS;
|
|
} else if (_mode == CAMERA_MODE_FIRST_PERSON) {
|
|
_newUpShift = CAMERA_FIRST_PERSON_MODE_UP_SHIFT;
|
|
_newDistance = CAMERA_FIRST_PERSON_MODE_DISTANCE;
|
|
_newTightness = CAMERA_FIRST_PERSON_MODE_TIGHTNESS;
|
|
} else if (_mode == CAMERA_MODE_MIRROR) {
|
|
_newUpShift = CAMERA_MIRROR_MODE_UP_SHIFT;
|
|
_newDistance = CAMERA_MIRROR_MODE_DISTANCE;
|
|
_newTightness = CAMERA_MIRROR_MODE_TIGHTNESS;
|
|
} else if (_mode == CAMERA_MODE_INDEPENDENT) {
|
|
_newUpShift = CAMERA_INDEPENDENT_MODE_UP_SHIFT;
|
|
_newDistance = CAMERA_INDEPENDENT_MODE_DISTANCE;
|
|
_newTightness = CAMERA_INDEPENDENT_MODE_TIGHTNESS;
|
|
|
|
}
|
|
}
|
|
|
|
void Camera::setTargetPosition(const glm::vec3& t) {
|
|
_targetPosition = t;
|
|
|
|
// handle keepLookingAt
|
|
if (_isKeepLookingAt) {
|
|
lookAt(_lookingAt);
|
|
}
|
|
|
|
}
|
|
|
|
void Camera::setTargetRotation( const glm::quat& targetRotation ) {
|
|
_targetRotation = targetRotation;
|
|
}
|
|
|
|
void Camera::setFieldOfView(float f) {
|
|
_fieldOfView = f;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setAspectRatio(float a) {
|
|
_aspectRatio = a;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setNearClip(float n) {
|
|
_nearClip = n;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setFarClip(float f) {
|
|
_farClip = f;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setEyeOffsetPosition(const glm::vec3& p) {
|
|
_eyeOffsetPosition = p;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setEyeOffsetOrientation(const glm::quat& o) {
|
|
_eyeOffsetOrientation = o;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::setScale(float s) {
|
|
_scale = s;
|
|
_needsToInitialize = true;
|
|
_frustumNeedsReshape = true;
|
|
}
|
|
|
|
void Camera::initialize() {
|
|
_needsToInitialize = true;
|
|
_modeShift = 0.0;
|
|
}
|
|
|
|
// call to find out if the view frustum needs to be reshaped
|
|
bool Camera::getFrustumNeedsReshape() const {
|
|
return _frustumNeedsReshape;
|
|
}
|
|
|
|
// call this when deciding whether to render the head or not
|
|
CameraMode Camera::getInterpolatedMode() const {
|
|
const float SHIFT_THRESHOLD_INTO_FIRST_PERSON = 0.7f;
|
|
const float SHIFT_THRESHOLD_OUT_OF_FIRST_PERSON = 0.6f;
|
|
if ((_mode == CAMERA_MODE_FIRST_PERSON && _linearModeShift < SHIFT_THRESHOLD_INTO_FIRST_PERSON) ||
|
|
(_prevMode == CAMERA_MODE_FIRST_PERSON && _linearModeShift < SHIFT_THRESHOLD_OUT_OF_FIRST_PERSON)) {
|
|
return _prevMode;
|
|
}
|
|
return _mode;
|
|
}
|
|
|
|
// call this after reshaping the view frustum
|
|
void Camera::setFrustumWasReshaped() {
|
|
_frustumNeedsReshape = false;
|
|
}
|
|
|
|
void Camera::lookAt(const glm::vec3& lookAt) {
|
|
glm::vec3 up = IDENTITY_UP;
|
|
glm::mat4 lookAtMatrix = glm::lookAt(_targetPosition, lookAt, up);
|
|
glm::quat rotation = glm::quat_cast(lookAtMatrix);
|
|
rotation.w = -rotation.w; // Rosedale approved
|
|
setTargetRotation(rotation);
|
|
}
|
|
|
|
void Camera::keepLookingAt(const glm::vec3& point) {
|
|
lookAt(point);
|
|
_isKeepLookingAt = true;
|
|
_lookingAt = point;
|
|
}
|
|
|
|
CameraScriptableObject::CameraScriptableObject(Camera* camera, ViewFrustum* viewFrustum) :
|
|
_camera(camera), _viewFrustum(viewFrustum)
|
|
{
|
|
}
|
|
|
|
PickRay CameraScriptableObject::computePickRay(float x, float y) {
|
|
float screenWidth = Application::getInstance()->getGLWidget()->width();
|
|
float screenHeight = Application::getInstance()->getGLWidget()->height();
|
|
PickRay result;
|
|
if (OculusManager::isConnected()) {
|
|
result.origin = _camera->getPosition();
|
|
Application::getInstance()->getApplicationOverlay().computeOculusPickRay(x / screenWidth, y / screenHeight, result.direction);
|
|
} else {
|
|
_viewFrustum->computePickRay(x / screenWidth, y / screenHeight, result.origin, result.direction);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
QString CameraScriptableObject::getMode() const {
|
|
QString mode("unknown");
|
|
switch(_camera->getMode()) {
|
|
case CAMERA_MODE_THIRD_PERSON:
|
|
mode = "third person";
|
|
break;
|
|
case CAMERA_MODE_FIRST_PERSON:
|
|
mode = "first person";
|
|
break;
|
|
case CAMERA_MODE_MIRROR:
|
|
mode = "mirror";
|
|
break;
|
|
case CAMERA_MODE_INDEPENDENT:
|
|
mode = "independent";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return mode;
|
|
}
|
|
|
|
void CameraScriptableObject::setMode(const QString& mode) {
|
|
CameraMode currentMode = _camera->getMode();
|
|
CameraMode targetMode = currentMode;
|
|
if (mode == "third person") {
|
|
targetMode = CAMERA_MODE_THIRD_PERSON;
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FullscreenMirror, false);
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FirstPerson, false);
|
|
} else if (mode == "first person") {
|
|
targetMode = CAMERA_MODE_FIRST_PERSON;
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FullscreenMirror, false);
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FirstPerson, true);
|
|
} else if (mode == "mirror") {
|
|
targetMode = CAMERA_MODE_MIRROR;
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FullscreenMirror, true);
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FirstPerson, false);
|
|
} else if (mode == "independent") {
|
|
targetMode = CAMERA_MODE_INDEPENDENT;
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FullscreenMirror, false);
|
|
Menu::getInstance()->setIsOptionChecked(MenuOption::FirstPerson, false);
|
|
}
|
|
if (currentMode != targetMode) {
|
|
_camera->setMode(targetMode);
|
|
const float DEFAULT_MODE_SHIFT_PERIOD = 0.5f; // half second
|
|
_camera->setModeShiftPeriod(DEFAULT_MODE_SHIFT_PERIOD);
|
|
}
|
|
}
|
|
|
|
|
|
|