Vasily
9d8e3ad3ef
chaperoneGeometryQuads was converted from an implicit pointer array to a std::vector because the only thing the pointer array did was hide the fact that it was an array.
1427 lines
48 KiB
C++
1427 lines
48 KiB
C++
#include "ChaperoneTabController.h"
|
|
#include <QQuickWindow>
|
|
#include "../overlaycontroller.h"
|
|
#include "../settings/settings.h"
|
|
#include <cmath>
|
|
|
|
// application namespace
|
|
namespace advsettings
|
|
{
|
|
void ChaperoneTabController::initStage1()
|
|
{
|
|
if ( disableChaperone() )
|
|
{
|
|
setFadeDistance( 0.0f, true );
|
|
}
|
|
|
|
reloadChaperoneProfiles();
|
|
m_chaperoneSettingsUpdateCounter
|
|
= utils::adjustUpdateRate( k_chaperoneSettingsUpdateCounter );
|
|
eventLoopTick( nullptr );
|
|
}
|
|
|
|
void ChaperoneTabController::initStage2( OverlayController* var_parent )
|
|
{
|
|
this->parent = var_parent;
|
|
}
|
|
|
|
ChaperoneTabController::~ChaperoneTabController()
|
|
{
|
|
m_chaperoneHapticFeedbackActive = false;
|
|
if ( m_chaperoneHapticFeedbackThread.joinable() )
|
|
{
|
|
m_chaperoneHapticFeedbackThread.join();
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::reloadChaperoneProfiles()
|
|
{
|
|
settings::loadAllObjects( chaperoneProfiles );
|
|
}
|
|
|
|
void ChaperoneTabController::saveChaperoneProfiles()
|
|
{
|
|
settings::saveAllObjects( chaperoneProfiles );
|
|
}
|
|
|
|
void ChaperoneTabController::handleChaperoneWarnings( float distance )
|
|
{
|
|
vr::VRControllerState_t hmdState;
|
|
vr::VRSystem()->GetControllerState( vr::k_unTrackedDeviceIndex_Hmd,
|
|
&hmdState,
|
|
sizeof( vr::VRControllerState_t ) );
|
|
// If proximity Sensor is True (only can be true if exists)
|
|
// Then use prox sensor else use hmd activity level.
|
|
// Needed as detection since the "has prox sensor" property is unreliable.
|
|
// Note m_isProxActive should only ever be set to true if there is a prox
|
|
// sensor AND its currently on.
|
|
|
|
bool proxSensorOverrideState = false;
|
|
m_HMDHasProx ? ( proxSensorOverrideState = m_isProxActive )
|
|
: ( proxSensorOverrideState = m_isHMDActive );
|
|
|
|
// Switch to Beginner Mode
|
|
if ( isChaperoneSwitchToBeginnerEnabled() )
|
|
{
|
|
float activationDistance = chaperoneSwitchToBeginnerDistance();
|
|
|
|
if ( distance <= activationDistance && m_isHMDActive
|
|
&& !m_chaperoneSwitchToBeginnerActive )
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
m_chaperoneSwitchToBeginnerLastStyle = vr::VRSettings()->GetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING )
|
|
<< "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32 << "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
else
|
|
{
|
|
vr::VRSettings()->SetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
vr::COLLISION_BOUNDS_STYLE_BEGINNER,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING )
|
|
<< "Could not set \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
else
|
|
{
|
|
m_chaperoneSwitchToBeginnerActive = true;
|
|
}
|
|
}
|
|
}
|
|
else if ( ( distance > activationDistance || !m_isHMDActive )
|
|
&& m_chaperoneSwitchToBeginnerActive )
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
vr::VRSettings()->SetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
m_chaperoneSwitchToBeginnerLastStyle,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING )
|
|
<< "Could not set \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32 << "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
else
|
|
{
|
|
m_chaperoneSwitchToBeginnerActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Haptic Feedback
|
|
|
|
if ( isChaperoneHapticFeedbackEnabled() )
|
|
{
|
|
float activationDistance = chaperoneHapticFeedbackDistance();
|
|
|
|
if ( distance <= activationDistance && proxSensorOverrideState )
|
|
{
|
|
if ( !m_chaperoneHapticFeedbackActive )
|
|
{
|
|
if ( m_chaperoneHapticFeedbackThread.joinable() )
|
|
{
|
|
m_chaperoneHapticFeedbackActive = false;
|
|
m_chaperoneHapticFeedbackThread.join();
|
|
}
|
|
m_chaperoneHapticFeedbackActive = true;
|
|
m_chaperoneHapticFeedbackThread = std::thread(
|
|
[&]( ChaperoneTabController* _this ) {
|
|
auto leftIndex
|
|
= vr::VRSystem()
|
|
->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_LeftHand );
|
|
auto rightIndex
|
|
= vr::VRSystem()
|
|
->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_RightHand );
|
|
while ( _this->m_chaperoneHapticFeedbackActive )
|
|
{
|
|
// AS it stands both controllers will vibrate
|
|
// regardless of which is closer to boundary
|
|
// haptic Frequency is 0-320Hz
|
|
if ( leftIndex
|
|
!= vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
vr::VRInput()->TriggerHapticVibrationAction(
|
|
m_leftActionHandle,
|
|
0.0f,
|
|
0.2f,
|
|
120.0f,
|
|
0.5f,
|
|
m_leftInputHandle );
|
|
}
|
|
if ( rightIndex
|
|
!= vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
vr::VRInput()->TriggerHapticVibrationAction(
|
|
m_rightActionHandle,
|
|
0.0f,
|
|
0.2f,
|
|
120.0f,
|
|
0.5f,
|
|
m_rightInputHandle );
|
|
}
|
|
std::this_thread::sleep_for(
|
|
std::chrono::milliseconds( 5 ) );
|
|
}
|
|
},
|
|
this );
|
|
}
|
|
}
|
|
else if ( ( distance > activationDistance || !proxSensorOverrideState )
|
|
&& m_chaperoneHapticFeedbackActive )
|
|
{
|
|
m_chaperoneHapticFeedbackActive = false;
|
|
}
|
|
}
|
|
|
|
// Alarm Sound
|
|
if ( isChaperoneAlarmSoundEnabled() )
|
|
{
|
|
// LOG(WARNING) << "In alarm";
|
|
float activationDistance = chaperoneAlarmSoundDistance();
|
|
|
|
if ( distance <= activationDistance && proxSensorOverrideState )
|
|
{
|
|
if ( !m_chaperoneAlarmSoundActive )
|
|
{
|
|
parent->playAlarm01Sound( isChaperoneAlarmSoundLooping() );
|
|
m_chaperoneAlarmSoundActive = true;
|
|
}
|
|
if ( isChaperoneAlarmSoundLooping()
|
|
&& isChaperoneAlarmSoundAdjustVolume() )
|
|
{
|
|
float vol = 1.1f - distance / activationDistance;
|
|
if ( vol > 1.0f )
|
|
{
|
|
vol = 1.0f;
|
|
}
|
|
parent->setAlarm01SoundVolume( vol );
|
|
}
|
|
else
|
|
{
|
|
parent->setAlarm01SoundVolume( 1.0f );
|
|
}
|
|
}
|
|
else if ( ( distance > activationDistance || !proxSensorOverrideState )
|
|
&& m_chaperoneAlarmSoundActive )
|
|
{
|
|
parent->cancelAlarm01Sound();
|
|
m_chaperoneAlarmSoundActive = false;
|
|
}
|
|
}
|
|
|
|
// Show Dashboard
|
|
if ( isChaperoneShowDashboardEnabled() )
|
|
{
|
|
float activationDistance = chaperoneShowDashboardDistance();
|
|
if ( distance <= activationDistance && !m_chaperoneShowDashboardActive )
|
|
{
|
|
if ( !vr::VROverlay()->IsDashboardVisible() )
|
|
{
|
|
vr::VROverlay()->ShowDashboard(
|
|
application_strings::applicationKey );
|
|
}
|
|
m_chaperoneShowDashboardActive = true;
|
|
}
|
|
else if ( distance > activationDistance
|
|
&& m_chaperoneShowDashboardActive )
|
|
{
|
|
m_chaperoneShowDashboardActive = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::eventLoopTick(
|
|
vr::TrackedDevicePose_t* devicePoses )
|
|
{
|
|
if ( devicePoses )
|
|
{
|
|
m_isHMDActive = false;
|
|
std::lock_guard<std::recursive_mutex> lock(
|
|
parent->chaperoneUtils().mutex() );
|
|
auto minDistance = NAN;
|
|
auto& poseHmd = devicePoses[vr::k_unTrackedDeviceIndex_Hmd];
|
|
|
|
// m_isHMDActive is true when prox sensor OR HMD is moving (~10 seconds
|
|
// to update from OVR)
|
|
// THIS IS A WORK-AROUND Until proper binding support/calls are made
|
|
// availble for prox sensor
|
|
if ( vr::VRSystem()->GetTrackedDeviceActivityLevel(
|
|
vr::k_unTrackedDeviceIndex_Hmd )
|
|
== vr::k_EDeviceActivityLevel_UserInteraction )
|
|
{
|
|
m_isHMDActive = true;
|
|
}
|
|
if ( poseHmd.bPoseIsValid && poseHmd.bDeviceIsConnected
|
|
&& poseHmd.eTrackingResult == vr::TrackingResult_Running_OK )
|
|
{
|
|
auto distanceHmd = parent->chaperoneUtils().getDistanceToChaperone(
|
|
{ poseHmd.mDeviceToAbsoluteTracking.m[0][3],
|
|
poseHmd.mDeviceToAbsoluteTracking.m[1][3],
|
|
poseHmd.mDeviceToAbsoluteTracking.m[2][3] } );
|
|
if ( !std::isnan( distanceHmd ) )
|
|
{
|
|
minDistance = distanceHmd;
|
|
}
|
|
}
|
|
auto leftIndex = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_LeftHand );
|
|
if ( leftIndex != vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
auto& poseLeft = devicePoses[leftIndex];
|
|
if ( poseLeft.bPoseIsValid && poseLeft.bDeviceIsConnected
|
|
&& poseLeft.eTrackingResult == vr::TrackingResult_Running_OK )
|
|
{
|
|
auto distanceLeft
|
|
= parent->chaperoneUtils().getDistanceToChaperone(
|
|
{ poseLeft.mDeviceToAbsoluteTracking.m[0][3],
|
|
poseLeft.mDeviceToAbsoluteTracking.m[1][3],
|
|
poseLeft.mDeviceToAbsoluteTracking.m[2][3] } );
|
|
if ( !std::isnan( distanceLeft )
|
|
&& ( std::isnan( minDistance )
|
|
|| distanceLeft < minDistance ) )
|
|
{
|
|
minDistance = distanceLeft;
|
|
}
|
|
}
|
|
}
|
|
auto rightIndex
|
|
= vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_RightHand );
|
|
if ( rightIndex != vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
auto& poseRight = devicePoses[rightIndex];
|
|
if ( poseRight.bPoseIsValid && poseRight.bDeviceIsConnected
|
|
&& poseRight.eTrackingResult == vr::TrackingResult_Running_OK )
|
|
{
|
|
auto distanceRight
|
|
= parent->chaperoneUtils().getDistanceToChaperone(
|
|
{ poseRight.mDeviceToAbsoluteTracking.m[0][3],
|
|
poseRight.mDeviceToAbsoluteTracking.m[1][3],
|
|
poseRight.mDeviceToAbsoluteTracking.m[2][3] } );
|
|
if ( !std::isnan( distanceRight )
|
|
&& ( std::isnan( minDistance )
|
|
|| distanceRight < minDistance ) )
|
|
{
|
|
minDistance = distanceRight;
|
|
}
|
|
}
|
|
}
|
|
if ( !std::isnan( minDistance ) )
|
|
{
|
|
handleChaperoneWarnings( minDistance );
|
|
}
|
|
else
|
|
{
|
|
// attempts to reload chaperone data once per ~5 seconds.
|
|
m_updateTicksChaperoneReload++;
|
|
if ( m_updateTicksChaperoneReload >= 500 )
|
|
{
|
|
m_updateTicksChaperoneReload = 0;
|
|
LOG( WARNING ) << "Attempting to reload chaperone data";
|
|
parent->chaperoneUtils().loadChaperoneData();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( settingsUpdateCounter >= m_chaperoneSettingsUpdateCounter )
|
|
{
|
|
if ( parent->isDashboardVisible() )
|
|
{
|
|
updateChaperoneSettings();
|
|
}
|
|
settingsUpdateCounter = 0;
|
|
}
|
|
else
|
|
{
|
|
settingsUpdateCounter++;
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::updateChaperoneSettings()
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
float vis = static_cast<float>(
|
|
vr::VRSettings()->GetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaA_Int32,
|
|
&vrSettingsError ) );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_ColorGammaA_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
setBoundsVisibility( vis / 255.0f );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_FadeDistance_Float
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
|
|
auto cm = vr::VRSettings()->GetBool(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_CenterMarkerOn_Bool,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_CenterMarkerOn_Bool
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
setCenterMarker( cm );
|
|
auto ps
|
|
= vr::VRSettings()->GetBool( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_PlaySpaceOn_Bool,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_PlaySpaceOn_Bool
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
setPlaySpaceMarker( ps );
|
|
}
|
|
|
|
float ChaperoneTabController::boundsVisibility() const
|
|
{
|
|
return m_visibility;
|
|
}
|
|
|
|
void ChaperoneTabController::setBoundsVisibility( float value, bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( m_visibility - m_visibility ) ) > 0.005 )
|
|
{
|
|
if ( value <= 0.3f )
|
|
{
|
|
m_visibility = 0.3f;
|
|
}
|
|
else
|
|
{
|
|
m_visibility = value;
|
|
}
|
|
vr::VRSettings()->SetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaA_Int32,
|
|
static_cast<int32_t>( 255 * m_visibility ) );
|
|
|
|
if ( notify )
|
|
{
|
|
emit boundsVisibilityChanged( m_visibility );
|
|
}
|
|
}
|
|
}
|
|
|
|
float ChaperoneTabController::fadeDistance() const
|
|
{
|
|
return m_fadeDistance;
|
|
}
|
|
|
|
void ChaperoneTabController::setFadeDistance( float value, bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( m_fadeDistance - value ) ) > 0.005 )
|
|
{
|
|
m_fadeDistance = value;
|
|
vr::VRSettings()->SetFloat(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_FadeDistance_Float,
|
|
m_fadeDistance );
|
|
if ( notify )
|
|
{
|
|
emit fadeDistanceChanged( m_fadeDistance );
|
|
}
|
|
}
|
|
}
|
|
|
|
float ChaperoneTabController::height() const
|
|
{
|
|
return m_height;
|
|
}
|
|
|
|
void ChaperoneTabController::setHeight( float value, bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( m_height - value ) ) > 0.005 )
|
|
{
|
|
m_height = value;
|
|
parent->m_moveCenterTabController.setBoundsBasisHeight( m_height );
|
|
if ( notify )
|
|
{
|
|
emit heightChanged( m_height );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::updateHeight( float value, bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( m_height - value ) ) > 0.005 )
|
|
{
|
|
m_height = value;
|
|
if ( notify )
|
|
{
|
|
emit heightChanged( m_height );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ChaperoneTabController::centerMarker() const
|
|
{
|
|
return m_centerMarker;
|
|
}
|
|
|
|
void ChaperoneTabController::setCenterMarker( bool value, bool notify )
|
|
{
|
|
if ( m_centerMarker != value )
|
|
{
|
|
m_centerMarker = value;
|
|
vr::VRSettings()->SetBool(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_CenterMarkerOn_Bool,
|
|
m_centerMarker );
|
|
if ( notify )
|
|
{
|
|
emit centerMarkerChanged( m_centerMarker );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ChaperoneTabController::playSpaceMarker() const
|
|
{
|
|
return m_playSpaceMarker;
|
|
}
|
|
|
|
void ChaperoneTabController::setPlaySpaceMarker( bool value, bool notify )
|
|
{
|
|
if ( m_playSpaceMarker != value )
|
|
{
|
|
m_playSpaceMarker = value;
|
|
vr::VRSettings()->SetBool( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_PlaySpaceOn_Bool,
|
|
m_playSpaceMarker );
|
|
if ( notify )
|
|
{
|
|
emit playSpaceMarkerChanged( m_playSpaceMarker );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ChaperoneTabController::forceBounds() const
|
|
{
|
|
return m_forceBounds;
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneSwitchToBeginnerEnabled() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneSwitchToBeginnerEnabled );
|
|
}
|
|
|
|
float ChaperoneTabController::chaperoneSwitchToBeginnerDistance() const
|
|
{
|
|
return static_cast<float>( settings::getSetting(
|
|
settings::DoubleSetting::CHAPERONE_switchToBeginnerDistance ) );
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneHapticFeedbackEnabled() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneHapticFeedbackEnabled );
|
|
}
|
|
|
|
float ChaperoneTabController::chaperoneHapticFeedbackDistance() const
|
|
{
|
|
return static_cast<float>( settings::getSetting(
|
|
settings::DoubleSetting::CHAPERONE_hapticFeedbackDistance ) );
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneAlarmSoundEnabled() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundEnabled );
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneAlarmSoundLooping() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundLooping );
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneAlarmSoundAdjustVolume() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundAdjustVolume );
|
|
}
|
|
|
|
bool ChaperoneTabController::disableChaperone() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_disableChaperone );
|
|
}
|
|
|
|
float ChaperoneTabController::chaperoneAlarmSoundDistance() const
|
|
{
|
|
return static_cast<float>( settings::getSetting(
|
|
settings::DoubleSetting::CHAPERONE_alarmSoundDistance ) );
|
|
}
|
|
|
|
bool ChaperoneTabController::isChaperoneShowDashboardEnabled() const
|
|
{
|
|
return settings::getSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneShowDashboardEnabled );
|
|
}
|
|
|
|
float ChaperoneTabController::chaperoneShowDashboardDistance() const
|
|
{
|
|
return static_cast<float>( settings::getSetting(
|
|
settings::DoubleSetting::CHAPERONE_showDashboardDistance ) );
|
|
}
|
|
|
|
Q_INVOKABLE unsigned ChaperoneTabController::getChaperoneProfileCount()
|
|
{
|
|
return static_cast<unsigned int>( chaperoneProfiles.size() );
|
|
}
|
|
|
|
Q_INVOKABLE QString
|
|
ChaperoneTabController::getChaperoneProfileName( unsigned index )
|
|
{
|
|
if ( index >= chaperoneProfiles.size() )
|
|
{
|
|
return QString();
|
|
}
|
|
else
|
|
{
|
|
return QString::fromStdString( chaperoneProfiles[index].profileName );
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setForceBounds( bool value, bool notify )
|
|
{
|
|
if ( m_forceBounds != value )
|
|
{
|
|
m_forceBounds = value;
|
|
vr::VRChaperone()->ForceBoundsVisible( m_forceBounds );
|
|
if ( notify )
|
|
{
|
|
emit forceBoundsChanged( m_forceBounds );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneSwitchToBeginnerEnabled( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneSwitchToBeginnerEnabled() != value )
|
|
{
|
|
if ( !value && m_chaperoneSwitchToBeginnerActive )
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
vr::VRSettings()->SetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
m_chaperoneSwitchToBeginnerLastStyle,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING )
|
|
<< "Could not set \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32 << "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
}
|
|
|
|
m_chaperoneSwitchToBeginnerActive = false;
|
|
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneSwitchToBeginnerEnabled,
|
|
value );
|
|
if ( notify )
|
|
{
|
|
emit chaperoneSwitchToBeginnerEnabledChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneSwitchToBeginnerDistance( float value,
|
|
bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( chaperoneSwitchToBeginnerDistance()
|
|
- value ) )
|
|
> 0.005 )
|
|
{
|
|
settings::setSetting(
|
|
settings::DoubleSetting::CHAPERONE_switchToBeginnerDistance,
|
|
static_cast<double>( value ) );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneSwitchToBeginnerDistanceChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneHapticFeedbackEnabled( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneHapticFeedbackEnabled() != value )
|
|
{
|
|
m_chaperoneHapticFeedbackActive = false;
|
|
if ( m_chaperoneHapticFeedbackThread.joinable() )
|
|
{
|
|
m_chaperoneHapticFeedbackThread.join();
|
|
}
|
|
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneHapticFeedbackEnabled,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneHapticFeedbackEnabledChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneHapticFeedbackDistance( float value,
|
|
bool notify )
|
|
{
|
|
if ( fabs(
|
|
static_cast<double>( chaperoneHapticFeedbackDistance() - value ) )
|
|
> 0.005 )
|
|
{
|
|
settings::setSetting(
|
|
settings::DoubleSetting::CHAPERONE_hapticFeedbackDistance,
|
|
static_cast<double>( value ) );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneHapticFeedbackDistanceChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneAlarmSoundEnabled( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneAlarmSoundEnabled() != value )
|
|
{
|
|
if ( !value && m_chaperoneAlarmSoundActive )
|
|
{
|
|
parent->cancelAlarm01Sound();
|
|
}
|
|
m_chaperoneAlarmSoundActive = false;
|
|
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundEnabled,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneAlarmSoundEnabledChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneAlarmSoundLooping( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneAlarmSoundLooping() != value )
|
|
{
|
|
if ( isChaperoneAlarmSoundEnabled() && m_chaperoneAlarmSoundActive )
|
|
{
|
|
if ( isChaperoneAlarmSoundLooping() )
|
|
{
|
|
parent->playAlarm01Sound( isChaperoneAlarmSoundLooping() );
|
|
}
|
|
else
|
|
{
|
|
parent->cancelAlarm01Sound();
|
|
}
|
|
}
|
|
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundLooping,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneAlarmSoundLoopingChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneAlarmSoundAdjustVolume( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneAlarmSoundAdjustVolume() != value )
|
|
{
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneAlarmSoundAdjustVolume,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneAlarmSoundAdjustVolumeChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneAlarmSoundDistance( float value,
|
|
bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( chaperoneAlarmSoundDistance() - value ) )
|
|
> 0.005 )
|
|
{
|
|
settings::setSetting(
|
|
settings::DoubleSetting::CHAPERONE_alarmSoundDistance,
|
|
static_cast<double>( value ) );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneAlarmSoundDistanceChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneShowDashboardEnabled( bool value,
|
|
bool notify )
|
|
{
|
|
if ( isChaperoneShowDashboardEnabled() != value )
|
|
{
|
|
m_chaperoneShowDashboardActive = false;
|
|
|
|
settings::setSetting(
|
|
settings::BoolSetting::CHAPERONE_chaperoneShowDashboardEnabled,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneShowDashboardEnabledChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setChaperoneShowDashboardDistance( float value,
|
|
bool notify )
|
|
{
|
|
if ( fabs( static_cast<double>( chaperoneShowDashboardDistance() - value ) )
|
|
> 0.005 )
|
|
{
|
|
settings::setSetting(
|
|
settings::DoubleSetting::CHAPERONE_showDashboardDistance,
|
|
static_cast<double>( value ) );
|
|
|
|
if ( notify )
|
|
{
|
|
emit chaperoneShowDashboardDistanceChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setDisableChaperone( bool value, bool notify )
|
|
{
|
|
if ( disableChaperone() != value )
|
|
{
|
|
if ( value )
|
|
{
|
|
settings::setSetting(
|
|
settings::DoubleSetting::CHAPERONE_fadeDistanceRemembered,
|
|
static_cast<double>( value ) );
|
|
|
|
setFadeDistance( 0.0f, true );
|
|
}
|
|
else
|
|
{
|
|
setFadeDistance( static_cast<float>( settings::getSetting(
|
|
settings::DoubleSetting::
|
|
CHAPERONE_fadeDistanceRemembered ) ),
|
|
true );
|
|
}
|
|
|
|
settings::setSetting( settings::BoolSetting::CHAPERONE_disableChaperone,
|
|
value );
|
|
|
|
if ( notify )
|
|
{
|
|
emit disableChaperoneChanged( value );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::flipOrientation( double degrees )
|
|
{
|
|
parent->m_moveCenterTabController.reset();
|
|
double rad = 0;
|
|
rad = degrees * ( M_PI / 180.0 );
|
|
|
|
parent->RotateUniverseCenter( vr::TrackingUniverseStanding,
|
|
static_cast<float>( rad ) );
|
|
parent->m_moveCenterTabController.zeroOffsets();
|
|
}
|
|
|
|
void ChaperoneTabController::reloadFromDisk()
|
|
{
|
|
parent->m_moveCenterTabController.reset();
|
|
vr::VRChaperoneSetup()->ReloadFromDisk( vr::EChaperoneConfigFile_Live );
|
|
vr::VRChaperoneSetup()->CommitWorkingCopy( vr::EChaperoneConfigFile_Live );
|
|
parent->m_moveCenterTabController.zeroOffsets();
|
|
}
|
|
|
|
void ChaperoneTabController::addChaperoneProfile(
|
|
QString name,
|
|
bool includeGeometry,
|
|
bool includeVisbility,
|
|
bool includeFadeDistance,
|
|
bool includeCenterMarker,
|
|
bool includePlaySpaceMarker,
|
|
bool includeFloorBounds,
|
|
bool includeBoundsColor,
|
|
bool includeChaperoneStyle,
|
|
bool includeForceBounds,
|
|
bool includesProximityWarningSettings )
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
ChaperoneProfile* profile = nullptr;
|
|
for ( auto& p : chaperoneProfiles )
|
|
{
|
|
if ( p.profileName.compare( name.toStdString() ) == 0 )
|
|
{
|
|
profile = &p;
|
|
break;
|
|
}
|
|
}
|
|
if ( !profile )
|
|
{
|
|
auto i = chaperoneProfiles.size();
|
|
chaperoneProfiles.emplace_back();
|
|
profile = &chaperoneProfiles[i];
|
|
}
|
|
profile->profileName = name.toStdString();
|
|
profile->includesChaperoneGeometry = includeGeometry;
|
|
if ( includeGeometry )
|
|
{
|
|
vr::VRChaperoneSetup()->HideWorkingSetPreview();
|
|
vr::VRChaperoneSetup()->RevertWorkingCopy();
|
|
uint32_t quadCount = 0;
|
|
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo( nullptr,
|
|
&quadCount );
|
|
profile->chaperoneGeometryQuadCount = quadCount;
|
|
for ( int i = 0; i < static_cast<int>( quadCount ); ++i )
|
|
{
|
|
profile->chaperoneGeometryQuads.emplace_back();
|
|
}
|
|
|
|
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(
|
|
profile->chaperoneGeometryQuads.data(), &quadCount );
|
|
vr::VRChaperoneSetup()->GetWorkingStandingZeroPoseToRawTrackingPose(
|
|
&profile->standingCenter );
|
|
vr::VRChaperoneSetup()->GetWorkingPlayAreaSize(
|
|
&profile->playSpaceAreaX, &profile->playSpaceAreaZ );
|
|
}
|
|
profile->includesVisibility = includeVisbility;
|
|
if ( includeVisbility )
|
|
{
|
|
profile->visibility = m_visibility;
|
|
}
|
|
profile->includesFadeDistance = includeFadeDistance;
|
|
if ( includeFadeDistance )
|
|
{
|
|
profile->fadeDistance = m_fadeDistance;
|
|
}
|
|
profile->includesCenterMarker = includeCenterMarker;
|
|
if ( includeCenterMarker )
|
|
{
|
|
profile->centerMarker = m_centerMarker;
|
|
}
|
|
profile->includesPlaySpaceMarker = includePlaySpaceMarker;
|
|
if ( includePlaySpaceMarker )
|
|
{
|
|
profile->playSpaceMarker = m_playSpaceMarker;
|
|
}
|
|
profile->includesFloorBoundsMarker = includeFloorBounds;
|
|
if ( includeFloorBounds )
|
|
{
|
|
profile->floorBoundsMarker = vr::VRSettings()->GetBool(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_GroundPerimeterOn_Bool,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_GroundPerimeterOn_Bool
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
}
|
|
profile->includesBoundsColor = includeBoundsColor;
|
|
if ( includeBoundsColor )
|
|
{
|
|
profile->boundsColor[0] = vr::VRSettings()->GetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaR_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_ColorGammaR_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
profile->boundsColor[1] = vr::VRSettings()->GetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaG_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_ColorGammaG_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
profile->boundsColor[2] = vr::VRSettings()->GetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaB_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_ColorGammaB_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
}
|
|
profile->includesChaperoneStyle = includeChaperoneStyle;
|
|
if ( includeChaperoneStyle )
|
|
{
|
|
profile->chaperoneStyle
|
|
= vr::VRSettings()->GetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not read \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
}
|
|
profile->includesForceBounds = includeForceBounds;
|
|
if ( includeForceBounds )
|
|
{
|
|
profile->forceBounds = m_forceBounds;
|
|
}
|
|
profile->includesProximityWarningSettings
|
|
= includesProximityWarningSettings;
|
|
if ( includesProximityWarningSettings )
|
|
{
|
|
profile->enableChaperoneSwitchToBeginner
|
|
= isChaperoneSwitchToBeginnerEnabled();
|
|
profile->chaperoneSwitchToBeginnerDistance
|
|
= chaperoneSwitchToBeginnerDistance();
|
|
profile->enableChaperoneHapticFeedback
|
|
= isChaperoneHapticFeedbackEnabled();
|
|
profile->chaperoneHapticFeedbackDistance
|
|
= chaperoneHapticFeedbackDistance();
|
|
profile->enableChaperoneAlarmSound = isChaperoneAlarmSoundEnabled();
|
|
profile->chaperoneAlarmSoundLooping = isChaperoneAlarmSoundLooping();
|
|
profile->chaperoneAlarmSoundAdjustVolume
|
|
= isChaperoneAlarmSoundAdjustVolume();
|
|
profile->chaperoneAlarmSoundDistance = chaperoneAlarmSoundDistance();
|
|
profile->enableChaperoneShowDashboard
|
|
= isChaperoneShowDashboardEnabled();
|
|
profile->chaperoneShowDashboardDistance
|
|
= chaperoneShowDashboardDistance();
|
|
}
|
|
saveChaperoneProfiles();
|
|
emit chaperoneProfilesUpdated();
|
|
}
|
|
|
|
void ChaperoneTabController::applyChaperoneProfile( unsigned index )
|
|
{
|
|
if ( index < chaperoneProfiles.size() )
|
|
{
|
|
auto& profile = chaperoneProfiles[index];
|
|
if ( profile.includesChaperoneGeometry )
|
|
{
|
|
parent->m_moveCenterTabController.reset();
|
|
vr::VRChaperoneSetup()->HideWorkingSetPreview();
|
|
vr::VRChaperoneSetup()->RevertWorkingCopy();
|
|
vr::VRChaperoneSetup()->SetWorkingCollisionBoundsInfo(
|
|
profile.chaperoneGeometryQuads.data(),
|
|
profile.chaperoneGeometryQuadCount );
|
|
vr::VRChaperoneSetup()->SetWorkingStandingZeroPoseToRawTrackingPose(
|
|
&profile.standingCenter );
|
|
vr::VRChaperoneSetup()->SetWorkingPlayAreaSize(
|
|
profile.playSpaceAreaX, profile.playSpaceAreaZ );
|
|
vr::VRChaperoneSetup()->CommitWorkingCopy(
|
|
vr::EChaperoneConfigFile_Live );
|
|
parent->m_moveCenterTabController.zeroOffsets();
|
|
}
|
|
if ( profile.includesVisibility )
|
|
{
|
|
setBoundsVisibility( profile.visibility );
|
|
}
|
|
if ( profile.includesFadeDistance )
|
|
{
|
|
setFadeDistance( profile.fadeDistance );
|
|
}
|
|
if ( profile.includesCenterMarker )
|
|
{
|
|
setCenterMarker( profile.centerMarker );
|
|
}
|
|
if ( profile.includesPlaySpaceMarker )
|
|
{
|
|
setPlaySpaceMarker( profile.playSpaceMarker );
|
|
}
|
|
if ( profile.includesFloorBoundsMarker )
|
|
{
|
|
vr::VRSettings()->SetBool(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_GroundPerimeterOn_Bool,
|
|
profile.floorBoundsMarker );
|
|
}
|
|
if ( profile.includesBoundsColor )
|
|
{
|
|
vr::VRSettings()->SetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaR_Int32,
|
|
profile.boundsColor[0] );
|
|
vr::VRSettings()->SetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaG_Int32,
|
|
profile.boundsColor[1] );
|
|
vr::VRSettings()->SetInt32(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaB_Int32,
|
|
profile.boundsColor[2] );
|
|
}
|
|
if ( profile.includesChaperoneStyle )
|
|
{
|
|
vr::VRSettings()->SetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
profile.chaperoneStyle );
|
|
}
|
|
if ( profile.includesForceBounds )
|
|
{
|
|
setForceBounds( profile.forceBounds );
|
|
}
|
|
if ( profile.includesProximityWarningSettings )
|
|
{
|
|
setChaperoneSwitchToBeginnerDistance(
|
|
profile.chaperoneSwitchToBeginnerDistance );
|
|
setChaperoneSwitchToBeginnerEnabled(
|
|
profile.enableChaperoneSwitchToBeginner );
|
|
setChaperoneHapticFeedbackDistance(
|
|
profile.chaperoneHapticFeedbackDistance );
|
|
setChaperoneHapticFeedbackEnabled(
|
|
profile.enableChaperoneHapticFeedback );
|
|
setChaperoneAlarmSoundLooping( profile.chaperoneAlarmSoundLooping );
|
|
setChaperoneAlarmSoundAdjustVolume(
|
|
profile.chaperoneAlarmSoundAdjustVolume );
|
|
setChaperoneAlarmSoundDistance(
|
|
profile.chaperoneAlarmSoundDistance );
|
|
setChaperoneAlarmSoundEnabled( profile.enableChaperoneAlarmSound );
|
|
setChaperoneShowDashboardDistance(
|
|
profile.chaperoneShowDashboardDistance );
|
|
setChaperoneShowDashboardEnabled(
|
|
profile.enableChaperoneShowDashboard );
|
|
}
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::deleteChaperoneProfile( unsigned index )
|
|
{
|
|
if ( index < chaperoneProfiles.size() )
|
|
{
|
|
auto pos = chaperoneProfiles.begin() + index;
|
|
chaperoneProfiles.erase( pos );
|
|
saveChaperoneProfiles();
|
|
emit chaperoneProfilesUpdated();
|
|
}
|
|
}
|
|
|
|
std::pair<bool, unsigned>
|
|
ChaperoneTabController::getChaperoneProfileIndexFromName( std::string name )
|
|
{
|
|
std::pair<bool, unsigned> result = { false, 0 };
|
|
unsigned profileIndex = 0;
|
|
for ( auto& p : chaperoneProfiles )
|
|
{
|
|
if ( name == p.profileName )
|
|
{
|
|
result.first = true;
|
|
result.second = profileIndex;
|
|
break;
|
|
}
|
|
profileIndex++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ChaperoneTabController::createNewAutosaveProfile()
|
|
{
|
|
// update settings to live chaperone
|
|
updateChaperoneSettings();
|
|
|
|
// lookup the index for old autosave and delete it
|
|
std::pair<bool, unsigned> previousAutosaveIndexLookup
|
|
= getChaperoneProfileIndexFromName( "«Autosaved Profile (previous)»" );
|
|
if ( previousAutosaveIndexLookup.first )
|
|
{
|
|
deleteChaperoneProfile( previousAutosaveIndexLookup.second );
|
|
}
|
|
else
|
|
{
|
|
LOG( INFO )
|
|
<< "[Chaperone Autosave] «Autosaved Profile (previous)» not found";
|
|
}
|
|
|
|
// lookup the index for current autosave and rename to old
|
|
std::pair<bool, unsigned> currentAutosaveIndexLookup
|
|
= getChaperoneProfileIndexFromName( "«Autosaved Profile»" );
|
|
if ( currentAutosaveIndexLookup.first )
|
|
{
|
|
chaperoneProfiles[currentAutosaveIndexLookup.second].profileName
|
|
= "«Autosaved Profile (previous)»";
|
|
saveChaperoneProfiles();
|
|
emit chaperoneProfilesUpdated();
|
|
}
|
|
else
|
|
{
|
|
LOG( INFO ) << "[Chaperone Autosave] «Autosaved Profile» not found";
|
|
}
|
|
|
|
// create a new autosave from current chaperone (all options set true)
|
|
addChaperoneProfile( "«Autosaved Profile»",
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true,
|
|
true );
|
|
}
|
|
|
|
void ChaperoneTabController::applyAutosavedProfile()
|
|
{
|
|
// lookup index of autosave
|
|
std::pair<bool, unsigned> autosaveIndexLookup
|
|
= getChaperoneProfileIndexFromName( "«Autosaved Profile»" );
|
|
|
|
// check if it exists
|
|
if ( autosaveIndexLookup.first )
|
|
{
|
|
// apply if it exists
|
|
applyChaperoneProfile( autosaveIndexLookup.second );
|
|
}
|
|
else
|
|
{
|
|
LOG( WARNING ) << "Failed to apply chaperone Autosaved Profile "
|
|
"(autosave doesn't exist)";
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::reset()
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
|
|
vr::VRSettings()->RemoveKeyInSection(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_ColorGammaA_Int32,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not remove \""
|
|
<< vr::k_pch_CollisionBounds_ColorGammaA_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
|
|
vr::VRSettings()->RemoveKeyInSection(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_FadeDistance_Float,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not remove \""
|
|
<< vr::k_pch_CollisionBounds_FadeDistance_Float
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
|
|
vr::VRSettings()->RemoveKeyInSection(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_CenterMarkerOn_Bool,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not remove \""
|
|
<< vr::k_pch_CollisionBounds_CenterMarkerOn_Bool
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
|
|
vr::VRSettings()->RemoveKeyInSection(
|
|
vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_PlaySpaceOn_Bool,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not remove \""
|
|
<< vr::k_pch_CollisionBounds_PlaySpaceOn_Bool
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
|
|
setForceBounds( false );
|
|
|
|
settingsUpdateCounter = 999; // Easiest way to get default values
|
|
}
|
|
|
|
void ChaperoneTabController::setRightHapticActionHandle(
|
|
vr::VRActionHandle_t handle )
|
|
{
|
|
m_rightActionHandle = handle;
|
|
}
|
|
void ChaperoneTabController::setLeftHapticActionHandle(
|
|
vr::VRActionHandle_t handle )
|
|
{
|
|
m_leftActionHandle = handle;
|
|
}
|
|
void ChaperoneTabController::setRightInputHandle(
|
|
vr::VRInputValueHandle_t handle )
|
|
{
|
|
m_rightInputHandle = handle;
|
|
}
|
|
void ChaperoneTabController::setLeftInputHandle(
|
|
vr::VRInputValueHandle_t handle )
|
|
{
|
|
m_leftInputHandle = handle;
|
|
}
|
|
|
|
void ChaperoneTabController::addLeftHapticClick( bool leftHapticClickPressed )
|
|
{
|
|
// detect new press
|
|
if ( leftHapticClickPressed && !m_leftHapticClickActivated )
|
|
{
|
|
// play activation haptic sequence
|
|
vr::VRInput()->TriggerHapticVibrationAction(
|
|
m_leftActionHandle, 0.0f, 0.08f, 300.0f, 0.7f, m_leftInputHandle );
|
|
m_leftHapticClickActivated = true;
|
|
return;
|
|
}
|
|
|
|
// detect new release
|
|
if ( !leftHapticClickPressed && m_leftHapticClickActivated )
|
|
{
|
|
// play deactivation haptic sequence
|
|
vr::VRInput()->TriggerHapticVibrationAction(
|
|
m_leftActionHandle, 0.0f, 0.08f, 120.0f, 0.7f, m_leftInputHandle );
|
|
|
|
m_leftHapticClickActivated = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::addRightHapticClick( bool rightHapticClickPressed )
|
|
{
|
|
// detect new press
|
|
if ( rightHapticClickPressed && !m_rightHapticClickActivated )
|
|
{
|
|
// play activation haptic sequence
|
|
vr::VRInput()->TriggerHapticVibrationAction( m_rightActionHandle,
|
|
0.0f,
|
|
0.08f,
|
|
300.0f,
|
|
0.7f,
|
|
m_rightInputHandle );
|
|
m_rightHapticClickActivated = true;
|
|
return;
|
|
}
|
|
|
|
// detect new release
|
|
if ( !rightHapticClickPressed && m_rightHapticClickActivated )
|
|
{
|
|
// play deactivation haptic sequence
|
|
vr::VRInput()->TriggerHapticVibrationAction( m_rightActionHandle,
|
|
0.0f,
|
|
0.08f,
|
|
120.0f,
|
|
0.7f,
|
|
m_rightInputHandle );
|
|
|
|
m_rightHapticClickActivated = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void ChaperoneTabController::setProxState( bool value )
|
|
{
|
|
if ( value )
|
|
{
|
|
m_HMDHasProx = true;
|
|
}
|
|
|
|
m_isProxActive = value;
|
|
}
|
|
|
|
void ChaperoneTabController::shutdown()
|
|
{
|
|
if ( isChaperoneSwitchToBeginnerEnabled()
|
|
&& m_chaperoneSwitchToBeginnerActive )
|
|
{
|
|
vr::EVRSettingsError vrSettingsError;
|
|
vr::VRSettings()->SetInt32( vr::k_pch_CollisionBounds_Section,
|
|
vr::k_pch_CollisionBounds_Style_Int32,
|
|
m_chaperoneSwitchToBeginnerLastStyle,
|
|
&vrSettingsError );
|
|
if ( vrSettingsError != vr::VRSettingsError_None )
|
|
{
|
|
LOG( WARNING ) << "Could not set \""
|
|
<< vr::k_pch_CollisionBounds_Style_Int32
|
|
<< "\" setting: "
|
|
<< vr::VRSettings()->GetSettingsErrorNameFromEnum(
|
|
vrSettingsError );
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace advsettings
|