matrixfurry.com
The open source OpenXR runtime
st/oxr: Improve Vulkan code
* Standardise argument names for VkInstance and PFN_vkGetInstanceProcAddr.
* Use helper define to load functions.
* Mark loaded functions very clearly.
Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2619>
authored by
Jakob Bornecrantz
and committed by
Marge Bot
9a5907dc
4329ac1d
+41
-45
src/xrt/state_trackers/oxr/oxr_vulkan.c
+41
-45
src/xrt/state_trackers/oxr/oxr_vulkan.c
···
1
1
// Copyright 2018-2024, Collabora, Ltd.
2
+
// Copyright 2024-2025, NVIDIA CORPORATION.
2
3
// SPDX-License-Identifier: BSL-1.0
3
4
/*!
4
5
* @file
···
31
32
*
32
33
*/
33
34
34
-
#define GET_PROC(name) PFN_##name name = (PFN_##name)getProc(vkInstance, #name)
35
+
#define GET_PROC(INST, NAME) PFN_vk##NAME loaded_##NAME = (PFN_vk##NAME)vulkanGetInstanceProcAddr(INST, "vk" #NAME)
35
36
36
37
#define UUID_STR_SIZE (XRT_UUID_SIZE * 3 + 1)
37
38
···
190
191
191
192
static XrResult
192
193
vk_get_instance_ext_props(struct oxr_logger *log,
193
-
VkInstance instance,
194
-
PFN_vkGetInstanceProcAddr GetInstanceProcAddr,
194
+
VkInstance vulkanInstance,
195
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr,
195
196
VkExtensionProperties **out_props,
196
197
uint32_t *out_prop_count)
197
198
{
198
-
PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties =
199
-
(PFN_vkEnumerateInstanceExtensionProperties)GetInstanceProcAddr(NULL,
200
-
"vkEnumerateInstanceExtensionProperties");
199
+
GET_PROC(vulkanInstance, EnumerateInstanceExtensionProperties);
201
200
202
-
if (!EnumerateInstanceExtensionProperties) {
201
+
if (!loaded_EnumerateInstanceExtensionProperties) {
203
202
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
204
-
"Failed to get EnumerateInstanceExtensionProperties fp");
203
+
"Failed to get vkEnumerateInstanceExtensionProperties function pointer.");
205
204
}
206
205
207
206
uint32_t prop_count = 0;
208
-
VkResult res = EnumerateInstanceExtensionProperties(NULL, &prop_count, NULL);
207
+
VkResult res = loaded_EnumerateInstanceExtensionProperties(NULL, &prop_count, NULL);
209
208
if (res != VK_SUCCESS) {
210
209
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
211
210
"Failed to enumerate instance extension properties count (%d)", res);
···
214
213
215
214
VkExtensionProperties *props = U_TYPED_ARRAY_CALLOC(VkExtensionProperties, prop_count);
216
215
217
-
res = EnumerateInstanceExtensionProperties(NULL, &prop_count, props);
216
+
res = loaded_EnumerateInstanceExtensionProperties(NULL, &prop_count, props);
218
217
if (res != VK_SUCCESS) {
219
218
free(props);
220
219
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
···
235
234
VkResult *vulkanResult)
236
235
{
237
236
238
-
PFN_vkGetInstanceProcAddr GetInstanceProcAddr = createInfo->pfnGetInstanceProcAddr;
237
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr = createInfo->pfnGetInstanceProcAddr;
238
+
GET_PROC(NULL, CreateInstance);
239
239
240
-
PFN_vkCreateInstance CreateInstance = (PFN_vkCreateInstance)GetInstanceProcAddr(NULL, "vkCreateInstance");
241
-
if (!CreateInstance) {
240
+
if (!loaded_CreateInstance) {
242
241
//! @todo: clarify in spec
243
242
*vulkanResult = VK_ERROR_INITIALIZATION_FAILED;
244
243
return XR_SUCCESS;
···
284
283
modified_info.ppEnabledExtensionNames = u_string_list_get_data(instance_ext_list);
285
284
modified_info.enabledExtensionCount = u_string_list_get_size(instance_ext_list);
286
285
287
-
*vulkanResult = CreateInstance(&modified_info, createInfo->vulkanAllocator, vulkanInstance);
286
+
*vulkanResult = loaded_CreateInstance(&modified_info, createInfo->vulkanAllocator, vulkanInstance);
288
287
289
288
290
289
// Logging
···
315
314
316
315
static XrResult
317
316
vk_get_device_ext_props(struct oxr_logger *log,
318
-
VkInstance instance,
319
-
PFN_vkGetInstanceProcAddr GetInstanceProcAddr,
317
+
VkInstance vulkanInstance,
318
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr,
320
319
VkPhysicalDevice physical_device,
321
320
VkExtensionProperties **out_props,
322
321
uint32_t *out_prop_count)
323
322
{
324
-
PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties =
325
-
(PFN_vkEnumerateDeviceExtensionProperties)GetInstanceProcAddr(instance,
326
-
"vkEnumerateDeviceExtensionProperties");
323
+
GET_PROC(vulkanInstance, EnumerateDeviceExtensionProperties);
327
324
328
-
if (!EnumerateDeviceExtensionProperties) {
325
+
if (!loaded_EnumerateDeviceExtensionProperties) {
329
326
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
330
-
"Failed to get vkEnumerateDeviceExtensionProperties fp");
327
+
"Failed to get vkEnumerateDeviceExtensionProperties function pointer");
331
328
}
332
329
333
330
uint32_t prop_count = 0;
334
-
VkResult res = EnumerateDeviceExtensionProperties(physical_device, NULL, &prop_count, NULL);
331
+
VkResult res = loaded_EnumerateDeviceExtensionProperties(physical_device, NULL, &prop_count, NULL);
335
332
if (res != VK_SUCCESS) {
336
333
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
337
334
"Failed to enumerate device extension properties count (%d)", res);
···
340
337
341
338
VkExtensionProperties *props = U_TYPED_ARRAY_CALLOC(VkExtensionProperties, prop_count);
342
339
343
-
res = EnumerateDeviceExtensionProperties(physical_device, NULL, &prop_count, props);
340
+
res = loaded_EnumerateDeviceExtensionProperties(physical_device, NULL, &prop_count, props);
344
341
if (res != VK_SUCCESS) {
345
342
free(props);
346
343
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Failed to enumerate device extension properties (%d)",
···
355
352
356
353
static XrResult
357
354
vk_get_device_features(struct oxr_logger *log,
358
-
VkInstance instance,
359
-
PFN_vkGetInstanceProcAddr GetInstanceProcAddr,
355
+
VkInstance vulkanInstance,
356
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr,
360
357
VkPhysicalDevice physical_device,
361
358
VkPhysicalDeviceFeatures2KHR *physical_device_features)
362
359
{
363
-
PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2 =
364
-
(PFN_vkGetPhysicalDeviceFeatures2KHR)GetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR");
360
+
GET_PROC(vulkanInstance, GetPhysicalDeviceFeatures2KHR);
365
361
366
-
if (!GetPhysicalDeviceFeatures2) {
367
-
oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Failed to get vkGetPhysicalDeviceFeatures2 fp");
362
+
if (!loaded_GetPhysicalDeviceFeatures2KHR) {
363
+
oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Failed to get vkGetPhysicalDeviceFeatures2KHR fp");
368
364
}
369
365
370
-
GetPhysicalDeviceFeatures2( //
371
-
physical_device, // physicalDevice
372
-
physical_device_features); // pFeatures
366
+
loaded_GetPhysicalDeviceFeatures2KHR( //
367
+
physical_device, // physicalDevice
368
+
physical_device_features); // pFeatures
373
369
374
370
return XR_SUCCESS;
375
371
}
···
395
391
{
396
392
XrResult res;
397
393
398
-
PFN_vkGetInstanceProcAddr GetInstanceProcAddr = createInfo->pfnGetInstanceProcAddr;
394
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr = createInfo->pfnGetInstanceProcAddr;
395
+
GET_PROC(sys->vulkan_enable2_instance, CreateDevice);
399
396
400
-
PFN_vkCreateDevice CreateDevice =
401
-
(PFN_vkCreateDevice)GetInstanceProcAddr(sys->vulkan_enable2_instance, "vkCreateDevice");
402
-
if (!CreateDevice) {
397
+
if (!loaded_CreateDevice) {
403
398
//! @todo: clarify in spec
404
399
*vulkanResult = VK_ERROR_INITIALIZATION_FAILED;
405
400
return XR_SUCCESS;
···
513
508
}
514
509
#endif
515
510
516
-
*vulkanResult = CreateDevice(physical_device, &modified_info, createInfo->vulkanAllocator, vulkanDevice);
511
+
*vulkanResult = loaded_CreateDevice(physical_device, &modified_info, createInfo->vulkanAllocator, vulkanDevice);
517
512
518
513
519
514
// Logging
···
571
566
oxr_vk_get_physical_device(struct oxr_logger *log,
572
567
struct oxr_instance *inst,
573
568
struct oxr_system *sys,
574
-
VkInstance vkInstance,
575
-
PFN_vkGetInstanceProcAddr getProc,
569
+
VkInstance vulkanInstance,
570
+
PFN_vkGetInstanceProcAddr vulkanGetInstanceProcAddr,
576
571
VkPhysicalDevice *vkPhysicalDevice)
577
572
{
578
-
GET_PROC(vkEnumeratePhysicalDevices);
579
-
GET_PROC(vkGetPhysicalDeviceProperties2KHR);
573
+
GET_PROC(vulkanInstance, EnumeratePhysicalDevices);
574
+
GET_PROC(vulkanInstance, GetPhysicalDeviceProperties2KHR);
575
+
580
576
VkResult vk_ret;
581
577
uint32_t count;
582
578
···
584
580
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, " sys->xsysc == NULL");
585
581
}
586
582
587
-
vk_ret = vkEnumeratePhysicalDevices(vkInstance, &count, NULL);
583
+
vk_ret = loaded_EnumeratePhysicalDevices(vulkanInstance, &count, NULL);
588
584
if (vk_ret != VK_SUCCESS) {
589
585
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Call to vkEnumeratePhysicalDevices returned %u",
590
586
vk_ret);
···
595
591
}
596
592
597
593
VkPhysicalDevice *phys = U_TYPED_ARRAY_CALLOC(VkPhysicalDevice, count);
598
-
vk_ret = vkEnumeratePhysicalDevices(vkInstance, &count, phys);
594
+
vk_ret = loaded_EnumeratePhysicalDevices(vulkanInstance, &count, phys);
599
595
if (vk_ret != VK_SUCCESS) {
600
596
free(phys);
601
597
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Call to vkEnumeratePhysicalDevices returned %u",
···
622
618
.pNext = &pdidp,
623
619
};
624
620
625
-
vkGetPhysicalDeviceProperties2KHR(phys[i], &pdp2);
621
+
loaded_GetPhysicalDeviceProperties2KHR(phys[i], &pdp2);
626
622
627
623
// These should always be true
628
624
static_assert(VK_UUID_SIZE == XRT_UUID_SIZE, "uuid sizes mismatch");
···
656
652
657
653
// vulkan_enable2 needs the physical device in xrCreateVulkanDeviceKHR
658
654
if (inst->extensions.KHR_vulkan_enable2) {
659
-
sys->vulkan_enable2_instance = vkInstance;
655
+
sys->vulkan_enable2_instance = vulkanInstance;
660
656
}
661
657
sys->suggested_vulkan_physical_device = *vkPhysicalDevice;
662
658
if (log_level <= U_LOGGING_DEBUG) {