Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-06 00:42:14 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

openvr: Rename ViveControllerManager to OpenVrInputPlugin.

Browse source
This commit is contained in:
Lubosz Sarnecki 2024-02-12 20:38:09 +01:00
parent ddae477059
commit e5d5659e76
4 changed files with 87 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
plugins/openvr/src/OpenVrDisplayPlugin.cpp
View file

@ -508,7 +508,7 @@ void OpenVrDisplayPlugin::internalDeactivate() {
_openVrDisplayActive = false; _openVrDisplayActive = false;
if (_system) { if (_system) {
// TODO: Invalidate poses. It's fine if someone else sets these shared values, but we're about to stop updating them, and // TODO: Invalidate poses. It's fine if someone else sets these shared values, but we're about to stop updating them, and
// we don't want ViveControllerManager to consider old values to be valid. // we don't want OpenVrInputPlugin to consider old values to be valid.
_container->makeRenderingContextCurrent(); _container->makeRenderingContextCurrent();
releaseOpenVrSystem(); releaseOpenVrSystem();
_system = nullptr; _system = nullptr;

162
plugins/openvr/src/ViveControllerManager.cpp → plugins/openvr/src/OpenVrInputPlugin.cpp
View file

@ -1,5 +1,5 @@
// //
// ViveControllerManager.cpp // OpenVrInputPlugin.cpp
// //
// Created by Sam Gondelman on 6/29/15. // Created by Sam Gondelman on 6/29/15.
// Copyright 2013 High Fidelity, Inc. // Copyright 2013 High Fidelity, Inc.
@ -9,7 +9,7 @@
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
// //
#include "ViveControllerManager.h" #include "OpenVrInputPlugin.h"
#include <algorithm> #include <algorithm>
#include <string> #include <string>
@ -105,7 +105,7 @@ enum ViveHandJointIndex {
}; };
#endif #endif
const char* ViveControllerManager::NAME { "OpenVR" }; const char* OpenVrInputPlugin::NAME { "OpenVR" };
const std::map<vr::ETrackingResult, QString> TRACKING_RESULT_TO_STRING = { const std::map<vr::ETrackingResult, QString> TRACKING_RESULT_TO_STRING = {
{vr::TrackingResult_Uninitialized, QString("vr::TrackingResult_Uninitialized")}, {vr::TrackingResult_Uninitialized, QString("vr::TrackingResult_Uninitialized")},
@ -204,46 +204,46 @@ public:
#endif #endif
static QString outOfRangeDataStrategyToString(ViveControllerManager::OutOfRangeDataStrategy strategy) { static QString outOfRangeDataStrategyToString(OpenVrInputPlugin::OutOfRangeDataStrategy strategy) {
switch (strategy) { switch (strategy) {
default: default:
case ViveControllerManager::OutOfRangeDataStrategy::None: case OpenVrInputPlugin::OutOfRangeDataStrategy::None:
return "None"; return "None";
case ViveControllerManager::OutOfRangeDataStrategy::Freeze: case OpenVrInputPlugin::OutOfRangeDataStrategy::Freeze:
return "Freeze"; return "Freeze";
case ViveControllerManager::OutOfRangeDataStrategy::Drop: case OpenVrInputPlugin::OutOfRangeDataStrategy::Drop:
return "Drop"; return "Drop";
case ViveControllerManager::OutOfRangeDataStrategy::DropAfterDelay: case OpenVrInputPlugin::OutOfRangeDataStrategy::DropAfterDelay:
return "DropAfterDelay"; return "DropAfterDelay";
} }
} }
static ViveControllerManager::OutOfRangeDataStrategy stringToOutOfRangeDataStrategy(const QString& string) { static OpenVrInputPlugin::OutOfRangeDataStrategy stringToOutOfRangeDataStrategy(const QString& string) {
if (string == "Drop") { if (string == "Drop") {
return ViveControllerManager::OutOfRangeDataStrategy::Drop; return OpenVrInputPlugin::OutOfRangeDataStrategy::Drop;
} else if (string == "Freeze") { } else if (string == "Freeze") {
return ViveControllerManager::OutOfRangeDataStrategy::Freeze; return OpenVrInputPlugin::OutOfRangeDataStrategy::Freeze;
} else if (string == "DropAfterDelay") { } else if (string == "DropAfterDelay") {
return ViveControllerManager::OutOfRangeDataStrategy::DropAfterDelay; return OpenVrInputPlugin::OutOfRangeDataStrategy::DropAfterDelay;
} else { } else {
return ViveControllerManager::OutOfRangeDataStrategy::None; return OpenVrInputPlugin::OutOfRangeDataStrategy::None;
} }
} }
bool ViveControllerManager::isDesktopMode() { bool OpenVrInputPlugin::isDesktopMode() {
if (_container) { if (_container) {
return !_container->getActiveDisplayPlugin()->isHmd(); return !_container->getActiveDisplayPlugin()->isHmd();
} }
return false; return false;
} }
void ViveControllerManager::calibrate() { void OpenVrInputPlugin::calibrate() {
if (isSupported()) { if (isSupported()) {
_inputDevice->calibrateNextFrame(); _inputDevice->calibrateNextFrame();
} }
} }
bool ViveControllerManager::uncalibrate() { bool OpenVrInputPlugin::uncalibrate() {
if (isSupported()) { if (isSupported()) {
_inputDevice->uncalibrate(); _inputDevice->uncalibrate();
return true; return true;
@ -251,11 +251,11 @@ bool ViveControllerManager::uncalibrate() {
return false; return false;
} }
bool ViveControllerManager::isSupported() const { bool OpenVrInputPlugin::isSupported() const {
return openVrSupported(); return openVrSupported();
} }
void ViveControllerManager::setConfigurationSettings(const QJsonObject configurationSettings) { void OpenVrInputPlugin::setConfigurationSettings(const QJsonObject configurationSettings) {
if (isSupported()) { if (isSupported()) {
if (configurationSettings.contains("desktopMode")) { if (configurationSettings.contains("desktopMode")) {
_desktopMode = configurationSettings["desktopMode"].toBool(); _desktopMode = configurationSettings["desktopMode"].toBool();
@ -274,7 +274,7 @@ void ViveControllerManager::setConfigurationSettings(const QJsonObject configura
} }
} }
QJsonObject ViveControllerManager::configurationSettings() { QJsonObject OpenVrInputPlugin::configurationSettings() {
if (isSupported()) { if (isSupported()) {
QJsonObject configurationSettings = _inputDevice->configurationSettings(); QJsonObject configurationSettings = _inputDevice->configurationSettings();
configurationSettings["desktopMode"] = _desktopMode; configurationSettings["desktopMode"] = _desktopMode;
@ -286,7 +286,7 @@ QJsonObject ViveControllerManager::configurationSettings() {
return QJsonObject(); return QJsonObject();
} }
QString ViveControllerManager::configurationLayout() { QString OpenVrInputPlugin::configurationLayout() {
return OPENVR_LAYOUT; return OPENVR_LAYOUT;
} }
@ -320,7 +320,7 @@ bool areBothHandControllersActive(vr::IVRSystem*& system) {
} }
#ifdef VIVE_PRO_EYE #ifdef VIVE_PRO_EYE
void ViveControllerManager::enableGestureDetection() { void OpenVrInputPlugin::enableGestureDetection() {
if (_viveCameraHandTracker) { if (_viveCameraHandTracker) {
return; return;
} }
@ -357,7 +357,7 @@ void ViveControllerManager::enableGestureDetection() {
} }
} }
void ViveControllerManager::disableGestureDetection() { void OpenVrInputPlugin::disableGestureDetection() {
if (!_viveCameraHandTracker) { if (!_viveCameraHandTracker) {
return; return;
} }
@ -366,7 +366,7 @@ void ViveControllerManager::disableGestureDetection() {
} }
#endif #endif
bool ViveControllerManager::activate() { bool OpenVrInputPlugin::activate() {
InputPlugin::activate(); InputPlugin::activate();
loadSettings(); loadSettings();
@ -413,7 +413,7 @@ bool ViveControllerManager::activate() {
return true; return true;
} }
void ViveControllerManager::deactivate() { void OpenVrInputPlugin::deactivate() {
InputPlugin::deactivate(); InputPlugin::deactivate();
disableOpenVrKeyboard(); disableOpenVrKeyboard();
@ -443,7 +443,7 @@ void ViveControllerManager::deactivate() {
saveSettings(); saveSettings();
} }
bool ViveControllerManager::isHeadControllerMounted() const { bool OpenVrInputPlugin::isHeadControllerMounted() const {
if (_inputDevice && _inputDevice->isHeadControllerMounted()) { if (_inputDevice && _inputDevice->isHeadControllerMounted()) {
return true; return true;
} }
@ -452,14 +452,14 @@ bool ViveControllerManager::isHeadControllerMounted() const {
} }
#ifdef VIVE_PRO_EYE #ifdef VIVE_PRO_EYE
void ViveControllerManager::invalidateEyeInputs() { void OpenVrInputPlugin::invalidateEyeInputs() {
_inputDevice->_poseStateMap[controller::LEFT_EYE].valid = false; _inputDevice->_poseStateMap[controller::LEFT_EYE].valid = false;
_inputDevice->_poseStateMap[controller::RIGHT_EYE].valid = false; _inputDevice->_poseStateMap[controller::RIGHT_EYE].valid = false;
_inputDevice->_axisStateMap[controller::EYEBLINK_L].valid = false; _inputDevice->_axisStateMap[controller::EYEBLINK_L].valid = false;
_inputDevice->_axisStateMap[controller::EYEBLINK_R].valid = false; _inputDevice->_axisStateMap[controller::EYEBLINK_R].valid = false;
} }
void ViveControllerManager::updateEyeTracker(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::updateEyeTracker(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
if (!isHeadControllerMounted()) { if (!isHeadControllerMounted()) {
invalidateEyeInputs(); invalidateEyeInputs();
return; return;
@ -546,7 +546,7 @@ void ViveControllerManager::updateEyeTracker(float deltaTime, const controller::
} }
} }
glm::vec3 ViveControllerManager::getRollingAverageHandPoint(int handIndex, int pointIndex) const { glm::vec3 OpenVrInputPlugin::getRollingAverageHandPoint(int handIndex, int pointIndex) const {
#if 0 #if 0
return _handPoints[0][handIndex][pointIndex]; return _handPoints[0][handIndex][pointIndex];
#else #else
@ -559,7 +559,7 @@ glm::vec3 ViveControllerManager::getRollingAverageHandPoint(int handIndex, int p
} }
controller::Pose ViveControllerManager::trackedHandDataToPose(int hand, const glm::vec3& palmFacing, controller::Pose OpenVrInputPlugin::trackedHandDataToPose(int hand, const glm::vec3& palmFacing,
int nearHandPositionIndex, int farHandPositionIndex) { int nearHandPositionIndex, int farHandPositionIndex) {
glm::vec3 nearPoint = getRollingAverageHandPoint(hand, nearHandPositionIndex); glm::vec3 nearPoint = getRollingAverageHandPoint(hand, nearHandPositionIndex);
@ -589,7 +589,7 @@ controller::Pose ViveControllerManager::trackedHandDataToPose(int hand, const gl
} }
void ViveControllerManager::trackFinger(int hand, int jointIndex1, int jointIndex2, int jointIndex3, int jointIndex4, void OpenVrInputPlugin::trackFinger(int hand, int jointIndex1, int jointIndex2, int jointIndex3, int jointIndex4,
controller::StandardPoseChannel joint1, controller::StandardPoseChannel joint2, controller::StandardPoseChannel joint1, controller::StandardPoseChannel joint2,
controller::StandardPoseChannel joint3, controller::StandardPoseChannel joint4) { controller::StandardPoseChannel joint3, controller::StandardPoseChannel joint4) {
@ -656,7 +656,7 @@ void ViveControllerManager::trackFinger(int hand, int jointIndex1, int jointInde
} }
void ViveControllerManager::updateCameraHandTracker(float deltaTime, void OpenVrInputPlugin::updateCameraHandTracker(float deltaTime,
const controller::InputCalibrationData& inputCalibrationData) { const controller::InputCalibrationData& inputCalibrationData) {
if (areBothHandControllersActive(_system)) { if (areBothHandControllersActive(_system)) {
@ -763,7 +763,7 @@ void ViveControllerManager::updateCameraHandTracker(float deltaTime,
#endif #endif
void ViveControllerManager::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::pluginUpdate(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
if (!_system) { if (!_system) {
return; return;
@ -809,7 +809,7 @@ void ViveControllerManager::pluginUpdate(float deltaTime, const controller::Inpu
} }
void ViveControllerManager::loadSettings() { void OpenVrInputPlugin::loadSettings() {
Settings settings; Settings settings;
QString nameString = getName(); QString nameString = getName();
settings.beginGroup(nameString); settings.beginGroup(nameString);
@ -831,7 +831,7 @@ void ViveControllerManager::loadSettings() {
settings.endGroup(); settings.endGroup();
} }
void ViveControllerManager::saveSettings() const { void OpenVrInputPlugin::saveSettings() const {
Settings settings; Settings settings;
QString nameString = getName(); QString nameString = getName();
settings.beginGroup(nameString); settings.beginGroup(nameString);
@ -849,7 +849,7 @@ void ViveControllerManager::saveSettings() const {
} }
ViveControllerManager::InputDevice::InputDevice(vr::IVRSystem*& system) : OpenVrInputPlugin::InputDevice::InputDevice(vr::IVRSystem*& system) :
controller::InputDevice("Vive"), controller::InputDevice("Vive"),
_system(system) { _system(system) {
@ -861,14 +861,14 @@ ViveControllerManager::InputDevice::InputDevice(vr::IVRSystem*& system) :
_configStringMap[Config::FeetHipsChestAndShoulders] = QString("FeetHipsChestAndShoulders"); _configStringMap[Config::FeetHipsChestAndShoulders] = QString("FeetHipsChestAndShoulders");
} }
void ViveControllerManager::InputDevice::setControllerStickHysteresisTime(float value) { void OpenVrInputPlugin::InputDevice::setControllerStickHysteresisTime(float value) {
qDebug() << "ViveControllerManager::InputDevice::setControllerStickHysteresisTime: " << value; qDebug() << "OpenVrInputPlugin::InputDevice::setControllerStickHysteresisTime: " << value;
_filteredLeftStick.setHysteresisPeriod(value); _filteredLeftStick.setHysteresisPeriod(value);
_filteredRightStick.setHysteresisPeriod(value); _filteredRightStick.setHysteresisPeriod(value);
} }
void ViveControllerManager::InputDevice::update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::InputDevice::update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
_poseStateMap.clear(); _poseStateMap.clear();
_buttonPressedMap.clear(); _buttonPressedMap.clear();
_validTrackedObjects.clear(); _validTrackedObjects.clear();
@ -889,7 +889,7 @@ void ViveControllerManager::InputDevice::update(float deltaTime, const controlle
return; return;
} }
PerformanceTimer perfTimer("ViveControllerManager::update"); PerformanceTimer perfTimer("OpenVrInputPlugin::update");
auto leftHandDeviceIndex = _system->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand); auto leftHandDeviceIndex = _system->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand);
auto rightHandDeviceIndex = _system->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand); auto rightHandDeviceIndex = _system->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
@ -928,7 +928,7 @@ void ViveControllerManager::InputDevice::update(float deltaTime, const controlle
_lastSimPoseData = _nextSimPoseData; _lastSimPoseData = _nextSimPoseData;
} }
void ViveControllerManager::InputDevice::calibrateFromHandController(const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::InputDevice::calibrateFromHandController(const controller::InputCalibrationData& inputCalibrationData) {
if (checkForCalibrationEvent()) { if (checkForCalibrationEvent()) {
quint64 currentTime = usecTimestampNow(); quint64 currentTime = usecTimestampNow();
if (!_timeTilCalibrationSet) { if (!_timeTilCalibrationSet) {
@ -946,7 +946,7 @@ void ViveControllerManager::InputDevice::calibrateFromHandController(const contr
} }
} }
void ViveControllerManager::InputDevice::calibrateFromUI(const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::InputDevice::calibrateFromUI(const controller::InputCalibrationData& inputCalibrationData) {
if (_calibrate) { if (_calibrate) {
uncalibrate(); uncalibrate();
calibrate(inputCalibrationData); calibrate(inputCalibrationData);
@ -958,7 +958,7 @@ void ViveControllerManager::InputDevice::calibrateFromUI(const controller::Input
static const float CM_TO_M = 0.01f; static const float CM_TO_M = 0.01f;
static const float M_TO_CM = 100.0f; static const float M_TO_CM = 100.0f;
void ViveControllerManager::InputDevice::configureCalibrationSettings(const QJsonObject configurationSettings) { void OpenVrInputPlugin::InputDevice::configureCalibrationSettings(const QJsonObject configurationSettings) {
Locker locker(_lock); Locker locker(_lock);
if (!configurationSettings.empty()) { if (!configurationSettings.empty()) {
auto iter = configurationSettings.begin(); auto iter = configurationSettings.begin();
@ -1009,12 +1009,12 @@ void ViveControllerManager::InputDevice::configureCalibrationSettings(const QJso
} }
} }
void ViveControllerManager::InputDevice::calibrateNextFrame() { void OpenVrInputPlugin::InputDevice::calibrateNextFrame() {
Locker locker(_lock); Locker locker(_lock);
_calibrate = true; _calibrate = true;
} }
QJsonObject ViveControllerManager::InputDevice::configurationSettings() { QJsonObject OpenVrInputPlugin::InputDevice::configurationSettings() {
Locker locker(_lock); Locker locker(_lock);
QJsonObject configurationSettings; QJsonObject configurationSettings;
configurationSettings["trackerConfiguration"] = configToString(_preferedConfig); configurationSettings["trackerConfiguration"] = configToString(_preferedConfig);
@ -1028,7 +1028,7 @@ QJsonObject ViveControllerManager::InputDevice::configurationSettings() {
return configurationSettings; return configurationSettings;
} }
void ViveControllerManager::InputDevice::emitCalibrationStatus() { void OpenVrInputPlugin::InputDevice::emitCalibrationStatus() {
auto inputConfiguration = DependencyManager::get<InputConfiguration>(); auto inputConfiguration = DependencyManager::get<InputConfiguration>();
QJsonObject status = QJsonObject(); QJsonObject status = QJsonObject();
status["calibrated"] = _calibrated; status["calibrated"] = _calibrated;
@ -1045,7 +1045,7 @@ static controller::Pose buildPose(const glm::mat4& mat, const glm::vec3& linearV
return controller::Pose(extractTranslation(mat), glmExtractRotation(mat), linearVelocity, angularVelocity); return controller::Pose(extractTranslation(mat), glmExtractRotation(mat), linearVelocity, angularVelocity);
} }
void ViveControllerManager::InputDevice::handleTrackedObject(uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::InputDevice::handleTrackedObject(uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData) {
uint32_t poseIndex = controller::TRACKED_OBJECT_00 + deviceIndex; uint32_t poseIndex = controller::TRACKED_OBJECT_00 + deviceIndex;
printDeviceTrackingResultChange(deviceIndex); printDeviceTrackingResultChange(deviceIndex);
if (_system->IsTrackedDeviceConnected(deviceIndex) && if (_system->IsTrackedDeviceConnected(deviceIndex) &&
@ -1118,7 +1118,7 @@ void ViveControllerManager::InputDevice::handleTrackedObject(uint32_t deviceInde
} }
} }
void ViveControllerManager::InputDevice::sendUserActivityData(QString activity) { void OpenVrInputPlugin::InputDevice::sendUserActivityData(QString activity) {
QJsonObject jsonData = { QJsonObject jsonData = {
{"num_pucks", (int)_validTrackedObjects.size()}, {"num_pucks", (int)_validTrackedObjects.size()},
{"configuration", configToString(_preferedConfig)}, {"configuration", configToString(_preferedConfig)},
@ -1129,7 +1129,7 @@ void ViveControllerManager::InputDevice::sendUserActivityData(QString activity)
UserActivityLogger::getInstance().logAction(activity, jsonData); UserActivityLogger::getInstance().logAction(activity, jsonData);
} }
void ViveControllerManager::InputDevice::calibrateOrUncalibrate(const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrateOrUncalibrate(const controller::InputCalibrationData& inputCalibration) {
if (!_calibrated) { if (!_calibrated) {
calibrate(inputCalibration); calibrate(inputCalibration);
if (_calibrated) { if (_calibrated) {
@ -1144,7 +1144,7 @@ void ViveControllerManager::InputDevice::calibrateOrUncalibrate(const controller
} }
} }
void ViveControllerManager::InputDevice::calibrate(const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrate(const controller::InputCalibrationData& inputCalibration) {
qDebug() << "Puck Calibration: Starting..."; qDebug() << "Puck Calibration: Starting...";
int puckCount = (int)_validTrackedObjects.size(); int puckCount = (int)_validTrackedObjects.size();
@ -1178,7 +1178,7 @@ void ViveControllerManager::InputDevice::calibrate(const controller::InputCalibr
} }
} }
bool ViveControllerManager::InputDevice::configureHands(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { bool OpenVrInputPlugin::InputDevice::configureHands(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
// Sort valid tracked objects in the default frame by the x dimension (left to right). // Sort valid tracked objects in the default frame by the x dimension (left to right).
// Because the sort is in the default frame we guarentee that poses are relative to the head facing. // Because the sort is in the default frame we guarentee that poses are relative to the head facing.
@ -1223,7 +1223,7 @@ bool ViveControllerManager::InputDevice::configureHands(const glm::mat4& default
return false; return false;
} }
bool ViveControllerManager::InputDevice::configureHead(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { bool OpenVrInputPlugin::InputDevice::configureHead(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition); std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition);
int puckCount = (int)_validTrackedObjects.size(); int puckCount = (int)_validTrackedObjects.size();
if (_headConfig == HeadConfig::Puck && puckCount >= MIN_HEAD) { if (_headConfig == HeadConfig::Puck && puckCount >= MIN_HEAD) {
@ -1237,7 +1237,7 @@ bool ViveControllerManager::InputDevice::configureHead(const glm::mat4& defaultT
return false; return false;
} }
bool ViveControllerManager::InputDevice::configureBody(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { bool OpenVrInputPlugin::InputDevice::configureBody(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition); std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition);
int puckCount = (int)_validTrackedObjects.size(); int puckCount = (int)_validTrackedObjects.size();
if (_config == Config::None) { if (_config == Config::None) {
@ -1274,7 +1274,7 @@ bool ViveControllerManager::InputDevice::configureBody(const glm::mat4& defaultT
return false; return false;
} }
void ViveControllerManager::InputDevice::uncalibrate() { void OpenVrInputPlugin::InputDevice::uncalibrate() {
_config = Config::None; _config = Config::None;
_pucksPostOffset.clear(); _pucksPostOffset.clear();
_pucksPreOffset.clear(); _pucksPreOffset.clear();
@ -1284,7 +1284,7 @@ void ViveControllerManager::InputDevice::uncalibrate() {
_overrideHands = false; _overrideHands = false;
} }
void ViveControllerManager::InputDevice::updateCalibratedLimbs(const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::updateCalibratedLimbs(const controller::InputCalibrationData& inputCalibration) {
_poseStateMap[controller::LEFT_FOOT] = addOffsetToPuckPose(inputCalibration, controller::LEFT_FOOT); _poseStateMap[controller::LEFT_FOOT] = addOffsetToPuckPose(inputCalibration, controller::LEFT_FOOT);
_poseStateMap[controller::RIGHT_FOOT] = addOffsetToPuckPose(inputCalibration, controller::RIGHT_FOOT); _poseStateMap[controller::RIGHT_FOOT] = addOffsetToPuckPose(inputCalibration, controller::RIGHT_FOOT);
_poseStateMap[controller::HIPS] = addOffsetToPuckPose(inputCalibration, controller::HIPS); _poseStateMap[controller::HIPS] = addOffsetToPuckPose(inputCalibration, controller::HIPS);
@ -1302,7 +1302,7 @@ void ViveControllerManager::InputDevice::updateCalibratedLimbs(const controller:
} }
} }
controller::Pose ViveControllerManager::InputDevice::addOffsetToPuckPose(const controller::InputCalibrationData& inputCalibration, int joint) const { controller::Pose OpenVrInputPlugin::InputDevice::addOffsetToPuckPose(const controller::InputCalibrationData& inputCalibration, int joint) const {
auto puck = _jointToPuckMap.find(joint); auto puck = _jointToPuckMap.find(joint);
if (puck != _jointToPuckMap.end()) { if (puck != _jointToPuckMap.end()) {
uint32_t puckIndex = puck->second; uint32_t puckIndex = puck->second;
@ -1336,7 +1336,7 @@ controller::Pose ViveControllerManager::InputDevice::addOffsetToPuckPose(const c
return controller::Pose(); return controller::Pose();
} }
void ViveControllerManager::InputDevice::handleHmd(uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData) { void OpenVrInputPlugin::InputDevice::handleHmd(uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData) {
if (_system->IsTrackedDeviceConnected(deviceIndex) && if (_system->IsTrackedDeviceConnected(deviceIndex) &&
_system->GetTrackedDeviceClass(deviceIndex) == vr::TrackedDeviceClass_HMD && _system->GetTrackedDeviceClass(deviceIndex) == vr::TrackedDeviceClass_HMD &&
_nextSimPoseData.vrPoses[deviceIndex].bPoseIsValid) { _nextSimPoseData.vrPoses[deviceIndex].bPoseIsValid) {
@ -1356,7 +1356,7 @@ void ViveControllerManager::InputDevice::handleHmd(uint32_t deviceIndex, const c
} }
} }
void ViveControllerManager::InputDevice::handleHandController(float deltaTime, uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData, bool isLeftHand) { void OpenVrInputPlugin::InputDevice::handleHandController(float deltaTime, uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData, bool isLeftHand) {
if (isDeviceIndexActive(_system, deviceIndex) && _nextSimPoseData.vrPoses[deviceIndex].bPoseIsValid) { if (isDeviceIndexActive(_system, deviceIndex) && _nextSimPoseData.vrPoses[deviceIndex].bPoseIsValid) {
@ -1398,7 +1398,7 @@ void ViveControllerManager::InputDevice::handleHandController(float deltaTime, u
// E_s = D * E_a => // E_s = D * E_a =>
// D = E_s * inverse(E_a) // D = E_s * inverse(E_a)
// //
glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHmd(const controller::InputCalibrationData& inputCalibration) { glm::mat4 OpenVrInputPlugin::InputDevice::calculateDefaultToReferenceForHmd(const controller::InputCalibrationData& inputCalibration) {
// the center-eye transform in avatar space. // the center-eye transform in avatar space.
glm::mat4 E_a = inputCalibration.defaultCenterEyeMat; glm::mat4 E_a = inputCalibration.defaultCenterEyeMat;
@ -1426,7 +1426,7 @@ glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHmd(
// E_s = D * E_a => // E_s = D * E_a =>
// D = E_s * inverse(E_a) // D = E_s * inverse(E_a)
// //
glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration) { glm::mat4 OpenVrInputPlugin::InputDevice::calculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration) {
// the center-eye transform in avatar space. // the center-eye transform in avatar space.
glm::mat4 E_a = inputCalibration.defaultCenterEyeMat; glm::mat4 E_a = inputCalibration.defaultCenterEyeMat;
@ -1450,7 +1450,7 @@ glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHead
return E_s * glm::inverse(E_a); return E_s * glm::inverse(E_a);
} }
void ViveControllerManager::InputDevice::partitionTouchpad(int sButton, int xAxis, int yAxis, int centerPseudoButton, int xPseudoButton, int yPseudoButton) { void OpenVrInputPlugin::InputDevice::partitionTouchpad(int sButton, int xAxis, int yAxis, int centerPseudoButton, int xPseudoButton, int yPseudoButton) {
// Populate the L/RS_CENTER/OUTER pseudo buttons, corresponding to a partition of the L/RS space based on the X/Y values. // Populate the L/RS_CENTER/OUTER pseudo buttons, corresponding to a partition of the L/RS space based on the X/Y values.
const float CENTER_DEADBAND = 0.6f; const float CENTER_DEADBAND = 0.6f;
const float DIAGONAL_DIVIDE_IN_RADIANS = PI / 4.0f; const float DIAGONAL_DIVIDE_IN_RADIANS = PI / 4.0f;
@ -1465,13 +1465,13 @@ void ViveControllerManager::InputDevice::partitionTouchpad(int sButton, int xAxi
} }
} }
void ViveControllerManager::InputDevice::focusOutEvent() { void OpenVrInputPlugin::InputDevice::focusOutEvent() {
_axisStateMap.clear(); _axisStateMap.clear();
_buttonPressedMap.clear(); _buttonPressedMap.clear();
}; };
// These functions do translation from the Steam IDs to the standard controller IDs // These functions do translation from the Steam IDs to the standard controller IDs
void ViveControllerManager::InputDevice::handleAxisEvent(float deltaTime, uint32_t axis, float x, float y, bool isLeftHand) { void OpenVrInputPlugin::InputDevice::handleAxisEvent(float deltaTime, uint32_t axis, float x, float y, bool isLeftHand) {
//FIX ME? It enters here every frame: probably we want to enter only if an event occurs //FIX ME? It enters here every frame: probably we want to enter only if an event occurs
axis += vr::k_EButton_Axis0; axis += vr::k_EButton_Axis0;
using namespace controller; using namespace controller;
@ -1501,7 +1501,7 @@ enum ViveButtonChannel {
RIGHT_APP_MENU RIGHT_APP_MENU
}; };
void ViveControllerManager::InputDevice::printDeviceTrackingResultChange(uint32_t deviceIndex) { void OpenVrInputPlugin::InputDevice::printDeviceTrackingResultChange(uint32_t deviceIndex) {
if (_nextSimPoseData.vrPoses[deviceIndex].eTrackingResult != _lastSimPoseData.vrPoses[deviceIndex].eTrackingResult) { if (_nextSimPoseData.vrPoses[deviceIndex].eTrackingResult != _lastSimPoseData.vrPoses[deviceIndex].eTrackingResult) {
qDebug() << "OpenVR: Device" << deviceIndex << "Tracking Result changed from" << qDebug() << "OpenVR: Device" << deviceIndex << "Tracking Result changed from" <<
deviceTrackingResultToString(_lastSimPoseData.vrPoses[deviceIndex].eTrackingResult) deviceTrackingResultToString(_lastSimPoseData.vrPoses[deviceIndex].eTrackingResult)
@ -1509,7 +1509,7 @@ void ViveControllerManager::InputDevice::printDeviceTrackingResultChange(uint32_
} }
} }
bool ViveControllerManager::InputDevice::checkForCalibrationEvent() { bool OpenVrInputPlugin::InputDevice::checkForCalibrationEvent() {
auto endOfMap = _buttonPressedMap.end(); auto endOfMap = _buttonPressedMap.end();
auto leftTrigger = _buttonPressedMap.find(controller::LT); auto leftTrigger = _buttonPressedMap.find(controller::LT);
auto rightTrigger = _buttonPressedMap.find(controller::RT); auto rightTrigger = _buttonPressedMap.find(controller::RT);
@ -1519,7 +1519,7 @@ bool ViveControllerManager::InputDevice::checkForCalibrationEvent() {
} }
// These functions do translation from the Steam IDs to the standard controller IDs // These functions do translation from the Steam IDs to the standard controller IDs
void ViveControllerManager::InputDevice::handleButtonEvent(float deltaTime, uint32_t button, bool pressed, bool touched, bool isLeftHand) { void OpenVrInputPlugin::InputDevice::handleButtonEvent(float deltaTime, uint32_t button, bool pressed, bool touched, bool isLeftHand) {
using namespace controller; using namespace controller;
@ -1546,7 +1546,7 @@ void ViveControllerManager::InputDevice::handleButtonEvent(float deltaTime, uint
} }
} }
void ViveControllerManager::InputDevice::handleHeadPoseEvent(const controller::InputCalibrationData& inputCalibrationData, const mat4& mat, void OpenVrInputPlugin::InputDevice::handleHeadPoseEvent(const controller::InputCalibrationData& inputCalibrationData, const mat4& mat,
const vec3& linearVelocity, const vec3& angularVelocity) { const vec3& linearVelocity, const vec3& angularVelocity) {
//perform a 180 flip to make the HMD face the +z instead of -z, beacuse the head faces +z //perform a 180 flip to make the HMD face the +z instead of -z, beacuse the head faces +z
glm::mat4 matYFlip = mat * Matrices::Y_180; glm::mat4 matYFlip = mat * Matrices::Y_180;
@ -1565,7 +1565,7 @@ void ViveControllerManager::InputDevice::handleHeadPoseEvent(const controller::I
_poseStateMap[controller::HEAD] = pose.postTransform(defaultHeadOffset).transform(sensorToAvatar); _poseStateMap[controller::HEAD] = pose.postTransform(defaultHeadOffset).transform(sensorToAvatar);
} }
void ViveControllerManager::InputDevice::handlePoseEvent(float deltaTime, const controller::InputCalibrationData& inputCalibrationData, void OpenVrInputPlugin::InputDevice::handlePoseEvent(float deltaTime, const controller::InputCalibrationData& inputCalibrationData,
const mat4& mat, const vec3& linearVelocity, const mat4& mat, const vec3& linearVelocity,
const vec3& angularVelocity, bool isLeftHand) { const vec3& angularVelocity, bool isLeftHand) {
auto pose = openVrControllerPoseToHandPose(isLeftHand, mat, linearVelocity, angularVelocity); auto pose = openVrControllerPoseToHandPose(isLeftHand, mat, linearVelocity, angularVelocity);
@ -1575,7 +1575,7 @@ void ViveControllerManager::InputDevice::handlePoseEvent(float deltaTime, const
_poseStateMap[isLeftHand ? controller::LEFT_HAND : controller::RIGHT_HAND] = pose.transform(controllerToAvatar); _poseStateMap[isLeftHand ? controller::LEFT_HAND : controller::RIGHT_HAND] = pose.transform(controllerToAvatar);
} }
bool ViveControllerManager::InputDevice::triggerHapticPulse(float strength, float duration, uint16_t index) { bool OpenVrInputPlugin::InputDevice::triggerHapticPulse(float strength, float duration, uint16_t index) {
if (index > 2) { if (index > 2) {
return false; return false;
} }
@ -1604,7 +1604,7 @@ bool ViveControllerManager::InputDevice::triggerHapticPulse(float strength, floa
return true; return true;
} }
void ViveControllerManager::InputDevice::hapticsHelper(float deltaTime, bool leftHand) { void OpenVrInputPlugin::InputDevice::hapticsHelper(float deltaTime, bool leftHand) {
auto handRole = leftHand ? vr::TrackedControllerRole_LeftHand : vr::TrackedControllerRole_RightHand; auto handRole = leftHand ? vr::TrackedControllerRole_LeftHand : vr::TrackedControllerRole_RightHand;
auto deviceIndex = _system->GetTrackedDeviceIndexForControllerRole(handRole); auto deviceIndex = _system->GetTrackedDeviceIndexForControllerRole(handRole);
@ -1630,7 +1630,7 @@ void ViveControllerManager::InputDevice::hapticsHelper(float deltaTime, bool lef
} }
} }
void ViveControllerManager::InputDevice::calibrateLeftHand(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) { void OpenVrInputPlugin::InputDevice::calibrateLeftHand(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) {
controller::Pose& handPose = handPair.second; controller::Pose& handPose = handPair.second;
glm::vec3 handPoseZAxis = handPose.getRotation() * glm::vec3(0.0f, 0.0f, 1.0f); glm::vec3 handPoseZAxis = handPose.getRotation() * glm::vec3(0.0f, 0.0f, 1.0f);
glm::vec3 referenceHandYAxis = transformVectorFast(defaultToReferenceMat * inputCalibration.defaultLeftHand, glm::vec3(0.0f, 1.0f, 0.0f)); glm::vec3 referenceHandYAxis = transformVectorFast(defaultToReferenceMat * inputCalibration.defaultLeftHand, glm::vec3(0.0f, 1.0f, 0.0f));
@ -1656,7 +1656,7 @@ void ViveControllerManager::InputDevice::calibrateLeftHand(const glm::mat4& defa
_pucksPostOffset[handPair.first] = postOffsetMat; _pucksPostOffset[handPair.first] = postOffsetMat;
} }
void ViveControllerManager::InputDevice::calibrateRightHand(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) { void OpenVrInputPlugin::InputDevice::calibrateRightHand(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) {
controller::Pose& handPose = handPair.second; controller::Pose& handPose = handPair.second;
glm::vec3 handPoseZAxis = handPose.getRotation() * glm::vec3(0.0f, 0.0f, 1.0f); glm::vec3 handPoseZAxis = handPose.getRotation() * glm::vec3(0.0f, 0.0f, 1.0f);
glm::vec3 referenceHandYAxis = transformVectorFast(defaultToReferenceMat * inputCalibration.defaultRightHand, glm::vec3(0.0f, 1.0f, 0.0f)); glm::vec3 referenceHandYAxis = transformVectorFast(defaultToReferenceMat * inputCalibration.defaultRightHand, glm::vec3(0.0f, 1.0f, 0.0f));
@ -1683,7 +1683,7 @@ void ViveControllerManager::InputDevice::calibrateRightHand(const glm::mat4& def
} }
void ViveControllerManager::InputDevice::calibrateFeet(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrateFeet(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
glm::vec3 headXAxis = getReferenceHeadXAxis(defaultToReferenceMat, inputCalibration.defaultHeadMat); glm::vec3 headXAxis = getReferenceHeadXAxis(defaultToReferenceMat, inputCalibration.defaultHeadMat);
glm::vec3 headPosition = getReferenceHeadPosition(defaultToReferenceMat, inputCalibration.defaultHeadMat); glm::vec3 headPosition = getReferenceHeadPosition(defaultToReferenceMat, inputCalibration.defaultHeadMat);
auto& firstFoot = _validTrackedObjects[FIRST_FOOT]; auto& firstFoot = _validTrackedObjects[FIRST_FOOT];
@ -1700,7 +1700,7 @@ void ViveControllerManager::InputDevice::calibrateFeet(const glm::mat4& defaultT
} }
} }
void ViveControllerManager::InputDevice::calibrateFoot(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& footPair, bool isLeftFoot){ void OpenVrInputPlugin::InputDevice::calibrateFoot(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& footPair, bool isLeftFoot){
controller::Pose footPose = footPair.second; controller::Pose footPose = footPair.second;
glm::mat4 puckPoseMat = createMatFromQuatAndPos(footPose.getRotation(), footPose.getTranslation()); glm::mat4 puckPoseMat = createMatFromQuatAndPos(footPose.getRotation(), footPose.getTranslation());
glm::mat4 defaultFoot = isLeftFoot ? inputCalibration.defaultLeftFoot : inputCalibration.defaultRightFoot; glm::mat4 defaultFoot = isLeftFoot ? inputCalibration.defaultLeftFoot : inputCalibration.defaultRightFoot;
@ -1725,12 +1725,12 @@ void ViveControllerManager::InputDevice::calibrateFoot(const glm::mat4& defaultT
} }
} }
void ViveControllerManager::InputDevice::calibrateHips(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrateHips(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
_jointToPuckMap[controller::HIPS] = _validTrackedObjects[HIP].first; _jointToPuckMap[controller::HIPS] = _validTrackedObjects[HIP].first;
_pucksPostOffset[_validTrackedObjects[HIP].first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultHips, _validTrackedObjects[HIP].second); _pucksPostOffset[_validTrackedObjects[HIP].first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultHips, _validTrackedObjects[HIP].second);
} }
void ViveControllerManager::InputDevice::calibrateChest(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrateChest(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
_jointToPuckMap[controller::SPINE2] = _validTrackedObjects[CHEST].first; _jointToPuckMap[controller::SPINE2] = _validTrackedObjects[CHEST].first;
_pucksPostOffset[_validTrackedObjects[CHEST].first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultSpine2, _validTrackedObjects[CHEST].second); _pucksPostOffset[_validTrackedObjects[CHEST].first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultSpine2, _validTrackedObjects[CHEST].second);
} }
@ -1751,7 +1751,7 @@ static glm::vec3 computeUserShoulderPositionFromMeasurements(float armCirc, floa
return transformPoint(headMat, glm::vec3(localArmX, localArmCenter.y, localArmCenter.z)); return transformPoint(headMat, glm::vec3(localArmX, localArmCenter.y, localArmCenter.z));
} }
void ViveControllerManager::InputDevice::calibrateShoulders(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, void OpenVrInputPlugin::InputDevice::calibrateShoulders(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration,
int firstShoulderIndex, int secondShoulderIndex) { int firstShoulderIndex, int secondShoulderIndex) {
const PuckPosePair& firstShoulder = _validTrackedObjects[firstShoulderIndex]; const PuckPosePair& firstShoulder = _validTrackedObjects[firstShoulderIndex];
const PuckPosePair& secondShoulder = _validTrackedObjects[secondShoulderIndex]; const PuckPosePair& secondShoulder = _validTrackedObjects[secondShoulderIndex];
@ -1803,18 +1803,18 @@ void ViveControllerManager::InputDevice::calibrateShoulders(const glm::mat4& def
} }
} }
void ViveControllerManager::InputDevice::calibrateHead(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) { void OpenVrInputPlugin::InputDevice::calibrateHead(const glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
size_t headIndex = _validTrackedObjects.size() - 1; size_t headIndex = _validTrackedObjects.size() - 1;
const PuckPosePair& head = _validTrackedObjects[headIndex]; const PuckPosePair& head = _validTrackedObjects[headIndex];
_jointToPuckMap[controller::HEAD] = head.first; _jointToPuckMap[controller::HEAD] = head.first;
_pucksPostOffset[head.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultHeadMat, head.second); _pucksPostOffset[head.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultHeadMat, head.second);
} }
QString ViveControllerManager::InputDevice::configToString(Config config) { QString OpenVrInputPlugin::InputDevice::configToString(Config config) {
return _configStringMap[config]; return _configStringMap[config];
} }
void ViveControllerManager::InputDevice::setConfigFromString(const QString& value) { void OpenVrInputPlugin::InputDevice::setConfigFromString(const QString& value) {
if (value == "None") { if (value == "None") {
_preferedConfig = Config::None; _preferedConfig = Config::None;
} else if (value == "Feet") { } else if (value == "Feet") {
@ -1960,7 +1960,7 @@ void ViveControllerManager::InputDevice::setConfigFromString(const QString& valu
* </table> * </table>
* @typedef {object} Controller.Hardware-Vive * @typedef {object} Controller.Hardware-Vive
*/ */
controller::Input::NamedVector ViveControllerManager::InputDevice::getAvailableInputs() const { controller::Input::NamedVector OpenVrInputPlugin::InputDevice::getAvailableInputs() const {
using namespace controller; using namespace controller;
QVector<Input::NamedPair> availableInputs{ QVector<Input::NamedPair> availableInputs{
// Trackpad analogs // Trackpad analogs
@ -2081,7 +2081,7 @@ controller::Input::NamedVector ViveControllerManager::InputDevice::getAvailableI
return availableInputs; return availableInputs;
} }
QString ViveControllerManager::InputDevice::getDefaultMappingConfig() const { QString OpenVrInputPlugin::InputDevice::getDefaultMappingConfig() const {
QString name(getOpenVrDeviceName().c_str()); QString name(getOpenVrDeviceName().c_str());
QString MAPPING_JSON; QString MAPPING_JSON;
// Workaround for having to press the thumbstick to be able to move. // Workaround for having to press the thumbstick to be able to move.

6
plugins/openvr/src/ViveControllerManager.h → plugins/openvr/src/OpenVrInputPlugin.h
View file

@ -1,5 +1,5 @@
// //
// ViveControllerManager.h // OpenVrInputPlugin.h
// //
// Created by Sam Gondelman on 6/29/15. // Created by Sam Gondelman on 6/29/15.
// Copyright 2013 High Fidelity, Inc. // Copyright 2013 High Fidelity, Inc.
@ -53,7 +53,7 @@ public:
#endif #endif
class ViveControllerManager : public InputPlugin { class OpenVrInputPlugin : public InputPlugin {
Q_OBJECT Q_OBJECT
public: public:
// Plugin functions // Plugin functions
@ -247,7 +247,7 @@ private:
std::map<uint32_t, uint64_t> _simDataRunningOkTimestampMap; std::map<uint32_t, uint64_t> _simDataRunningOkTimestampMap;
QString configToString(Config config); QString configToString(Config config);
friend class ViveControllerManager; friend class OpenVrInputPlugin;
}; };
void renderHand(const controller::Pose& pose, gpu::Batch& batch, int sign); void renderHand(const controller::Pose& pose, gpu::Batch& batch, int sign);

4
plugins/openvr/src/OpenVrProvider.cpp
View file

@ -15,7 +15,7 @@
#include <plugins/RuntimePlugin.h> #include <plugins/RuntimePlugin.h>
#include "OpenVrDisplayPlugin.h" #include "OpenVrDisplayPlugin.h"
#include "ViveControllerManager.h" #include "OpenVrInputPlugin.h"
class OpenVrProvider : public QObject, public DisplayProvider, InputProvider class OpenVrProvider : public QObject, public DisplayProvider, InputProvider
{ {
@ -43,7 +43,7 @@ public:
virtual InputPluginList getInputPlugins() override { virtual InputPluginList getInputPlugins() override {
static std::once_flag once; static std::once_flag once;
std::call_once(once, [&] { std::call_once(once, [&] {
InputPluginPointer plugin(std::make_shared<ViveControllerManager>()); InputPluginPointer plugin(std::make_shared<OpenVrInputPlugin>());
if (plugin->isSupported()) { if (plugin->isSupported()) {
_inputPlugins.push_back(plugin); _inputPlugins.push_back(plugin);
} }