Add XR_FB_hand_tracking_capsules extension wrapper and OpenXRFbHandTrackingCapsules node

.gitignore

@@ -24,3 +24,4 @@ local.properties
 
 # Misc
 .DS_Store
+~*.dll

CHANGES.md

@@ -7,6 +7,7 @@
 - Update to OpenXR 1.0.34 headers
 - Add XR_FB_render_model extension wrapper and OpenXRFBRenderModel node
 - Add XR_FB_passthrough extension wrapper
+- Add XR_FB_hand_tracking_capsules extension wrapper and OpenXRFbHandTrackingCapsules node
 
 ## 2.0.3
 - Migrate the export scripts from gdscript to C++ via gdextension

common/src/main/cpp/classes/openxr_fb_hand_tracking_capsules.cpp

@@ -0,0 +1,291 @@
+/**************************************************************************/
+/*  openxr_fb_hand_tracking_capsules.cpp                                  */
+/**************************************************************************/
+/*                       This file is part of:                            */
+/*                              GODOT XR                                  */
+/*                      https://godotengine.org                           */
+/**************************************************************************/
+/* Copyright (c) 2022-present Godot XR contributors (see CONTRIBUTORS.md) */
+/*                                                                        */
+/* 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 "classes/openxr_fb_hand_tracking_capsules.h"
+
+#include "extensions/openxr_fb_hand_tracking_capsules_extension_wrapper.h"
+
+#include <godot_cpp/classes/capsule_shape3d.hpp>
+#include <godot_cpp/classes/collision_shape3d.hpp>
+#include <godot_cpp/classes/engine.hpp>
+#include <godot_cpp/classes/xr_origin3d.hpp>
+
+using namespace godot;
+
+void OpenXRFbHandTrackingCapsules::_ready() {
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		AnimatableBody3D *animatable_body = memnew(AnimatableBody3D);
+		animatable_bodies[i] = animatable_body;
+
+		animatable_body->set_sync_to_physics(sync_to_physics);
+		animatable_body->set_physics_material_override(physics_material_override);
+		animatable_body->set_constant_linear_velocity(constant_linear_velocity);
+		animatable_body->set_constant_angular_velocity(constant_angular_velocity);
+		animatable_body->set_disable_mode(disable_mode);
+		animatable_body->set_collision_layer(collision_layer);
+		animatable_body->set_collision_mask(collision_mask);
+
+		CollisionShape3D *collision_shape = memnew(CollisionShape3D);
+		Ref<CapsuleShape3D> shape;
+		shape.instantiate();
+		collision_shape->set_shape(shape);
+		animatable_body->add_child(collision_shape);
+	}
+}
+
+void OpenXRFbHandTrackingCapsules::_physics_process(double delta) {
+	if (!Engine::get_singleton()->is_editor_hint()) {
+		place_capsules();
+	}
+}
+
+void OpenXRFbHandTrackingCapsules::place_capsules() {
+	XrHandCapsuleFB *capsules = OpenXRFbHandTrackingCapsulesExtensionWrapper::get_singleton()->get_hand_capsules(hand);
+
+	// points will be NaN until an instance of valid hand tracking takes place for corresponding hand
+	if (Math::is_nan(capsules[0].points[0].x)) {
+		return;
+	}
+
+	// on first instance of valid hand tracking, add the animatable bodies to the scene tree
+	if (!are_bodies_in_scene_tree) {
+		for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+			add_child(animatable_bodies[i]);
+		}
+		are_bodies_in_scene_tree = true;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		XrHandCapsuleFB capsule = capsules[i];
+
+		XrVector3f xr_vec1 = capsules[i].points[0];
+		XrVector3f xr_vec2 = capsules[i].points[1];
+		Vector3 vec1 = Vector3(xr_vec1.x, xr_vec1.y, xr_vec1.z);
+		Vector3 vec2 = Vector3(xr_vec2.x, xr_vec2.y, xr_vec2.z);
+
+		AnimatableBody3D *animatable_body = animatable_bodies[i];
+		CollisionShape3D *collision_shape;
+		for (int i = 0; i < animatable_body->get_child_count(); i++) {
+			collision_shape = Object::cast_to<CollisionShape3D>(animatable_body->get_child(i));
+			if (collision_shape) {
+				break;
+			}
+		}
+
+		if (collision_shape == nullptr) {
+			continue;
+		}
+
+		float height = vec1.distance_to(vec2);
+		Ref<CapsuleShape3D> shape = collision_shape->get_shape();
+		shape->set_height(height);
+		shape->set_radius(capsule.radius);
+
+		Vector3 y_dir = (vec2 - vec1).normalized();
+		Vector3 x_dir;
+		if (y_dir.is_equal_approx(Vector3(0, 1, 0))) {
+			x_dir = y_dir.cross(Vector3(1, 0, 0)).normalized();
+		} else {
+			x_dir = y_dir.cross(Vector3(0, 1, 0)).normalized();
+		}
+		Vector3 z_dir = y_dir.cross(x_dir).normalized();
+		Basis basis = Basis(x_dir, y_dir, z_dir);
+		Vector3 center = (vec1 + vec2) / 2.0;
+
+		if (basis.determinant() == 0.0) {
+			continue;
+		}
+
+		animatable_body->set_transform(Transform3D(basis, center));
+	}
+}
+
+void OpenXRFbHandTrackingCapsules::set_hand(Hand p_hand) {
+	hand = p_hand;
+}
+
+OpenXRFbHandTrackingCapsules::Hand OpenXRFbHandTrackingCapsules::get_hand() const {
+	return hand;
+}
+
+void OpenXRFbHandTrackingCapsules::set_sync_to_physics(bool p_enable) {
+	sync_to_physics = p_enable;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_sync_to_physics(sync_to_physics);
+	}
+}
+
+bool OpenXRFbHandTrackingCapsules::is_sync_to_physics_enabled() const {
+	return sync_to_physics;
+}
+
+void OpenXRFbHandTrackingCapsules::set_physics_material_override(const Ref<PhysicsMaterial> &p_physics_material_override) {
+	physics_material_override = p_physics_material_override;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_physics_material_override(physics_material_override);
+	}
+}
+
+Ref<PhysicsMaterial> OpenXRFbHandTrackingCapsules::get_physics_material_override() const {
+	return physics_material_override;
+}
+
+void OpenXRFbHandTrackingCapsules::set_constant_linear_velocity(const Vector3 &p_vel) {
+	constant_linear_velocity = p_vel;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_constant_linear_velocity(constant_linear_velocity);
+	}
+}
+
+Vector3 OpenXRFbHandTrackingCapsules::get_constant_linear_velocity() const {
+	return constant_linear_velocity;
+}
+
+void OpenXRFbHandTrackingCapsules::set_constant_angular_velocity(const Vector3 &p_vel) {
+	constant_angular_velocity = p_vel;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_constant_angular_velocity(constant_angular_velocity);
+	}
+}
+
+Vector3 OpenXRFbHandTrackingCapsules::get_constant_angular_velocity() const {
+	return constant_angular_velocity;
+}
+
+void OpenXRFbHandTrackingCapsules::set_disable_mode(CollisionObject3D::DisableMode p_mode) {
+	disable_mode = p_mode;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_disable_mode(disable_mode);
+	}
+}
+
+CollisionObject3D::DisableMode OpenXRFbHandTrackingCapsules::get_disable_mode() const {
+	return disable_mode;
+}
+
+void OpenXRFbHandTrackingCapsules::set_collision_layer(uint32_t p_layer) {
+	collision_layer = p_layer;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_collision_layer(collision_layer);
+	}
+}
+
+uint32_t OpenXRFbHandTrackingCapsules::get_collision_layer() const {
+	return collision_layer;
+}
+
+void OpenXRFbHandTrackingCapsules::set_collision_mask(uint32_t p_mask) {
+	collision_mask = p_mask;
+
+	if (!is_node_ready()) {
+		return;
+	}
+
+	for (int i = 0; i < XR_HAND_TRACKING_CAPSULE_COUNT_FB; i++) {
+		animatable_bodies[i]->set_collision_mask(collision_mask);
+	}
+}
+
+uint32_t OpenXRFbHandTrackingCapsules::get_collision_mask() const {
+	return collision_mask;
+}
+
+PackedStringArray OpenXRFbHandTrackingCapsules::_get_configuration_warnings() const {
+	PackedStringArray warnings = Node::_get_configuration_warnings();
+
+	XROrigin3D *origin = Object::cast_to<XROrigin3D>(get_parent());
+	if (origin == nullptr) {
+		warnings.push_back("OpenXRFbHandTrackingCapsules must have an XROrigin3D node as its parent.");
+	}
+
+	return warnings;
+}
+
+void OpenXRFbHandTrackingCapsules::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_hand", "hand"), &OpenXRFbHandTrackingCapsules::set_hand);
+	ClassDB::bind_method(D_METHOD("get_hand"), &OpenXRFbHandTrackingCapsules::get_hand);
+	ClassDB::bind_method(D_METHOD("set_sync_to_physics", "enable"), &OpenXRFbHandTrackingCapsules::set_sync_to_physics);
+	ClassDB::bind_method(D_METHOD("is_sync_to_physics_enabled"), &OpenXRFbHandTrackingCapsules::is_sync_to_physics_enabled);
+	ClassDB::bind_method(D_METHOD("set_physics_material_override", "physics_material_override"), &OpenXRFbHandTrackingCapsules::set_physics_material_override);
+	ClassDB::bind_method(D_METHOD("get_physics_material_override"), &OpenXRFbHandTrackingCapsules::get_physics_material_override);
+	ClassDB::bind_method(D_METHOD("set_constant_linear_velocity", "vel"), &OpenXRFbHandTrackingCapsules::set_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_linear_velocity"), &OpenXRFbHandTrackingCapsules::get_constant_linear_velocity);
+	ClassDB::bind_method(D_METHOD("set_constant_angular_velocity", "vel"), &OpenXRFbHandTrackingCapsules::set_constant_angular_velocity);
+	ClassDB::bind_method(D_METHOD("get_constant_angular_velocity"), &OpenXRFbHandTrackingCapsules::get_constant_angular_velocity);
+	ClassDB::bind_method(D_METHOD("set_disable_mode", "mode"), &OpenXRFbHandTrackingCapsules::set_disable_mode);
+	ClassDB::bind_method(D_METHOD("get_disable_mode"), &OpenXRFbHandTrackingCapsules::get_disable_mode);
+	ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &OpenXRFbHandTrackingCapsules::set_collision_layer);
+	ClassDB::bind_method(D_METHOD("get_collision_layer"), &OpenXRFbHandTrackingCapsules::get_collision_layer);
+	ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &OpenXRFbHandTrackingCapsules::set_collision_mask);
+	ClassDB::bind_method(D_METHOD("get_collision_mask"), &OpenXRFbHandTrackingCapsules::get_collision_mask);
+
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "hand", PROPERTY_HINT_ENUM, "Left,Right"), "set_hand", "get_hand");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sync_to_physics"), "set_sync_to_physics", "is_sync_to_physics_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material_override", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material_override", "get_physics_material_override");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_linear_velocity", PROPERTY_HINT_NONE, "suffix:m/s"), "set_constant_linear_velocity", "get_constant_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "constant_angular_velocity", PROPERTY_HINT_NONE, U"radians_as_degrees,suffix:\u00B0/s"), "set_constant_angular_velocity", "get_constant_angular_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "disable_mode", PROPERTY_HINT_ENUM, "Remove,Make Static,Keep Active"), "set_disable_mode", "get_disable_mode");
+
+	ADD_GROUP("Collision", "collision_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+
+	BIND_ENUM_CONSTANT(LEFT_HAND);
+	BIND_ENUM_CONSTANT(RIGHT_HAND);
+}

common/src/main/cpp/extensions/openxr_fb_hand_tracking_capsules_extension_wrapper.cpp

@@ -0,0 +1,91 @@
+/**************************************************************************/
+/*  openxr_fb_hand_tracking_capsules_extension_wrapper.cpp                */
+/**************************************************************************/
+/*                       This file is part of:                            */
+/*                              GODOT XR                                  */
+/*                      https://godotengine.org                           */
+/**************************************************************************/
+/* Copyright (c) 2022-present Godot XR contributors (see CONTRIBUTORS.md) */
+/*                                                                        */
+/* 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 "extensions/openxr_fb_hand_tracking_capsules_extension_wrapper.h"
+
+using namespace godot;
+
+OpenXRFbHandTrackingCapsulesExtensionWrapper *OpenXRFbHandTrackingCapsulesExtensionWrapper::singleton = nullptr;
+
+OpenXRFbHandTrackingCapsulesExtensionWrapper *OpenXRFbHandTrackingCapsulesExtensionWrapper::get_singleton() {
+	if (singleton == nullptr) {
+		singleton = memnew(OpenXRFbHandTrackingCapsulesExtensionWrapper());
+	}
+	return singleton;
+}
+
+OpenXRFbHandTrackingCapsulesExtensionWrapper::OpenXRFbHandTrackingCapsulesExtensionWrapper() :
+		OpenXRExtensionWrapperExtension() {
+	ERR_FAIL_COND_MSG(singleton != nullptr, "An OpenXRFbHandTrackingCapsulesExtensionWrapper singleton already exists.");
+
+	request_extensions[XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME] = &fb_hand_tracking_capsules_ext;
+	singleton = this;
+}
+
+OpenXRFbHandTrackingCapsulesExtensionWrapper::~OpenXRFbHandTrackingCapsulesExtensionWrapper() {
+	cleanup();
+}
+
+void OpenXRFbHandTrackingCapsulesExtensionWrapper::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("is_enabled"), &OpenXRFbHandTrackingCapsulesExtensionWrapper::is_enabled);
+}
+
+void OpenXRFbHandTrackingCapsulesExtensionWrapper::cleanup() {
+	fb_hand_tracking_capsules_ext = false;
+}
+
+godot::Dictionary OpenXRFbHandTrackingCapsulesExtensionWrapper::_get_requested_extensions() {
+	godot::Dictionary result;
+	for (auto ext : request_extensions) {
+		godot::String key = ext.first;
+		uint64_t value = reinterpret_cast<uint64_t>(ext.second);
+		result[key] = (godot::Variant)value;
+	}
+	return result;
+}
+
+void OpenXRFbHandTrackingCapsulesExtensionWrapper::_on_instance_destroyed() {
+	cleanup();
+}
+
+uint64_t OpenXRFbHandTrackingCapsulesExtensionWrapper::_set_hand_joint_locations_and_get_next_pointer(int32_t p_hand_index, void *p_next_pointer) {
+	if (!fb_hand_tracking_capsules_ext) {
+		return reinterpret_cast<uint64_t>(p_next_pointer);
+	}
+
+	capsules_state[p_hand_index].type = XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB;
+	capsules_state[p_hand_index].next = p_next_pointer;
+
+	return reinterpret_cast<uint64_t>(&capsules_state[p_hand_index]);
+}
+
+XrHandCapsuleFB *OpenXRFbHandTrackingCapsulesExtensionWrapper::get_hand_capsules(int p_hand_index) {
+	ERR_FAIL_COND_V_MSG(!is_enabled(), nullptr, "OpenXR extension XR_FB_hand_tracking_capsules is not available");
+	return capsules_state[p_hand_index].capsules;
+}