CoCalc -- openxr_api_extension.cpp

GitHub Repository: godotengine/godot
Path: blob/master/modules/openxr/openxr_api_extension.cpp
¹⁰²⁷⁷ views
1
/**************************************************************************/
2
/*  openxr_api_extension.cpp                                              */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#include "openxr_api_extension.h"
32

33
#include "extensions/openxr_extension_wrapper.h"
34
#include "openxr_api_extension.compat.inc"
35

36
void OpenXRAPIExtension::_bind_methods() {
37
	ClassDB::bind_method(D_METHOD("get_instance"), &OpenXRAPIExtension::get_instance);
38
	ClassDB::bind_method(D_METHOD("get_system_id"), &OpenXRAPIExtension::get_system_id);
39
	ClassDB::bind_method(D_METHOD("get_session"), &OpenXRAPIExtension::get_session);
40

41
	ClassDB::bind_method(D_METHOD("transform_from_pose", "pose"), &OpenXRAPIExtension::transform_from_pose);
42
	ClassDB::bind_method(D_METHOD("xr_result", "result", "format", "args"), &OpenXRAPIExtension::xr_result);
43
	ClassDB::bind_static_method("OpenXRAPIExtension", D_METHOD("openxr_is_enabled", "check_run_in_editor"), &OpenXRAPIExtension::openxr_is_enabled);
44
	ClassDB::bind_method(D_METHOD("get_instance_proc_addr", "name"), &OpenXRAPIExtension::get_instance_proc_addr);
45
	ClassDB::bind_method(D_METHOD("get_error_string", "result"), &OpenXRAPIExtension::get_error_string);
46
	ClassDB::bind_method(D_METHOD("get_swapchain_format_name", "swapchain_format"), &OpenXRAPIExtension::get_swapchain_format_name);
47
	ClassDB::bind_method(D_METHOD("set_object_name", "object_type", "object_handle", "object_name"), &OpenXRAPIExtension::set_object_name);
48
	ClassDB::bind_method(D_METHOD("begin_debug_label_region", "label_name"), &OpenXRAPIExtension::begin_debug_label_region);
49
	ClassDB::bind_method(D_METHOD("end_debug_label_region"), &OpenXRAPIExtension::end_debug_label_region);
50
	ClassDB::bind_method(D_METHOD("insert_debug_label", "label_name"), &OpenXRAPIExtension::insert_debug_label);
51

52
	ClassDB::bind_method(D_METHOD("is_initialized"), &OpenXRAPIExtension::is_initialized);
53
	ClassDB::bind_method(D_METHOD("is_running"), &OpenXRAPIExtension::is_running);
54

55
	ClassDB::bind_method(D_METHOD("set_custom_play_space", "space"), &OpenXRAPIExtension::set_custom_play_space);
56
	ClassDB::bind_method(D_METHOD("get_play_space"), &OpenXRAPIExtension::get_play_space);
57
	ClassDB::bind_method(D_METHOD("get_predicted_display_time"), &OpenXRAPIExtension::get_predicted_display_time);
58
	ClassDB::bind_method(D_METHOD("get_next_frame_time"), &OpenXRAPIExtension::get_next_frame_time);
59
	ClassDB::bind_method(D_METHOD("can_render"), &OpenXRAPIExtension::can_render);
60

61
	ClassDB::bind_method(D_METHOD("find_action", "name", "action_set"), &OpenXRAPIExtension::find_action);
62
	ClassDB::bind_method(D_METHOD("action_get_handle", "action"), &OpenXRAPIExtension::action_get_handle);
63

64
	ClassDB::bind_method(D_METHOD("get_hand_tracker", "hand_index"), &OpenXRAPIExtension::get_hand_tracker);
65

66
	ClassDB::bind_method(D_METHOD("register_composition_layer_provider", "extension"), &OpenXRAPIExtension::register_composition_layer_provider);
67
	ClassDB::bind_method(D_METHOD("unregister_composition_layer_provider", "extension"), &OpenXRAPIExtension::unregister_composition_layer_provider);
68

69
	ClassDB::bind_method(D_METHOD("register_projection_views_extension", "extension"), &OpenXRAPIExtension::register_projection_views_extension);
70
	ClassDB::bind_method(D_METHOD("unregister_projection_views_extension", "extension"), &OpenXRAPIExtension::unregister_projection_views_extension);
71

72
	ClassDB::bind_method(D_METHOD("register_frame_info_extension", "extension"), &OpenXRAPIExtension::register_frame_info_extension);
73
	ClassDB::bind_method(D_METHOD("unregister_frame_info_extension", "extension"), &OpenXRAPIExtension::unregister_frame_info_extension);
74

75
	ClassDB::bind_method(D_METHOD("get_render_state_z_near"), &OpenXRAPIExtension::get_render_state_z_near);
76
	ClassDB::bind_method(D_METHOD("get_render_state_z_far"), &OpenXRAPIExtension::get_render_state_z_far);
77

78
	ClassDB::bind_method(D_METHOD("set_velocity_texture", "render_target"), &OpenXRAPIExtension::set_velocity_texture);
79
	ClassDB::bind_method(D_METHOD("set_velocity_depth_texture", "render_target"), &OpenXRAPIExtension::set_velocity_depth_texture);
80
	ClassDB::bind_method(D_METHOD("set_velocity_target_size", "target_size"), &OpenXRAPIExtension::set_velocity_target_size);
81

82
	ClassDB::bind_method(D_METHOD("get_supported_swapchain_formats"), &OpenXRAPIExtension::get_supported_swapchain_formats);
83

84
	ClassDB::bind_method(D_METHOD("openxr_swapchain_create", "create_flags", "usage_flags", "swapchain_format", "width", "height", "sample_count", "array_size"), &OpenXRAPIExtension::openxr_swapchain_create);
85
	ClassDB::bind_method(D_METHOD("openxr_swapchain_free", "swapchain"), &OpenXRAPIExtension::openxr_swapchain_free);
86
	ClassDB::bind_method(D_METHOD("openxr_swapchain_get_swapchain", "swapchain"), &OpenXRAPIExtension::openxr_swapchain_get_swapchain);
87
	ClassDB::bind_method(D_METHOD("openxr_swapchain_acquire", "swapchain"), &OpenXRAPIExtension::openxr_swapchain_acquire);
88
	ClassDB::bind_method(D_METHOD("openxr_swapchain_get_image", "swapchain"), &OpenXRAPIExtension::openxr_swapchain_get_image);
89
	ClassDB::bind_method(D_METHOD("openxr_swapchain_release", "swapchain"), &OpenXRAPIExtension::openxr_swapchain_release);
90

91
	ClassDB::bind_method(D_METHOD("get_projection_layer"), &OpenXRAPIExtension::get_projection_layer);
92

93
	ClassDB::bind_method(D_METHOD("set_render_region", "render_region"), &OpenXRAPIExtension::set_render_region);
94

95
	ClassDB::bind_method(D_METHOD("set_emulate_environment_blend_mode_alpha_blend", "enabled"), &OpenXRAPIExtension::set_emulate_environment_blend_mode_alpha_blend);
96
	ClassDB::bind_method(D_METHOD("is_environment_blend_mode_alpha_supported"), &OpenXRAPIExtension::is_environment_blend_mode_alpha_blend_supported);
97

98
	BIND_ENUM_CONSTANT(OPENXR_ALPHA_BLEND_MODE_SUPPORT_NONE);
99
	BIND_ENUM_CONSTANT(OPENXR_ALPHA_BLEND_MODE_SUPPORT_REAL);
100
	BIND_ENUM_CONSTANT(OPENXR_ALPHA_BLEND_MODE_SUPPORT_EMULATING);
101
}
102

103
uint64_t OpenXRAPIExtension::get_instance() {
104
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
105
	return (uint64_t)OpenXRAPI::get_singleton()->get_instance();
106
}
107

108
uint64_t OpenXRAPIExtension::get_system_id() {
109
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
110
	return (uint64_t)OpenXRAPI::get_singleton()->get_system_id();
111
}
112

113
uint64_t OpenXRAPIExtension::get_session() {
114
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
115
	return (uint64_t)OpenXRAPI::get_singleton()->get_session();
116
}
117

118
Transform3D OpenXRAPIExtension::transform_from_pose(GDExtensionConstPtr<const void> p_pose) {
119
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), Transform3D());
120
	return OpenXRAPI::get_singleton()->transform_from_pose(*(XrPosef *)p_pose.data);
121
}
122

123
bool OpenXRAPIExtension::xr_result(uint64_t result, String format, Array args) {
124
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
125
	return OpenXRAPI::get_singleton()->xr_result((XrResult)result, format.utf8().get_data(), args);
126
}
127

128
bool OpenXRAPIExtension::openxr_is_enabled(bool p_check_run_in_editor) {
129
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
130
	return OpenXRAPI::openxr_is_enabled(p_check_run_in_editor);
131
}
132

133
uint64_t OpenXRAPIExtension::get_instance_proc_addr(String p_name) {
134
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
135
	CharString str = p_name.utf8();
136
	PFN_xrVoidFunction addr = nullptr;
137
	XrResult result = OpenXRAPI::get_singleton()->get_instance_proc_addr(str.get_data(), &addr);
138
	if (result != XR_SUCCESS) {
139
		return 0;
140
	}
141
	return reinterpret_cast<uint64_t>(addr);
142
}
143

144
String OpenXRAPIExtension::get_error_string(uint64_t result) {
145
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), String());
146
	return OpenXRAPI::get_singleton()->get_error_string((XrResult)result);
147
}
148

149
String OpenXRAPIExtension::get_swapchain_format_name(int64_t p_swapchain_format) {
150
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), String());
151
	return OpenXRAPI::get_singleton()->get_swapchain_format_name(p_swapchain_format);
152
}
153

154
void OpenXRAPIExtension::set_object_name(int64_t p_object_type, uint64_t p_object_handle, const String &p_object_name) {
155
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
156

157
	OpenXRAPI::get_singleton()->set_object_name(XrObjectType(p_object_type), p_object_handle, p_object_name);
158
}
159

160
void OpenXRAPIExtension::begin_debug_label_region(const String &p_label_name) {
161
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
162

163
	OpenXRAPI::get_singleton()->begin_debug_label_region(p_label_name);
164
}
165

166
void OpenXRAPIExtension::end_debug_label_region() {
167
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
168

169
	OpenXRAPI::get_singleton()->end_debug_label_region();
170
}
171

172
void OpenXRAPIExtension::insert_debug_label(const String &p_label_name) {
173
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
174

175
	OpenXRAPI::get_singleton()->insert_debug_label(p_label_name);
176
}
177

178
bool OpenXRAPIExtension::is_initialized() {
179
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
180
	return OpenXRAPI::get_singleton()->is_initialized();
181
}
182

183
bool OpenXRAPIExtension::is_running() {
184
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
185
	return OpenXRAPI::get_singleton()->is_running();
186
}
187

188
void OpenXRAPIExtension::set_custom_play_space(GDExtensionConstPtr<const void> p_custom_space) {
189
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
190
	OpenXRAPI::get_singleton()->set_custom_play_space(*(XrSpace *)p_custom_space.data);
191
}
192

193
uint64_t OpenXRAPIExtension::get_play_space() {
194
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
195
	return (uint64_t)OpenXRAPI::get_singleton()->get_play_space();
196
}
197

198
int64_t OpenXRAPIExtension::get_predicted_display_time() {
199
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
200
	return (XrTime)OpenXRAPI::get_singleton()->get_predicted_display_time();
201
}
202

203
int64_t OpenXRAPIExtension::get_next_frame_time() {
204
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
205

206
	// In the past we needed to look a frame ahead, may be calling this unintentionally so lets warn the dev.
207
	WARN_PRINT_ONCE("OpenXR: Next frame timing called, verify this is intended.");
208

209
	return (XrTime)OpenXRAPI::get_singleton()->get_next_frame_time();
210
}
211

212
bool OpenXRAPIExtension::can_render() {
213
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), false);
214
	return OpenXRAPI::get_singleton()->can_render();
215
}
216

217
RID OpenXRAPIExtension::find_action(const String &p_name, const RID &p_action_set) {
218
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), RID());
219
	return OpenXRAPI::get_singleton()->find_action(p_name, p_action_set);
220
}
221

222
uint64_t OpenXRAPIExtension::action_get_handle(RID p_action) {
223
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
224
	XrAction action_handle = OpenXRAPI::get_singleton()->action_get_handle(p_action);
225
	return (uint64_t)action_handle;
226
}
227

228
uint64_t OpenXRAPIExtension::get_hand_tracker(int p_hand_index) {
229
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
230
	return (uint64_t)OpenXRAPI::get_singleton()->get_hand_tracker(p_hand_index);
231
}
232

233
void OpenXRAPIExtension::register_composition_layer_provider(OpenXRExtensionWrapper *p_extension) {
234
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
235
	OpenXRAPI::get_singleton()->register_composition_layer_provider(p_extension);
236
}
237

238
void OpenXRAPIExtension::unregister_composition_layer_provider(OpenXRExtensionWrapper *p_extension) {
239
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
240
	OpenXRAPI::get_singleton()->unregister_composition_layer_provider(p_extension);
241
}
242

243
void OpenXRAPIExtension::register_projection_views_extension(OpenXRExtensionWrapper *p_extension) {
244
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
245
	OpenXRAPI::get_singleton()->register_projection_views_extension(p_extension);
246
}
247

248
void OpenXRAPIExtension::unregister_projection_views_extension(OpenXRExtensionWrapper *p_extension) {
249
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
250
	OpenXRAPI::get_singleton()->unregister_projection_views_extension(p_extension);
251
}
252

253
void OpenXRAPIExtension::register_frame_info_extension(OpenXRExtensionWrapper *p_extension) {
254
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
255
	OpenXRAPI::get_singleton()->register_frame_info_extension(p_extension);
256
}
257

258
void OpenXRAPIExtension::unregister_frame_info_extension(OpenXRExtensionWrapper *p_extension) {
259
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
260
	OpenXRAPI::get_singleton()->unregister_frame_info_extension(p_extension);
261
}
262

263
double OpenXRAPIExtension::get_render_state_z_near() {
264
	ERR_NOT_ON_RENDER_THREAD_V(0.0);
265
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0.0);
266
	return OpenXRAPI::get_singleton()->get_render_state_z_near();
267
}
268

269
double OpenXRAPIExtension::get_render_state_z_far() {
270
	ERR_NOT_ON_RENDER_THREAD_V(0.0);
271
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0.0);
272
	return OpenXRAPI::get_singleton()->get_render_state_z_far();
273
}
274

275
void OpenXRAPIExtension::set_velocity_texture(RID p_render_target) {
276
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
277
	OpenXRAPI::get_singleton()->set_velocity_texture(p_render_target);
278
}
279

280
void OpenXRAPIExtension::set_velocity_depth_texture(RID p_render_target) {
281
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
282
	OpenXRAPI::get_singleton()->set_velocity_depth_texture(p_render_target);
283
}
284

285
void OpenXRAPIExtension::set_velocity_target_size(const Size2i &p_target_size) {
286
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
287
	OpenXRAPI::get_singleton()->set_velocity_target_size(p_target_size);
288
}
289

290
PackedInt64Array OpenXRAPIExtension::get_supported_swapchain_formats() {
291
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), PackedInt64Array());
292
	return OpenXRAPI::get_singleton()->get_supported_swapchain_formats();
293
}
294

295
uint64_t OpenXRAPIExtension::openxr_swapchain_create(XrSwapchainCreateFlags p_create_flags, XrSwapchainUsageFlags p_usage_flags, int64_t p_swapchain_format, uint32_t p_width, uint32_t p_height, uint32_t p_sample_count, uint32_t p_array_size) {
296
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
297

298
	OpenXRAPI::OpenXRSwapChainInfo *new_swapchain_info = memnew(OpenXRAPI::OpenXRSwapChainInfo);
299
	new_swapchain_info->create(p_create_flags, p_usage_flags, p_swapchain_format, p_width, p_height, p_sample_count, p_array_size);
300
	return reinterpret_cast<uint64_t>(new_swapchain_info);
301
}
302

303
void OpenXRAPIExtension::openxr_swapchain_free(uint64_t p_swapchain_info) {
304
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
305

306
	OpenXRAPI::OpenXRSwapChainInfo *swapchain_info = reinterpret_cast<OpenXRAPI::OpenXRSwapChainInfo *>(p_swapchain_info);
307
	swapchain_info->free();
308
	memfree(swapchain_info);
309
}
310

311
uint64_t OpenXRAPIExtension::openxr_swapchain_get_swapchain(uint64_t p_swapchain_info) {
312
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
313

314
	OpenXRAPI::OpenXRSwapChainInfo *swapchain_info = reinterpret_cast<OpenXRAPI::OpenXRSwapChainInfo *>(p_swapchain_info);
315
	XrSwapchain swapchain = swapchain_info->get_swapchain();
316
	return (uint64_t)swapchain;
317
}
318

319
void OpenXRAPIExtension::openxr_swapchain_acquire(uint64_t p_swapchain_info) {
320
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
321

322
	OpenXRAPI::OpenXRSwapChainInfo *swapchain_info = reinterpret_cast<OpenXRAPI::OpenXRSwapChainInfo *>(p_swapchain_info);
323
	bool should_render = true; // Can ignore should_render.
324
	swapchain_info->acquire(should_render);
325
}
326

327
RID OpenXRAPIExtension::openxr_swapchain_get_image(uint64_t p_swapchain_info) {
328
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), RID());
329

330
	OpenXRAPI::OpenXRSwapChainInfo *swapchain_info = reinterpret_cast<OpenXRAPI::OpenXRSwapChainInfo *>(p_swapchain_info);
331
	return swapchain_info->get_image();
332
}
333

334
void OpenXRAPIExtension::openxr_swapchain_release(uint64_t p_swapchain_info) {
335
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
336

337
	OpenXRAPI::OpenXRSwapChainInfo *swapchain_info = reinterpret_cast<OpenXRAPI::OpenXRSwapChainInfo *>(p_swapchain_info);
338
	swapchain_info->release();
339
}
340

341
uint64_t OpenXRAPIExtension::get_projection_layer() {
342
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), 0);
343
	return (uint64_t)OpenXRAPI::get_singleton()->get_projection_layer();
344
}
345

346
void OpenXRAPIExtension::set_render_region(const Rect2i &p_render_region) {
347
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
348
	OpenXRAPI::get_singleton()->set_render_region(p_render_region);
349
}
350

351
void OpenXRAPIExtension::set_emulate_environment_blend_mode_alpha_blend(bool p_enabled) {
352
	ERR_FAIL_NULL(OpenXRAPI::get_singleton());
353
	OpenXRAPI::get_singleton()->set_emulate_environment_blend_mode_alpha_blend(p_enabled);
354
}
355

356
OpenXRAPIExtension::OpenXRAlphaBlendModeSupport OpenXRAPIExtension::is_environment_blend_mode_alpha_blend_supported() {
357
	ERR_FAIL_NULL_V(OpenXRAPI::get_singleton(), OPENXR_ALPHA_BLEND_MODE_SUPPORT_NONE);
358
	return (OpenXRAPIExtension::OpenXRAlphaBlendModeSupport)OpenXRAPI::get_singleton()->is_environment_blend_mode_alpha_blend_supported();
359
}
360

361
OpenXRAPIExtension::OpenXRAPIExtension() {
362
}
363

364
Product

Resources

Company
