////  OverlayConductor.cpp//  interface/src/ui////  Copyright 2015 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 <OffscreenUi.h>#include <display-plugins/CompositorHelper.h> #include "Application.h"#include "avatar/AvatarManager.h"#include "InterfaceLogging.h"#include "OverlayConductor.h" OverlayConductor::OverlayConductor() { } OverlayConductor::~OverlayConductor() {} bool OverlayConductor::headOutsideOverlay() const {    glm::mat4 hmdMat = qApp->getHMDSensorPose();    glm::vec3 hmdPos = extractTranslation(hmdMat);    glm::vec3 hmdForward = transformVectorFast(hmdMat, glm::vec3(0.0f, 0.0f, -1.0f));     Transform uiTransform = qApp->getApplicationCompositor().getModelTransform();    glm::vec3 uiPos = uiTransform.getTranslation();    glm::vec3 uiForward = uiTransform.getRotation() * glm::vec3(0.0f, 0.0f, -1.0f);     const float MAX_COMPOSITOR_DISTANCE = 0.99f; // If you're 1m from center of ui sphere, you're at the surface.    const float MAX_COMPOSITOR_ANGLE = 180.0f;  // rotation check is effectively disabled    if (glm::distance(uiPos, hmdPos) > MAX_COMPOSITOR_DISTANCE ||        glm::dot(uiForward, hmdForward) < cosf(glm::radians(MAX_COMPOSITOR_ANGLE))) {        return true;    }    return false;} bool OverlayConductor::updateAvatarIsAtRest() {     MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();     const quint64 REST_ENABLE_TIME_USECS = 1000 * 1000; // 1 s    const quint64 REST_DISABLE_TIME_USECS = 200 * 1000;  // 200 ms     const float AT_REST_THRESHOLD = 0.01f;    bool desiredAtRest = glm::length(myAvatar->getVelocity()) < AT_REST_THRESHOLD;    if (desiredAtRest != _desiredAtRest) {        // start timer        _desiredAtRestTimer = usecTimestampNow() + (desiredAtRest ? REST_ENABLE_TIME_USECS : REST_DISABLE_TIME_USECS);    }     _desiredAtRest = desiredAtRest;     if (_desiredAtRestTimer != 0 && usecTimestampNow() > _desiredAtRestTimer) {        // timer expired        // change state!        _currentAtRest = _desiredAtRest;        // disable timer        _desiredAtRestTimer = 0;    }     return _currentAtRest;} bool OverlayConductor::updateAvatarHasDriveInput() {    MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();     const quint64 DRIVE_ENABLE_TIME_USECS = 200 * 1000;  // 200 ms    const quint64 DRIVE_DISABLE_TIME_USECS = 1000 * 1000; // 1 s     bool desiredDriving = myAvatar->hasDriveInput();    if (desiredDriving != _desiredDriving) {        // start timer        _desiredDrivingTimer = usecTimestampNow() + (desiredDriving ? DRIVE_ENABLE_TIME_USECS : DRIVE_DISABLE_TIME_USECS);    }     _desiredDriving = desiredDriving;     if (_desiredDrivingTimer != 0 && usecTimestampNow() > _desiredDrivingTimer) {        // timer expired        // change state!        _currentDriving = _desiredDriving;        // disable timer        _desiredDrivingTimer = 0;    }     return _currentDriving;} void OverlayConductor::centerUI() {    // place the overlay at the current hmd position in sensor space    auto camMat = cancelOutRollAndPitch(qApp->getHMDSensorPose());    qApp->getApplicationCompositor().setModelTransform(Transform(camMat));} void OverlayConductor::update(float dt) {    auto offscreenUi = DependencyManager::get<OffscreenUi>();    bool currentVisible = !offscreenUi->getDesktop()->property("pinned").toBool();     MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();    // centerUI when hmd mode is first enabled and mounted    if (qApp->isHMDMode() && qApp->getActiveDisplayPlugin()->isDisplayVisible()) {        if (!_hmdMode) {            _hmdMode = true;            centerUI();        }    } else {        _hmdMode = false;    }     bool prevDriving = _currentDriving;    bool isDriving = updateAvatarHasDriveInput();    bool drivingChanged = prevDriving != isDriving;    bool isAtRest = updateAvatarIsAtRest();    bool shouldRecenter = false;     if (_flags & SuppressedByDrive) {        if (!isDriving) {            _flags &= ~SuppressedByDrive;             shouldRecenter = true;        }    } else {        if (myAvatar->getClearOverlayWhenMoving() && drivingChanged && isDriving) {            _flags |= SuppressedByDrive;        }    }     if (_flags & SuppressedByHead) {        if (isAtRest) {            _flags &= ~SuppressedByHead;            shouldRecenter = true;        }    } else {        if (_hmdMode && headOutsideOverlay()) {            _flags |= SuppressedByHead;        }    }      bool targetVisible = Menu::getInstance()->isOptionChecked(MenuOption::Overlays) && (0 == (_flags & SuppressMask));    if (targetVisible != currentVisible) {        offscreenUi->setPinned(!targetVisible);    }    if (shouldRecenter && !_flags) {        centerUI();    }}