hertog/godot-module-template
Template
2
1
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Decouple RenderingServer from XR/OpenXR headers

Browse source 
Move BlitToScreen to RenderingServerTypes.
This commit is contained in:
Rémi Verschelde 2026-02-18 20:24:47 +01:00
parent b144637ae1
commit a3cb56dd38
No known key found for this signature in database
GPG key ID: C3336907360768E1
36 changed files with 333 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

8
modules/mobile_vr/mobile_vr_interface.cpp
View file

@ -33,7 +33,7 @@
#include "core/input/input.h"
#include "core/os/os.h"
#include "servers/display/display_server.h"
#include "servers/rendering/renderer_compositor.h"
#include "servers/rendering/rendering_server_types.h"
StringName MobileVRInterface::get_name() const {
return "Native mobile";
@ -509,10 +509,10 @@ Projection MobileVRInterface::get_projection_for_view(uint32_t p_view, double p_
return eye;
}
Vector<BlitToScreen> MobileVRInterface::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
Vector<RenderingServerTypes::BlitToScreen> MobileVRInterface::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
_THREAD_SAFE_METHOD_
Vector<BlitToScreen> blit_to_screen;
Vector<RenderingServerTypes::BlitToScreen> blit_to_screen;
// We must have a valid render target.
ERR_FAIL_COND_V(!p_render_target.is_valid(), blit_to_screen);
@ -528,7 +528,7 @@ Vector<BlitToScreen> MobileVRInterface::post_draw_viewport(RID p_render_target,
Rect2 modified_screen_rect = Rect2(p_screen_rect.position + offset_rect.position * p_screen_rect.size, p_screen_rect.size * offset_rect.size);
// and add our blits
BlitToScreen blit;
RenderingServerTypes::BlitToScreen blit;
blit.render_target = p_render_target;
blit.multi_view.use_layer = true;
blit.lens_distortion.apply = true;

2
modules/mobile_vr/mobile_vr_interface.h
View file

@ -165,7 +165,7 @@ public:
virtual Transform3D get_camera_transform() override;
virtual Transform3D get_transform_for_view(uint32_t p_view, const Transform3D &p_cam_transform) override;
virtual Projection get_projection_for_view(uint32_t p_view, double p_aspect, double p_z_near, double p_z_far) override;
virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual Vector<RenderingServerTypes::BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual void process() override;

57
modules/openxr/extensions/openxr_composition_layer_extension.cpp
View file

@ -39,10 +39,67 @@
#include "platform/android/api/java_class_wrapper.h"
#include "servers/rendering/rendering_server.h"
#include "servers/rendering/rendering_server_globals.h"
#include "servers/xr/xr_server.h"
////////////////////////////////////////////////////////////////////////////
// OpenXRCompositionLayerExtension
#define OPENXR_LAYER_FUNC1_IMPL(m_name, m_arg1) \
void OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1) { \
CompositionLayer *layer = composition_layer_owner.get_or_null(p_layer); \
ERR_FAIL_NULL(layer); \
layer->m_name(p1); \
} \
void OpenXRCompositionLayerExtension::composition_layer_##m_name(RID p_layer, m_arg1 p1) { \
RenderingServer::get_singleton()->call_on_render_thread(callable_mp(this, &OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt).bind(p_layer, p1)); \
}
#define OPENXR_LAYER_FUNC2_IMPL(m_name, m_arg1, m_arg2) \
void OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1, m_arg2 p2) { \
CompositionLayer *layer = composition_layer_owner.get_or_null(p_layer); \
ERR_FAIL_NULL(layer); \
layer->m_name(p1, p2); \
} \
void OpenXRCompositionLayerExtension::composition_layer_##m_name(RID p_layer, m_arg1 p1, m_arg2 p2) { \
RenderingServer::get_singleton()->call_on_render_thread(callable_mp(this, &OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt).bind(p_layer, p1, p2)); \
}
OPENXR_LAYER_FUNC2_IMPL(set_viewport, RID, const Size2i &);
OPENXR_LAYER_FUNC2_IMPL(set_use_android_surface, bool, const Size2i &);
OPENXR_LAYER_FUNC1_IMPL(set_sort_order, int);
OPENXR_LAYER_FUNC1_IMPL(set_alpha_blend, bool);
OPENXR_LAYER_FUNC1_IMPL(set_transform, const Transform3D &);
OPENXR_LAYER_FUNC1_IMPL(set_protected_content, bool);
OPENXR_LAYER_FUNC1_IMPL(set_extension_property_values, Dictionary);
OPENXR_LAYER_FUNC1_IMPL(set_min_filter, Filter);
OPENXR_LAYER_FUNC1_IMPL(set_mag_filter, Filter);
OPENXR_LAYER_FUNC1_IMPL(set_mipmap_mode, MipmapMode);
OPENXR_LAYER_FUNC1_IMPL(set_horizontal_wrap, Wrap);
OPENXR_LAYER_FUNC1_IMPL(set_vertical_wrap, Wrap);
OPENXR_LAYER_FUNC1_IMPL(set_red_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_IMPL(set_blue_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_IMPL(set_green_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_IMPL(set_alpha_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_IMPL(set_max_anisotropy, float);
OPENXR_LAYER_FUNC1_IMPL(set_border_color, const Color &);
OPENXR_LAYER_FUNC1_IMPL(set_pose_space, PoseSpace);
OPENXR_LAYER_FUNC1_IMPL(set_eye_visibility, EyeVisibility);
OPENXR_LAYER_FUNC1_IMPL(set_quad_size, const Size2 &);
OPENXR_LAYER_FUNC1_IMPL(set_cylinder_radius, float);
OPENXR_LAYER_FUNC1_IMPL(set_cylinder_aspect_ratio, float);
OPENXR_LAYER_FUNC1_IMPL(set_cylinder_central_angle, float);
OPENXR_LAYER_FUNC1_IMPL(set_equirect_radius, float);
OPENXR_LAYER_FUNC1_IMPL(set_equirect_central_horizontal_angle, float);
OPENXR_LAYER_FUNC1_IMPL(set_equirect_upper_vertical_angle, float);
OPENXR_LAYER_FUNC1_IMPL(set_equirect_lower_vertical_angle, float);
#undef OPENXR_LAYER_FUNC1_IMPL
#undef OPENXR_LAYER_FUNC2_IMPL
OpenXRCompositionLayerExtension *OpenXRCompositionLayerExtension::singleton = nullptr;
OpenXRCompositionLayerExtension *OpenXRCompositionLayerExtension::get_singleton() {

95
modules/openxr/extensions/openxr_composition_layer_extension.h
View file

@ -44,28 +44,6 @@ typedef XrResult(XRAPI_PTR *PFN_xrCreateSwapchainAndroidSurfaceKHR)(XrSession se
class JavaObject;
// This extension provides access to composition layers for displaying 2D content through the XR compositor.
#define OPENXR_LAYER_FUNC1(m_name, m_arg1) \
void _composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1) { \
CompositionLayer *layer = composition_layer_owner.get_or_null(p_layer); \
ERR_FAIL_NULL(layer); \
layer->m_name(p1); \
} \
void composition_layer_##m_name(RID p_layer, m_arg1 p1) { \
RenderingServer::get_singleton()->call_on_render_thread(callable_mp(this, &OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt).bind(p_layer, p1)); \
}
#define OPENXR_LAYER_FUNC2(m_name, m_arg1, m_arg2) \
void _composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1, m_arg2 p2) { \
CompositionLayer *layer = composition_layer_owner.get_or_null(p_layer); \
ERR_FAIL_NULL(layer); \
layer->m_name(p1, p2); \
} \
void composition_layer_##m_name(RID p_layer, m_arg1 p1, m_arg2 p2) { \
RenderingServer::get_singleton()->call_on_render_thread(callable_mp(this, &OpenXRCompositionLayerExtension::_composition_layer_##m_name##_rt).bind(p_layer, p1, p2)); \
}
// OpenXRCompositionLayerExtension enables the extensions related to this functionality
class OpenXRCompositionLayerExtension : public OpenXRExtensionWrapper {
GDCLASS(OpenXRCompositionLayerExtension, OpenXRExtensionWrapper);
@ -155,38 +133,52 @@ public:
void composition_layer_register(RID p_layer);
void composition_layer_unregister(RID p_layer);
OPENXR_LAYER_FUNC2(set_viewport, RID, const Size2i &);
OPENXR_LAYER_FUNC2(set_use_android_surface, bool, const Size2i &);
OPENXR_LAYER_FUNC1(set_sort_order, int);
OPENXR_LAYER_FUNC1(set_alpha_blend, bool);
OPENXR_LAYER_FUNC1(set_transform, const Transform3D &);
OPENXR_LAYER_FUNC1(set_protected_content, bool);
OPENXR_LAYER_FUNC1(set_extension_property_values, Dictionary);
// This extension provides access to composition layers for displaying 2D content through the XR compositor.
// Declarations are made here, and implementations in the .cpp, to avoid having to include RenderingServer in a header.
OPENXR_LAYER_FUNC1(set_min_filter, Filter);
OPENXR_LAYER_FUNC1(set_mag_filter, Filter);
OPENXR_LAYER_FUNC1(set_mipmap_mode, MipmapMode);
OPENXR_LAYER_FUNC1(set_horizontal_wrap, Wrap);
OPENXR_LAYER_FUNC1(set_vertical_wrap, Wrap);
OPENXR_LAYER_FUNC1(set_red_swizzle, Swizzle);
OPENXR_LAYER_FUNC1(set_blue_swizzle, Swizzle);
OPENXR_LAYER_FUNC1(set_green_swizzle, Swizzle);
OPENXR_LAYER_FUNC1(set_alpha_swizzle, Swizzle);
OPENXR_LAYER_FUNC1(set_max_anisotropy, float);
OPENXR_LAYER_FUNC1(set_border_color, const Color &);
OPENXR_LAYER_FUNC1(set_pose_space, PoseSpace);
OPENXR_LAYER_FUNC1(set_eye_visibility, EyeVisibility);
#define OPENXR_LAYER_FUNC1_DECL(m_name, m_arg1) \
void _composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1); \
void composition_layer_##m_name(RID p_layer, m_arg1 p1);
OPENXR_LAYER_FUNC1(set_quad_size, const Size2 &);
#define OPENXR_LAYER_FUNC2_DECL(m_name, m_arg1, m_arg2) \
void _composition_layer_##m_name##_rt(RID p_layer, m_arg1 p1, m_arg2 p2); \
void composition_layer_##m_name(RID p_layer, m_arg1 p1, m_arg2 p2);
OPENXR_LAYER_FUNC1(set_cylinder_radius, float);
OPENXR_LAYER_FUNC1(set_cylinder_aspect_ratio, float);
OPENXR_LAYER_FUNC1(set_cylinder_central_angle, float);
OPENXR_LAYER_FUNC2_DECL(set_viewport, RID, const Size2i &);
OPENXR_LAYER_FUNC2_DECL(set_use_android_surface, bool, const Size2i &);
OPENXR_LAYER_FUNC1_DECL(set_sort_order, int);
OPENXR_LAYER_FUNC1_DECL(set_alpha_blend, bool);
OPENXR_LAYER_FUNC1_DECL(set_transform, const Transform3D &);
OPENXR_LAYER_FUNC1_DECL(set_protected_content, bool);
OPENXR_LAYER_FUNC1_DECL(set_extension_property_values, Dictionary);
OPENXR_LAYER_FUNC1(set_equirect_radius, float);
OPENXR_LAYER_FUNC1(set_equirect_central_horizontal_angle, float);
OPENXR_LAYER_FUNC1(set_equirect_upper_vertical_angle, float);
OPENXR_LAYER_FUNC1(set_equirect_lower_vertical_angle, float);
OPENXR_LAYER_FUNC1_DECL(set_min_filter, Filter);
OPENXR_LAYER_FUNC1_DECL(set_mag_filter, Filter);
OPENXR_LAYER_FUNC1_DECL(set_mipmap_mode, MipmapMode);
OPENXR_LAYER_FUNC1_DECL(set_horizontal_wrap, Wrap);
OPENXR_LAYER_FUNC1_DECL(set_vertical_wrap, Wrap);
OPENXR_LAYER_FUNC1_DECL(set_red_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_DECL(set_blue_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_DECL(set_green_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_DECL(set_alpha_swizzle, Swizzle);
OPENXR_LAYER_FUNC1_DECL(set_max_anisotropy, float);
OPENXR_LAYER_FUNC1_DECL(set_border_color, const Color &);
OPENXR_LAYER_FUNC1_DECL(set_pose_space, PoseSpace);
OPENXR_LAYER_FUNC1_DECL(set_eye_visibility, EyeVisibility);
OPENXR_LAYER_FUNC1_DECL(set_quad_size, const Size2 &);
OPENXR_LAYER_FUNC1_DECL(set_cylinder_radius, float);
OPENXR_LAYER_FUNC1_DECL(set_cylinder_aspect_ratio, float);
OPENXR_LAYER_FUNC1_DECL(set_cylinder_central_angle, float);
OPENXR_LAYER_FUNC1_DECL(set_equirect_radius, float);
OPENXR_LAYER_FUNC1_DECL(set_equirect_central_horizontal_angle, float);
OPENXR_LAYER_FUNC1_DECL(set_equirect_upper_vertical_angle, float);
OPENXR_LAYER_FUNC1_DECL(set_equirect_lower_vertical_angle, float);
#undef OPENXR_LAYER_FUNC1_DECL
#undef OPENXR_LAYER_FUNC2_DECL
Ref<JavaObject> composition_layer_get_android_surface(RID p_layer);
@ -311,6 +303,3 @@ VARIANT_ENUM_CAST(OpenXRCompositionLayerExtension::Wrap);
VARIANT_ENUM_CAST(OpenXRCompositionLayerExtension::Swizzle);
VARIANT_ENUM_CAST(OpenXRCompositionLayerExtension::PoseSpace);
VARIANT_ENUM_CAST(OpenXRCompositionLayerExtension::EyeVisibility);
#undef OPENXR_LAYER_FUNC1
#undef OPENXR_LAYER_FUNC2

14
modules/openxr/extensions/openxr_fb_foveation_extension.cpp
View file

@ -29,10 +29,12 @@
/**************************************************************************/
#include "openxr_fb_foveation_extension.h"
#include "core/config/project_settings.h"
#include "openxr_eye_gaze_interaction.h"
#include "../openxr_platform_inc.h"
#include "openxr_eye_gaze_interaction.h"
#include "core/config/project_settings.h"
#include "servers/rendering/rendering_server.h"
OpenXRFBFoveationExtension *OpenXRFBFoveationExtension::singleton = nullptr;
@ -282,3 +284,11 @@ void OpenXRFBFoveationExtension::_update_profile_rt() {
print_line("OpenXR: Unable to destroy the foveation profile [", openxr_api->get_error_string(result), "]");
}
}
void OpenXRFBFoveationExtension::update_profile() {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp(this, &OpenXRFBFoveationExtension::_update_profile_rt));
}

8
modules/openxr/extensions/openxr_fb_foveation_extension.h
View file

@ -92,13 +92,7 @@ private:
void _update_profile_rt();
void update_profile() {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp(this, &OpenXRFBFoveationExtension::_update_profile_rt));
}
void update_profile();
// Enable foveation on this swapchain
XrSwapchainCreateInfoFoveationFB swapchain_create_info_foveation_fb;

2
modules/openxr/extensions/platform/openxr_metal_extension.mm
View file

@ -34,7 +34,7 @@
#import "drivers/metal/rendering_device_driver_metal.h"
#include "servers/rendering/rendering_device.h"
#include "servers/rendering/rendering_server_globals.h"
#include "servers/rendering/rendering_server.h"
HashMap<String, bool *> OpenXRMetalExtension::get_requested_extensions(XrVersion p_version) {
HashMap<String, bool *> request_extensions;

4
modules/openxr/extensions/platform/openxr_opengl_extension.cpp
View file

@ -34,11 +34,7 @@
#include "../../openxr_util.h"
#include "core/templates/rb_map.h"
#include "drivers/gles3/effects/copy_effects.h"
#include "drivers/gles3/storage/texture_storage.h"
#include "servers/rendering/rendering_server.h"
#include "servers/rendering/rendering_server_globals.h"
// OpenXR requires us to submit sRGB textures so that it recognizes the content
// as being in sRGB color space. We do fall back on "normal" textures but this

63
modules/openxr/openxr_api.cpp
View file

@ -38,6 +38,7 @@
#include "core/os/memory.h"
#include "core/profiling/profiling.h"
#include "core/version.h"
#include "servers/rendering/rendering_server.h"
#include "openxr_platform_inc.h"
@ -2268,6 +2269,68 @@ void OpenXRAPI::_update_main_swapchain_size_rt() {
#endif
}
void OpenXRAPI::allocate_view_buffers(uint32_t p_view_count, bool p_submit_depth_buffer) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_allocate_view_buffers_rt).bind(p_view_count, p_submit_depth_buffer));
}
void OpenXRAPI::set_render_session_running(bool p_is_running) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_session_running_rt).bind(p_is_running));
}
void OpenXRAPI::set_render_display_info(XrTime p_predicted_display_time, bool p_should_render) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_display_info_rt).bind(p_predicted_display_time, p_should_render));
}
void OpenXRAPI::set_render_play_space(XrSpace p_play_space) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_play_space_rt).bind(uint64_t(p_play_space)));
}
void OpenXRAPI::set_render_environment_blend_mode(XrEnvironmentBlendMode p_mode) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_environment_blend_mode_rt).bind((int32_t)p_mode));
}
void OpenXRAPI::set_render_state_multiplier(double p_render_target_size_multiplier) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_state_multiplier_rt).bind(p_render_target_size_multiplier));
}
void OpenXRAPI::set_render_state_render_region(const Rect2i &p_render_region) {
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_state_render_region_rt).bind(p_render_region));
}
void OpenXRAPI::update_main_swapchain_size() {
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_update_main_swapchain_size_rt));
}
bool OpenXRAPI::process() {
ERR_FAIL_COND_V(instance == XR_NULL_HANDLE, false);

69
modules/openxr/openxr_api.h
View file

@ -41,7 +41,6 @@
#include "core/string/ustring.h"
#include "core/templates/rid_owner.h"
#include "core/templates/vector.h"
#include "servers/rendering/rendering_server.h"
#include "servers/xr/xr_pose.h"
#include <openxr/openxr.h>
@ -392,68 +391,16 @@ private:
static void _set_render_state_render_region_rt(const Rect2i &p_render_region);
static void _update_main_swapchain_size_rt();
_FORCE_INLINE_ void allocate_view_buffers(uint32_t p_view_count, bool p_submit_depth_buffer) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_allocate_view_buffers_rt).bind(p_view_count, p_submit_depth_buffer));
}
_FORCE_INLINE_ void set_render_session_running(bool p_is_running) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_session_running_rt).bind(p_is_running));
}
_FORCE_INLINE_ void set_render_display_info(XrTime p_predicted_display_time, bool p_should_render) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_display_info_rt).bind(p_predicted_display_time, p_should_render));
}
_FORCE_INLINE_ void set_render_play_space(XrSpace p_play_space) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_play_space_rt).bind(uint64_t(p_play_space)));
}
_FORCE_INLINE_ void set_render_environment_blend_mode(XrEnvironmentBlendMode p_mode) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_environment_blend_mode_rt).bind((int32_t)p_mode));
}
_FORCE_INLINE_ void set_render_state_multiplier(double p_render_target_size_multiplier) {
// If we're rendering on a separate thread, we may still be processing the last frame, don't communicate this till we're ready...
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_state_multiplier_rt).bind(p_render_target_size_multiplier));
}
_FORCE_INLINE_ void set_render_state_render_region(const Rect2i &p_render_region) {
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_set_render_state_render_region_rt).bind(p_render_region));
}
void allocate_view_buffers(uint32_t p_view_count, bool p_submit_depth_buffer);
void set_render_session_running(bool p_is_running);
void set_render_display_info(XrTime p_predicted_display_time, bool p_should_render);
void set_render_play_space(XrSpace p_play_space);
void set_render_environment_blend_mode(XrEnvironmentBlendMode p_mode);
void set_render_state_multiplier(double p_render_target_size_multiplier);
void set_render_state_render_region(const Rect2i &p_render_region);
public:
_FORCE_INLINE_ void update_main_swapchain_size() {
RenderingServer *rendering_server = RenderingServer::get_singleton();
ERR_FAIL_NULL(rendering_server);
rendering_server->call_on_render_thread(callable_mp_static(&OpenXRAPI::_update_main_swapchain_size_rt));
}
void update_main_swapchain_size();
XrVersion get_openxr_version() const { return openxr_version; }
XrInstance get_instance() const { return instance; }

2
modules/openxr/openxr_api_extension.cpp
View file

@ -33,6 +33,8 @@
#include "extensions/openxr_extension_wrapper.h"
#include "openxr_api_extension.compat.inc"
#include "servers/rendering/rendering_server.h" // ERR_NOT_ON_RENDER_THREAD_V
void OpenXRAPIExtension::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_openxr_version"), &OpenXRAPIExtension::get_openxr_version);
ClassDB::bind_method(D_METHOD("get_instance"), &OpenXRAPIExtension::get_instance);

15
modules/openxr/openxr_interface.cpp
View file

@ -30,14 +30,15 @@
#include "openxr_interface.h"
#include "core/io/resource_loader.h"
#include "core/io/resource_saver.h"
#include "extensions/openxr_eye_gaze_interaction.h"
#include "extensions/openxr_hand_interaction_extension.h"
#include "extensions/openxr_performance_settings_extension.h"
#include "extensions/openxr_user_presence_extension.h"
#include "servers/rendering/renderer_compositor.h"
#include "core/io/resource_loader.h"
#include "core/io/resource_saver.h"
#include "servers/display/display_server.h"
#include "servers/rendering/rendering_server_types.h"
#include <openxr/openxr.h>
@ -1253,13 +1254,13 @@ bool OpenXRInterface::pre_draw_viewport(RID p_render_target) {
}
}
Vector<BlitToScreen> OpenXRInterface::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
Vector<BlitToScreen> blit_to_screen;
Vector<RenderingServerTypes::BlitToScreen> OpenXRInterface::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
Vector<RenderingServerTypes::BlitToScreen> blit_to_screen;
#ifndef ANDROID_ENABLED
// If separate HMD we should output one eye to screen
if (p_screen_rect != Rect2()) {
BlitToScreen blit;
RenderingServerTypes::BlitToScreen blit;
blit.render_target = p_render_target;
blit.multi_view.use_layer = true;

3
modules/openxr/openxr_interface.h
View file

@ -59,6 +59,7 @@
#include "servers/xr/xr_controller_tracker.h"
#include "servers/xr/xr_interface.h"
#include "servers/xr/xr_vrs.h"
// declare some default strings
#define INTERACTION_PROFILE_NONE "/interaction_profiles/none"
@ -193,7 +194,7 @@ public:
virtual void process() override;
virtual void pre_render() override;
bool pre_draw_viewport(RID p_render_target) override;
virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual Vector<RenderingServerTypes::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;

6
modules/webxr/webxr_interface_js.cpp
View file

@ -40,8 +40,6 @@
#include "scene/main/scene_tree.h"
#include "scene/main/window.h"
#include "scene/scene_string_names.h"
#include "servers/rendering/renderer_compositor.h"
#include "servers/rendering/rendering_server_globals.h"
#include "servers/xr/xr_hand_tracker.h"
#include <emscripten.h>
@ -523,8 +521,8 @@ bool WebXRInterfaceJS::pre_draw_viewport(RID p_render_target) {
return true;
}
Vector<BlitToScreen> WebXRInterfaceJS::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
Vector<BlitToScreen> blit_to_screen;
Vector<RenderingServerTypes::BlitToScreen> WebXRInterfaceJS::post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) {
Vector<RenderingServerTypes::BlitToScreen> blit_to_screen;
GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
if (texture_storage == nullptr) {

2
modules/webxr/webxr_interface_js.h
View file

@ -134,7 +134,7 @@ public:
virtual Transform3D get_transform_for_view(uint32_t p_view, const Transform3D &p_cam_transform) override;
virtual Projection get_projection_for_view(uint32_t p_view, double p_aspect, double p_z_near, double p_z_far) override;
virtual bool pre_draw_viewport(RID p_render_target) override;
virtual Vector<BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual Vector<RenderingServerTypes::BlitToScreen> post_draw_viewport(RID p_render_target, const Rect2 &p_screen_rect) override;
virtual RID get_color_texture() override;
virtual RID get_depth_texture() override;
virtual RID get_velocity_texture() override;