diff options
Diffstat (limited to 'servers')
| -rw-r--r-- | servers/register_server_types.cpp | 2 | ||||
| -rw-r--r-- | servers/xr/xr_hand_tracker.cpp | 179 | ||||
| -rw-r--r-- | servers/xr/xr_hand_tracker.h | 137 | ||||
| -rw-r--r-- | servers/xr_server.cpp | 48 | ||||
| -rw-r--r-- | servers/xr_server.h | 11 |
5 files changed, 376 insertions, 1 deletions
diff --git a/servers/register_server_types.cpp b/servers/register_server_types.cpp index 150c155f1a..7a55219af2 100644 --- a/servers/register_server_types.cpp +++ b/servers/register_server_types.cpp @@ -87,6 +87,7 @@ #include "text/text_server_extension.h" #include "text_server.h" #include "xr/xr_face_tracker.h" +#include "xr/xr_hand_tracker.h" #include "xr/xr_interface.h" #include "xr/xr_interface_extension.h" #include "xr/xr_positional_tracker.h" @@ -193,6 +194,7 @@ void register_server_types() { GDREGISTER_ABSTRACT_CLASS(RenderingDevice); GDREGISTER_ABSTRACT_CLASS(XRInterface); + GDREGISTER_CLASS(XRHandTracker); GDREGISTER_CLASS(XRInterfaceExtension); // can't register this as virtual because we need a creation function for our extensions. GDREGISTER_CLASS(XRPose); GDREGISTER_CLASS(XRPositionalTracker); diff --git a/servers/xr/xr_hand_tracker.cpp b/servers/xr/xr_hand_tracker.cpp new file mode 100644 index 0000000000..8cc2d5f7d2 --- /dev/null +++ b/servers/xr/xr_hand_tracker.cpp @@ -0,0 +1,179 @@ +/**************************************************************************/ +/* xr_hand_tracker.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#include "xr_hand_tracker.h" + +void XRHandTracker::_bind_methods() { + ClassDB::bind_method(D_METHOD("set_hand", "hand"), &XRHandTracker::set_hand); + ClassDB::bind_method(D_METHOD("get_hand"), &XRHandTracker::get_hand); + + ClassDB::bind_method(D_METHOD("set_has_tracking_data", "has_data"), &XRHandTracker::set_has_tracking_data); + ClassDB::bind_method(D_METHOD("get_has_tracking_data"), &XRHandTracker::get_has_tracking_data); + + ClassDB::bind_method(D_METHOD("set_hand_tracking_source", "source"), &XRHandTracker::set_hand_tracking_source); + ClassDB::bind_method(D_METHOD("get_hand_tracking_source"), &XRHandTracker::get_hand_tracking_source); + + ClassDB::bind_method(D_METHOD("set_hand_joint_flags", "joint", "flags"), &XRHandTracker::set_hand_joint_flags); + ClassDB::bind_method(D_METHOD("get_hand_joint_flags", "joint"), &XRHandTracker::get_hand_joint_flags); + + ClassDB::bind_method(D_METHOD("set_hand_joint_transform", "joint", "transform"), &XRHandTracker::set_hand_joint_transform); + ClassDB::bind_method(D_METHOD("get_hand_joint_transform", "joint"), &XRHandTracker::get_hand_joint_transform); + + ClassDB::bind_method(D_METHOD("set_hand_joint_radius", "joint", "radius"), &XRHandTracker::set_hand_joint_radius); + ClassDB::bind_method(D_METHOD("get_hand_joint_radius", "joint"), &XRHandTracker::get_hand_joint_radius); + + ClassDB::bind_method(D_METHOD("set_hand_joint_linear_velocity", "joint", "linear_velocity"), &XRHandTracker::set_hand_joint_linear_velocity); + ClassDB::bind_method(D_METHOD("get_hand_joint_linear_velocity", "joint"), &XRHandTracker::get_hand_joint_linear_velocity); + + ClassDB::bind_method(D_METHOD("set_hand_joint_angular_velocity", "joint", "angular_velocity"), &XRHandTracker::set_hand_joint_angular_velocity); + ClassDB::bind_method(D_METHOD("get_hand_joint_angular_velocity", "joint"), &XRHandTracker::get_hand_joint_angular_velocity); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "hand", PROPERTY_HINT_ENUM, "Left,Right"), "set_hand", "get_hand"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "has_tracking_data", PROPERTY_HINT_NONE), "set_has_tracking_data", "get_has_tracking_data"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "hand_tracking_source", PROPERTY_HINT_ENUM, "Unknown,Unobstructed,Controller"), "set_hand_tracking_source", "get_hand_tracking_source"); + + BIND_ENUM_CONSTANT(HAND_LEFT); + BIND_ENUM_CONSTANT(HAND_RIGHT); + BIND_ENUM_CONSTANT(HAND_MAX); + + BIND_ENUM_CONSTANT(HAND_TRACKING_SOURCE_UNKNOWN); + BIND_ENUM_CONSTANT(HAND_TRACKING_SOURCE_UNOBSTRUCTED); + BIND_ENUM_CONSTANT(HAND_TRACKING_SOURCE_CONTROLLER); + BIND_ENUM_CONSTANT(HAND_TRACKING_SOURCE_MAX); + + BIND_ENUM_CONSTANT(HAND_JOINT_PALM); + BIND_ENUM_CONSTANT(HAND_JOINT_WRIST); + BIND_ENUM_CONSTANT(HAND_JOINT_THUMB_METACARPAL); + BIND_ENUM_CONSTANT(HAND_JOINT_THUMB_PHALANX_PROXIMAL); + BIND_ENUM_CONSTANT(HAND_JOINT_THUMB_PHALANX_DISTAL); + BIND_ENUM_CONSTANT(HAND_JOINT_THUMB_TIP); + BIND_ENUM_CONSTANT(HAND_JOINT_INDEX_FINGER_METACARPAL); + BIND_ENUM_CONSTANT(HAND_JOINT_INDEX_FINGER_PHALANX_PROXIMAL); + BIND_ENUM_CONSTANT(HAND_JOINT_INDEX_FINGER_PHALANX_INTERMEDIATE); + BIND_ENUM_CONSTANT(HAND_JOINT_INDEX_FINGER_PHALANX_DISTAL); + BIND_ENUM_CONSTANT(HAND_JOINT_INDEX_FINGER_TIP); + BIND_ENUM_CONSTANT(HAND_JOINT_MIDDLE_FINGER_METACARPAL); + BIND_ENUM_CONSTANT(HAND_JOINT_MIDDLE_FINGER_PHALANX_PROXIMAL); + BIND_ENUM_CONSTANT(HAND_JOINT_MIDDLE_FINGER_PHALANX_INTERMEDIATE); + BIND_ENUM_CONSTANT(HAND_JOINT_MIDDLE_FINGER_PHALANX_DISTAL); + BIND_ENUM_CONSTANT(HAND_JOINT_MIDDLE_FINGER_TIP); + BIND_ENUM_CONSTANT(HAND_JOINT_RING_FINGER_METACARPAL); + BIND_ENUM_CONSTANT(HAND_JOINT_RING_FINGER_PHALANX_PROXIMAL); + BIND_ENUM_CONSTANT(HAND_JOINT_RING_FINGER_PHALANX_INTERMEDIATE); + BIND_ENUM_CONSTANT(HAND_JOINT_RING_FINGER_PHALANX_DISTAL); + BIND_ENUM_CONSTANT(HAND_JOINT_RING_FINGER_TIP); + BIND_ENUM_CONSTANT(HAND_JOINT_PINKY_FINGER_METACARPAL); + BIND_ENUM_CONSTANT(HAND_JOINT_PINKY_FINGER_PHALANX_PROXIMAL); + BIND_ENUM_CONSTANT(HAND_JOINT_PINKY_FINGER_PHALANX_INTERMEDIATE); + BIND_ENUM_CONSTANT(HAND_JOINT_PINKY_FINGER_PHALANX_DISTAL); + BIND_ENUM_CONSTANT(HAND_JOINT_PINKY_FINGER_TIP); + BIND_ENUM_CONSTANT(HAND_JOINT_MAX); + + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_ORIENTATION_VALID); + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_ORIENTATION_TRACKED); + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_POSITION_VALID); + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_POSITION_TRACKED); + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_LINEAR_VELOCITY_VALID); + BIND_BITFIELD_FLAG(HAND_JOINT_FLAG_ANGULAR_VELOCITY_VALID); +} + +void XRHandTracker::set_hand(XRHandTracker::Hand p_hand) { + hand = p_hand; +} + +XRHandTracker::Hand XRHandTracker::get_hand() const { + return hand; +} + +void XRHandTracker::set_has_tracking_data(bool p_has_tracking_data) { + has_tracking_data = p_has_tracking_data; +} + +bool XRHandTracker::get_has_tracking_data() const { + return has_tracking_data; +} + +void XRHandTracker::set_hand_tracking_source(XRHandTracker::HandTrackingSource p_source) { + hand_tracking_source = p_source; +} + +XRHandTracker::HandTrackingSource XRHandTracker::get_hand_tracking_source() const { + return hand_tracking_source; +} + +void XRHandTracker::set_hand_joint_flags(XRHandTracker::HandJoint p_joint, BitField<XRHandTracker::HandJointFlags> p_flags) { + ERR_FAIL_INDEX(p_joint, HAND_JOINT_MAX); + hand_joint_flags[p_joint] = p_flags; +} + +BitField<XRHandTracker::HandJointFlags> XRHandTracker::get_hand_joint_flags(XRHandTracker::HandJoint p_joint) const { + ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, BitField<HandJointFlags>()); + return hand_joint_flags[p_joint]; +} + +void XRHandTracker::set_hand_joint_transform(XRHandTracker::HandJoint p_joint, const Transform3D &p_transform) { + ERR_FAIL_INDEX(p_joint, HAND_JOINT_MAX); + hand_joint_transforms[p_joint] = p_transform; +} + +Transform3D XRHandTracker::get_hand_joint_transform(XRHandTracker::HandJoint p_joint) const { + ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, Transform3D()); + return hand_joint_transforms[p_joint]; +} + +void XRHandTracker::set_hand_joint_radius(XRHandTracker::HandJoint p_joint, float p_radius) { + ERR_FAIL_INDEX(p_joint, HAND_JOINT_MAX); + hand_joint_radii[p_joint] = p_radius; +} + +float XRHandTracker::get_hand_joint_radius(XRHandTracker::HandJoint p_joint) const { + ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, 0.0); + return hand_joint_radii[p_joint]; +} + +void XRHandTracker::set_hand_joint_linear_velocity(XRHandTracker::HandJoint p_joint, const Vector3 &p_velocity) { + ERR_FAIL_INDEX(p_joint, HAND_JOINT_MAX); + hand_joint_linear_velocities[p_joint] = p_velocity; +} + +Vector3 XRHandTracker::get_hand_joint_linear_velocity(XRHandTracker::HandJoint p_joint) const { + ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, Vector3()); + return hand_joint_linear_velocities[p_joint]; +} + +void XRHandTracker::set_hand_joint_angular_velocity(XRHandTracker::HandJoint p_joint, const Vector3 &p_velocity) { + ERR_FAIL_INDEX(p_joint, HAND_JOINT_MAX); + hand_joint_angular_velocities[p_joint] = p_velocity; +} + +Vector3 XRHandTracker::get_hand_joint_angular_velocity(XRHandTracker::HandJoint p_joint) const { + ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, Vector3()); + return hand_joint_angular_velocities[p_joint]; +} diff --git a/servers/xr/xr_hand_tracker.h b/servers/xr/xr_hand_tracker.h new file mode 100644 index 0000000000..648f02d1f8 --- /dev/null +++ b/servers/xr/xr_hand_tracker.h @@ -0,0 +1,137 @@ +/**************************************************************************/ +/* xr_hand_tracker.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#ifndef XR_HAND_TRACKER_H +#define XR_HAND_TRACKER_H + +#include "core/object/ref_counted.h" + +class XRHandTracker : public RefCounted { + GDCLASS(XRHandTracker, RefCounted); + _THREAD_SAFE_CLASS_ + +public: + enum Hand { + HAND_LEFT, + HAND_RIGHT, + HAND_MAX, + }; + + enum HandTrackingSource { + HAND_TRACKING_SOURCE_UNKNOWN, + HAND_TRACKING_SOURCE_UNOBSTRUCTED, + HAND_TRACKING_SOURCE_CONTROLLER, + HAND_TRACKING_SOURCE_MAX + }; + + enum HandJoint { + HAND_JOINT_PALM, + HAND_JOINT_WRIST, + HAND_JOINT_THUMB_METACARPAL, + HAND_JOINT_THUMB_PHALANX_PROXIMAL, + HAND_JOINT_THUMB_PHALANX_DISTAL, + HAND_JOINT_THUMB_TIP, + HAND_JOINT_INDEX_FINGER_METACARPAL, + HAND_JOINT_INDEX_FINGER_PHALANX_PROXIMAL, + HAND_JOINT_INDEX_FINGER_PHALANX_INTERMEDIATE, + HAND_JOINT_INDEX_FINGER_PHALANX_DISTAL, + HAND_JOINT_INDEX_FINGER_TIP, + HAND_JOINT_MIDDLE_FINGER_METACARPAL, + HAND_JOINT_MIDDLE_FINGER_PHALANX_PROXIMAL, + HAND_JOINT_MIDDLE_FINGER_PHALANX_INTERMEDIATE, + HAND_JOINT_MIDDLE_FINGER_PHALANX_DISTAL, + HAND_JOINT_MIDDLE_FINGER_TIP, + HAND_JOINT_RING_FINGER_METACARPAL, + HAND_JOINT_RING_FINGER_PHALANX_PROXIMAL, + HAND_JOINT_RING_FINGER_PHALANX_INTERMEDIATE, + HAND_JOINT_RING_FINGER_PHALANX_DISTAL, + HAND_JOINT_RING_FINGER_TIP, + HAND_JOINT_PINKY_FINGER_METACARPAL, + HAND_JOINT_PINKY_FINGER_PHALANX_PROXIMAL, + HAND_JOINT_PINKY_FINGER_PHALANX_INTERMEDIATE, + HAND_JOINT_PINKY_FINGER_PHALANX_DISTAL, + HAND_JOINT_PINKY_FINGER_TIP, + HAND_JOINT_MAX, + }; + + enum HandJointFlags { + HAND_JOINT_FLAG_ORIENTATION_VALID = 1, + HAND_JOINT_FLAG_ORIENTATION_TRACKED = 2, + HAND_JOINT_FLAG_POSITION_VALID = 4, + HAND_JOINT_FLAG_POSITION_TRACKED = 8, + HAND_JOINT_FLAG_LINEAR_VELOCITY_VALID = 16, + HAND_JOINT_FLAG_ANGULAR_VELOCITY_VALID = 32, + }; + + void set_hand(Hand p_hand); + Hand get_hand() const; + + void set_has_tracking_data(bool p_has_tracking_data); + bool get_has_tracking_data() const; + + void set_hand_tracking_source(HandTrackingSource p_source); + HandTrackingSource get_hand_tracking_source() const; + + void set_hand_joint_flags(HandJoint p_joint, BitField<HandJointFlags> p_flags); + BitField<HandJointFlags> get_hand_joint_flags(HandJoint p_joint) const; + + void set_hand_joint_transform(HandJoint p_joint, const Transform3D &p_transform); + Transform3D get_hand_joint_transform(HandJoint p_joint) const; + + void set_hand_joint_radius(HandJoint p_joint, float p_radius); + float get_hand_joint_radius(HandJoint p_joint) const; + + void set_hand_joint_linear_velocity(HandJoint p_joint, const Vector3 &p_velocity); + Vector3 get_hand_joint_linear_velocity(HandJoint p_joint) const; + + void set_hand_joint_angular_velocity(HandJoint p_joint, const Vector3 &p_velocity); + Vector3 get_hand_joint_angular_velocity(HandJoint p_joint) const; + +protected: + static void _bind_methods(); + +private: + Hand hand = HAND_LEFT; + bool has_tracking_data = false; + HandTrackingSource hand_tracking_source = HAND_TRACKING_SOURCE_UNKNOWN; + + BitField<HandJointFlags> hand_joint_flags[HAND_JOINT_MAX]; + Transform3D hand_joint_transforms[HAND_JOINT_MAX]; + float hand_joint_radii[HAND_JOINT_MAX] = {}; + Vector3 hand_joint_linear_velocities[HAND_JOINT_MAX]; + Vector3 hand_joint_angular_velocities[HAND_JOINT_MAX]; +}; + +VARIANT_ENUM_CAST(XRHandTracker::Hand) +VARIANT_ENUM_CAST(XRHandTracker::HandTrackingSource) +VARIANT_ENUM_CAST(XRHandTracker::HandJoint) +VARIANT_BITFIELD_CAST(XRHandTracker::HandJointFlags) + +#endif // XR_HAND_TRACKER_H diff --git a/servers/xr_server.cpp b/servers/xr_server.cpp index b3bb0a3702..1e497e22c3 100644 --- a/servers/xr_server.cpp +++ b/servers/xr_server.cpp @@ -31,6 +31,7 @@ #include "xr_server.h" #include "core/config/project_settings.h" #include "xr/xr_face_tracker.h" +#include "xr/xr_hand_tracker.h" #include "xr/xr_interface.h" #include "xr/xr_positional_tracker.h" @@ -75,6 +76,11 @@ void XRServer::_bind_methods() { ClassDB::bind_method(D_METHOD("get_trackers", "tracker_types"), &XRServer::get_trackers); ClassDB::bind_method(D_METHOD("get_tracker", "tracker_name"), &XRServer::get_tracker); + ClassDB::bind_method(D_METHOD("add_hand_tracker", "tracker_name", "hand_tracker"), &XRServer::add_hand_tracker); + ClassDB::bind_method(D_METHOD("remove_hand_tracker", "tracker_name"), &XRServer::remove_hand_tracker); + ClassDB::bind_method(D_METHOD("get_hand_trackers"), &XRServer::get_hand_trackers); + ClassDB::bind_method(D_METHOD("get_hand_tracker", "tracker_name"), &XRServer::get_hand_tracker); + ClassDB::bind_method(D_METHOD("add_face_tracker", "tracker_name", "face_tracker"), &XRServer::add_face_tracker); ClassDB::bind_method(D_METHOD("remove_face_tracker", "tracker_name"), &XRServer::remove_face_tracker); ClassDB::bind_method(D_METHOD("get_face_trackers"), &XRServer::get_face_trackers); @@ -104,6 +110,10 @@ void XRServer::_bind_methods() { ADD_SIGNAL(MethodInfo("tracker_updated", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type"))); ADD_SIGNAL(MethodInfo("tracker_removed", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::INT, "type"))); + ADD_SIGNAL(MethodInfo("hand_tracker_added", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::OBJECT, "hand_tracker", PROPERTY_HINT_RESOURCE_TYPE, "XRHandTracker"))); + ADD_SIGNAL(MethodInfo("hand_tracker_updated", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::OBJECT, "hand_tracker", PROPERTY_HINT_RESOURCE_TYPE, "XRHandTracker"))); + ADD_SIGNAL(MethodInfo("hand_tracker_removed", PropertyInfo(Variant::STRING_NAME, "tracker_name"))); + ADD_SIGNAL(MethodInfo("face_tracker_added", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::OBJECT, "face_tracker", PROPERTY_HINT_RESOURCE_TYPE, "XRFaceTracker"))); ADD_SIGNAL(MethodInfo("face_tracker_updated", PropertyInfo(Variant::STRING_NAME, "tracker_name"), PropertyInfo(Variant::OBJECT, "face_tracker", PROPERTY_HINT_RESOURCE_TYPE, "XRFaceTracker"))); ADD_SIGNAL(MethodInfo("face_tracker_removed", PropertyInfo(Variant::STRING_NAME, "tracker_name"))); @@ -362,6 +372,44 @@ PackedStringArray XRServer::get_suggested_pose_names(const StringName &p_tracker return arr; } +void XRServer::add_hand_tracker(const StringName &p_tracker_name, Ref<XRHandTracker> p_hand_tracker) { + ERR_FAIL_COND(p_hand_tracker.is_null()); + + if (!hand_trackers.has(p_tracker_name)) { + // We don't have a tracker with this name, we're going to add it. + hand_trackers[p_tracker_name] = p_hand_tracker; + emit_signal(SNAME("hand_tracker_added"), p_tracker_name, p_hand_tracker); + } else if (hand_trackers[p_tracker_name] != p_hand_tracker) { + // We already have a tracker with this name, we're going to replace it. + hand_trackers[p_tracker_name] = p_hand_tracker; + emit_signal(SNAME("hand_tracker_updated"), p_tracker_name, p_hand_tracker); + } +} + +void XRServer::remove_hand_tracker(const StringName &p_tracker_name) { + // Skip if no hand tracker is found. + if (!hand_trackers.has(p_tracker_name)) { + return; + } + + // Send the removed signal, then remove the hand tracker. + emit_signal(SNAME("hand_tracker_removed"), p_tracker_name); + hand_trackers.erase(p_tracker_name); +} + +Dictionary XRServer::get_hand_trackers() const { + return hand_trackers; +} + +Ref<XRHandTracker> XRServer::get_hand_tracker(const StringName &p_tracker_name) const { + // Skip if no tracker is found. + if (!hand_trackers.has(p_tracker_name)) { + return Ref<XRHandTracker>(); + } + + return hand_trackers[p_tracker_name]; +} + void XRServer::add_face_tracker(const StringName &p_tracker_name, Ref<XRFaceTracker> p_face_tracker) { ERR_FAIL_COND(p_face_tracker.is_null()); diff --git a/servers/xr_server.h b/servers/xr_server.h index 0a4e020a1f..3e45bbb76c 100644 --- a/servers/xr_server.h +++ b/servers/xr_server.h @@ -39,6 +39,7 @@ class XRInterface; class XRPositionalTracker; +class XRHandTracker; class XRFaceTracker; /** @@ -86,7 +87,7 @@ private: Vector<Ref<XRInterface>> interfaces; Dictionary trackers; - + Dictionary hand_trackers; Dictionary face_trackers; Ref<XRInterface> primary_interface; /* we'll identify one interface as primary, this will be used by our viewports */ @@ -187,6 +188,14 @@ public: // Q: Should we add get_suggested_input_names and get_suggested_haptic_names even though we don't use them for the IDE? /* + Hand trackers are objects that expose the tracked joints of a hand. + */ + void add_hand_tracker(const StringName &p_tracker_name, Ref<XRHandTracker> p_hand_tracker); + void remove_hand_tracker(const StringName &p_tracker_name); + Dictionary get_hand_trackers() const; + Ref<XRHandTracker> get_hand_tracker(const StringName &p_tracker_name) const; + + /* Face trackers are objects that expose the tracked blend shapes of a face. */ void add_face_tracker(const StringName &p_tracker_name, Ref<XRFaceTracker> p_face_tracker); |