openxr_interface.cpp | Explore in Territory

/**************************************************************************/
/*  openxr_interface.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 "openxr_interface.h"

#include "core/io/resource_loader.h"
#include "core/io/resource_saver.h"
#include "servers/rendering/rendering_server_globals.h"

#include "extensions/openxr_eye_gaze_interaction.h"
#include "extensions/openxr_hand_interaction_extension.h"

#include <openxr/openxr.h>

void OpenXRInterface::_bind_methods() { … }

StringName OpenXRInterface::get_name() const { … }

uint32_t OpenXRInterface::get_capabilities() const { … }

PackedStringArray OpenXRInterface::get_suggested_tracker_names() const { … }

XRInterface::TrackingStatus OpenXRInterface::get_tracking_status() const { … }

void OpenXRInterface::_load_action_map() { … }

OpenXRInterface::ActionSet *OpenXRInterface::create_action_set(const String &p_action_set_name, const String &p_localized_name, const int p_priority) { … }

void OpenXRInterface::free_action_sets() { … }

OpenXRInterface::Action *OpenXRInterface::create_action(ActionSet *p_action_set, const String &p_action_name, const String &p_localized_name, OpenXRAction::ActionType p_action_type, const Vector<Tracker *> p_trackers) { … }

OpenXRInterface::Action *OpenXRInterface::find_action(const String &p_action_name) { … }

void OpenXRInterface::free_actions(ActionSet *p_action_set) { … }

OpenXRInterface::Tracker *OpenXRInterface::find_tracker(const String &p_tracker_name, bool p_create) { … }

void OpenXRInterface::tracker_profile_changed(RID p_tracker, RID p_interaction_profile) { … }

void OpenXRInterface::handle_tracker(Tracker *p_tracker) { … }

void OpenXRInterface::trigger_haptic_pulse(const String &p_action_name, const StringName &p_tracker_name, double p_frequency, double p_amplitude, double p_duration_sec, double p_delay_sec) { … }

void OpenXRInterface::free_trackers() { … }

void OpenXRInterface::free_interaction_profiles() { … }

bool OpenXRInterface::initialize_on_startup() const { … }

bool OpenXRInterface::is_initialized() const { … }

bool OpenXRInterface::initialize() { … }

void OpenXRInterface::uninitialize() { … }

Dictionary OpenXRInterface::get_system_info() { … }

bool OpenXRInterface::supports_play_area_mode(XRInterface::PlayAreaMode p_mode) { … }

XRInterface::PlayAreaMode OpenXRInterface::get_play_area_mode() const { … }

bool OpenXRInterface::set_play_area_mode(XRInterface::PlayAreaMode p_mode) { … }

PackedVector3Array OpenXRInterface::get_play_area() const { … }

float OpenXRInterface::get_display_refresh_rate() const { … }

void OpenXRInterface::set_display_refresh_rate(float p_refresh_rate) { … }

Array OpenXRInterface::get_available_display_refresh_rates() const { … }

bool OpenXRInterface::is_hand_tracking_supported() { … }

bool OpenXRInterface::is_hand_interaction_supported() const { … }

bool OpenXRInterface::is_eye_gaze_interaction_supported() { … }

bool OpenXRInterface::is_action_set_active(const String &p_action_set) const { … }

void OpenXRInterface::set_action_set_active(const String &p_action_set, bool p_active) { … }

Array OpenXRInterface::get_action_sets() const { … }

float OpenXRInterface::get_vrs_min_radius() const { … }

void OpenXRInterface::set_vrs_min_radius(float p_vrs_min_radius) { … }

float OpenXRInterface::get_vrs_strength() const { … }

void OpenXRInterface::set_vrs_strength(float p_vrs_strength) { … }

double OpenXRInterface::get_render_target_size_multiplier() const { … }

void OpenXRInterface::set_render_target_size_multiplier(double multiplier) { … }

bool OpenXRInterface::is_foveation_supported() const { … }

int OpenXRInterface::get_foveation_level() const { … }

void OpenXRInterface::set_foveation_level(int p_foveation_level) { … }

bool OpenXRInterface::get_foveation_dynamic() const { … }

void OpenXRInterface::set_foveation_dynamic(bool p_foveation_dynamic) { … }

Size2 OpenXRInterface::get_render_target_size() { … }

uint32_t OpenXRInterface::get_view_count() { … }

void OpenXRInterface::_set_default_pos(Transform3D &p_transform, double p_world_scale, uint64_t p_eye) { … }

Transform3D OpenXRInterface::get_camera_transform() { … }

Transform3D OpenXRInterface::get_transform_for_view(uint32_t p_view, const Transform3D &p_cam_transform) { … }

Projection OpenXRInterface::get_projection_for_view(uint32_t p_view, double p_aspect, double p_z_near, double p_z_far) { … }

RID OpenXRInterface::get_color_texture() { … }

RID OpenXRInterface::get_depth_texture() { … }

void OpenXRInterface::handle_hand_tracking(const String &p_path, OpenXRHandTrackingExtension::HandTrackedHands p_hand) { … }

void OpenXRInterface::process() { … }

void OpenXRInterface::pre_render() { … }

bool OpenXRInterface::pre_draw_viewport(RID p_render_target) { … }

Vector<BlitToScreen> OpenXRInterface::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) { … }

void OpenXRInterface::end_frame() { … }

bool OpenXRInterface::is_passthrough_supported() { … }

bool OpenXRInterface::is_passthrough_enabled() { … }

bool OpenXRInterface::start_passthrough() { … }

void OpenXRInterface::stop_passthrough() { … }

Array OpenXRInterface::get_supported_environment_blend_modes() { … }

XRInterface::EnvironmentBlendMode OpenXRInterface::get_environment_blend_mode() const { … }

bool OpenXRInterface::set_environment_blend_mode(XRInterface::EnvironmentBlendMode mode) { … }

void OpenXRInterface::on_state_ready() { … }

void OpenXRInterface::on_state_visible() { … }

void OpenXRInterface::on_state_focused() { … }

void OpenXRInterface::on_state_stopping() { … }

void OpenXRInterface::on_state_loss_pending() { … }

void OpenXRInterface::on_state_exiting() { … }

void OpenXRInterface::on_reference_space_change_pending() { … }

void OpenXRInterface::on_refresh_rate_changes(float p_new_rate) { … }

/** Hand tracking. */
void OpenXRInterface::set_motion_range(const Hand p_hand, const HandMotionRange p_motion_range) { … }

OpenXRInterface::HandMotionRange OpenXRInterface::get_motion_range(const Hand p_hand) const { … }

OpenXRInterface::HandTrackedSource OpenXRInterface::get_hand_tracking_source(const Hand p_hand) const { … }

BitField<OpenXRInterface::HandJointFlags> OpenXRInterface::get_hand_joint_flags(Hand p_hand, HandJoints p_joint) const { … }

Quaternion OpenXRInterface::get_hand_joint_rotation(Hand p_hand, HandJoints p_joint) const { … }

Vector3 OpenXRInterface::get_hand_joint_position(Hand p_hand, HandJoints p_joint) const { … }

float OpenXRInterface::get_hand_joint_radius(Hand p_hand, HandJoints p_joint) const { … }

Vector3 OpenXRInterface::get_hand_joint_linear_velocity(Hand p_hand, HandJoints p_joint) const { … }

Vector3 OpenXRInterface::get_hand_joint_angular_velocity(Hand p_hand, HandJoints p_joint) const { … }

RID OpenXRInterface::get_vrs_texture() { … }

OpenXRInterface::OpenXRInterface() { … }

OpenXRInterface::~OpenXRInterface() { … }
godot/modules/openxr/openxr_interface.cpp
