summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--core/variant/variant_utility.cpp12
-rw-r--r--doc/classes/XRInterface.xml25
-rw-r--r--drivers/windows/dir_access_windows.cpp2
-rw-r--r--modules/navigation/nav_map.cpp20
-rw-r--r--modules/openxr/SCsub1
-rw-r--r--modules/openxr/extensions/openxr_composition_layer_provider.h7
-rw-r--r--modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.cpp234
-rw-r--r--modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.h254
-rw-r--r--modules/openxr/openxr_api.cpp22
-rw-r--r--modules/openxr/openxr_api.h6
-rw-r--r--modules/openxr/openxr_interface.cpp20
-rw-r--r--modules/openxr/openxr_interface.h8
-rw-r--r--platform/windows/display_server_windows.cpp25
-rw-r--r--servers/xr/xr_interface.cpp5
-rw-r--r--servers/xr/xr_interface.h7
15 files changed, 615 insertions, 33 deletions
diff --git a/core/variant/variant_utility.cpp b/core/variant/variant_utility.cpp
index 5bad27c607..670b66d53e 100644
--- a/core/variant/variant_utility.cpp
+++ b/core/variant/variant_utility.cpp
@@ -128,8 +128,8 @@ struct VariantUtilityFunctions {
return Math::floor(x);
}
- static inline int floori(double x) {
- return int(Math::floor(x));
+ static inline int64_t floori(double x) {
+ return int64_t(Math::floor(x));
}
static inline Variant ceil(Variant x, Callable::CallError &r_error) {
@@ -161,8 +161,8 @@ struct VariantUtilityFunctions {
return Math::ceil(x);
}
- static inline int ceili(double x) {
- return int(Math::ceil(x));
+ static inline int64_t ceili(double x) {
+ return int64_t(Math::ceil(x));
}
static inline Variant round(Variant x, Callable::CallError &r_error) {
@@ -194,8 +194,8 @@ struct VariantUtilityFunctions {
return Math::round(x);
}
- static inline int roundi(double x) {
- return int(Math::round(x));
+ static inline int64_t roundi(double x) {
+ return int64_t(Math::round(x));
}
static inline Variant abs(const Variant &x, Callable::CallError &r_error) {
diff --git a/doc/classes/XRInterface.xml b/doc/classes/XRInterface.xml
index 6296b95e6c..3e48b8284a 100644
--- a/doc/classes/XRInterface.xml
+++ b/doc/classes/XRInterface.xml
@@ -69,6 +69,18 @@
Is [code]true[/code] if this interface has been initialised.
</description>
</method>
+ <method name="is_passthrough_enabled">
+ <return type="bool" />
+ <description>
+ Is [code]true[/code] if passthrough is enabled.
+ </description>
+ </method>
+ <method name="is_passthrough_supported">
+ <return type="bool" />
+ <description>
+ Is [code]true[/code] if this interface supports passthrough.
+ </description>
+ </method>
<method name="set_play_area_mode">
<return type="bool" />
<param index="0" name="mode" type="int" enum="XRInterface.PlayAreaMode" />
@@ -76,6 +88,19 @@
Sets the active play area mode, will return [code]false[/code] if the mode can't be used with this interface.
</description>
</method>
+ <method name="start_passthrough">
+ <return type="bool" />
+ <description>
+ Starts passthrough, will return [code]false[/code] if passthrough couldn't be started.
+ [b]Note:[/b] The viewport used for XR must have a transparent background, otherwise passthrough may not properly render.
+ </description>
+ </method>
+ <method name="stop_passthrough">
+ <return type="void" />
+ <description>
+ Stops passthrough.
+ </description>
+ </method>
<method name="supports_play_area_mode">
<return type="bool" />
<param index="0" name="mode" type="int" enum="XRInterface.PlayAreaMode" />
diff --git a/drivers/windows/dir_access_windows.cpp b/drivers/windows/dir_access_windows.cpp
index 11fd29c8f5..7dd294c7a1 100644
--- a/drivers/windows/dir_access_windows.cpp
+++ b/drivers/windows/dir_access_windows.cpp
@@ -160,7 +160,7 @@ Error DirAccessWindows::make_dir(String p_dir) {
p_dir = current_dir.path_join(p_dir);
}
- p_dir = p_dir.replace("/", "\\");
+ p_dir = p_dir.simplify_path().replace("/", "\\");
bool success;
int err;
diff --git a/modules/navigation/nav_map.cpp b/modules/navigation/nav_map.cpp
index 100db9bc82..394c32f20d 100644
--- a/modules/navigation/nav_map.cpp
+++ b/modules/navigation/nav_map.cpp
@@ -140,20 +140,17 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
// This is an implementation of the A* algorithm.
int least_cost_id = 0;
+ int prev_least_cost_id = -1;
bool found_route = false;
const gd::Polygon *reachable_end = nullptr;
float reachable_d = 1e30;
bool is_reachable = true;
- gd::NavigationPoly *prev_least_cost_poly = nullptr;
-
while (true) {
// Takes the current least_cost_poly neighbors (iterating over its edges) and compute the traveled_distance.
for (size_t i = 0; i < navigation_polys[least_cost_id].poly->edges.size(); i++) {
- gd::NavigationPoly *least_cost_poly = &navigation_polys[least_cost_id];
-
- const gd::Edge &edge = least_cost_poly->poly->edges[i];
+ const gd::Edge &edge = navigation_polys[least_cost_id].poly->edges[i];
// Iterate over connections in this edge, then compute the new optimized travel distance assigned to this polygon.
for (int connection_index = 0; connection_index < edge.connections.size(); connection_index++) {
@@ -164,17 +161,18 @@ Vector<Vector3> NavMap::get_path(Vector3 p_origin, Vector3 p_destination, bool p
continue;
}
+ const gd::NavigationPoly &least_cost_poly = navigation_polys[least_cost_id];
float poly_enter_cost = 0.0;
- float poly_travel_cost = least_cost_poly->poly->owner->get_travel_cost();
+ float poly_travel_cost = least_cost_poly.poly->owner->get_travel_cost();
- if (prev_least_cost_poly != nullptr && (prev_least_cost_poly->poly->owner->get_self() != least_cost_poly->poly->owner->get_self())) {
- poly_enter_cost = least_cost_poly->poly->owner->get_enter_cost();
+ if (prev_least_cost_id != -1 && (navigation_polys[prev_least_cost_id].poly->owner->get_self() != least_cost_poly.poly->owner->get_self())) {
+ poly_enter_cost = least_cost_poly.poly->owner->get_enter_cost();
}
- prev_least_cost_poly = least_cost_poly;
+ prev_least_cost_id = least_cost_id;
Vector3 pathway[2] = { connection.pathway_start, connection.pathway_end };
- const Vector3 new_entry = Geometry3D::get_closest_point_to_segment(least_cost_poly->entry, pathway);
- const float new_distance = (least_cost_poly->entry.distance_to(new_entry) * poly_travel_cost) + poly_enter_cost + least_cost_poly->traveled_distance;
+ const Vector3 new_entry = Geometry3D::get_closest_point_to_segment(least_cost_poly.entry, pathway);
+ const float new_distance = (least_cost_poly.entry.distance_to(new_entry) * poly_travel_cost) + poly_enter_cost + least_cost_poly.traveled_distance;
int64_t already_visited_polygon_index = navigation_polys.find(gd::NavigationPoly(connection.polygon));
diff --git a/modules/openxr/SCsub b/modules/openxr/SCsub
index 6b6a4f2ed5..c8e9b9a11e 100644
--- a/modules/openxr/SCsub
+++ b/modules/openxr/SCsub
@@ -94,6 +94,7 @@ if env["vulkan"]:
env_openxr.add_source_files(module_obj, "extensions/openxr_palm_pose_extension.cpp")
env_openxr.add_source_files(module_obj, "extensions/openxr_htc_vive_tracker_extension.cpp")
env_openxr.add_source_files(module_obj, "extensions/openxr_hand_tracking_extension.cpp")
+env_openxr.add_source_files(module_obj, "extensions/openxr_fb_passthrough_extension_wrapper.cpp")
env.modules_sources += module_obj
diff --git a/modules/openxr/extensions/openxr_composition_layer_provider.h b/modules/openxr/extensions/openxr_composition_layer_provider.h
index 019dffa2a8..ba51389f7d 100644
--- a/modules/openxr/extensions/openxr_composition_layer_provider.h
+++ b/modules/openxr/extensions/openxr_composition_layer_provider.h
@@ -36,10 +36,9 @@
// Interface for OpenXR extensions that provide a composition layer.
class OpenXRCompositionLayerProvider {
public:
- // TODO changed to normal method definition for now
- // CI complains until we implement this, haven't ported it yet from plugin
- // virtual XrCompositionLayerBaseHeader *get_composition_layer() = 0;
- XrCompositionLayerBaseHeader *get_composition_layer() { return nullptr; };
+ virtual XrCompositionLayerBaseHeader *get_composition_layer() = 0;
+
+ virtual ~OpenXRCompositionLayerProvider() {}
};
#endif // OPENXR_COMPOSITION_LAYER_PROVIDER_H
diff --git a/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.cpp b/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.cpp
new file mode 100644
index 0000000000..259b1236a3
--- /dev/null
+++ b/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.cpp
@@ -0,0 +1,234 @@
+/*************************************************************************/
+/* openxr_fb_passthrough_extension_wrapper.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.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 "openxr_fb_passthrough_extension_wrapper.h"
+
+#include "core/os/os.h"
+#include "scene/main/viewport.h"
+#include "scene/main/window.h"
+
+using namespace godot;
+
+OpenXRFbPassthroughExtensionWrapper *OpenXRFbPassthroughExtensionWrapper::singleton = nullptr;
+
+OpenXRFbPassthroughExtensionWrapper *OpenXRFbPassthroughExtensionWrapper::get_singleton() {
+ return singleton;
+}
+
+OpenXRFbPassthroughExtensionWrapper::OpenXRFbPassthroughExtensionWrapper(OpenXRAPI *p_openxr_api) :
+ OpenXRExtensionWrapper(p_openxr_api) {
+ request_extensions[XR_FB_PASSTHROUGH_EXTENSION_NAME] = &fb_passthrough_ext;
+ request_extensions[XR_FB_TRIANGLE_MESH_EXTENSION_NAME] = &fb_triangle_mesh_ext;
+ singleton = this;
+}
+
+OpenXRFbPassthroughExtensionWrapper::~OpenXRFbPassthroughExtensionWrapper() {
+ cleanup();
+}
+
+void OpenXRFbPassthroughExtensionWrapper::cleanup() {
+ fb_passthrough_ext = false;
+ fb_triangle_mesh_ext = false;
+}
+
+Viewport *OpenXRFbPassthroughExtensionWrapper::get_main_viewport() {
+ MainLoop *main_loop = OS::get_singleton()->get_main_loop();
+ if (!main_loop) {
+ print_error("Unable to retrieve main loop");
+ return nullptr;
+ }
+
+ auto *scene_tree = Object::cast_to<SceneTree>(main_loop);
+ if (!scene_tree) {
+ print_error("Unable to retrieve scene tree");
+ return nullptr;
+ }
+
+ Viewport *viewport = scene_tree->get_root()->get_viewport();
+ return viewport;
+}
+
+void OpenXRFbPassthroughExtensionWrapper::on_instance_created(const XrInstance instance) {
+ if (fb_passthrough_ext) {
+ bool result = initialize_fb_passthrough_extension(instance);
+ if (!result) {
+ print_error("Failed to initialize fb_passthrough extension");
+ fb_passthrough_ext = false;
+ }
+ }
+
+ if (fb_triangle_mesh_ext) {
+ bool result = initialize_fb_triangle_mesh_extension(instance);
+ if (!result) {
+ print_error("Failed to initialize fb_triangle_mesh extension");
+ fb_triangle_mesh_ext = false;
+ }
+ }
+
+ if (fb_passthrough_ext) {
+ openxr_api->register_composition_layer_provider(this);
+ }
+}
+
+bool OpenXRFbPassthroughExtensionWrapper::is_passthrough_enabled() {
+ return fb_passthrough_ext && passthrough_handle != XR_NULL_HANDLE && passthrough_layer != XR_NULL_HANDLE;
+}
+
+bool OpenXRFbPassthroughExtensionWrapper::is_composition_passthrough_layer_ready() {
+ return fb_passthrough_ext && passthrough_handle != XR_NULL_HANDLE && composition_passthrough_layer.layerHandle != XR_NULL_HANDLE;
+}
+
+bool OpenXRFbPassthroughExtensionWrapper::start_passthrough() {
+ if (passthrough_handle == XR_NULL_HANDLE) {
+ return false;
+ }
+
+ if (is_passthrough_enabled()) {
+ return true;
+ }
+
+ // Start the passthrough feature
+ XrResult result = xrPassthroughStartFB(passthrough_handle);
+ if (!is_valid_passthrough_result(result, "Failed to start passthrough")) {
+ stop_passthrough();
+ return false;
+ }
+
+ // Create the passthrough layer
+ result = xrCreatePassthroughLayerFB(openxr_api->get_session(), &passthrough_layer_config, &passthrough_layer);
+ if (!is_valid_passthrough_result(result, "Failed to create the passthrough layer")) {
+ stop_passthrough();
+ return false;
+ }
+
+ // Check if the the viewport has transparent background
+ Viewport *viewport = get_main_viewport();
+ if (viewport && !viewport->has_transparent_background()) {
+ print_error("Main viewport doesn't have transparent background! Passthrough may not properly render.");
+ }
+
+ composition_passthrough_layer.layerHandle = passthrough_layer;
+
+ return true;
+}
+
+void OpenXRFbPassthroughExtensionWrapper::on_session_created(const XrSession session) {
+ if (fb_passthrough_ext) {
+ // Create the passthrough feature and start it.
+ XrResult result = xrCreatePassthroughFB(openxr_api->get_session(), &passthrough_create_info, &passthrough_handle);
+ if (!openxr_api->xr_result(result, "Failed to create passthrough")) {
+ passthrough_handle = XR_NULL_HANDLE;
+ return;
+ }
+ }
+}
+
+XrCompositionLayerBaseHeader *OpenXRFbPassthroughExtensionWrapper::get_composition_layer() {
+ if (is_composition_passthrough_layer_ready()) {
+ return (XrCompositionLayerBaseHeader *)&composition_passthrough_layer;
+ } else {
+ return nullptr;
+ }
+}
+
+void OpenXRFbPassthroughExtensionWrapper::stop_passthrough() {
+ if (!fb_passthrough_ext) {
+ return;
+ }
+
+ composition_passthrough_layer.layerHandle = XR_NULL_HANDLE;
+
+ XrResult result;
+ if (passthrough_layer != XR_NULL_HANDLE) {
+ // Destroy the layer
+ result = xrDestroyPassthroughLayerFB(passthrough_layer);
+ openxr_api->xr_result(result, "Unable to destroy passthrough layer");
+ passthrough_layer = XR_NULL_HANDLE;
+ }
+
+ if (passthrough_handle != XR_NULL_HANDLE) {
+ result = xrPassthroughPauseFB(passthrough_handle);
+ openxr_api->xr_result(result, "Unable to stop passthrough feature");
+ }
+}
+
+void OpenXRFbPassthroughExtensionWrapper::on_session_destroyed() {
+ if (fb_passthrough_ext) {
+ stop_passthrough();
+
+ XrResult result;
+ if (passthrough_handle != XR_NULL_HANDLE) {
+ result = xrDestroyPassthroughFB(passthrough_handle);
+ openxr_api->xr_result(result, "Unable to destroy passthrough feature");
+ passthrough_handle = XR_NULL_HANDLE;
+ }
+ }
+}
+
+void OpenXRFbPassthroughExtensionWrapper::on_instance_destroyed() {
+ if (fb_passthrough_ext) {
+ openxr_api->unregister_composition_layer_provider(this);
+ }
+ cleanup();
+}
+
+bool OpenXRFbPassthroughExtensionWrapper::initialize_fb_passthrough_extension(const XrInstance p_instance) {
+ ERR_FAIL_NULL_V(openxr_api, false);
+
+ EXT_INIT_XR_FUNC_V(xrCreatePassthroughFB);
+ EXT_INIT_XR_FUNC_V(xrDestroyPassthroughFB);
+ EXT_INIT_XR_FUNC_V(xrPassthroughStartFB);
+ EXT_INIT_XR_FUNC_V(xrPassthroughPauseFB);
+ EXT_INIT_XR_FUNC_V(xrCreatePassthroughLayerFB);
+ EXT_INIT_XR_FUNC_V(xrDestroyPassthroughLayerFB);
+ EXT_INIT_XR_FUNC_V(xrPassthroughLayerPauseFB);
+ EXT_INIT_XR_FUNC_V(xrPassthroughLayerResumeFB);
+ EXT_INIT_XR_FUNC_V(xrPassthroughLayerSetStyleFB);
+ EXT_INIT_XR_FUNC_V(xrCreateGeometryInstanceFB);
+ EXT_INIT_XR_FUNC_V(xrDestroyGeometryInstanceFB);
+ EXT_INIT_XR_FUNC_V(xrGeometryInstanceSetTransformFB);
+
+ return true;
+}
+
+bool OpenXRFbPassthroughExtensionWrapper::initialize_fb_triangle_mesh_extension(const XrInstance p_instance) {
+ ERR_FAIL_NULL_V(openxr_api, false);
+
+ EXT_INIT_XR_FUNC_V(xrCreateTriangleMeshFB);
+ EXT_INIT_XR_FUNC_V(xrDestroyTriangleMeshFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshGetVertexBufferFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshGetIndexBufferFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshBeginUpdateFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshEndUpdateFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshBeginVertexBufferUpdateFB);
+ EXT_INIT_XR_FUNC_V(xrTriangleMeshEndVertexBufferUpdateFB);
+
+ return true;
+}
diff --git a/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.h b/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.h
new file mode 100644
index 0000000000..1959f3fdc4
--- /dev/null
+++ b/modules/openxr/extensions/openxr_fb_passthrough_extension_wrapper.h
@@ -0,0 +1,254 @@
+/*************************************************************************/
+/* openxr_fb_passthrough_extension_wrapper.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.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. */
+/*************************************************************************/
+
+#ifndef OPENXR_FB_PASSTHROUGH_EXTENSION_WRAPPER_H
+#define OPENXR_FB_PASSTHROUGH_EXTENSION_WRAPPER_H
+
+#include "../openxr_api.h"
+#include "../util.h"
+
+#include "openxr_composition_layer_provider.h"
+#include "openxr_extension_wrapper.h"
+
+#include <map>
+
+class Viewport;
+
+// Wrapper for the set of Facebook XR passthrough extensions.
+class OpenXRFbPassthroughExtensionWrapper : public OpenXRExtensionWrapper, public OpenXRCompositionLayerProvider {
+ friend class OpenXRAPI;
+
+public:
+ void on_instance_created(const XrInstance instance) override;
+
+ void on_session_created(const XrSession session) override;
+
+ void on_session_destroyed() override;
+
+ void on_instance_destroyed() override;
+
+ XrCompositionLayerBaseHeader *get_composition_layer() override;
+
+ bool is_passthrough_supported() {
+ return fb_passthrough_ext;
+ }
+
+ bool is_passthrough_enabled();
+
+ bool start_passthrough();
+
+ void stop_passthrough();
+
+ static OpenXRFbPassthroughExtensionWrapper *get_singleton();
+
+protected:
+ OpenXRFbPassthroughExtensionWrapper(OpenXRAPI *p_openxr_api);
+ ~OpenXRFbPassthroughExtensionWrapper();
+
+private:
+ // Create a passthrough feature
+ EXT_PROTO_XRRESULT_FUNC3(xrCreatePassthroughFB,
+ (XrSession), session,
+ (const XrPassthroughCreateInfoFB *), create_info,
+ (XrPassthroughFB *), feature_out)
+
+ // Destroy a previously created passthrough feature
+ EXT_PROTO_XRRESULT_FUNC1(xrDestroyPassthroughFB, (XrPassthroughFB), feature)
+
+ //*** Passthrough feature state management functions *********
+ // Start the passthrough feature
+ EXT_PROTO_XRRESULT_FUNC1(xrPassthroughStartFB, (XrPassthroughFB), passthrough)
+ // Pause the passthrough feature
+ EXT_PROTO_XRRESULT_FUNC1(xrPassthroughPauseFB, (XrPassthroughFB), passthrough)
+
+ EXT_PROTO_XRRESULT_FUNC3(xrCreatePassthroughLayerFB, (XrSession), session,
+ (const XrPassthroughLayerCreateInfoFB *), config,
+ (XrPassthroughLayerFB *), layer_out)
+
+ EXT_PROTO_XRRESULT_FUNC1(xrDestroyPassthroughLayerFB, (XrPassthroughLayerFB), layer)
+
+ EXT_PROTO_XRRESULT_FUNC1(xrPassthroughLayerPauseFB, (XrPassthroughLayerFB), layer)
+ EXT_PROTO_XRRESULT_FUNC1(xrPassthroughLayerResumeFB, (XrPassthroughLayerFB), layer)
+
+ // Set the style of an existing passthrough layer. If the enabled feature set
+ // doesn’t change, this is a lightweight operation that can be called in every
+ // frame to animate the style. Changes that may incur a bigger cost:
+ // - Enabling/disabling the color mapping, or changing the type of mapping
+ // (monochromatic to RGBA or back).
+ // - Changing `textureOpacityFactor` from 0 to non-zero or vice versa
+ // - Changing `edgeColor[3]` from 0 to non-zero or vice versa
+ // NOTE: For XR_FB_passthrough, all color values are treated as linear.
+ EXT_PROTO_XRRESULT_FUNC2(xrPassthroughLayerSetStyleFB,
+ (XrPassthroughLayerFB), layer,
+ (const XrPassthroughStyleFB *), style)
+
+ // Create a geometry instance to be used as a projection surface for passthrough.
+ // A geometry instance assigns a triangle mesh as part of the specified layer's
+ // projection surface.
+ // The operation is only valid if the passthrough layer's purpose has been set to
+ // `XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB`. Otherwise, the call this function will
+ // result in an error. In the specified layer, Passthrough will be visible where the view
+ // is covered by the user-specified geometries.
+ //
+ // A triangle mesh object can be instantiated multiple times - in the same or different layers'
+ // projection surface. Each instantiation has its own transformation, which
+ // can be updated using `xrGeometryInstanceSetTransformFB`.
+ EXT_PROTO_XRRESULT_FUNC3(xrCreateGeometryInstanceFB,
+ (XrSession), session,
+ (const XrGeometryInstanceCreateInfoFB *), create_info,
+ (XrGeometryInstanceFB *), out_geometry_instance)
+
+ // Destroys a previously created geometry instance from passthrough rendering.
+ // This removes the geometry instance from passthrough rendering.
+ // The operation has no effect on other instances or the underlying mesh.
+ EXT_PROTO_XRRESULT_FUNC1(xrDestroyGeometryInstanceFB, (XrGeometryInstanceFB), instance)
+
+ // Update the transformation of a passthrough geometry instance.
+ EXT_PROTO_XRRESULT_FUNC2(xrGeometryInstanceSetTransformFB,
+ (XrGeometryInstanceFB), instance,
+ (const XrGeometryInstanceTransformFB *), transformation)
+
+ // Create a triangle mesh geometry object.
+ // Depending on the behavior flags, the mesh could be created immutable (data is assigned
+ // at creation and cannot be changed) or mutable (the mesh is created empty and can be updated
+ // by calling begin/end update functions).
+ EXT_PROTO_XRRESULT_FUNC3(xrCreateTriangleMeshFB,
+ (XrSession), session,
+ (const XrTriangleMeshCreateInfoFB *), create_info,
+ (XrTriangleMeshFB *), out_triangle_mesh)
+
+ // Destroy an `XrTriangleMeshFB` object along with its data. The mesh buffers must not be
+ // accessed anymore after their parent mesh object has been destroyed.
+ EXT_PROTO_XRRESULT_FUNC1(xrDestroyTriangleMeshFB, (XrTriangleMeshFB), mesh)
+
+ // Retrieve a pointer to the vertex buffer. The vertex buffer is structured as an array of 3 floats
+ // per vertex representing x, y, and z: `[x0, y0, z0, x1, y1, z1, ...]`. The size of the buffer is
+ // `maxVertexCount * 3` floats. The application must call `xrTriangleMeshBeginUpdateFB` or
+ // `xrTriangleMeshBeginVertexBufferUpdateFB` before making modifications to the vertex
+ // buffer. The buffer location is guaranteed to remain constant over the lifecycle of the mesh
+ // object.
+ EXT_PROTO_XRRESULT_FUNC2(xrTriangleMeshGetVertexBufferFB,
+ (XrTriangleMeshFB), mesh,
+ (XrVector3f **), out_vertex_buffer)
+
+ // Retrieve the index buffer that defines the topology of the triangle mesh. Each triplet of
+ // consecutive elements point to three vertices in the vertex buffer and thus form a triangle. The
+ // size of each element is `indexElementSize` bytes, and thus the size of the buffer is
+ // `maxTriangleCount * 3 * indexElementSize` bytes. The application must call
+ // `xrTriangleMeshBeginUpdateFB` before making modifications to the index buffer. The buffer
+ // location is guaranteed to remain constant over the lifecycle of the mesh object.
+ EXT_PROTO_XRRESULT_FUNC2(xrTriangleMeshGetIndexBufferFB,
+ (XrTriangleMeshFB), mesh,
+ (uint32_t **), out_index_buffer)
+
+ // Begin updating the mesh buffer data. The application must call this function before it makes any
+ // modifications to the buffers retrieved by `xrTriangleMeshGetVertexBufferFB` and
+ // `xrTriangleMeshGetIndexBufferFB`. If only the vertex buffer needs to be updated,
+ // `xrTriangleMeshBeginVertexBufferUpdateFB` can be used instead. To commit the
+ // modifications, the application must call `xrTriangleMeshEndUpdateFB`.
+ EXT_PROTO_XRRESULT_FUNC1(xrTriangleMeshBeginUpdateFB, (XrTriangleMeshFB), mesh)
+
+ // Signal the API that the application has finished updating the mesh buffers after a call to
+ // `xrTriangleMeshBeginUpdateFB`. `vertexCount` and `triangleCount` specify the actual
+ // number of primitives that make up the mesh after the update. They must be larger than zero but
+ // smaller or equal to the maximum counts defined at create time. Buffer data beyond these counts
+ // is ignored.
+ EXT_PROTO_XRRESULT_FUNC3(xrTriangleMeshEndUpdateFB,
+ (XrTriangleMeshFB), mesh,
+ (uint32_t), vertexCount,
+ (uint32_t), triangle_count)
+
+ // Update the vertex positions of a triangle mesh. Can only be called once the mesh topology has
+ // been set using `xrTriangleMeshBeginUpdateFB`/`xrTriangleMeshEndUpdateFB`. The
+ // vertex count is defined by the last invocation to `xrTriangleMeshEndUpdateFB`. Once the
+ // modification is done, `xrTriangleMeshEndVertexBufferUpdateFB` must be called.
+ EXT_PROTO_XRRESULT_FUNC2(xrTriangleMeshBeginVertexBufferUpdateFB,
+ (XrTriangleMeshFB), mesh,
+ (uint32_t *), out_vertex_count)
+
+ // Signal the API that the contents of the vertex buffer data has been updated
+ // after a call to `xrTriangleMeshBeginVertexBufferUpdateFB`.
+ EXT_PROTO_XRRESULT_FUNC1(xrTriangleMeshEndVertexBufferUpdateFB, (XrTriangleMeshFB), mesh)
+
+ bool initialize_fb_passthrough_extension(const XrInstance instance);
+
+ bool initialize_fb_triangle_mesh_extension(const XrInstance instance);
+
+ void cleanup();
+
+ // TODO: Temporary workaround (https://github.com/GodotVR/godot_openxr/issues/138)
+ // Address a bug in the passthrough api where XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB is
+ // returned even when the operation is valid on Meta Quest devices.
+ // The issue should be addressed on that platform in OS release v37.
+ inline bool is_valid_passthrough_result(XrResult result, const char *format) {
+ return openxr_api->xr_result(result, format) || result == XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB;
+ }
+
+ Viewport *get_main_viewport();
+
+ bool is_composition_passthrough_layer_ready();
+
+ static OpenXRFbPassthroughExtensionWrapper *singleton;
+
+ bool fb_passthrough_ext = false; // required for any passthrough functionality
+ bool fb_triangle_mesh_ext = false; // only use for projected passthrough
+
+ XrPassthroughCreateInfoFB passthrough_create_info = {
+ XR_TYPE_PASSTHROUGH_CREATE_INFO_FB,
+ nullptr,
+ 0,
+ };
+ XrPassthroughFB passthrough_handle = XR_NULL_HANDLE;
+
+ XrPassthroughLayerCreateInfoFB passthrough_layer_config = {
+ XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB,
+ nullptr,
+ passthrough_handle,
+ XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB,
+ XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB,
+ };
+ XrPassthroughStyleFB passthrough_layer_style = {
+ XR_TYPE_PASSTHROUGH_STYLE_FB,
+ nullptr,
+ 1,
+ { 0, 0, 0, 0 },
+ };
+ XrPassthroughLayerFB passthrough_layer = XR_NULL_HANDLE;
+
+ XrCompositionLayerPassthroughFB composition_passthrough_layer = {
+ XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB,
+ nullptr,
+ XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT,
+ XR_NULL_HANDLE,
+ XR_NULL_HANDLE,
+ };
+};
+
+#endif // OPENXR_FB_PASSTHROUGH_EXTENSION_WRAPPER_H
diff --git a/modules/openxr/openxr_api.cpp b/modules/openxr/openxr_api.cpp
index 827c8f715f..16879ac4e5 100644
--- a/modules/openxr/openxr_api.cpp
+++ b/modules/openxr/openxr_api.cpp
@@ -49,6 +49,7 @@
#include "extensions/openxr_vulkan_extension.h"
#endif
+#include "extensions/openxr_fb_passthrough_extension_wrapper.h"
#include "extensions/openxr_hand_tracking_extension.h"
#include "extensions/openxr_htc_vive_tracker_extension.h"
#include "extensions/openxr_palm_pose_extension.h"
@@ -1764,6 +1765,7 @@ OpenXRAPI::OpenXRAPI() {
register_extension_wrapper(memnew(OpenXRPalmPoseExtension(this)));
register_extension_wrapper(memnew(OpenXRHTCViveTrackerExtension(this)));
register_extension_wrapper(memnew(OpenXRHandTrackingExtension(this)));
+ register_extension_wrapper(memnew(OpenXRFbPassthroughExtensionWrapper(this)));
}
OpenXRAPI::~OpenXRAPI() {
@@ -1872,6 +1874,18 @@ void OpenXRAPI::parse_velocities(const XrSpaceVelocity &p_velocity, Vector3 &r_l
}
}
+bool OpenXRAPI::xr_result(XrResult result, const char *format, Array args) const {
+ if (XR_SUCCEEDED(result))
+ return true;
+
+ char resultString[XR_MAX_RESULT_STRING_SIZE];
+ xrResultToString(instance, result, resultString);
+
+ print_error(String("OpenXR ") + String(format).format(args) + String(" [") + String(resultString) + String("]"));
+
+ return false;
+}
+
RID OpenXRAPI::get_tracker_rid(XrPath p_path) {
List<RID> current;
tracker_owner.get_owned_list(&current);
@@ -2563,3 +2577,11 @@ bool OpenXRAPI::trigger_haptic_pulse(RID p_action, RID p_tracker, float p_freque
return true;
}
+
+void OpenXRAPI::register_composition_layer_provider(OpenXRCompositionLayerProvider *provider) {
+ composition_layer_providers.append(provider);
+}
+
+void OpenXRAPI::unregister_composition_layer_provider(OpenXRCompositionLayerProvider *provider) {
+ composition_layer_providers.erase(provider);
+}
diff --git a/modules/openxr/openxr_api.h b/modules/openxr/openxr_api.h
index f15617b604..316886239e 100644
--- a/modules/openxr/openxr_api.h
+++ b/modules/openxr/openxr_api.h
@@ -36,6 +36,7 @@
#include "core/math/transform_3d.h"
#include "core/math/vector2.h"
#include "core/os/memory.h"
+#include "core/string/print_string.h"
#include "core/string/ustring.h"
#include "core/templates/rb_map.h"
#include "core/templates/rid_owner.h"
@@ -287,6 +288,8 @@ public:
XRPose::TrackingConfidence transform_from_location(const XrHandJointLocationEXT &p_location, Transform3D &r_transform);
void parse_velocities(const XrSpaceVelocity &p_velocity, Vector3 &r_linear_velocity, Vector3 &r_angular_velocity);
+ bool xr_result(XrResult result, const char *format, Array args = Array()) const;
+
static bool openxr_is_enabled(bool p_check_run_in_editor = true);
static OpenXRAPI *get_singleton();
@@ -349,6 +352,9 @@ public:
XRPose::TrackingConfidence get_action_pose(RID p_action, RID p_tracker, Transform3D &r_transform, Vector3 &r_linear_velocity, Vector3 &r_angular_velocity);
bool trigger_haptic_pulse(RID p_action, RID p_tracker, float p_frequency, float p_amplitude, XrDuration p_duration_ns);
+ void register_composition_layer_provider(OpenXRCompositionLayerProvider *provider);
+ void unregister_composition_layer_provider(OpenXRCompositionLayerProvider *provider);
+
OpenXRAPI();
~OpenXRAPI();
};
diff --git a/modules/openxr/openxr_interface.cpp b/modules/openxr/openxr_interface.cpp
index c5eda88db8..01e148e00f 100644
--- a/modules/openxr/openxr_interface.cpp
+++ b/modules/openxr/openxr_interface.cpp
@@ -746,6 +746,24 @@ void OpenXRInterface::end_frame() {
}
}
+bool OpenXRInterface::is_passthrough_supported() {
+ return passthrough_wrapper != nullptr && passthrough_wrapper->is_passthrough_supported();
+}
+
+bool OpenXRInterface::is_passthrough_enabled() {
+ return passthrough_wrapper != nullptr && passthrough_wrapper->is_passthrough_enabled();
+}
+
+bool OpenXRInterface::start_passthrough() {
+ return passthrough_wrapper != nullptr && passthrough_wrapper->start_passthrough();
+}
+
+void OpenXRInterface::stop_passthrough() {
+ if (passthrough_wrapper) {
+ passthrough_wrapper->stop_passthrough();
+ }
+}
+
void OpenXRInterface::on_state_ready() {
emit_signal(SNAME("session_begun"));
}
@@ -776,6 +794,8 @@ OpenXRInterface::OpenXRInterface() {
_set_default_pos(head_transform, 1.0, 0);
_set_default_pos(transform_for_view[0], 1.0, 1);
_set_default_pos(transform_for_view[1], 1.0, 2);
+
+ passthrough_wrapper = OpenXRFbPassthroughExtensionWrapper::get_singleton();
}
OpenXRInterface::~OpenXRInterface() {
diff --git a/modules/openxr/openxr_interface.h b/modules/openxr/openxr_interface.h
index a99012fd1d..3765f18637 100644
--- a/modules/openxr/openxr_interface.h
+++ b/modules/openxr/openxr_interface.h
@@ -37,6 +37,8 @@
#include "action_map/openxr_action_map.h"
#include "openxr_api.h"
+#include "extensions/openxr_fb_passthrough_extension_wrapper.h"
+
// declare some default strings
#define INTERACTION_PROFILE_NONE "/interaction_profiles/none"
@@ -47,6 +49,7 @@ private:
OpenXRAPI *openxr_api = nullptr;
bool initialized = false;
XRInterface::TrackingStatus tracking_state;
+ OpenXRFbPassthroughExtensionWrapper *passthrough_wrapper = nullptr;
// At a minimum we need a tracker for our head
Ref<XRPositionalTracker> head;
@@ -129,6 +132,11 @@ public:
virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual void end_frame() override;
+ virtual bool is_passthrough_supported() override;
+ virtual bool is_passthrough_enabled() override;
+ virtual bool start_passthrough() override;
+ virtual void stop_passthrough() override;
+
void on_state_ready();
void on_state_visible();
void on_state_focused();
diff --git a/platform/windows/display_server_windows.cpp b/platform/windows/display_server_windows.cpp
index b9e6f7b843..77b20dd924 100644
--- a/platform/windows/display_server_windows.cpp
+++ b/platform/windows/display_server_windows.cpp
@@ -2554,24 +2554,27 @@ LRESULT DisplayServerWindows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARA
if ((tablet_get_current_driver() == "wintab") && wintab_available && windows[window_id].wtctx) {
PACKET packet;
if (wintab_WTPacket(windows[window_id].wtctx, wParam, &packet)) {
- float pressure = float(packet.pkNormalPressure - windows[window_id].min_pressure) / float(windows[window_id].max_pressure - windows[window_id].min_pressure);
- windows[window_id].last_pressure = pressure;
+ POINT coords;
+ GetCursorPos(&coords);
+ ScreenToClient(windows[window_id].hWnd, &coords);
+
windows[window_id].last_pressure_update = 0;
+ float pressure = float(packet.pkNormalPressure - windows[window_id].min_pressure) / float(windows[window_id].max_pressure - windows[window_id].min_pressure);
double azim = (packet.pkOrientation.orAzimuth / 10.0f) * (Math_PI / 180);
double alt = Math::tan((Math::abs(packet.pkOrientation.orAltitude / 10.0f)) * (Math_PI / 180));
+ bool inverted = packet.pkStatus & TPS_INVERT;
- if (windows[window_id].tilt_supported) {
- windows[window_id].last_tilt = Vector2(Math::atan(Math::sin(azim) / alt), Math::atan(Math::cos(azim) / alt));
- } else {
- windows[window_id].last_tilt = Vector2();
- }
+ Vector2 tilt = (windows[window_id].tilt_supported) ? Vector2(Math::atan(Math::sin(azim) / alt), Math::atan(Math::cos(azim) / alt)) : Vector2();
- windows[window_id].last_pen_inverted = packet.pkStatus & TPS_INVERT;
+ // Nothing changed, ignore event.
+ if (!old_invalid && coords.x == old_x && coords.y == old_y && windows[window_id].last_pressure == pressure && windows[window_id].last_tilt == tilt && windows[window_id].last_pen_inverted == inverted) {
+ break;
+ }
- POINT coords;
- GetCursorPos(&coords);
- ScreenToClient(windows[window_id].hWnd, &coords);
+ windows[window_id].last_pressure = pressure;
+ windows[window_id].last_tilt = tilt;
+ windows[window_id].last_pen_inverted = inverted;
// Don't calculate relative mouse movement if we don't have focus in CAPTURED mode.
if (!windows[window_id].window_has_focus && mouse_mode == MOUSE_MODE_CAPTURED) {
diff --git a/servers/xr/xr_interface.cpp b/servers/xr/xr_interface.cpp
index 4b9ea40223..430a5bfd16 100644
--- a/servers/xr/xr_interface.cpp
+++ b/servers/xr/xr_interface.cpp
@@ -68,6 +68,11 @@ void XRInterface::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_anchor_detection_is_enabled", "enable"), &XRInterface::set_anchor_detection_is_enabled);
ClassDB::bind_method(D_METHOD("get_camera_feed_id"), &XRInterface::get_camera_feed_id);
+ ClassDB::bind_method(D_METHOD("is_passthrough_supported"), &XRInterface::is_passthrough_supported);
+ ClassDB::bind_method(D_METHOD("is_passthrough_enabled"), &XRInterface::is_passthrough_enabled);
+ ClassDB::bind_method(D_METHOD("start_passthrough"), &XRInterface::start_passthrough);
+ ClassDB::bind_method(D_METHOD("stop_passthrough"), &XRInterface::stop_passthrough);
+
ADD_GROUP("AR", "ar_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ar_is_anchor_detection_enabled"), "set_anchor_detection_is_enabled", "get_anchor_detection_is_enabled");
diff --git a/servers/xr/xr_interface.h b/servers/xr/xr_interface.h
index f11458f1cc..17ff5f8add 100644
--- a/servers/xr/xr_interface.h
+++ b/servers/xr/xr_interface.h
@@ -130,6 +130,13 @@ public:
virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) = 0; /* inform XR interface we finished our viewport draw process */
virtual void end_frame(){};
+ /** passthrough **/
+
+ virtual bool is_passthrough_supported() { return false; }
+ virtual bool is_passthrough_enabled() { return false; }
+ virtual bool start_passthrough() { return false; }
+ virtual void stop_passthrough() {}
+
virtual void notification(int p_what){};
XRInterface();
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 07:36:45 +0000