ykeara
b883d2cffd
Update logging dependency from 9.84 to 9.89 This is the newest version that doesn't lead to compile errors. It has also reduced the amount of "-Wexpansion-to-defined" errors on clang-msvc by about 80 (from ~400 to 320). Update easylogging license file Originally came as LICENCE.txt (notice C instead of S in LICENSE), renamed to better fit into the git history. Move logging defines to QMAKE instead of logging.h Defines done outside of easylogging++.h does not work according to official documentation (https://github.com/zuhd-org/easyloggingpp/blob/master/README.md#configuration-macros) "NOTE: All the macros can be defined in one of the following ways: 1. Define macros using -D option of compiler, for example in case of g++ you will do g++ source.cpp ... -DELPP_SYSLOG -DELPP_THREAD_SAFE ... (recommended way) 2. Define macros inside "easylogging++.h" (defining macros in other files won't work)" Linking to this issue: https://github.com/zuhd-org/easyloggingpp/issues/590#issuecomment-346753951 We are using the developer recommended way of defining them by command line. What is assumed to be the intention of enabling debug logs before including easylogging++ never actually did anything, hence this define is dropped. Newer versions of easylogging++ uses the macro ELPP_DISABLE_DEBUG_LOGS to _disable_ debug logs. Leaving that macro undefined satisfies the original intent. Move easylogging++ include into necessary files logging.h previously had logic to enable debug logging even on release builds. This logic was moved to the QMAKE file, hence the logging.h file is no longer necessary. Update easylogging++ to 9.96.7, turn on /WX for clang-msvc Updating from easylogging++ 9.89 to 9.96.7 turns it from a header only library to one requiring a source file. It has been added to sources near the other third party includes in the QMAKE to signify that it isn't a first party file. Updating easylogging++ also means that clang-msvc can compile without any warnings, hence turning on warnings as errors for that compiler as well, to avoid any regressions. updated to current fixed formatting fixed ptt add bug/compilerwarnings/c++14 target cleaned up .pro file fixed casting back to c++ style added default profile and ptt profile view fixed c++ casts fixed logic error on getDevice functions
828 lines
29 KiB
C++
828 lines
29 KiB
C++
#include "PttController.h"
|
|
#include <QQuickWindow>
|
|
#include <QApplication>
|
|
#include "../overlaycontroller.h"
|
|
|
|
// application namespace
|
|
namespace advsettings
|
|
{
|
|
bool PttController::pttEnabled() const
|
|
{
|
|
return m_pttEnabled;
|
|
}
|
|
|
|
bool PttController::pttActive() const
|
|
{
|
|
return m_pttActive;
|
|
}
|
|
|
|
bool PttController::pttShowNotification() const
|
|
{
|
|
return m_pttShowNotification;
|
|
}
|
|
|
|
bool PttController::pttLeftControllerEnabled() const
|
|
{
|
|
return m_pttLeftControllerEnabled;
|
|
}
|
|
|
|
bool PttController::pttRightControllerEnabled() const
|
|
{
|
|
return m_pttRightControllerEnabled;
|
|
}
|
|
|
|
void PttController::setPttControllerConfig( unsigned controller,
|
|
QVariantList buttons,
|
|
unsigned triggerMode,
|
|
unsigned padMode,
|
|
unsigned padAreas )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( controller < 2 )
|
|
{
|
|
uint64_t buttonMask = 0;
|
|
for ( auto b : buttons )
|
|
{
|
|
buttonMask |= vr::ButtonMaskFromId( ( vr::EVRButtonId ) b.toInt() );
|
|
}
|
|
m_pttControllerConfigs[controller].digitalButtons = buttons;
|
|
m_pttControllerConfigs[controller].digitalButtonMask = buttonMask;
|
|
m_pttControllerConfigs[controller].triggerMode = triggerMode;
|
|
m_pttControllerConfigs[controller].touchpadMode = padMode;
|
|
m_pttControllerConfigs[controller].touchpadAreas = padAreas;
|
|
savePttConfig();
|
|
}
|
|
}
|
|
|
|
void PttController::reloadPttProfiles()
|
|
{
|
|
pttProfiles.clear();
|
|
auto settings = OverlayController::appSettings();
|
|
settings->beginGroup( getSettingsName() );
|
|
auto profileCount = settings->beginReadArray( "pttProfiles" );
|
|
for ( int i = 0; i < profileCount; i++ )
|
|
{
|
|
settings->setArrayIndex( i );
|
|
pttProfiles.emplace_back();
|
|
auto& entry = pttProfiles[i];
|
|
entry.profileName
|
|
= settings->value( "profileName" ).toString().toStdString();
|
|
entry.showNotification
|
|
= settings->value( "showNotification", true ).toBool();
|
|
entry.leftControllerEnabled
|
|
= settings->value( "leftControllerEnabled", false ).toBool();
|
|
entry.rightControllerEnabled
|
|
= settings->value( "rightControllerEnabled", false ).toBool();
|
|
entry.controllerConfigs[0].digitalButtons
|
|
= settings->value( "digitalButtons_0" ).toList();
|
|
uint64_t buttonMask = 0;
|
|
for ( auto b : entry.controllerConfigs[0].digitalButtons )
|
|
{
|
|
buttonMask |= vr::ButtonMaskFromId( ( vr::EVRButtonId ) b.toInt() );
|
|
}
|
|
entry.controllerConfigs[0].digitalButtonMask = buttonMask;
|
|
entry.controllerConfigs[0].triggerMode
|
|
= settings->value( "triggerMode_0", 0 ).toUInt();
|
|
entry.controllerConfigs[0].touchpadMode
|
|
= settings->value( "touchpadMode_0", 0 ).toUInt();
|
|
entry.controllerConfigs[0].touchpadAreas
|
|
= settings->value( "touchPadAreas_0", 0 ).toUInt();
|
|
entry.controllerConfigs[1].digitalButtons
|
|
= settings->value( "digitalButtons_1" ).toList();
|
|
buttonMask = 0;
|
|
for ( auto b : entry.controllerConfigs[1].digitalButtons )
|
|
{
|
|
buttonMask |= vr::ButtonMaskFromId( ( vr::EVRButtonId ) b.toInt() );
|
|
}
|
|
entry.controllerConfigs[1].digitalButtonMask = buttonMask;
|
|
entry.controllerConfigs[1].triggerMode
|
|
= settings->value( "triggerMode_1", 0 ).toUInt();
|
|
entry.controllerConfigs[1].touchpadMode
|
|
= settings->value( "touchpadMode_1", 0 ).toUInt();
|
|
entry.controllerConfigs[1].touchpadAreas
|
|
= settings->value( "touchPadAreas_1", 0 ).toUInt();
|
|
}
|
|
settings->endArray();
|
|
settings->endGroup();
|
|
}
|
|
|
|
void PttController::savePttProfiles()
|
|
{
|
|
auto settings = OverlayController::appSettings();
|
|
settings->beginGroup( getSettingsName() );
|
|
settings->beginWriteArray( "pttProfiles" );
|
|
unsigned i = 0;
|
|
for ( auto& p : pttProfiles )
|
|
{
|
|
settings->setArrayIndex( i );
|
|
settings->setValue( "profileName",
|
|
QString::fromStdString( p.profileName ) );
|
|
settings->setValue( "showNotification", p.showNotification );
|
|
settings->setValue( "leftControllerEnabled", p.leftControllerEnabled );
|
|
settings->setValue( "rightControllerEnabled",
|
|
p.rightControllerEnabled );
|
|
settings->setValue( "digitalButtons_0",
|
|
p.controllerConfigs[0].digitalButtons );
|
|
settings->setValue( "triggerMode_0",
|
|
p.controllerConfigs[0].triggerMode );
|
|
settings->setValue( "touchpadMode_0",
|
|
p.controllerConfigs[0].touchpadMode );
|
|
settings->setValue( "touchPadAreas_0",
|
|
p.controllerConfigs[0].touchpadAreas );
|
|
settings->setValue( "digitalButtons_1",
|
|
p.controllerConfigs[1].digitalButtons );
|
|
settings->setValue( "triggerMode_1",
|
|
p.controllerConfigs[1].triggerMode );
|
|
settings->setValue( "touchpadMode_1",
|
|
p.controllerConfigs[1].touchpadMode );
|
|
settings->setValue( "touchPadAreas_1",
|
|
p.controllerConfigs[1].touchpadAreas );
|
|
i++;
|
|
}
|
|
settings->endArray();
|
|
settings->endGroup();
|
|
}
|
|
|
|
void PttController::reloadPttConfig()
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
auto settings = OverlayController::appSettings();
|
|
settings->beginGroup( getSettingsName() );
|
|
setPttEnabled(
|
|
settings->value( "pttEnabled", false ).toBool(), true, false );
|
|
setPttLeftControllerEnabled(
|
|
settings->value( "pttLeftControllerEnabled", false ).toBool(),
|
|
true,
|
|
false );
|
|
setPttRightControllerEnabled(
|
|
settings->value( "pttRightControllerEnabled", false ).toBool(),
|
|
true,
|
|
false );
|
|
setPttShowNotification(
|
|
settings->value( "pttShowNotification", true ).toBool(), true, false );
|
|
m_pttControllerConfigs[0].digitalButtons
|
|
= settings->value( "pttDigitalButtons_0" ).toList();
|
|
uint64_t buttonMask = 0;
|
|
for ( auto b : m_pttControllerConfigs[0].digitalButtons )
|
|
{
|
|
buttonMask |= vr::ButtonMaskFromId( ( vr::EVRButtonId ) b.toInt() );
|
|
}
|
|
m_pttControllerConfigs[0].digitalButtonMask = buttonMask;
|
|
m_pttControllerConfigs[0].triggerMode
|
|
= settings->value( "pttTriggerMode_0", 0 ).toUInt();
|
|
m_pttControllerConfigs[0].touchpadMode
|
|
= settings->value( "pttTouchpadMode_0", 0 ).toUInt();
|
|
m_pttControllerConfigs[0].touchpadAreas
|
|
= settings->value( "pttTouchPadAreas_0", 0 ).toUInt();
|
|
m_pttControllerConfigs[1].digitalButtons
|
|
= settings->value( "pttDigitalButtons_1" ).toList();
|
|
buttonMask = 0;
|
|
for ( auto b : m_pttControllerConfigs[0].digitalButtons )
|
|
{
|
|
buttonMask |= vr::ButtonMaskFromId( ( vr::EVRButtonId ) b.toInt() );
|
|
}
|
|
m_pttControllerConfigs[1].digitalButtonMask = buttonMask;
|
|
m_pttControllerConfigs[1].triggerMode
|
|
= settings->value( "pttTriggerMode_1", 0 ).toUInt();
|
|
m_pttControllerConfigs[1].touchpadMode
|
|
= settings->value( "pttTouchpadMode_1", 0 ).toUInt();
|
|
m_pttControllerConfigs[1].touchpadAreas
|
|
= settings->value( "pttTouchPadAreas_1", 0 ).toUInt();
|
|
settings->endGroup();
|
|
}
|
|
|
|
void PttController::savePttConfig()
|
|
{
|
|
auto settings = OverlayController::appSettings();
|
|
settings->beginGroup( getSettingsName() );
|
|
settings->setValue( "pttEnabled", pttEnabled() );
|
|
settings->setValue( "pttLeftControllerEnabled",
|
|
pttLeftControllerEnabled() );
|
|
settings->setValue( "pttRightControllerEnabled",
|
|
pttRightControllerEnabled() );
|
|
settings->setValue( "pttShowNotification", pttShowNotification() );
|
|
settings->setValue( "pttDigitalButtons_0",
|
|
m_pttControllerConfigs[0].digitalButtons );
|
|
settings->setValue( "pttTriggerMode_0",
|
|
m_pttControllerConfigs[0].triggerMode );
|
|
settings->setValue( "pttTouchpadMode_0",
|
|
m_pttControllerConfigs[0].touchpadMode );
|
|
settings->setValue( "pttTouchPadAreas_0",
|
|
m_pttControllerConfigs[0].touchpadAreas );
|
|
settings->setValue( "pttDigitalButtons_1",
|
|
m_pttControllerConfigs[1].digitalButtons );
|
|
settings->setValue( "pttTriggerMode_1",
|
|
m_pttControllerConfigs[1].triggerMode );
|
|
settings->setValue( "pttTouchpadMode_1",
|
|
m_pttControllerConfigs[1].touchpadMode );
|
|
settings->setValue( "pttTouchPadAreas_1",
|
|
m_pttControllerConfigs[1].touchpadAreas );
|
|
settings->endGroup();
|
|
}
|
|
|
|
void PttController::checkPttStatus()
|
|
{
|
|
static auto handleControllerState
|
|
= []( const vr::VRControllerState_t& state,
|
|
PttControllerConfig* config ) -> bool {
|
|
if ( state.ulButtonPressed & config->digitalButtonMask )
|
|
{
|
|
return true;
|
|
}
|
|
if ( config->triggerMode )
|
|
{
|
|
if ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId( vr::k_EButton_SteamVR_Trigger )
|
|
|| state.ulButtonTouched
|
|
& vr::ButtonMaskFromId(
|
|
vr::k_EButton_SteamVR_Trigger ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
if ( config->touchpadMode )
|
|
{
|
|
if ( ( ( config->touchpadMode & 1 )
|
|
&& ( state.ulButtonTouched
|
|
& vr::ButtonMaskFromId(
|
|
vr::k_EButton_SteamVR_Touchpad ) ) )
|
|
|| ( ( config->touchpadMode & 2 )
|
|
&& ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId(
|
|
vr::k_EButton_SteamVR_Touchpad ) ) ) )
|
|
{
|
|
if ( config->touchpadAreas
|
|
== ( PAD_AREA_LEFT + PAD_AREA_TOP + PAD_AREA_RIGHT
|
|
+ PAD_AREA_BOTTOM ) )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
float x = state.rAxis[0].x;
|
|
float y = state.rAxis[0].y;
|
|
if ( std::abs( x ) >= 0.2 || std::abs( y ) >= 0.2 )
|
|
{ // deadzone in the middle
|
|
if ( x < 0 && std::abs( y ) < -x
|
|
&& ( config->touchpadAreas & PAD_AREA_LEFT ) )
|
|
{
|
|
return true;
|
|
}
|
|
else if ( y > 0 && std::abs( x ) < y
|
|
&& ( config->touchpadAreas & PAD_AREA_TOP ) )
|
|
{
|
|
return true;
|
|
}
|
|
else if ( x > 0 && std::abs( y ) < x
|
|
&& ( config->touchpadAreas
|
|
& PAD_AREA_RIGHT ) )
|
|
{
|
|
return true;
|
|
}
|
|
else if ( y < 0 && std::abs( x ) < -y
|
|
&& ( config->touchpadAreas
|
|
& PAD_AREA_BOTTOM ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
if ( m_pttEnabled )
|
|
{
|
|
bool newState = false;
|
|
if ( m_pttLeftControllerEnabled )
|
|
{
|
|
auto leftId
|
|
= vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_LeftHand );
|
|
if ( leftId != vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
vr::VRControllerState_t state;
|
|
if ( vr::VRSystem()->GetControllerState(
|
|
leftId, &state, sizeof( vr::VRControllerState_t ) ) )
|
|
{
|
|
// logControllerState(state, "Left ");
|
|
newState |= handleControllerState( state,
|
|
m_pttControllerConfigs );
|
|
}
|
|
}
|
|
}
|
|
if ( m_pttRightControllerEnabled )
|
|
{
|
|
auto rightId
|
|
= vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(
|
|
vr::TrackedControllerRole_RightHand );
|
|
if ( rightId != vr::k_unTrackedDeviceIndexInvalid )
|
|
{
|
|
vr::VRControllerState_t state;
|
|
if ( vr::VRSystem()->GetControllerState(
|
|
rightId, &state, sizeof( vr::VRControllerState_t ) ) )
|
|
{
|
|
// logControllerState(state, "Right ");
|
|
newState |= handleControllerState(
|
|
state, m_pttControllerConfigs + 1 );
|
|
}
|
|
}
|
|
}
|
|
if ( newState && !m_pttActive && pttChangeValid() )
|
|
{
|
|
startPtt();
|
|
}
|
|
else if ( !newState && m_pttActive && pttChangeValid() )
|
|
{
|
|
stopPtt();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PttController::startPtt()
|
|
{
|
|
m_pttActive = true;
|
|
onPttStart();
|
|
if ( m_pttShowNotification
|
|
&& getNotificationOverlayHandle() != vr::k_ulOverlayHandleInvalid )
|
|
{
|
|
vr::VROverlay()->ShowOverlay( getNotificationOverlayHandle() );
|
|
}
|
|
emit pttActiveChanged( m_pttActive );
|
|
}
|
|
|
|
void PttController::stopPtt()
|
|
{
|
|
m_pttActive = false;
|
|
onPttStop();
|
|
if ( m_pttShowNotification
|
|
&& getNotificationOverlayHandle() != vr::k_ulOverlayHandleInvalid )
|
|
{
|
|
vr::VROverlay()->HideOverlay( getNotificationOverlayHandle() );
|
|
}
|
|
emit pttActiveChanged( m_pttActive );
|
|
}
|
|
|
|
void PttController::addPttProfile( QString name )
|
|
{
|
|
PttProfile* profile = nullptr;
|
|
for ( auto& p : pttProfiles )
|
|
{
|
|
if ( p.profileName.compare( name.toStdString() ) == 0 )
|
|
{
|
|
profile = &p;
|
|
break;
|
|
}
|
|
}
|
|
if ( !profile )
|
|
{
|
|
auto i = pttProfiles.size();
|
|
pttProfiles.emplace_back();
|
|
profile = &pttProfiles[i];
|
|
}
|
|
profile->profileName = name.toStdString();
|
|
profile->showNotification = m_pttShowNotification;
|
|
profile->leftControllerEnabled = m_pttLeftControllerEnabled;
|
|
profile->rightControllerEnabled = m_pttRightControllerEnabled;
|
|
profile->controllerConfigs[0].digitalButtons
|
|
= m_pttControllerConfigs[0].digitalButtons;
|
|
profile->controllerConfigs[0].digitalButtonMask
|
|
= m_pttControllerConfigs[0].digitalButtonMask;
|
|
profile->controllerConfigs[0].triggerMode
|
|
= m_pttControllerConfigs[0].triggerMode;
|
|
profile->controllerConfigs[0].touchpadMode
|
|
= m_pttControllerConfigs[0].touchpadMode;
|
|
profile->controllerConfigs[0].touchpadAreas
|
|
= m_pttControllerConfigs[0].touchpadAreas;
|
|
profile->controllerConfigs[1].digitalButtons
|
|
= m_pttControllerConfigs[1].digitalButtons;
|
|
profile->controllerConfigs[1].digitalButtonMask
|
|
= m_pttControllerConfigs[1].digitalButtonMask;
|
|
profile->controllerConfigs[1].triggerMode
|
|
= m_pttControllerConfigs[1].triggerMode;
|
|
profile->controllerConfigs[1].touchpadMode
|
|
= m_pttControllerConfigs[1].touchpadMode;
|
|
profile->controllerConfigs[1].touchpadAreas
|
|
= m_pttControllerConfigs[1].touchpadAreas;
|
|
savePttProfiles();
|
|
OverlayController::appSettings()->sync();
|
|
emit pttProfilesUpdated();
|
|
emit pttProfileAdded();
|
|
}
|
|
|
|
void PttController::applyPttProfile( unsigned index )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( index < pttProfiles.size() )
|
|
{
|
|
auto& profile = pttProfiles[index];
|
|
setPttShowNotification( profile.showNotification );
|
|
setPttLeftControllerEnabled( profile.leftControllerEnabled );
|
|
setPttRightControllerEnabled( profile.rightControllerEnabled );
|
|
m_pttControllerConfigs[0].digitalButtons
|
|
= profile.controllerConfigs[0].digitalButtons;
|
|
m_pttControllerConfigs[0].digitalButtonMask
|
|
= profile.controllerConfigs[0].digitalButtonMask;
|
|
m_pttControllerConfigs[0].triggerMode
|
|
= profile.controllerConfigs[0].triggerMode;
|
|
m_pttControllerConfigs[0].touchpadMode
|
|
= profile.controllerConfigs[0].touchpadMode;
|
|
m_pttControllerConfigs[0].touchpadAreas
|
|
= profile.controllerConfigs[0].touchpadAreas;
|
|
m_pttControllerConfigs[1].digitalButtons
|
|
= profile.controllerConfigs[1].digitalButtons;
|
|
m_pttControllerConfigs[1].digitalButtonMask
|
|
= profile.controllerConfigs[1].digitalButtonMask;
|
|
m_pttControllerConfigs[1].triggerMode
|
|
= profile.controllerConfigs[1].triggerMode;
|
|
m_pttControllerConfigs[1].touchpadMode
|
|
= profile.controllerConfigs[1].touchpadMode;
|
|
m_pttControllerConfigs[1].touchpadAreas
|
|
= profile.controllerConfigs[1].touchpadAreas;
|
|
}
|
|
}
|
|
|
|
void PttController::deletePttProfile( unsigned index )
|
|
{
|
|
if ( index < pttProfiles.size() )
|
|
{
|
|
auto pos = pttProfiles.begin() + index;
|
|
pttProfiles.erase( pos );
|
|
savePttProfiles();
|
|
OverlayController::appSettings()->sync();
|
|
emit pttProfilesUpdated();
|
|
}
|
|
}
|
|
|
|
QVariantList PttController::pttDigitalButtons( unsigned controller )
|
|
{
|
|
if ( controller < 2 )
|
|
{
|
|
return m_pttControllerConfigs[controller].digitalButtons;
|
|
}
|
|
return QVariantList();
|
|
}
|
|
|
|
unsigned long PttController::pttDigitalButtonMask( unsigned controller )
|
|
{
|
|
if ( controller < 2 )
|
|
{
|
|
return m_pttControllerConfigs[controller].digitalButtonMask;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned PttController::pttTouchpadMode( unsigned controller )
|
|
{
|
|
if ( controller < 2 )
|
|
{
|
|
return m_pttControllerConfigs[controller].touchpadMode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned PttController::pttTriggerMode( unsigned controller )
|
|
{
|
|
if ( controller < 2 )
|
|
{
|
|
return m_pttControllerConfigs[controller].triggerMode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned PttController::pttTouchpadArea( unsigned controller )
|
|
{
|
|
if ( controller < 2 )
|
|
{
|
|
return m_pttControllerConfigs[controller].touchpadAreas;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned PttController::getPttProfileCount()
|
|
{
|
|
return ( unsigned ) pttProfiles.size();
|
|
}
|
|
|
|
QString PttController::getPttProfileName( unsigned index )
|
|
{
|
|
if ( index < pttProfiles.size() )
|
|
{
|
|
return QString::fromStdString( pttProfiles[index].profileName );
|
|
}
|
|
return "";
|
|
}
|
|
|
|
void PttController::setPttEnabled( bool value, bool notify, bool save )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( value != m_pttEnabled )
|
|
{
|
|
m_pttEnabled = value;
|
|
if ( value )
|
|
{
|
|
onPttEnabled();
|
|
}
|
|
else
|
|
{
|
|
onPttDisabled();
|
|
}
|
|
if ( notify )
|
|
{
|
|
emit pttEnabledChanged( value );
|
|
}
|
|
if ( save )
|
|
{
|
|
savePttConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PttController::setPttShowNotification( bool value, bool notify, bool save )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( value != m_pttShowNotification )
|
|
{
|
|
m_pttShowNotification = value;
|
|
if ( notify )
|
|
{
|
|
emit pttShowNotificationChanged( value );
|
|
}
|
|
if ( save )
|
|
{
|
|
savePttConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PttController::setPttLeftControllerEnabled( bool value,
|
|
bool notify,
|
|
bool save )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( value != m_pttLeftControllerEnabled )
|
|
{
|
|
m_pttLeftControllerEnabled = value;
|
|
if ( notify )
|
|
{
|
|
emit pttLeftControllerEnabledChanged( value );
|
|
}
|
|
if ( save )
|
|
{
|
|
savePttConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PttController::setPttRightControllerEnabled( bool value,
|
|
bool notify,
|
|
bool save )
|
|
{
|
|
std::lock_guard<std::recursive_mutex> lock( eventLoopMutex );
|
|
if ( value != m_pttRightControllerEnabled )
|
|
{
|
|
m_pttRightControllerEnabled = value;
|
|
if ( notify )
|
|
{
|
|
emit pttRightControllerEnabledChanged( value );
|
|
}
|
|
if ( save )
|
|
{
|
|
savePttConfig();
|
|
}
|
|
}
|
|
}
|
|
|
|
void logControllerState( const vr::VRControllerState_t& state,
|
|
const std::string& prefix )
|
|
{
|
|
if ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId( vr::k_EButton_ApplicationMenu ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_ApplicationMenu )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched
|
|
& vr::ButtonMaskFromId( vr::k_EButton_ApplicationMenu ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_ApplicationMenu )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Grip ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Grip )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Grip ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Grip )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Left ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Left )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Left ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Left )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_DPad_Up ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Up )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_DPad_Up ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Up )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Right ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Right )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Right ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Right )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Down ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Down )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched
|
|
& vr::ButtonMaskFromId( vr::k_EButton_DPad_Down ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_DPad_Down )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_A ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_A )
|
|
<< " pressed";
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_A ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_A )
|
|
<< " touched";
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Axis0 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis0 )
|
|
<< " pressed";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis0 )
|
|
<< " x: " << state.rAxis[0].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Axis0 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis0 )
|
|
<< " touched";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis0 )
|
|
<< " x: " << state.rAxis[0].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Axis1 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis1 )
|
|
<< " pressed";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis1 )
|
|
<< " x: " << state.rAxis[1].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Axis1 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis1 )
|
|
<< " touched";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis1 )
|
|
<< " x: " << state.rAxis[1].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Axis2 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis2 )
|
|
<< " pressed";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis2 )
|
|
<< " x: " << state.rAxis[2].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Axis2 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis2 )
|
|
<< " touched";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis2 )
|
|
<< " x: " << state.rAxis[2].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Axis3 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis3 )
|
|
<< " pressed";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis3 )
|
|
<< " x: " << state.rAxis[3].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Axis3 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis3 )
|
|
<< " touched";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis3 )
|
|
<< " x: " << state.rAxis[3].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonPressed & vr::ButtonMaskFromId( vr::k_EButton_Axis4 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis4 )
|
|
<< " pressed";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis4 )
|
|
<< " x: " << state.rAxis[4].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
if ( state.ulButtonTouched & vr::ButtonMaskFromId( vr::k_EButton_Axis4 ) )
|
|
{
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis4 )
|
|
<< " touched";
|
|
LOG( INFO ) << prefix
|
|
<< vr::VRSystem()->GetButtonIdNameFromEnum(
|
|
vr::k_EButton_Axis4 )
|
|
<< " x: " << state.rAxis[4].x
|
|
<< " y: " << state.rAxis[0].y;
|
|
}
|
|
}
|
|
|
|
} // namespace advsettings
|