/**************************************************************************/
/* register_types.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 "register_types.h"
#include "action_map/openxr_action.h"
#include "action_map/openxr_action_map.h"
#include "action_map/openxr_action_set.h"
#include "action_map/openxr_haptic_feedback.h"
#include "action_map/openxr_interaction_profile.h"
#include "action_map/openxr_interaction_profile_metadata.h"
#include "openxr_api_extension.h"
#include "openxr_interface.h"
#include "core/config/engine.h"
#include "core/config/project_settings.h"
#include "core/object/class_db.h"
#include "core/os/os.h"
#include "modules/modules_enabled.gen.h"
#ifndef DISABLE_DEPRECATED
#include "extensions/openxr_extension_wrapper_extension.h"
#include "scene/openxr_hand.h"
#endif // DISABLE_DEPRECATED
#include "extensions/openxr_android_thread_settings_extension.h"
#include "extensions/openxr_composition_layer_depth_extension.h"
#include "extensions/openxr_composition_layer_extension.h"
#include "extensions/openxr_debug_utils_extension.h"
#include "extensions/openxr_dpad_binding_extension.h"
#include "extensions/openxr_eye_gaze_interaction.h"
#include "extensions/openxr_fb_display_refresh_rate_extension.h"
#include "extensions/openxr_frame_synthesis_extension.h"
#include "extensions/openxr_future_extension.h"
#include "extensions/openxr_hand_interaction_extension.h"
#include "extensions/openxr_hand_tracking_extension.h"
#include "extensions/openxr_htc_controller_extension.h"
#include "extensions/openxr_htc_vive_tracker_extension.h"
#include "extensions/openxr_huawei_controller_extension.h"
#include "extensions/openxr_khr_generic_controller_extension.h"
#include "extensions/openxr_local_floor_extension.h"
#include "extensions/openxr_meta_controller_extension.h"
#include "extensions/openxr_ml2_controller_extension.h"
#include "extensions/openxr_mxink_extension.h"
#include "extensions/openxr_palm_pose_extension.h"
#include "extensions/openxr_performance_settings_extension.h"
#include "extensions/openxr_pico_controller_extension.h"
#include "extensions/openxr_user_presence_extension.h"
#include "extensions/openxr_valve_analog_threshold_extension.h"
#include "extensions/openxr_valve_controller_extension.h"
#include "extensions/openxr_visibility_mask_extension.h"
#include "extensions/openxr_wmr_controller_extension.h"
#include "extensions/spatial_entities/openxr_spatial_anchor.h"
#include "extensions/spatial_entities/openxr_spatial_entity_extension.h"
#include "extensions/spatial_entities/openxr_spatial_marker_tracking.h"
#include "extensions/spatial_entities/openxr_spatial_plane_tracking.h"
#include "scene/openxr_composition_layer.h"
#include "scene/openxr_composition_layer_cylinder.h"
#include "scene/openxr_composition_layer_equirect.h"
#include "scene/openxr_composition_layer_quad.h"
#include "scene/openxr_visibility_mask.h"
#ifdef MODULE_GLTF_ENABLED
#include "extensions/openxr_render_model_extension.h"
#include "scene/openxr_render_model.h"
#include "scene/openxr_render_model_manager.h"
#endif
#ifdef TOOLS_ENABLED
#include "editor/openxr_editor_plugin.h"
#endif
#ifdef ANDROID_ENABLED
#include "extensions/platform/openxr_android_extension.h"
#endif
#ifdef TOOLS_ENABLED
#include "editor/openxr_binding_modifier_editor.h"
#include "editor/openxr_interaction_profile_editor.h"
//
#include "editor/editor_node.h"
#endif
static OpenXRAPI *openxr_api = nullptr;
static OpenXRInteractionProfileMetadata *openxr_interaction_profile_metadata = nullptr;
static Ref<OpenXRInterface> openxr_interface;
#ifdef TOOLS_ENABLED
static void _editor_init() {
if (OpenXRAPI::openxr_is_enabled(false)) {
if (openxr_interaction_profile_metadata == nullptr) {
// If we didn't initialize our actionmap metadata at startup, we initialize it now.
openxr_interaction_profile_metadata = memnew(OpenXRInteractionProfileMetadata);
ERR_FAIL_NULL(openxr_interaction_profile_metadata);
}
}
OpenXREditorPlugin *openxr_plugin = memnew(OpenXREditorPlugin());
EditorNode::get_singleton()->add_editor_plugin(openxr_plugin);
}
#endif
void initialize_openxr_module(ModuleInitializationLevel p_level) {
if (p_level == MODULE_INITIALIZATION_LEVEL_CORE) {
GDREGISTER_VIRTUAL_CLASS(OpenXRExtensionWrapper);
#ifndef DISABLE_DEPRECATED
GDREGISTER_VIRTUAL_CLASS(OpenXRExtensionWrapperExtension);
#endif // DISABLE_DEPRECATED
GDREGISTER_CLASS(OpenXRInteractionProfileMetadata);
GDREGISTER_ABSTRACT_CLASS(OpenXRFutureResult); // Declared abstract, should never be instantiated by a user (Q or should this be internal?)
GDREGISTER_CLASS(OpenXRFrameSynthesisExtension);
GDREGISTER_CLASS(OpenXRFutureExtension);
GDREGISTER_CLASS(OpenXRAPIExtension);
#ifdef MODULE_GLTF_ENABLED
GDREGISTER_CLASS(OpenXRRenderModelExtension);
#endif
GDREGISTER_CLASS(OpenXRAndroidThreadSettingsExtension);
// Note, we're not registering all wrapper classes here, there is no point in exposing them
// if there isn't specific logic to expose.
}
if (p_level == MODULE_INITIALIZATION_LEVEL_SERVERS) {
if (OpenXRAPI::openxr_is_enabled(false)) {
// Always register our extension wrappers even if we don't initialize OpenXR.
// Some of these wrappers will add functionality to our editor.
#ifdef ANDROID_ENABLED
OpenXRAPI::register_extension_wrapper(memnew(OpenXRAndroidExtension));
#endif
// register our other extensions
OpenXRAPI::register_extension_wrapper(memnew(OpenXRPalmPoseExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRLocalFloorExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRPicoControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRCompositionLayerDepthExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRCompositionLayerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRHTCControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRHTCViveTrackerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRHuaweiControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRDisplayRefreshRateExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRWMRControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRML2ControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRMetaControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXREyeGazeInteractionExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRHandInteractionExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRMxInkExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRVisibilityMaskExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRPerformanceSettingsExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRValveControllerExtension));
OpenXRAPI::register_extension_wrapper(memnew(OpenXRKHRGenericController));
// Futures extension has to be registered as a singleton so extensions can access it.
OpenXRFutureExtension *future_extension = memnew(OpenXRFutureExtension);
OpenXRAPI::register_extension_wrapper(future_extension);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRFutureExtension", future_extension));
// Register render model extension as a singleton.
#ifdef MODULE_GLTF_ENABLED
OpenXRRenderModelExtension *render_model_extension = memnew(OpenXRRenderModelExtension);
OpenXRAPI::register_extension_wrapper(render_model_extension);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRRenderModelExtension", render_model_extension));
#endif
// Register spatial entity extensions
OpenXRSpatialEntityExtension *spatial_entity_extension = memnew(OpenXRSpatialEntityExtension);
OpenXRAPI::register_extension_wrapper(spatial_entity_extension);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRSpatialEntityExtension", spatial_entity_extension));
OpenXRSpatialAnchorCapability *anchor_capability = memnew(OpenXRSpatialAnchorCapability);
OpenXRAPI::register_extension_wrapper(anchor_capability);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRSpatialAnchorCapability", anchor_capability));
OpenXRSpatialPlaneTrackingCapability *plane_tracking_capability = memnew(OpenXRSpatialPlaneTrackingCapability);
OpenXRAPI::register_extension_wrapper(plane_tracking_capability);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRSpatialPlaneTrackingCapability", plane_tracking_capability));
OpenXRSpatialMarkerTrackingCapability *marker_tracking_capability = memnew(OpenXRSpatialMarkerTrackingCapability);
OpenXRAPI::register_extension_wrapper(marker_tracking_capability);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRSpatialMarkerTrackingCapability", marker_tracking_capability));
// Register frame synthesis extension as a singleton.
OpenXRFrameSynthesisExtension *frame_synthesis_extension = memnew(OpenXRFrameSynthesisExtension);
OpenXRAPI::register_extension_wrapper(frame_synthesis_extension);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRFrameSynthesisExtension", frame_synthesis_extension));
// Register android thread settings extension as a singleton.
OpenXRAndroidThreadSettingsExtension *android_thread_settings = memnew(OpenXRAndroidThreadSettingsExtension);
OpenXRAPI::register_extension_wrapper(android_thread_settings);
Engine::get_singleton()->add_singleton(Engine::Singleton("OpenXRAndroidThreadSettingsExtension", android_thread_settings));
// Register user presence extension as a singleton
OpenXRUserPresenceExtension *user_presence_extension = memnew(OpenXRUserPresenceExtension);
OpenXRAPI::register_extension_wrapper(user_presence_extension);
// register gated extensions
if (int(GLOBAL_GET("xr/openxr/extensions/debug_utils")) > 0) {
OpenXRAPI::register_extension_wrapper(memnew(OpenXRDebugUtilsExtension));
}
if (GLOBAL_GET("xr/openxr/extensions/hand_tracking")) {
OpenXRAPI::register_extension_wrapper(memnew(OpenXRHandTrackingExtension));
}
// register gated binding modifiers
if (GLOBAL_GET("xr/openxr/binding_modifiers/analog_threshold")) {
OpenXRAPI::register_extension_wrapper(memnew(OpenXRValveAnalogThresholdExtension));
}
if (GLOBAL_GET("xr/openxr/binding_modifiers/dpad_binding")) {
OpenXRAPI::register_extension_wrapper(memnew(OpenXRDPadBindingExtension));
}
}
if (OpenXRAPI::openxr_is_enabled()) {
openxr_interaction_profile_metadata = memnew(OpenXRInteractionProfileMetadata);
ERR_FAIL_NULL(openxr_interaction_profile_metadata);
openxr_api = memnew(OpenXRAPI);
ERR_FAIL_NULL(openxr_api);
if (!openxr_api->initialize(OS::get_singleton()->get_current_rendering_driver_name())) {
const char *init_error_message =
"OpenXR was requested but failed to start.\n"
"HMD was not detected or a required feature was not supported.\n\n"
#ifdef TOOLS_ENABLED
// Editor only message - this is useful for app developer, but not user
"Check logged errors in debugger for more details.\n\n"
#endif
#ifdef WINDOWS_ENABLED
"When using Windows Mixed Reality, note that WMR only has DirectX support. Make sure SteamVR is your default OpenXR runtime.\n\n"
#endif
"Godot will start in normal mode.\n";
WARN_PRINT(init_error_message);
bool init_show_startup_alert = GLOBAL_GET("xr/openxr/startup_alert");
if (init_show_startup_alert) {
OS::get_singleton()->alert(init_error_message);
}
memdelete(openxr_api);
openxr_api = nullptr;
return;
}
}
}
if (p_level == MODULE_INITIALIZATION_LEVEL_SCENE) {
GDREGISTER_CLASS(OpenXRInterface);
GDREGISTER_CLASS(OpenXRAction);
GDREGISTER_CLASS(OpenXRActionSet);
GDREGISTER_CLASS(OpenXRActionMap);
GDREGISTER_CLASS(OpenXRIPBinding);
GDREGISTER_CLASS(OpenXRInteractionProfile);
GDREGISTER_ABSTRACT_CLASS(OpenXRBindingModifier);
GDREGISTER_VIRTUAL_CLASS(OpenXRIPBindingModifier);
GDREGISTER_VIRTUAL_CLASS(OpenXRActionBindingModifier);
GDREGISTER_CLASS(OpenXRAnalogThresholdModifier);
GDREGISTER_CLASS(OpenXRDpadBindingModifier);
GDREGISTER_ABSTRACT_CLASS(OpenXRHapticBase);
GDREGISTER_CLASS(OpenXRHapticVibration);
GDREGISTER_ABSTRACT_CLASS(OpenXRCompositionLayer);
GDREGISTER_CLASS(OpenXRCompositionLayerEquirect);
GDREGISTER_CLASS(OpenXRCompositionLayerCylinder);
GDREGISTER_CLASS(OpenXRCompositionLayerQuad);
#ifndef DISABLE_DEPRECATED
GDREGISTER_CLASS(OpenXRHand);
#endif
GDREGISTER_CLASS(OpenXRVisibilityMask);
#ifdef MODULE_GLTF_ENABLED
GDREGISTER_CLASS(OpenXRRenderModel);
GDREGISTER_CLASS(OpenXRRenderModelManager);
#endif
GDREGISTER_CLASS(OpenXRSpatialEntityExtension);
GDREGISTER_VIRTUAL_CLASS(OpenXRSpatialEntityTracker);
GDREGISTER_CLASS(OpenXRAnchorTracker);
GDREGISTER_CLASS(OpenXRPlaneTracker);
GDREGISTER_CLASS(OpenXRMarkerTracker);
GDREGISTER_VIRTUAL_CLASS(OpenXRStructureBase);
GDREGISTER_VIRTUAL_CLASS(OpenXRSpatialCapabilityConfigurationBaseHeader);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationAnchor);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationQrCode);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationMicroQrCode);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationAruco);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationAprilTag);
GDREGISTER_CLASS(OpenXRSpatialContextPersistenceConfig);
GDREGISTER_CLASS(OpenXRSpatialCapabilityConfigurationPlaneTracking);
GDREGISTER_VIRTUAL_CLASS(OpenXRSpatialComponentData);
GDREGISTER_CLASS(OpenXRSpatialComponentBounded2DList);
GDREGISTER_CLASS(OpenXRSpatialComponentBounded3DList);
GDREGISTER_CLASS(OpenXRSpatialComponentParentList);
GDREGISTER_CLASS(OpenXRSpatialComponentMesh2DList);
GDREGISTER_CLASS(OpenXRSpatialComponentMesh3DList);
GDREGISTER_CLASS(OpenXRSpatialComponentPlaneAlignmentList);
GDREGISTER_CLASS(OpenXRSpatialComponentPolygon2DList);
GDREGISTER_CLASS(OpenXRSpatialComponentPlaneSemanticLabelList);
GDREGISTER_CLASS(OpenXRSpatialComponentMarkerList);
GDREGISTER_CLASS(OpenXRSpatialQueryResultData);
GDREGISTER_CLASS(OpenXRSpatialComponentAnchorList);
GDREGISTER_CLASS(OpenXRSpatialComponentPersistenceList);
GDREGISTER_CLASS(OpenXRSpatialAnchorCapability);
GDREGISTER_CLASS(OpenXRSpatialPlaneTrackingCapability);
GDREGISTER_CLASS(OpenXRSpatialMarkerTrackingCapability);
XRServer *xr_server = XRServer::get_singleton();
if (xr_server) {
openxr_interface.instantiate();
xr_server->add_interface(openxr_interface);
if (openxr_interface->initialize_on_startup()) {
openxr_interface->initialize();
}
}
}
#ifdef TOOLS_ENABLED
if (p_level == MODULE_INITIALIZATION_LEVEL_EDITOR) {
GDREGISTER_ABSTRACT_CLASS(OpenXRInteractionProfileEditorBase);
GDREGISTER_VIRTUAL_CLASS(OpenXRInteractionProfileEditor);
GDREGISTER_VIRTUAL_CLASS(OpenXRBindingModifierEditor);
EditorNode::add_init_callback(_editor_init);
}
#endif
}
void uninitialize_openxr_module(ModuleInitializationLevel p_level) {
if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
return;
}
if (openxr_interface.is_valid()) {
// uninitialize just in case
if (openxr_interface->is_initialized()) {
openxr_interface->uninitialize();
}
// unregister our interface from the XR server
XRServer *xr_server = XRServer::get_singleton();
if (xr_server) {
if (xr_server->get_primary_interface() == openxr_interface) {
xr_server->set_primary_interface(Ref<XRInterface>());
}
xr_server->remove_interface(openxr_interface);
}
// and release
openxr_interface.unref();
}
if (openxr_api) {
openxr_api->finish();
memdelete(openxr_api);
openxr_api = nullptr;
}
if (openxr_interaction_profile_metadata) {
memdelete(openxr_interaction_profile_metadata);
openxr_interaction_profile_metadata = nullptr;
}
// cleanup our extension wrappers
OpenXRAPI::cleanup_extension_wrappers();
}