BIND_BITFIELD_FLAG(JOINT_FLAG_POSITION_TRACKED);

}

void XRBodyTracker::set_has_tracking_data(bool p_has_tracking_data) {

has_tracking_data = p_has_tracking_data;

}

ERR_FAIL_INDEX_V(p_joint, JOINT_MAX, Transform3D());

return joint_transforms[p_joint];

}

#ifndef XR_BODY_TRACKER_H

#define XR_BODY_TRACKER_H

_THREAD_SAFE_CLASS_

public:

JOINT_FLAG_POSITION_TRACKED = 8,

};

void set_has_tracking_data(bool p_has_tracking_data);

bool get_has_tracking_data() const;

void set_joint_transform(Joint p_joint, const Transform3D &p_transform);

Transform3D get_joint_transform(Joint p_joint) const;

protected:

static void _bind_methods();

ADD_PROPERTY_DEFAULT("blend_shapes", PackedFloat32Array()); // To prevent ludicrously large default values.

}

float XRFaceTracker::get_blend_shape(BlendShapeEntry p_blend_shape) const {

// Fail if the blend shape index is out of range.

ERR_FAIL_INDEX_V(p_blend_shape, FT_MAX, 0.0f);

// Copy the blend shape values into the blend shape array.

memcpy(blend_shape_values, p_blend_shapes.ptr(), sizeof(blend_shape_values));

}

#ifndef XR_FACE_TRACKER_H

#define XR_FACE_TRACKER_H

/**

The XRFaceTracker class provides face blend shape weights.

and Meta Movement standards.

*/

_THREAD_SAFE_CLASS_

public:

FT_MAX // Maximum blend shape.

};

float get_blend_shape(BlendShapeEntry p_blend_shape) const;

void set_blend_shape(BlendShapeEntry p_blend_shape, float p_value);

PackedFloat32Array get_blend_shapes() const;

void set_blend_shapes(const PackedFloat32Array &p_blend_shapes);

protected:

static void _bind_methods();

#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_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::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_BITFIELD_FLAG(HAND_JOINT_FLAG_ANGULAR_VELOCITY_VALID);

}

void XRHandTracker::set_hand(XRHandTracker::Hand p_hand) {

}

XRHandTracker::Hand XRHandTracker::get_hand() const {

ERR_FAIL_INDEX_V(p_joint, HAND_JOINT_MAX, Vector3());

return hand_joint_angular_velocities[p_joint];

}

#ifndef XR_HAND_TRACKER_H

#define XR_HAND_TRACKER_H

_THREAD_SAFE_CLASS_

public:

HAND_JOINT_FLAG_ANGULAR_VELOCITY_VALID = 32,

};

void set_hand(Hand p_hand);

Hand get_hand() 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();

#include "xr_positional_tracker.h"

#include "core/input/input.h"

void XRPositionalTracker::_bind_methods() {

BIND_ENUM_CONSTANT(TRACKER_HAND_UNKNOWN);

BIND_ENUM_CONSTANT(TRACKER_HAND_LEFT);

BIND_ENUM_CONSTANT(TRACKER_HAND_RIGHT);

ClassDB::bind_method(D_METHOD("get_tracker_profile"), &XRPositionalTracker::get_tracker_profile);

ClassDB::bind_method(D_METHOD("set_tracker_profile", "profile"), &XRPositionalTracker::set_tracker_profile);

ADD_SIGNAL(MethodInfo("profile_changed", PropertyInfo(Variant::STRING, "role")));

};

void XRPositionalTracker::set_tracker_profile(const String &p_profile) {

if (profile != p_profile) {

profile = p_profile;

}

XRPositionalTracker::TrackerHand XRPositionalTracker::get_tracker_hand() const {

};

void XRPositionalTracker::set_tracker_hand(const XRPositionalTracker::TrackerHand p_hand) {

};

bool XRPositionalTracker::has_pose(const StringName &p_action_name) const {

}

Variant XRPositionalTracker::get_input(const StringName &p_action_name) const {

if (inputs.has(p_action_name)) {

return inputs[p_action_name];

} else {

}

void XRPositionalTracker::set_input(const StringName &p_action_name, const Variant &p_value) {

// XR inputs

if (inputs.has(p_action_name)) {

changed = inputs[p_action_name] != p_value;

} else {

}

}

}

#include "core/os/thread_safe.h"

#include "scene/resources/mesh.h"

#include "servers/xr/xr_pose.h"

#include "servers/xr_server.h"

/**

This is where potentially additional AR/VR interfaces may be active as there are AR/VR SDKs that solely deal with positional tracking.

*/

_THREAD_SAFE_CLASS_

public:

enum TrackerHand {

TRACKER_HAND_UNKNOWN, /* unknown or not applicable */

TRACKER_HAND_LEFT, /* controller is the left hand controller */

};

String profile; // this is interface dependent, for OpenXR this will be the interaction profile bound for to the tracker

HashMap<StringName, Ref<XRPose>> poses;

HashMap<StringName, Variant> inputs;

static void _bind_methods();

public:

void set_tracker_profile(const String &p_profile);

String get_tracker_profile() const;

XRPositionalTracker::TrackerHand get_tracker_hand() const;

bool has_pose(const StringName &p_action_name) const;

Ref<XRPose> get_pose(const StringName &p_action_name) const;

Variant get_input(const StringName &p_action_name) const;

void set_input(const StringName &p_action_name, const Variant &p_value);

};

VARIANT_ENUM_CAST(XRPositionalTracker::TrackerHand);