Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "../qquick3dxrinputmanager_p.h"
#include "qopenxrinputmanager_p.h"
#include "openxr/qopenxrhelpers_p.h"
#include "qquick3dxrhandinput_p.h"
#include "qquick3dxrhandmodel_p.h"
#include "qquick3dxrcontroller_p.h" //### InputAction enum
#include <QDebug>
#include <private/qquick3djoint_p.h>
#include <QtGui/qquaternion.h>
QT_BEGIN_NAMESPACE
Q_DECLARE_LOGGING_CATEGORY(lcQuick3DXr);
QQuick3DXrInputManagerPrivate::QQuick3DXrInputManagerPrivate(QQuick3DXrInputManager &manager)
: q_ptr(&manager)
{
m_handInputState[uint(Handedness::Left)] = new QQuick3DXrHandInput(this);
m_handInputState[uint(Handedness::Right)] = new QQuick3DXrHandInput(this);
}
QQuick3DXrInputManagerPrivate::~QQuick3DXrInputManagerPrivate()
{
teardown();
delete m_handInputState[uint(Handedness::Left)];
delete m_handInputState[uint(Handedness::Right)];
m_handInputState[uint(Handedness::Left)] = nullptr;
m_handInputState[uint(Handedness::Right)] = nullptr;
}
QQuick3DXrInputManagerPrivate::QXRHandComponentPath QQuick3DXrInputManagerPrivate::makeHandInputPaths(const QByteArrayView path)
{
QXRHandComponentPath res;
setPath(res.paths[uint(Handedness::Left)], "/user/hand/left/" + path);
setPath(res.paths[uint(Handedness::Right)], "/user/hand/right/" + path);
return res;
}
XrPath QQuick3DXrInputManagerPrivate::makeInputPath(const QByteArrayView path)
{
XrPath res;
setPath(res, path.toByteArray());
return res;
}
QQuick3DGeometry *QQuick3DXrInputManagerPrivate::createHandMeshGeometry(const HandMeshData &handMeshData)
{
QQuick3DGeometry *geometry = new QQuick3DGeometry();
geometry->setPrimitiveType(QQuick3DGeometry::PrimitiveType::Triangles);
// Figure out which attributes should be used
const qsizetype expectedLength = handMeshData.vertexPositions.size();
bool hasPositions = !handMeshData.vertexPositions.isEmpty();
bool hasNormals = handMeshData.vertexNormals.size() >= expectedLength;
bool hasUV0s = handMeshData.vertexUVs.size() >= expectedLength;
bool hasJoints = handMeshData.vertexBlendIndices.size() >= expectedLength;
bool hasWeights = handMeshData.vertexBlendWeights.size() >= expectedLength;
bool hasIndexes = !handMeshData.indices.isEmpty();
int offset = 0;
if (hasPositions) {
geometry->addAttribute(QQuick3DGeometry::Attribute::PositionSemantic, offset, QQuick3DGeometry::Attribute::ComponentType::F32Type);
offset += 3 * sizeof(float);
}
if (hasNormals) {
geometry->addAttribute(QQuick3DGeometry::Attribute::NormalSemantic, offset, QQuick3DGeometry::Attribute::ComponentType::F32Type);
offset += 3 * sizeof(float);
}
if (hasUV0s) {
geometry->addAttribute(QQuick3DGeometry::Attribute::TexCoordSemantic, offset, QQuick3DGeometry::Attribute::ComponentType::F32Type);
offset += 2 * sizeof(float);
}
if (hasJoints) {
geometry->addAttribute(QQuick3DGeometry::Attribute::JointSemantic, offset, QQuick3DGeometry::Attribute::ComponentType::I32Type);
offset += 4 * sizeof(qint32);
}
if (hasWeights) {
geometry->addAttribute(QQuick3DGeometry::Attribute::WeightSemantic, offset, QQuick3DGeometry::Attribute::ComponentType::F32Type);
offset += 4 * sizeof(float);
}
if (hasIndexes)
geometry->addAttribute(QQuick3DGeometry::Attribute::IndexSemantic, 0, QQuick3DGeometry::Attribute::ComponentType::U16Type);
// set up the vertex buffer
const int stride = offset;
const qsizetype bufferSize = expectedLength * stride;
geometry->setStride(stride);
QByteArray vertexBuffer;
vertexBuffer.reserve(bufferSize);
QVector3D minBounds;
QVector3D maxBounds;
auto appendFloat = [&vertexBuffer](float f) {
vertexBuffer.append(reinterpret_cast<const char *>(&f), sizeof(float));
};
auto appendInt = [&vertexBuffer](qint32 i) {
vertexBuffer.append(reinterpret_cast<const char *>(&i), sizeof(qint32));
};
for (qsizetype i = 0; i < expectedLength; ++i) {
// start writing float values to vertexBuffer
if (hasPositions) {
const QVector3D position = OpenXRHelpers::toQVector(handMeshData.vertexPositions[i]);
appendFloat(position.x());
appendFloat(position.y());
appendFloat(position.z());
minBounds.setX(qMin(minBounds.x(), position.x()));
maxBounds.setX(qMax(maxBounds.x(), position.x()));
minBounds.setY(qMin(minBounds.y(), position.y()));
maxBounds.setY(qMax(maxBounds.y(), position.y()));
minBounds.setZ(qMin(minBounds.z(), position.z()));
maxBounds.setZ(qMax(maxBounds.z(), position.z()));
}
if (hasNormals) {
const auto &normal = handMeshData.vertexNormals[i];
appendFloat(normal.x);
appendFloat(normal.y);
appendFloat(normal.z);
}
if (hasUV0s) {
const auto &uv0 = handMeshData.vertexUVs[i];
appendFloat(uv0.x);
appendFloat(uv0.y);
}
if (hasJoints) {
const auto &joint = handMeshData.vertexBlendIndices[i];
appendInt(joint.x);
appendInt(joint.y);
appendInt(joint.z);
appendInt(joint.w);
}
if (hasWeights) {
const auto &weight = handMeshData.vertexBlendWeights[i];
appendFloat(weight.x);
appendFloat(weight.y);
appendFloat(weight.z);
appendFloat(weight.w);
}
}
geometry->setBounds(minBounds, maxBounds);
geometry->setVertexData(vertexBuffer);
// Index Buffer
if (hasIndexes) {
const qsizetype indexLength = handMeshData.indices.size();
QByteArray indexBuffer;
indexBuffer.reserve(indexLength * sizeof(int16_t));
for (qsizetype i = 0; i < indexLength; ++i) {
const auto &index = handMeshData.indices[i];
indexBuffer.append(reinterpret_cast<const char *>(&index), sizeof(int16_t));
}
geometry->setIndexData(indexBuffer);
}
return geometry;
}
void QQuick3DXrInputManagerPrivate::loadBindings(QList<ControllerBindings>* controllerBindingsList)
{
// Oculus touch and HTC Vive Controllers
QList<ActionPaths> GripAimHapticSupported = {
ActionPaths::leftGripPose,
ActionPaths::leftAimPose,
ActionPaths::leftHaptic,
ActionPaths::rightGripPose,
ActionPaths::rightAimPose,
ActionPaths::rightHaptic
};
// Oculus Touch
QList<InputMapping> oculusTouchInputMapping = {
InputMapping{QQuick3DXrInputAction::Button1Pressed, InputNames::XClick, LeftHandSubPath},
InputMapping{QQuick3DXrInputAction::Button1Pressed, InputNames::AClick, RightHandSubPath},
InputMapping{QQuick3DXrInputAction::Button2Pressed, InputNames::YClick, LeftHandSubPath},
InputMapping{QQuick3DXrInputAction::Button2Pressed, InputNames::BClick, RightHandSubPath},
InputMapping{QQuick3DXrInputAction::Button1Touched, InputNames::XTouch, LeftHandSubPath},
InputMapping{QQuick3DXrInputAction::Button1Touched, InputNames::ATouch, RightHandSubPath},
InputMapping{QQuick3DXrInputAction::Button2Touched, InputNames::YTouch, LeftHandSubPath},
InputMapping{QQuick3DXrInputAction::Button2Touched, InputNames::BTouch, RightHandSubPath},
InputMapping{QQuick3DXrInputAction::ButtonMenuPressed, InputNames::MenuClick, LeftHandSubPath},
InputMapping{QQuick3DXrInputAction::ButtonSystemPressed, InputNames::SystemClick, RightHandSubPath},
InputMapping{QQuick3DXrInputAction::SqueezeValue, InputNames::SqueezeValue, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TriggerValue, InputNames::TriggerValue, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TriggerTouched, InputNames::TriggerTouch, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ThumbstickX, InputNames::ThumbstickX, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ThumbstickY, InputNames::ThumbstickY, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ThumbstickPressed, InputNames::ThumbstickClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ThumbstickTouched, InputNames::ThumbstickTouch, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ThumbrestTouched, InputNames::ThumbrestTouch, BothHandsSubPath},
};
ControllerBindings oculusTouch{
"Oculus touch",
"/interaction_profiles/oculus/touch_controller",
oculusTouchInputMapping,
GripAimHapticSupported
};
controllerBindingsList->append(oculusTouch);
// HTC Vive controller
QList<InputMapping> viveControllerInputMapping {
InputMapping{QQuick3DXrInputAction::ButtonMenuPressed, InputNames::MenuClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::ButtonSystemPressed, InputNames::SystemClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::SqueezePressed, InputNames::SqueezeClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TriggerValue, InputNames::TriggerValue, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TriggerPressed, InputNames::TriggerClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TrackpadX, InputNames::TrackpadX, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TrackpadY, InputNames::TrackpadY, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TrackpadPressed, InputNames::TrackpadClick, BothHandsSubPath},
InputMapping{QQuick3DXrInputAction::TrackpadTouched, InputNames::TrackpadTouch, BothHandsSubPath},
};
ControllerBindings viveController {
"Vive controller",
"/interaction_profiles/htc/vive_controller",
viveControllerInputMapping,
GripAimHapticSupported
};
controllerBindingsList->append(viveController);
// Microsoft hand interaction extension as supported by Quest 3
// TODO: there are other, very similar, extensions: XR_HTC_HAND_INTERACTION_EXTENSION_NAME and XR_EXT_HAND_INTERACTION_EXTENSION_NAME
QList<InputMapping> microsoftHandInteractionExtensionInputMapping {
InputMapping{QQuick3DXrInputAction::SqueezeValue, InputNames::SqueezeValue, BothHandsSubPath},
};
QList<ActionPaths> microsoftHandInteractionExtensionActionPaths = {
ActionPaths::leftGripPose,
ActionPaths::leftAimPose,
ActionPaths::rightGripPose,
ActionPaths::rightAimPose
};
ControllerBindings microsoftHandInteractionExtension {
"microsoftHandInteractionExtension",
"/interaction_profiles/microsoft/hand_interaction",
microsoftHandInteractionExtensionInputMapping,
microsoftHandInteractionExtensionActionPaths
};
controllerBindingsList->append(microsoftHandInteractionExtension);
#if 0 // Unused
// Microsoft MRM ### TODO
QList<InputMapping> microsoftMRMInputMapping {};
QList<ActionPaths> microsoftMRMActionPaths;
ControllerBindings microsoftMRM{
"Microsoft MRM",
"/interaction_profiles/microsoft/motion_controller",
microsoftMRMInputMapping,
microsoftMRMActionPaths
};
controllerBindingsList->append(microsoftMRM);
// Valve Index ### TODO
QList<InputMapping> valveIndexInputMapping {};
QList<ActionPaths> valveIndexActionPaths;
ControllerBindings valveIndex{
"Valve Index",
"/interaction_profiles/valve/index_controller",
valveIndexInputMapping,
valveIndexActionPaths
};
controllerBindingsList->append(valveIndex);
#endif // Unused
}
void QQuick3DXrInputManagerPrivate::setUpBindings(QList<ControllerBindings>* controllerBindingsList, QMap<InputNames, QXRHandComponentPath>* handComponentPaths)
{
QMap<ActionPaths, XrActionSuggestedBinding> actionPaths;
// Hand Left
XrPath leftGripPose; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
XrPath leftAimPose; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
XrPath leftHaptic; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
setPath(leftGripPose, "/user/hand/left/input/grip/pose");
setPath(leftAimPose, "/user/hand/left/input/aim/pose");
setPath(leftHaptic, "/user/hand/left/output/haptic");
actionPaths.insert(ActionPaths::leftGripPose, {m_handActions.gripPoseAction, leftGripPose});
actionPaths.insert(ActionPaths::leftAimPose, {m_handActions.aimPoseAction, leftAimPose});
actionPaths.insert(ActionPaths::leftHaptic, {m_handActions.hapticAction, leftHaptic});
// Hand Right
XrPath rightGripPose; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
XrPath rightAimPose; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
XrPath rightHaptic; // OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
setPath(rightGripPose, "/user/hand/right/input/grip/pose");
setPath(rightAimPose, "/user/hand/right/input/aim/pose");
setPath(rightHaptic, "/user/hand/right/output/haptic");
actionPaths.insert(ActionPaths::rightGripPose, {m_handActions.gripPoseAction, rightGripPose});
actionPaths.insert(ActionPaths::rightAimPose, {m_handActions.aimPoseAction, rightAimPose});
actionPaths.insert(ActionPaths::rightHaptic, {m_handActions.hapticAction, rightHaptic});
for (int i = 0; i < controllerBindingsList->size(); i++) {
ControllerBindings controllerBindings = controllerBindingsList->at(i);
if (controllerBindings.profileMappingDefs.size() == 0 || controllerBindings.supportedActionPaths.size() == 0)
continue;
XrPath profilePath;
setPath(profilePath, controllerBindings.profilePath);
std::vector<XrActionSuggestedBinding> bindings {};
for (const auto &path : std::as_const(controllerBindings.supportedActionPaths)) {
bindings.push_back(actionPaths.value(path));
}
for (const auto &[actionId, path, selector] : std::as_const(controllerBindings.profileMappingDefs)) {
if (selector & LeftHandSubPath)
bindings.push_back({m_inputActions[actionId], handComponentPaths->value(path).paths[uint(Handedness::Left)]});
if (selector & RightHandSubPath)
bindings.push_back({m_inputActions[actionId], handComponentPaths->value(path).paths[uint(Handedness::Right)]});
}
XrInteractionProfileSuggestedBinding suggestedBindings{};
suggestedBindings.type = XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING;
suggestedBindings.interactionProfile = profilePath;
suggestedBindings.suggestedBindings = bindings.data();
suggestedBindings.countSuggestedBindings = (uint32_t)bindings.size();
if (!checkXrResult(xrSuggestInteractionProfileBindings(m_instance, &suggestedBindings)))
qWarning() << "Failed to get suggested interaction profile bindings for " << controllerBindings.profileName;
}
}
void QQuick3DXrInputManagerPrivate::init(XrInstance instance, XrSession session)
{
if (m_initialized) {
qWarning() << "QQuick3DXrInputManager: Trying to initialize an already initialized session";
teardown();
}
m_instance = instance;
m_session = session;
setupHandTracking();
setupActions();
QMap<InputNames, QXRHandComponentPath> handComponentPaths;
handComponentPaths.insert(InputNames::AClick, makeHandInputPaths("input/a/click")); // OCULUS_TOUCH (right) | VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::BClick, makeHandInputPaths("input/b/click")); // OCULUS_TOUCH (right) | VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::ATouch, makeHandInputPaths("input/a/touch")); // OCULUS_TOUCH (right) | VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::BTouch, makeHandInputPaths("input/b/touch")); // OCULUS_TOUCH (right) | VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::XClick, makeHandInputPaths("input/x/click")); // OCULUS_TOUCH (left)
handComponentPaths.insert(InputNames::YClick, makeHandInputPaths("input/y/click")); // OCULUS_TOUCH (left)
handComponentPaths.insert(InputNames::XTouch, makeHandInputPaths("input/x/touch")); // OCULUS_TOUCH (left)
handComponentPaths.insert(InputNames::YTouch, makeHandInputPaths("input/y/touch")); // OCULUS_TOUCH (left)
handComponentPaths.insert(InputNames::MenuClick, makeHandInputPaths("input/menu/click")); // OCULUS_TOUCH (left) | MICROSOFT_MRM (right + left) | HTC_VIVE (right + left)
handComponentPaths.insert(InputNames::SystemClick, makeHandInputPaths("input/system/click")); // OCULUS_TOUCH (right) | VALVE_INDEX (right + left) | HTC_VIVE (right + left)
handComponentPaths.insert(InputNames::SystemTouch, makeHandInputPaths("input/system/touch")); // VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::SqueezeValue, makeHandInputPaths("input/squeeze/value")); // right + left: OCULUS_TOUCH | VALVE_INDEX
handComponentPaths.insert(InputNames::SqueezeForce, makeHandInputPaths("input/squeeze/force")); // right + left: VALVE_INDEX
handComponentPaths.insert(InputNames::SqueezeClick, makeHandInputPaths("input/squeeze/click")); // right + left: MICROSOFT_MRM | HTC_VIVE
handComponentPaths.insert(InputNames::TriggerValue, makeHandInputPaths("input/trigger/value")); // right + left: OCULUS_TOUCH | VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
handComponentPaths.insert(InputNames::TriggerTouch, makeHandInputPaths("input/trigger/touch")); // right + left: OCULUS_TOUCH | VALVE_INDEX
handComponentPaths.insert(InputNames::TriggerClick, makeHandInputPaths("input/trigger/click")); // right + left: VALVE_INDEX | HTC_VIVE
handComponentPaths.insert(InputNames::ThumbstickX, makeHandInputPaths("input/thumbstick/x")); // OCULUS_TOUCH (right + left) | VALVE_INDEX (right + left) | MICROSOFT_MRM (left)
handComponentPaths.insert(InputNames::ThumbstickY, makeHandInputPaths("input/thumbstick/y")); // OCULUS_TOUCH (right + left) | VALVE_INDEX (right + left) | MICROSOFT_MRM (left)
handComponentPaths.insert(InputNames::ThumbstickClick, makeHandInputPaths("input/thumbstick/click")); // OCULUS_TOUCH (right + left) | VALVE_INDEX (right + left) | MICROSOFT_MRM (left)
handComponentPaths.insert(InputNames::ThumbstickTouch, makeHandInputPaths("input/thumbstick/touch")); // OCULUS_TOUCH (right + left) | VALVE_INDEX (right + left)
handComponentPaths.insert(InputNames::ThumbrestTouch, makeHandInputPaths("input/thumbrest/touch")); // OCULUS_TOUCH (right + left)
handComponentPaths.insert(InputNames::TrackpadX, makeHandInputPaths("input/trackpad/x")); // right + left: VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
handComponentPaths.insert(InputNames::TrackpadY, makeHandInputPaths("input/trackpad/y")); // right + left: VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
handComponentPaths.insert(InputNames::TrackpadForce, makeHandInputPaths("input/trackpad/force")); // right + left: VALVE_INDEX
handComponentPaths.insert(InputNames::TrackpadClick, makeHandInputPaths("input/trackpad/click")); // right + left: VALVE_INDEX | MICROSOFT_MRM | HTC_VIVE
handComponentPaths.insert(InputNames::TrackpadTouch, makeHandInputPaths("input/trackpad/touch")); // right + left: MICROSOFT_MRM | HTC_VIVE
// Bindings
QList<ControllerBindings> controllerBindingsList;
loadBindings(&controllerBindingsList);
setUpBindings(&controllerBindingsList, &handComponentPaths);
// Setup Action Spaces
XrActionSpaceCreateInfo actionSpaceInfo{};
actionSpaceInfo.type = XR_TYPE_ACTION_SPACE_CREATE_INFO;
actionSpaceInfo.action = m_handActions.gripPoseAction;
actionSpaceInfo.poseInActionSpace.orientation.w = 1.0f;
//actionSpaceInfo.poseInActionSpace.orientation.y = 1.0f;
actionSpaceInfo.subactionPath = m_handSubactionPath[0];
if (!checkXrResult(xrCreateActionSpace(m_session, &actionSpaceInfo, &m_handGripSpace[0])))
qWarning("Failed to create action space for handGripSpace[0]");
actionSpaceInfo.subactionPath = m_handSubactionPath[1];
if (!checkXrResult(xrCreateActionSpace(m_session, &actionSpaceInfo, &m_handGripSpace[1])))
qWarning("Failed to create action space for handGripSpace[1]");
actionSpaceInfo.action = m_handActions.aimPoseAction;
actionSpaceInfo.subactionPath = m_handSubactionPath[0];
if (!checkXrResult(xrCreateActionSpace(m_session, &actionSpaceInfo, &m_handAimSpace[0])))
qWarning("Failed to create action space for handAimSpace[0]");
actionSpaceInfo.subactionPath = m_handSubactionPath[1];
if (!checkXrResult(xrCreateActionSpace(m_session, &actionSpaceInfo, &m_handAimSpace[1])))
qWarning("Failed to create action space for handAimSpace[1]");
// Attach Action set to session
XrSessionActionSetsAttachInfo attachInfo{};
attachInfo.type = XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO;
attachInfo.countActionSets = 1;
attachInfo.actionSets = &m_actionSet;
if (!checkXrResult(xrAttachSessionActionSets(m_session, &attachInfo)))
qWarning("Failed to attach action sets to session");
m_initialized = true;
}
void QQuick3DXrInputManagerPrivate::teardown()
{
if (!m_initialized)
return;
m_initialized = false;
xrDestroySpace(m_handGripSpace[0]);
xrDestroySpace(m_handGripSpace[1]);
xrDestroySpace(m_handAimSpace[0]);
xrDestroySpace(m_handAimSpace[1]);
destroyActions();
if (xrDestroyHandTrackerEXT_) {
xrDestroyHandTrackerEXT_(handTracker[uint(Handedness::Left)]);
xrDestroyHandTrackerEXT_(handTracker[uint(Handedness::Right)]);
}
m_instance = {XR_NULL_HANDLE};
m_session = {XR_NULL_HANDLE};
}
QQuick3DXrInputManagerPrivate *QQuick3DXrInputManagerPrivate::get(QQuick3DXrInputManager *inputManager)
{
QSSG_ASSERT(inputManager != nullptr, return nullptr);
return inputManager->d_func();
}
void QQuick3DXrInputManagerPrivate::pollActions()
{
if (!m_initialized)
return;
// Sync Actions
const XrActiveActionSet activeActionSet{m_actionSet, XR_NULL_PATH};
XrActionsSyncInfo syncInfo{};
syncInfo.type = XR_TYPE_ACTIONS_SYNC_INFO;
syncInfo.countActiveActionSets = 1;
syncInfo.activeActionSets = &activeActionSet;
XrResult result = xrSyncActions(m_session, &syncInfo);
if (!(result == XR_SUCCESS ||
result == XR_SESSION_LOSS_PENDING ||
result == XR_SESSION_NOT_FOCUSED))
{
if (!checkXrResult(result)) {
qWarning("xrSyncActions failed");
return;
}
}
// Hands
XrActionStateGetInfo getInfo{};
getInfo.type = XR_TYPE_ACTION_STATE_GET_INFO;
for (auto handedness : {Handedness::Left, Handedness::Right}) {
getInfo.subactionPath = m_handSubactionPath[uint(handedness)];
auto &inputState = m_handInputState[uint(handedness)];
for (const auto &def : std::as_const(m_handInputActionDefs)) {
getInfo.action = m_inputActions[def.id];
switch (def.type) {
case XR_ACTION_TYPE_BOOLEAN_INPUT: {
XrActionStateBoolean boolValue{};
boolValue.type = XR_TYPE_ACTION_STATE_BOOLEAN;
if (checkXrResult(xrGetActionStateBoolean(m_session, &getInfo, &boolValue))) {
if (boolValue.isActive && boolValue.changedSinceLastSync) {
//qDebug() << "ACTION" << i << def.shortName << bool(boolValue.currentState);
setInputValue(handedness, def.id, def.shortName, float(boolValue.currentState));
}
} else {
qWarning("Failed to get action state for bool hand input");
}
break;
}
case XR_ACTION_TYPE_FLOAT_INPUT: {
XrActionStateFloat floatValue{};
floatValue.type = XR_TYPE_ACTION_STATE_FLOAT;
if (checkXrResult(xrGetActionStateFloat(m_session, &getInfo, &floatValue))) {
if (floatValue.isActive && floatValue.changedSinceLastSync) {
//qDebug() << "ACTION" << i << def.shortName << floatValue.currentState;
setInputValue(handedness, def.id, def.shortName, float(floatValue.currentState));
}
} else {
qWarning("Failed to get action state for float hand input");
}
break;
}
case XR_ACTION_TYPE_VECTOR2F_INPUT:
case XR_ACTION_TYPE_POSE_INPUT:
case XR_ACTION_TYPE_VIBRATION_OUTPUT:
case XR_ACTION_TYPE_MAX_ENUM:
break;
}
}
// Get pose activity status
getInfo.action = m_handActions.gripPoseAction;
XrActionStatePose poseState{};
poseState.type = XR_TYPE_ACTION_STATE_POSE;
if (checkXrResult(xrGetActionStatePose(m_session, &getInfo, &poseState)))
inputState->setIsActive(poseState.isActive);
else
qWarning("Failed to get action state pose");
// XrAction gripPoseAction{XR_NULL_HANDLE};
// XrAction aimPoseAction{XR_NULL_HANDLE};
// XrAction hapticAction{XR_NULL_HANDLE};
const QList<QPointer<QQuick3DXrHapticFeedback>> hapticOutputData = QQuick3DXrActionMapper::getHapticEffects(static_cast<QtQuick3DXr::Controller>(handedness));
for (auto &hapticFeedback : hapticOutputData) {
const bool triggered = hapticFeedback->testAndClear();
if (triggered) {
if (auto *hapticEffect = qobject_cast<QQuick3DXrSimpleHapticEffect*>(hapticFeedback->hapticEffect())) {
XrHapticVibration vibration {XR_TYPE_HAPTIC_VIBRATION, nullptr, 0, 0, 0};
vibration.amplitude = hapticEffect->amplitude();
vibration.duration = hapticEffect->duration() * 1000000; // Change from milliseconds to nanoseconds
vibration.frequency = hapticEffect->frequency();
XrHapticActionInfo hapticActionInfo {XR_TYPE_HAPTIC_ACTION_INFO, nullptr, m_handActions.hapticAction, m_handSubactionPath[uint(handedness)]};
if (!checkXrResult(xrApplyHapticFeedback(m_session, &hapticActionInfo, (const XrHapticBaseHeader*)&vibration))) {
qWarning("Failed to trigger haptic feedback");
}
}
}
}
}
}
void QQuick3DXrInputManagerPrivate::updatePoses(XrTime predictedDisplayTime, XrSpace appSpace)
{
// Update the Hands pose
for (auto poseSpace : {HandPoseSpace::AimPose, HandPoseSpace::GripPose}) {
for (auto handedness : {Handedness::Left, Handedness::Right}) {
if (!isPoseInUse(handedness, poseSpace))
continue;
XrSpaceLocation spaceLocation{};
spaceLocation.type = XR_TYPE_SPACE_LOCATION;
XrResult res;
res = xrLocateSpace(handSpace(handedness, poseSpace), appSpace, predictedDisplayTime, &spaceLocation);
// qDebug() << "LOCATE SPACE hand:" << hand << "res" << res << "flags" << spaceLocation.locationFlags
// << "active" << m_handInputState[hand]->isActive()
// << "Pos" << spaceLocation.pose.position.x << spaceLocation.pose.position.y << spaceLocation.pose.position.z;
m_validAimStateFromUpdatePoses[uint(handedness)] = poseSpace == HandPoseSpace::AimPose
&& XR_UNQUALIFIED_SUCCESS(res) && (spaceLocation.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT)
&& (spaceLocation.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT); // ### Workaround for Quest issue with hand interaction aim pose
if (XR_UNQUALIFIED_SUCCESS(res)) {
if ((spaceLocation.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0 &&
(spaceLocation.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) != 0) {
// Update hand transform
setPosePositionAndRotation(handedness, poseSpace,
QVector3D(spaceLocation.pose.position.x,
spaceLocation.pose.position.y,
spaceLocation.pose.position.z) * 100.0f,
QQuaternion(spaceLocation.pose.orientation.w,
spaceLocation.pose.orientation.x,
spaceLocation.pose.orientation.y,
spaceLocation.pose.orientation.z));
}
} else {
// Tracking loss is expected when the hand is not active so only log a message
// if the hand is active.
if (isHandActive(handedness)) {
const char* handName[] = {"left", "right"};
qCDebug(lcQuick3DXr, "Unable to locate %s hand action space in app space: %d", handName[uint(handedness)], res);
}
}
}
}
}
void QQuick3DXrInputManagerPrivate::updateHandtracking(XrTime predictedDisplayTime, XrSpace appSpace, bool aimExtensionEnabled)
{
if (xrLocateHandJointsEXT_) {
XrHandTrackingAimStateFB aimState[2] = {{}, {}}; // Only used when aim extension is enabled
XrHandJointVelocitiesEXT velocities[2]{{}, {}};
XrHandJointLocationsEXT locations[2]{{}, {}};
XrHandJointsLocateInfoEXT locateInfo[2] = {{}, {}};
for (auto handedness : {Handedness::Left, Handedness::Right}) {
if (handTracker[uint(handedness)] == XR_NULL_HANDLE)
continue;
aimState[uint(handedness)].type = XR_TYPE_HAND_TRACKING_AIM_STATE_FB;
velocities[uint(handedness)].type = XR_TYPE_HAND_JOINT_VELOCITIES_EXT;
velocities[uint(handedness)].jointCount = XR_HAND_JOINT_COUNT_EXT;
velocities[uint(handedness)].jointVelocities = jointVelocities[uint(handedness)];
velocities[uint(handedness)].next = aimExtensionEnabled ? &aimState[uint(handedness)] : nullptr;
locations[uint(handedness)].type = XR_TYPE_HAND_JOINT_LOCATIONS_EXT;
locations[uint(handedness)].next = &velocities[uint(handedness)];
locations[uint(handedness)].jointCount = XR_HAND_JOINT_COUNT_EXT;
locations[uint(handedness)].jointLocations = jointLocations[uint(handedness)];
locateInfo[uint(handedness)].type = XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT;
locateInfo[uint(handedness)].baseSpace = appSpace;
locateInfo[uint(handedness)].time = predictedDisplayTime;
if (!checkXrResult(xrLocateHandJointsEXT_(handTracker[uint(handedness)], &locateInfo[uint(handedness)], &locations[uint(handedness)])))
qWarning("Failed to locate hand joints for hand tracker");
QList<QVector3D> jp;
jp.reserve(XR_HAND_JOINT_COUNT_EXT);
QList<QQuaternion> jr;
jr.reserve(XR_HAND_JOINT_COUNT_EXT);
for (uint i = 0; i < locations[uint(handedness)].jointCount; ++i) {
auto &pose = jointLocations[uint(handedness)][i].pose;
jp.append(OpenXRHelpers::toQVector(pose.position));
jr.append(OpenXRHelpers::toQQuaternion(pose.orientation));
}
m_handInputState[uint(handedness)]->setJointPositionsAndRotations(jp, jr);
m_handInputState[uint(handedness)]->setIsHandTrackingActive(locations[uint(handedness)].isActive);
}
if (aimExtensionEnabled) {
// Finger pinch handling
for (auto handedness : {Handedness::Left, Handedness::Right}) {
const uint state = aimState[uint(handedness)].status;
const uint oldState = m_aimStateFlags[uint(handedness)];
auto updateState = [&](const char *name, QQuick3DXrInputAction::Action id, uint flag) {
if ((state & flag) != (oldState & flag))
setInputValue(handedness, id, name, float(!!(state & flag)));
};
updateState("index_pinch", QQuick3DXrInputAction::IndexFingerPinch, XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB);
updateState("middle_pinch", QQuick3DXrInputAction::MiddleFingerPinch, XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB);
updateState("ring_pinch", QQuick3DXrInputAction::RingFingerPinch, XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB);
updateState("little_pinch", QQuick3DXrInputAction::LittleFingerPinch, XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB);
updateState("hand_tracking_menu_press", QQuick3DXrInputAction::HandTrackingMenuPress, XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB);
m_aimStateFlags[uint(handedness)] = state;
}
// ### Workaround for Quest issue with hand interaction aim pose
for (auto handedness : {Handedness::Left, Handedness::Right}) {
if (isPoseInUse(handedness, HandPoseSpace::AimPose) && !m_validAimStateFromUpdatePoses[uint(handedness)]) {
if ((aimState[uint(handedness)].status & XR_HAND_TRACKING_AIM_VALID_BIT_FB)) {
setPosePositionAndRotation(handedness, HandPoseSpace::AimPose,
QVector3D(aimState[uint(handedness)].aimPose.position.x,
aimState[uint(handedness)].aimPose.position.y,
aimState[uint(handedness)].aimPose.position.z) * 100.0f,
QQuaternion(aimState[uint(handedness)].aimPose.orientation.w,
aimState[uint(handedness)].aimPose.orientation.x,
aimState[uint(handedness)].aimPose.orientation.y,
aimState[uint(handedness)].aimPose.orientation.z));
m_handInputState[uint(handedness)]->setIsActive(true); // TODO: clean up
}
}
}
}
}
}
void QQuick3DXrInputManagerPrivate::setupHandTracking()
{
OpenXRHelpers::resolveXrFunction(
m_instance,
"xrCreateHandTrackerEXT",
(PFN_xrVoidFunction*)(&xrCreateHandTrackerEXT_));
OpenXRHelpers::resolveXrFunction(
m_instance,
"xrDestroyHandTrackerEXT",
(PFN_xrVoidFunction*)(&xrDestroyHandTrackerEXT_));
OpenXRHelpers::resolveXrFunction(
m_instance,
"xrLocateHandJointsEXT",
(PFN_xrVoidFunction*)(&xrLocateHandJointsEXT_));
OpenXRHelpers::resolveXrFunction(
m_instance,
"xrGetHandMeshFB",
(PFN_xrVoidFunction*)(&xrGetHandMeshFB_));
if (xrCreateHandTrackerEXT_) {
XrHandTrackerCreateInfoEXT createInfo{};
createInfo.type = XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT;
createInfo.handJointSet = XR_HAND_JOINT_SET_DEFAULT_EXT;
createInfo.hand = XR_HAND_LEFT_EXT;
if (!checkXrResult(xrCreateHandTrackerEXT_(m_session, &createInfo, &handTracker[uint(QtQuick3DXr::Handedness::Left)])))
qWarning("Failed to create left hand tracker");
createInfo.hand = XR_HAND_RIGHT_EXT;
if (!checkXrResult(xrCreateHandTrackerEXT_(m_session, &createInfo, &handTracker[uint(QtQuick3DXr::Handedness::Right)])))
qWarning("Failed to create right hand tracker");
}
if (xrGetHandMeshFB_) {
for (auto handedness : {Handedness::Left, Handedness::Right}) {
if (queryHandMesh(handedness))
createHandModelData(handedness);
}
}
}
bool QQuick3DXrInputManagerPrivate::queryHandMesh(Handedness handedness)
{
XrHandTrackingMeshFB mesh {};
mesh.type = XR_TYPE_HAND_TRACKING_MESH_FB;
// Left hand
if (!checkXrResult(xrGetHandMeshFB_(handTracker[uint(handedness)], &mesh))) {
qWarning("Failed to query hand mesh info.");
return false;
}
mesh.jointCapacityInput = mesh.jointCountOutput;
mesh.vertexCapacityInput = mesh.vertexCountOutput;
mesh.indexCapacityInput = mesh.indexCountOutput;
m_handMeshData[uint(handedness)].vertexPositions.resize(mesh.vertexCapacityInput);
m_handMeshData[uint(handedness)].vertexNormals.resize(mesh.vertexCapacityInput);
m_handMeshData[uint(handedness)].vertexUVs.resize(mesh.vertexCapacityInput);
m_handMeshData[uint(handedness)].vertexBlendIndices.resize(mesh.vertexCapacityInput);
m_handMeshData[uint(handedness)].vertexBlendWeights.resize(mesh.vertexCapacityInput);
m_handMeshData[uint(handedness)].indices.resize(mesh.indexCapacityInput);
mesh.jointBindPoses = m_handMeshData[uint(handedness)].jointBindPoses;
mesh.jointParents = m_handMeshData[uint(handedness)].jointParents;
mesh.jointRadii = m_handMeshData[uint(handedness)].jointRadii;
mesh.vertexPositions = m_handMeshData[uint(handedness)].vertexPositions.data();
mesh.vertexNormals = m_handMeshData[uint(handedness)].vertexNormals.data();
mesh.vertexUVs = m_handMeshData[uint(handedness)].vertexUVs.data();
mesh.vertexBlendIndices = m_handMeshData[uint(handedness)].vertexBlendIndices.data();
mesh.vertexBlendWeights = m_handMeshData[uint(handedness)].vertexBlendWeights.data();
mesh.indices = m_handMeshData[uint(handedness)].indices.data();
if (!checkXrResult(xrGetHandMeshFB_(handTracker[uint(handedness)], &mesh))) {
qWarning("Failed to get hand mesh data.");
return false;
}
return true;
};
void QQuick3DXrInputManagerPrivate::setupActions()
{
m_handInputActionDefs = {
{ QQuick3DXrInputAction::Button1Pressed, "b1_pressed", "Button 1 Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::Button1Touched, "b1_touched", "Button 1 Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::Button2Pressed, "b2_pressed", "Button 2 Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::Button2Touched, "b2_touched", "Button 2 Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ButtonMenuPressed, "bmenu_pressed", "Button Menu Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ButtonMenuTouched, "bmenu_touched", "Button Menu Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ButtonSystemPressed, "bsystem_pressed", "Button System Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ButtonSystemTouched, "bsystem_touched", "Button System Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::SqueezeValue, "squeeze_value", "Squeeze Value", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::SqueezeForce, "squeeze_force", "Squeeze Force", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::SqueezePressed, "squeeze_pressed", "Squeeze Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::TriggerValue, "trigger_value", "Trigger Value", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::TriggerPressed, "trigger_pressed", "Trigger Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::TriggerTouched, "trigger_touched", "Trigger Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ThumbstickX, "thumbstick_x", "Thumbstick X", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::ThumbstickY, "thumbstick_y", "Thumbstick Y", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::ThumbstickPressed, "thumbstick_pressed", "Thumbstick Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ThumbstickTouched, "thumbstick_touched", "Thumbstick Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::ThumbrestTouched, "thumbrest_touched", "Thumbrest Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::TrackpadX, "trackpad_x", "Trackpad X", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::TrackpadY, "trackpad_y", "Trackpad Y", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::TrackpadForce, "trackpad_force", "Trackpad Force", XR_ACTION_TYPE_FLOAT_INPUT },
{ QQuick3DXrInputAction::TrackpadTouched, "trackpad_touched", "Trackpad Touched", XR_ACTION_TYPE_BOOLEAN_INPUT },
{ QQuick3DXrInputAction::TrackpadPressed, "trackpad_pressed", "Trackpad Pressed", XR_ACTION_TYPE_BOOLEAN_INPUT }
};
// Create an action set.
{
XrActionSetCreateInfo actionSetInfo{};
actionSetInfo.type = XR_TYPE_ACTION_SET_CREATE_INFO;
strcpy(actionSetInfo.actionSetName, "gameplay");
strcpy(actionSetInfo.localizedActionSetName, "Gameplay");
actionSetInfo.priority = 0;
if (!checkXrResult(xrCreateActionSet(m_instance, &actionSetInfo, &m_actionSet)))
qWarning("Failed to create gameplay action set");
}
// Create Hand Actions
setPath(m_handSubactionPath[0], "/user/hand/left");
setPath(m_handSubactionPath[1], "/user/hand/right");
for (const auto &def : std::as_const(m_handInputActionDefs)) {
createAction(def.type,
def.shortName,
def.localizedName,
2,
m_handSubactionPath,
m_inputActions[def.id]);
}
createAction(XR_ACTION_TYPE_VIBRATION_OUTPUT,
"vibrate_hand",
"Vibrate Hand",
2,
m_handSubactionPath,
m_handActions.hapticAction);
createAction(XR_ACTION_TYPE_POSE_INPUT,
"hand_grip_pose",
"Hand Grip Pose",
2,
m_handSubactionPath,
m_handActions.gripPoseAction);
createAction(XR_ACTION_TYPE_POSE_INPUT,
"hand_aim_pose",
"Hand Aim Pose",
2,
m_handSubactionPath,
m_handActions.aimPoseAction);
}
void QQuick3DXrInputManagerPrivate::destroyActions()
{
for (auto &action : m_inputActions) {
if (action)
xrDestroyAction(action);
}
xrDestroyAction(m_handActions.gripPoseAction);
xrDestroyAction(m_handActions.aimPoseAction);
xrDestroyAction(m_handActions.hapticAction);
xrDestroyActionSet(m_actionSet);
}
bool QQuick3DXrInputManagerPrivate::checkXrResult(const XrResult &result)
{
return OpenXRHelpers::checkXrResult(result, m_instance);
}
void QQuick3DXrInputManagerPrivate::setPath(XrPath &path, const QByteArray &pathString)
{
if (!checkXrResult(xrStringToPath(m_instance, pathString.constData(), &path)))
qWarning("xrStringToPath failed");
}
void QQuick3DXrInputManagerPrivate::createAction(XrActionType type,
const char *name,
const char *localizedName,
int numSubactions,
XrPath *subactionPath,
XrAction &action)
{
XrActionCreateInfo actionInfo{};
actionInfo.type = XR_TYPE_ACTION_CREATE_INFO;
actionInfo.actionType = type;
strcpy(actionInfo.actionName, name);
strcpy(actionInfo.localizedActionName, localizedName);
actionInfo.countSubactionPaths = quint32(numSubactions);
actionInfo.subactionPaths = subactionPath;
if (!checkXrResult(xrCreateAction(m_actionSet, &actionInfo, &action)))
qCDebug(lcQuick3DXr) << "xrCreateAction failed. Name:" << name << "localizedName:" << localizedName;
}
void QQuick3DXrInputManagerPrivate::getBoolInputState(XrActionStateGetInfo &getInfo, const XrAction &action, std::function<void(bool)> setter)
{
getInfo.action = action;
XrActionStateBoolean boolValue{};
boolValue.type = XR_TYPE_ACTION_STATE_BOOLEAN;
if (checkXrResult(xrGetActionStateBoolean(m_session, &getInfo, &boolValue))) {
if (boolValue.isActive == XR_TRUE)
setter(bool(boolValue.currentState));
} else {
qWarning("Failed to get action state: bool");
}
}
void QQuick3DXrInputManagerPrivate::getFloatInputState(XrActionStateGetInfo &getInfo, const XrAction &action, std::function<void(float)> setter)
{
getInfo.action = action;
XrActionStateFloat floatValue{};
floatValue.type = XR_TYPE_ACTION_STATE_FLOAT;
if (checkXrResult(xrGetActionStateFloat(m_session, &getInfo, &floatValue))) {
if (floatValue.isActive == XR_TRUE)
setter(float(floatValue.currentState));
} else {
qWarning("Failed to get action state: float");
}
}
XrSpace QQuick3DXrInputManagerPrivate::handSpace(QQuick3DXrInputManagerPrivate::Handedness handedness, HandPoseSpace poseSpace)
{
if (poseSpace == HandPoseSpace::GripPose)
return m_handGripSpace[uint(handedness)];
else
return m_handAimSpace[uint(handedness)];
}
bool QQuick3DXrInputManagerPrivate::isHandActive(QQuick3DXrInputManagerPrivate::Handedness handedness)
{
return m_handInputState[uint(handedness)]->isActive();
}
bool QQuick3DXrInputManagerPrivate::isHandTrackerActive(Handedness handedness)
{
return m_handInputState[uint(handedness)]->isHandTrackingActive();
}
void QQuick3DXrInputManagerPrivate::setPosePositionAndRotation(Handedness handedness, HandPoseSpace poseSpace, const QVector3D &position, const QQuaternion &rotation)
{
for (auto *controller : std::as_const(m_controllers)) {
if (QtQuick3DXr::handednessForController(static_cast<QtQuick3DXr::Controller>(controller->controller())) == handedness && static_cast<QtQuick3DXr::HandPoseSpace>(controller->poseSpace()) == poseSpace) {
controller->setPosition(position);
controller->setRotation(rotation);
}
}
}
void QQuick3DXrInputManagerPrivate::setInputValue(Handedness handedness, int id, const char *shortName, float value)
{
QSSG_ASSERT(uint(handedness) < 2, handedness = Handedness::Left);
QQuick3DXrActionMapper::handleInput(QQuick3DXrInputAction::Action(id), static_cast<QtQuick3DXr::Controller>(handedness), shortName, value);
}
QQuick3DXrHandInput *QQuick3DXrInputManagerPrivate::leftHandInput() const
{
return m_handInputState[uint(Handedness::Left)];
}
QQuick3DXrHandInput *QQuick3DXrInputManagerPrivate::rightHandInput() const
{
return m_handInputState[uint(Handedness::Right)];
}
static inline QMatrix4x4 transformMatrix(const QVector3D &position, const QQuaternion &rotation)
{
QMatrix4x4 transform = QMatrix4x4{rotation.toRotationMatrix()};
transform(0, 3) += position[0];
transform(1, 3) += position[1];
transform(2, 3) += position[2];
return transform;
}
void QQuick3DXrInputManagerPrivate::setupHandModelInternal(QQuick3DXrHandModel *model, Handedness handedness)
{
QQuick3DGeometry *geometry = m_handGeometryData[uint(handedness)].geometry;
if (!geometry)
return;
model->setGeometry(geometry);
QQuick3DSkin *skin = new QQuick3DSkin(model);
auto jointListProp = skin->joints();
QList<QMatrix4x4> inverseBindPoses;
inverseBindPoses.reserve(XR_HAND_JOINT_COUNT_EXT);
const auto &handMeshData = m_handMeshData[uint(handedness)];
for (int i = 0; i < XR_HAND_JOINT_COUNT_EXT; ++i) {
const auto &pose = handMeshData.jointBindPoses[i];
const QVector3D pos = OpenXRHelpers::toQVector(pose.position);
const QQuaternion rot = OpenXRHelpers::toQQuaternion(pose.orientation);
inverseBindPoses.append(transformMatrix(pos, rot).inverted());
QQuick3DNode *joint = new QQuick3DNode(model);
joint->setPosition(pos);
joint->setRotation(rot);
jointListProp.append(&jointListProp, joint);
}
skin->setInverseBindPoses(inverseBindPoses);
model->setSkin(skin);
}
void QQuick3DXrInputManagerPrivate::setupHandModel(QQuick3DXrHandModel *model)
{
QSSG_ASSERT(model != nullptr, return);
if (model->geometry() != nullptr || model->skin() != nullptr) {
qWarning() << "Hand model already has geometry or skin set.";
return;
}
auto controller = static_cast<QtQuick3DXr::Controller>(model->hand());
if (controller == QtQuick3DXr::Controller::UnknownController)
qWarning() << "No matching hand tracker input found for hand model.";
else if (controller == QtQuick3DXr::Controller::LeftHand)
setupHandModelInternal(model, Handedness::Left);
else if (controller == QtQuick3DXr::Controller::RightHand)
setupHandModelInternal(model, Handedness::Right);
}
// Used both to add a new controller, and notify that an existing one has changed
void QQuick3DXrInputManagerPrivate::registerController(QQuick3DXrController *controller)
{
m_poseUsageDirty = true;
if (static_cast<QtQuick3DXr::Controller>(controller->controller()) == QtQuick3DXr::Controller::UnknownController) {
m_controllers.remove(controller);
return;
}
// No point in checking whether it's already in the set: that's just as expensive as inserting
m_controllers.insert(controller);
}
void QQuick3DXrInputManagerPrivate::unregisterController(QQuick3DXrController *controller)
{
m_poseUsageDirty = m_controllers.remove(controller);
}
bool QQuick3DXrInputManagerPrivate::isPoseInUse(Handedness handedness, HandPoseSpace poseSpace)
{
QSSG_ASSERT(uint(handedness) < 2 && uint(poseSpace) < 2, return false);
if (m_poseUsageDirty) {
std::fill_n(&m_poseInUse[0][0], 4, false);
for (const auto *controller : std::as_const(m_controllers)) {
m_poseInUse[uint(controller->controller())][uint(controller->poseSpace())] = true;
}
m_poseUsageDirty = false;
}
return m_poseInUse[uint(handedness)][uint(poseSpace)];
}
void QQuick3DXrInputManagerPrivate::createHandModelData(Handedness handedness)
{
const auto &handMeshData = m_handMeshData[uint(handedness)];
auto &geometry = m_handGeometryData[uint(handedness)].geometry;
delete geometry;
geometry = createHandMeshGeometry(handMeshData);
}
QT_END_NAMESPACE