SteamFrame/OpenVR-AdvancedSettings-frame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
734581f495e4cd736e8b7d8b33501f1f6c752f10
OpenVR-AdvancedSettings-frame/src/tabcontrollers/ChaperoneTabController.cpp
T

1058 lines
44 KiB
C++
Raw Blame History

#include "ChaperoneTabController.h"
#include <QQuickWindow>
#include "../overlaycontroller.h"
#include <math.h>
// application namespace
namespace advsettings {
void ChaperoneTabController::initStage1() {
m_height = getBoundsMaxY();
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
m_enableChaperoneSwitchToBeginner = settings->value("chaperoneSwitchToBeginnerEnabled", false).toBool();
m_chaperoneSwitchToBeginnerDistance = settings->value("chaperoneSwitchToBeginnerDistance", 0.5f).toFloat();
m_enableChaperoneHapticFeedback = settings->value("chaperoneHapticFeedbackEnabled", false).toBool();
m_chaperoneHapticFeedbackDistance = settings->value("chaperoneHapticFeedbackDistance", 0.5f).toFloat();
m_enableChaperoneAlarmSound = settings->value("chaperoneAlarmSoundEnabled", false).toBool();
m_chaperoneAlarmSoundLooping = settings->value("chaperoneAlarmSoundLooping", true).toBool();
m_chaperoneAlarmSoundAdjustVolume = settings->value("chaperoneAlarmSoundAdjustVolume", false).toBool();
m_chaperoneAlarmSoundDistance = settings->value("chaperoneAlarmSoundDistance", 0.5f).toFloat();
m_enableChaperoneShowDashboard = settings->value("chaperoneShowDashboardEnabled", false).toBool();
m_chaperoneShowDashboardDistance = settings->value("chaperoneShowDashboardDistance", 0.5f).toFloat();
m_enableChaperoneVelocityModifier = settings->value("chaperoneVelocityModifierEnabled", false).toBool();
m_chaperoneVelocityModifier = settings->value("chaperoneVelocityModifier", 0.3f).toFloat();
m_chaperoneVelocityModifierCurrent = 1.0f;
settings->endGroup();
reloadChaperoneProfiles();
eventLoopTick(nullptr, 0.0f, 0.0f, 0.0f);
}
void ChaperoneTabController::initStage2(OverlayController * parent, QQuickWindow * widget) {
this->parent = parent;
this->widget = widget;
}
ChaperoneTabController::~ChaperoneTabController() {
m_chaperoneHapticFeedbackActive = false;
if (m_chaperoneHapticFeedbackThread.joinable()) {
m_chaperoneHapticFeedbackThread.join();
}
}
void ChaperoneTabController::reloadChaperoneProfiles() {
chaperoneProfiles.clear();
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
auto profileCount = settings->beginReadArray("chaperoneProfiles");
for (int i = 0; i < profileCount; i++) {
settings->setArrayIndex(i);
chaperoneProfiles.emplace_back();
auto& entry = chaperoneProfiles[i];
entry.profileName = settings->value("profileName").toString().toStdString();
entry.includesChaperoneGeometry = settings->value("includesChaperoneGeometry", false).toBool();
if (entry.includesChaperoneGeometry) {
entry.chaperoneGeometryQuadCount = settings->value("chaperoneGeometryQuadCount", 0).toUInt();
entry.chaperoneGeometryQuads.reset(new vr::HmdQuad_t[entry.chaperoneGeometryQuadCount]);
unsigned qi = 0;
for (auto q : settings->value("chaperoneGeometryQuads").toList()) {
unsigned ci = 0;
for (auto c : q.toList()) {
unsigned cci = 0;
for (auto cc : c.toList()) {
entry.chaperoneGeometryQuads.get()[qi].vCorners[ci].v[cci] = cc.toFloat();
cci++;
}
ci++;
}
qi++;
}
unsigned i1 = 0;
for (auto l1 : settings->value("standingCenter").toList()) {
unsigned i2 = 0;
for (auto l2 : l1.toList()) {
entry.standingCenter.m[i1][i2] = l2.toFloat();
i2++;
}
i1++;
}
entry.playSpaceAreaX = settings->value("playSpaceAreaX", 0.0f).toFloat();
entry.playSpaceAreaZ = settings->value("playSpaceAreaZ", 0.0f).toFloat();
}
entry.includesVisibility = settings->value("includesVisibility", false).toBool();
if (entry.includesVisibility) {
entry.visibility = settings->value("visibility", 0.6).toFloat();
}
entry.includesFadeDistance = settings->value("includesFadeDistance", false).toBool();
if (entry.includesFadeDistance) {
entry.fadeDistance = settings->value("fadeDistance", 0.7).toFloat();
}
entry.includesCenterMarker = settings->value("includesCenterMarker", false).toBool();
if (entry.includesCenterMarker) {
entry.centerMarker = settings->value("centerMarker", false).toBool();
}
entry.includesPlaySpaceMarker = settings->value("includesPlaySpaceMarker", false).toBool();
if (entry.includesPlaySpaceMarker) {
entry.playSpaceMarker = settings->value("playSpaceMarker", false).toBool();
}
entry.includesFloorBoundsMarker = settings->value("includesFloorBoundsMarker", false).toBool();
if (entry.includesFloorBoundsMarker) {
entry.floorBoundsMarker = settings->value("floorBoundsMarker", false).toBool();
}
entry.includesBoundsColor = settings->value("includesBoundsColor", false).toBool();
if (entry.includesBoundsColor) {
auto color = settings->value("boundsColor").toList();
entry.boundsColor[0] = color[0].toInt();
entry.boundsColor[1] = color[1].toInt();
entry.boundsColor[2] = color[2].toInt();
}
entry.includesChaperoneStyle = settings->value("includesChaperoneStyle", false).toBool();
if (entry.includesChaperoneStyle) {
entry.chaperoneStyle = settings->value("chaperoneStyle", 0).toInt();
}
entry.includesForceBounds = settings->value("includesForceBounds", false).toBool();
if (entry.includesForceBounds) {
entry.forceBounds = settings->value("forceBounds", false).toBool();
}
entry.includesProximityWarningSettings = settings->value("includesProximityWarningSettings", false).toBool();
if (entry.includesProximityWarningSettings){
entry.enableChaperoneSwitchToBeginner = settings->value("chaperoneSwitchToBeginnerEnabled", false).toBool();
entry.chaperoneSwitchToBeginnerDistance = settings->value("chaperoneSwitchToBeginnerDistance", 0.5f).toFloat();
entry.enableChaperoneHapticFeedback = settings->value("chaperoneHapticFeedbackEnabled", false).toBool();
entry.chaperoneHapticFeedbackDistance = settings->value("chaperoneHapticFeedbackDistance", 0.5f).toFloat();
entry.enableChaperoneAlarmSound = settings->value("chaperoneAlarmSoundEnabled", false).toBool();
entry.chaperoneAlarmSoundLooping = settings->value("chaperoneAlarmSoundLooping", true).toBool();
entry.chaperoneAlarmSoundAdjustVolume = settings->value("chaperoneAlarmSoundAdjustVolume", false).toBool();
entry.chaperoneAlarmSoundDistance = settings->value("chaperoneAlarmSoundDistance", 0.5f).toFloat();
entry.enableChaperoneShowDashboard = settings->value("chaperoneShowDashboardEnabled", false).toBool();
entry.chaperoneShowDashboardDistance = settings->value("chaperoneShowDashboardDistance", 0.5f).toFloat();
entry.enableChaperoneVelocityModifier = settings->value("chaperoneVelocityModifierEnabled", false).toBool();
entry.chaperoneVelocityModifier = settings->value("chaperoneVelocityModifier", 0.3f).toFloat();
}
}
settings->endArray();
settings->endGroup();
}
void ChaperoneTabController::saveChaperoneProfiles() {
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->beginWriteArray("chaperoneProfiles");
unsigned i = 0;
for (auto& p : chaperoneProfiles) {
settings->setArrayIndex(i);
settings->setValue("profileName", QString::fromStdString(p.profileName));
settings->setValue("includesChaperoneGeometry", p.includesChaperoneGeometry);
if (p.includesChaperoneGeometry) {
settings->setValue("chaperoneGeometryQuadCount", p.chaperoneGeometryQuadCount);
QVariantList quadList;
for (unsigned qi = 0; qi < p.chaperoneGeometryQuadCount; qi++) {
QVariantList cornerList;
for (unsigned ci = 0; ci < 4; ci++) {
QVariantList coordVector;
for (unsigned cci = 0; cci < 3; cci++) {
coordVector.push_back(p.chaperoneGeometryQuads.get()[qi].vCorners[ci].v[cci]);
}
cornerList.push_back(coordVector);
}
quadList.push_back(cornerList);
}
settings->setValue("chaperoneGeometryQuads", quadList);
QVariantList l1;
for (unsigned i1 = 0; i1 < 3; i1++) {
QVariantList l2;
for (unsigned i2 = 0; i2 < 4; i2++) {
l2.push_back(p.standingCenter.m[i1][i2]);
}
l1.push_back(l2);
}
settings->setValue("standingCenter", l1);
settings->setValue("playSpaceAreaX", p.playSpaceAreaX);
settings->setValue("playSpaceAreaZ", p.playSpaceAreaZ);
}
settings->setValue("includesVisibility", p.includesVisibility);
if (p.includesVisibility) {
settings->setValue("visibility", p.visibility);
}
settings->setValue("includesFadeDistance", p.includesFadeDistance);
if (p.includesFadeDistance) {
settings->setValue("fadeDistance", p.fadeDistance);
}
settings->setValue("includesCenterMarker", p.includesCenterMarker);
if (p.includesCenterMarker) {
settings->setValue("centerMarker", p.centerMarker);
}
settings->setValue("includesPlaySpaceMarker", p.includesPlaySpaceMarker);
if (p.includesPlaySpaceMarker) {
settings->setValue("playSpaceMarker", p.playSpaceMarker);
}
settings->setValue("includesFloorBoundsMarker", p.includesFloorBoundsMarker);
if (p.includesFloorBoundsMarker) {
settings->setValue("floorBoundsMarker", p.floorBoundsMarker);
}
settings->setValue("includesBoundsColor", p.includesBoundsColor);
if (p.includesBoundsColor) {
QVariantList color;
color.push_back(p.boundsColor[0]);
color.push_back(p.boundsColor[1]);
color.push_back(p.boundsColor[2]);
settings->setValue("boundsColor", color);
}
settings->setValue("includesChaperoneStyle", p.includesChaperoneStyle);
if (p.includesChaperoneStyle) {
settings->setValue("chaperoneStyle", p.chaperoneStyle);
}
settings->setValue("includesForceBounds", p.includesForceBounds);
if (p.includesForceBounds) {
settings->setValue("forceBounds", p.forceBounds);
}
settings->setValue("includesProximityWarningSettings", p.includesProximityWarningSettings);
if (p.includesProximityWarningSettings) {
settings->setValue("chaperoneSwitchToBeginnerEnabled", p.enableChaperoneSwitchToBeginner);
settings->setValue("chaperoneSwitchToBeginnerDistance", p.chaperoneSwitchToBeginnerDistance);
settings->setValue("chaperoneHapticFeedbackEnabled", p.enableChaperoneHapticFeedback);
settings->setValue("chaperoneHapticFeedbackDistance", p.chaperoneHapticFeedbackDistance);
settings->setValue("chaperoneAlarmSoundEnabled", p.enableChaperoneAlarmSound);
settings->setValue("chaperoneAlarmSoundLooping", p.chaperoneAlarmSoundLooping);
settings->setValue("chaperoneAlarmSoundAdjustVolume", p.chaperoneAlarmSoundAdjustVolume);
settings->setValue("chaperoneAlarmSoundDistance", p.chaperoneAlarmSoundDistance);
settings->setValue("chaperoneShowDashboardEnabled", p.enableChaperoneShowDashboard);
settings->setValue("chaperoneShowDashboardDistance", p.chaperoneShowDashboardDistance);
settings->setValue("chaperoneVelocityModifierEnabled", p.enableChaperoneVelocityModifier);
settings->setValue("chaperoneVelocityModifier", p.chaperoneVelocityModifier);
}
i++;
}
settings->endArray();
settings->endGroup();
}
void ChaperoneTabController::handleChaperoneWarnings(float distance) {
vr::VRControllerState_t hmdState;
vr::VRSystem()->GetControllerState(vr::k_unTrackedDeviceIndex_Hmd, &hmdState, sizeof(vr::VRControllerState_t));
// Switch to Beginner Mode
if (m_enableChaperoneSwitchToBeginner) {
float activationDistance = m_chaperoneSwitchToBeginnerDistance * m_chaperoneVelocityModifierCurrent;
if (distance <= activationDistance && (hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor)) && !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 {
vr::VRSettings()->Sync(true);
m_chaperoneSwitchToBeginnerActive = true;
}
}
} else if ((distance > activationDistance || !(hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor))) && 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 {
vr::VRSettings()->Sync(true);
m_chaperoneSwitchToBeginnerActive = false;
}
}
}
// Haptic Feedback
if (m_enableChaperoneHapticFeedback) {
float activationDistance = m_chaperoneHapticFeedbackDistance * m_chaperoneVelocityModifierCurrent;
if (distance <= activationDistance && (hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor))) {
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) {
if (leftIndex != vr::k_unTrackedDeviceIndexInvalid) {
vr::VRSystem()->TriggerHapticPulse(leftIndex, 0, 2000);
}
if (rightIndex != vr::k_unTrackedDeviceIndexInvalid) {
vr::VRSystem()->TriggerHapticPulse(rightIndex, 0, 2000);
}
std::this_thread::sleep_for(std::chrono::milliseconds(5));
}
}, this);
}
} else if ((distance > activationDistance || !(hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor))) && m_chaperoneHapticFeedbackActive) {
m_chaperoneHapticFeedbackActive = false;
}
}
// Alarm Sound
if (m_enableChaperoneAlarmSound) {
float activationDistance = m_chaperoneAlarmSoundDistance * m_chaperoneVelocityModifierCurrent;
if (distance <= activationDistance && (hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor))) {
if (!m_chaperoneAlarmSoundActive) {
parent->playAlarm01Sound(m_chaperoneAlarmSoundLooping);
m_chaperoneAlarmSoundActive = true;
}
if (m_chaperoneAlarmSoundLooping && m_chaperoneAlarmSoundAdjustVolume) {
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 || !(hmdState.ulButtonPressed & vr::ButtonMaskFromId(vr::k_EButton_ProximitySensor))) && m_chaperoneAlarmSoundActive) {
parent->cancelAlarm01Sound();
m_chaperoneAlarmSoundActive = false;
}
}
// Show Dashboard
if (m_enableChaperoneShowDashboard) {
float activationDistance = m_chaperoneShowDashboardDistance * m_chaperoneVelocityModifierCurrent;
if (distance <= activationDistance && !m_chaperoneShowDashboardActive) {
if (!vr::VROverlay()->IsDashboardVisible()) {
vr::VROverlay()->ShowDashboard(OverlayController::applicationKey);
}
m_chaperoneShowDashboardActive = true;
} else if (distance > activationDistance && m_chaperoneShowDashboardActive) {
m_chaperoneShowDashboardActive = false;
}
}
}
void ChaperoneTabController::eventLoopTick(vr::TrackedDevicePose_t* devicePoses, float leftSpeed, float rightSpeed, float hmdSpeed) {
m_chaperoneVelocityModifierCurrent = 1.0f;
if (m_enableChaperoneVelocityModifier) {
float mod = m_chaperoneVelocityModifier * std::max({ leftSpeed, rightSpeed, hmdSpeed });
if (mod > 0.02) {
m_chaperoneVelocityModifierCurrent += mod;
}
}
//LOG(INFO) << "m_chaperoneVelocityModifierCurrent: " << m_chaperoneVelocityModifierCurrent;
float newFadeDistance = m_fadeDistance * m_chaperoneVelocityModifierCurrent;
if (m_fadeDistanceModified != newFadeDistance) {
m_fadeDistanceModified = newFadeDistance;
vr::VRSettings()->SetFloat(vr::k_pch_CollisionBounds_Section, vr::k_pch_CollisionBounds_FadeDistance_Float, m_fadeDistanceModified);
vr::VRSettings()->Sync();
}
if (devicePoses) {
std::lock_guard<std::recursive_mutex> lock(parent->chaperoneUtils().mutex());
auto minDistance = NAN;
auto& poseHmd = devicePoses[vr::k_unTrackedDeviceIndex_Hmd];
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 (!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 (!isnan(distanceLeft) && (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 (!isnan(distanceRight) && (isnan(minDistance) || distanceRight < minDistance)) {
minDistance = distanceRight;
}
}
}
if (!isnan(minDistance)) {
handleChaperoneWarnings(minDistance);
}
}
if (settingsUpdateCounter >= 50) {
vr::EVRSettingsError vrSettingsError;
float vis = 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 (m_chaperoneVelocityModifierCurrent == 1.0f) {
auto fd = vr::VRSettings()->GetFloat(vr::k_pch_CollisionBounds_Section, vr::k_pch_CollisionBounds_FadeDistance_Float, &vrSettingsError);
if (vrSettingsError != vr::VRSettingsError_None) {
LOG(WARNING) << "Could not read \"" << vr::k_pch_CollisionBounds_FadeDistance_Float << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
}
setFadeDistance(fd);
}
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);
updateHeight(getBoundsMaxY());
settingsUpdateCounter = 0;
} else {
settingsUpdateCounter++;
}
}
float ChaperoneTabController::boundsVisibility() const {
return m_visibility;
}
void ChaperoneTabController::setBoundsVisibility(float value, bool notify) {
if (m_visibility != value) {
m_visibility = value;
vr::VRSettings()->SetInt32(vr::k_pch_CollisionBounds_Section, vr::k_pch_CollisionBounds_ColorGammaA_Int32, 255 * m_visibility);
vr::VRSettings()->Sync();
if (notify) {
emit boundsVisibilityChanged(m_visibility);
}
}
}
float ChaperoneTabController::fadeDistance() const {
return m_fadeDistance;
}
void ChaperoneTabController::setFadeDistance(float value, bool notify) {
if (m_fadeDistance != value) {
m_fadeDistance = value;
vr::VRSettings()->SetFloat(vr::k_pch_CollisionBounds_Section, vr::k_pch_CollisionBounds_FadeDistance_Float, m_fadeDistance);
vr::VRSettings()->Sync();
if (notify) {
emit fadeDistanceChanged(m_fadeDistance);
}
}
}
float ChaperoneTabController::height() const {
return m_height;
}
void ChaperoneTabController::setHeight(float value, bool notify) {
if (m_height != value) {
m_height = value;
vr::VRChaperoneSetup()->RevertWorkingCopy();
unsigned collisionBoundsCount = 0;
vr::VRChaperoneSetup()->GetWorkingCollisionBoundsInfo(nullptr, &collisionBoundsCount);
if (collisionBoundsCount > 0) {
vr::HmdQuad_t* collisionBounds = new vr::HmdQuad_t[collisionBoundsCount];
vr::VRChaperoneSetup()->GetWorkingCollisionBoundsInfo(collisionBounds, &collisionBoundsCount);
for (unsigned b = 0; b < collisionBoundsCount; b++) {
collisionBounds[b].vCorners[0].v[1] = 0.0;
collisionBounds[b].vCorners[1].v[1] = value;
collisionBounds[b].vCorners[2].v[1] = value;
collisionBounds[b].vCorners[3].v[1] = 0.0;
}
vr::VRChaperoneSetup()->SetWorkingCollisionBoundsInfo(collisionBounds, collisionBoundsCount);
vr::VRChaperoneSetup()->CommitWorkingCopy(vr::EChaperoneConfigFile_Live);
delete collisionBounds;
}
if (notify) {
emit heightChanged(m_fadeDistance);
}
}
}
void ChaperoneTabController::updateHeight(float value, bool notify) {
if (m_height != value) {
m_height = value;
if (notify) {
emit heightChanged(m_fadeDistance);
}
}
}
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);
vr::VRSettings()->Sync();
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);
vr::VRSettings()->Sync();
if (notify) {
emit playSpaceMarkerChanged(m_playSpaceMarker);
}
}
}
bool ChaperoneTabController::forceBounds() const {
return m_forceBounds;
}
bool ChaperoneTabController::isChaperoneSwitchToBeginnerEnabled() const {
return m_enableChaperoneSwitchToBeginner;
}
float ChaperoneTabController::chaperoneSwitchToBeginnerDistance() const {
return m_chaperoneSwitchToBeginnerDistance;
}
bool ChaperoneTabController::isChaperoneHapticFeedbackEnabled() const {
return m_enableChaperoneHapticFeedback;
}
float ChaperoneTabController::chaperoneHapticFeedbackDistance() const {
return m_chaperoneHapticFeedbackDistance;
}
bool ChaperoneTabController::isChaperoneAlarmSoundEnabled() const {
return m_enableChaperoneAlarmSound;
}
bool ChaperoneTabController::isChaperoneAlarmSoundLooping() const {
return m_chaperoneAlarmSoundLooping;
}
bool ChaperoneTabController::isChaperoneAlarmSoundAdjustVolume() const {
return m_chaperoneAlarmSoundAdjustVolume;
}
float ChaperoneTabController::chaperoneAlarmSoundDistance() const {
return m_chaperoneAlarmSoundDistance;
}
bool ChaperoneTabController::isChaperoneShowDashboardEnabled() const {
return m_enableChaperoneShowDashboard;
}
float ChaperoneTabController::chaperoneShowDashboardDistance() const {
return m_chaperoneShowDashboardDistance;
}
bool ChaperoneTabController::isChaperoneVelocityModifierEnabled() const {
return m_enableChaperoneVelocityModifier;
}
float ChaperoneTabController::chaperoneVelocityModifier() const {
return m_chaperoneVelocityModifier;
}
Q_INVOKABLE unsigned ChaperoneTabController::getChaperoneProfileCount() {
return (unsigned)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 (m_enableChaperoneSwitchToBeginner != 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);
} else {
vr::VRSettings()->Sync(true);
}
}
m_enableChaperoneSwitchToBeginner = value;
m_chaperoneSwitchToBeginnerActive = false;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneSwitchToBeginnerEnabled", m_enableChaperoneSwitchToBeginner);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneSwitchToBeginnerEnabledChanged(m_enableChaperoneSwitchToBeginner);
}
}
}
void ChaperoneTabController::setChaperoneSwitchToBeginnerDistance(float value, bool notify) {
if (m_chaperoneSwitchToBeginnerDistance != value) {
m_chaperoneSwitchToBeginnerDistance = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneSwitchToBeginnerDistance", m_chaperoneSwitchToBeginnerDistance);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneSwitchToBeginnerDistanceChanged(m_chaperoneSwitchToBeginnerDistance);
}
}
}
void ChaperoneTabController::setChaperoneHapticFeedbackEnabled(bool value, bool notify) {
if (m_enableChaperoneHapticFeedback != value) {
m_chaperoneHapticFeedbackActive = false;
if (m_chaperoneHapticFeedbackThread.joinable()) {
m_chaperoneHapticFeedbackThread.join();
}
m_enableChaperoneHapticFeedback = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneHapticFeedbackEnabled", m_enableChaperoneHapticFeedback);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneHapticFeedbackEnabledChanged(m_enableChaperoneHapticFeedback);
}
}
}
void ChaperoneTabController::setChaperoneHapticFeedbackDistance(float value, bool notify) {
if (m_chaperoneHapticFeedbackDistance != value) {
m_chaperoneHapticFeedbackDistance = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneHapticFeedbackDistance", m_chaperoneHapticFeedbackDistance);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneHapticFeedbackDistanceChanged(m_chaperoneHapticFeedbackDistance);
}
}
}
void ChaperoneTabController::setChaperoneAlarmSoundEnabled(bool value, bool notify) {
if (m_enableChaperoneAlarmSound != value) {
if (!value && m_chaperoneAlarmSoundActive) {
parent->cancelAlarm01Sound();
}
m_enableChaperoneAlarmSound = value;
m_chaperoneAlarmSoundActive = false;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneAlarmSoundEnabled", m_enableChaperoneAlarmSound);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneAlarmSoundEnabledChanged(m_enableChaperoneAlarmSound);
}
}
}
void ChaperoneTabController::setChaperoneAlarmSoundLooping(bool value, bool notify) {
if (m_chaperoneAlarmSoundLooping != value) {
m_chaperoneAlarmSoundLooping = value;
if (m_enableChaperoneAlarmSound && m_chaperoneAlarmSoundActive) {
if (m_chaperoneAlarmSoundLooping) {
parent->playAlarm01Sound(m_chaperoneAlarmSoundLooping);
} else {
parent->cancelAlarm01Sound();
}
}
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneAlarmSoundLooping", m_chaperoneAlarmSoundLooping);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneAlarmSoundLoopingChanged(m_chaperoneAlarmSoundLooping);
}
}
}
void ChaperoneTabController::setChaperoneAlarmSoundAdjustVolume(bool value, bool notify) {
if (m_chaperoneAlarmSoundAdjustVolume != value) {
m_chaperoneAlarmSoundAdjustVolume = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneAlarmSoundAdjustVolume", m_chaperoneAlarmSoundAdjustVolume);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneAlarmSoundAdjustVolumeChanged(m_chaperoneAlarmSoundAdjustVolume);
}
}
}
void ChaperoneTabController::setChaperoneAlarmSoundDistance(float value, bool notify) {
if (m_chaperoneAlarmSoundDistance != value) {
m_chaperoneAlarmSoundDistance = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneAlarmSoundDistance", m_chaperoneAlarmSoundDistance);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneAlarmSoundDistanceChanged(m_chaperoneAlarmSoundDistance);
}
}
}
void ChaperoneTabController::setChaperoneShowDashboardEnabled(bool value, bool notify) {
if (m_enableChaperoneShowDashboard != value) {
m_enableChaperoneShowDashboard = value;
m_chaperoneShowDashboardActive = false;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneShowDashboardEnabled", m_enableChaperoneShowDashboard);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneShowDashboardEnabledChanged(m_enableChaperoneShowDashboard);
}
}
}
void ChaperoneTabController::setChaperoneShowDashboardDistance(float value, bool notify) {
if (m_chaperoneShowDashboardDistance != value) {
m_chaperoneShowDashboardDistance = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneShowDashboardDistance", m_chaperoneShowDashboardDistance);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneShowDashboardDistanceChanged(m_chaperoneShowDashboardDistance);
}
}
}
void ChaperoneTabController::setChaperoneVelocityModifierEnabled(bool value, bool notify) {
if (m_enableChaperoneVelocityModifier != value) {
m_enableChaperoneVelocityModifier = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneVelocityModifierEnabled", m_enableChaperoneVelocityModifier);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneVelocityModifierEnabledChanged(m_enableChaperoneVelocityModifier);
}
}
}
void ChaperoneTabController::setChaperoneVelocityModifier(float value, bool notify) {
if (m_chaperoneVelocityModifier != value) {
m_chaperoneVelocityModifier = value;
auto settings = OverlayController::appSettings();
settings->beginGroup("chaperoneSettings");
settings->setValue("chaperoneVelocityModifier", m_chaperoneVelocityModifier);
settings->endGroup();
settings->sync();
if (notify) {
emit chaperoneVelocityModifierChanged(m_chaperoneVelocityModifier);
}
}
}
void ChaperoneTabController::flipOrientation() {
parent->RotateUniverseCenter(vr::TrackingUniverseStanding, (float)M_PI);
}
void ChaperoneTabController::reloadFromDisk() {
vr::VRChaperoneSetup()->ReloadFromDisk(vr::EChaperoneConfigFile_Live);
vr::VRChaperoneSetup()->CommitWorkingCopy(vr::EChaperoneConfigFile_Live);
}
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()->RevertWorkingCopy();
uint32_t quadCount = 0;
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(nullptr, &quadCount);
profile->chaperoneGeometryQuadCount = quadCount;
profile->chaperoneGeometryQuads.reset(new vr::HmdQuad_t[quadCount]);
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(profile->chaperoneGeometryQuads.get(), &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 = m_enableChaperoneSwitchToBeginner;
profile->chaperoneSwitchToBeginnerDistance = m_chaperoneSwitchToBeginnerDistance;
profile->enableChaperoneHapticFeedback = m_enableChaperoneHapticFeedback;
profile->chaperoneHapticFeedbackDistance = m_chaperoneHapticFeedbackDistance;
profile->enableChaperoneAlarmSound = m_enableChaperoneAlarmSound;
profile->chaperoneAlarmSoundLooping = m_chaperoneAlarmSoundLooping;
profile->chaperoneAlarmSoundAdjustVolume = m_chaperoneAlarmSoundAdjustVolume;
profile->chaperoneAlarmSoundDistance = m_chaperoneAlarmSoundDistance;
profile->enableChaperoneShowDashboard = m_enableChaperoneShowDashboard;
profile->chaperoneShowDashboardDistance = m_chaperoneShowDashboardDistance;
profile->enableChaperoneVelocityModifier = m_enableChaperoneVelocityModifier;
profile->chaperoneVelocityModifier = m_chaperoneVelocityModifier;
}
saveChaperoneProfiles();
OverlayController::appSettings()->sync();
emit chaperoneProfilesUpdated();
}
void ChaperoneTabController::applyChaperoneProfile(unsigned index) {
if (index < chaperoneProfiles.size()) {
auto& profile = chaperoneProfiles[index];
if (profile.includesChaperoneGeometry) {
vr::VRChaperoneSetup()->RevertWorkingCopy();
vr::VRChaperoneSetup()->SetWorkingCollisionBoundsInfo(profile.chaperoneGeometryQuads.get(), profile.chaperoneGeometryQuadCount);
vr::VRChaperoneSetup()->SetWorkingStandingZeroPoseToRawTrackingPose(&profile.standingCenter);
vr::VRChaperoneSetup()->SetWorkingPlayAreaSize(profile.playSpaceAreaX, profile.playSpaceAreaZ);
vr::VRChaperoneSetup()->CommitWorkingCopy(vr::EChaperoneConfigFile_Live);
}
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);
setChaperoneVelocityModifier(profile.chaperoneVelocityModifier);
setChaperoneVelocityModifierEnabled(profile.enableChaperoneVelocityModifier);
}
vr::VRSettings()->Sync(true);
updateHeight(getBoundsMaxY());
}
}
void ChaperoneTabController::deleteChaperoneProfile(unsigned index) {
if (index < chaperoneProfiles.size()) {
auto pos = chaperoneProfiles.begin() + index;
chaperoneProfiles.erase(pos);
saveChaperoneProfiles();
OverlayController::appSettings()->sync();
emit chaperoneProfilesUpdated();
}
}
float ChaperoneTabController::getBoundsMaxY() {
unsigned collisionBoundsCount = 0;
float result = FP_NAN;
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(nullptr, &collisionBoundsCount);
if (collisionBoundsCount > 0) {
vr::HmdQuad_t* collisionBounds = new vr::HmdQuad_t[collisionBoundsCount];
vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(collisionBounds, &collisionBoundsCount);
for (unsigned b = 0; b < collisionBoundsCount; b++) {
int ci;
if (collisionBounds[b].vCorners[1].v[1] >= collisionBounds[b].vCorners[2].v[1]) {
ci = 1;
} else {
ci = 2;
}
if (isnan(result) || result < collisionBounds[b].vCorners[ci].v[1]) {
result = collisionBounds[b].vCorners[ci].v[1];
}
}
delete collisionBounds;
}
return result;
}
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);
vr::VRSettings()->Sync();
settingsUpdateCounter = 999; // Easiest way to get default values
}
void ChaperoneTabController::shutdown() {
if (m_enableChaperoneSwitchToBeginner && 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 {
vr::VRSettings()->Sync(true);
}
}
}
} // namespace advconfig
Reference in New Issue View Git Blame Copy Permalink