1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Copyright © 2025 Lucas Francisco Fryzek
* SPDX-License-Identifier: MIT
*/
#include "fgvk_instance.h"
#include "fgvk_entrypoints.h"
#include "vulkan/wsi/wsi_common.h"
#include "util/build_id.h"
VKAPI_ATTR VkResult VKAPI_CALL
fgvk_EnumerateInstanceVersion(uint32_t *pApiVersion)
{
uint32_t version_override = vk_get_version_override();
*pApiVersion = version_override ? version_override :
VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
return VK_SUCCESS;
}
static const struct vk_instance_extension_table instance_extensions = {
};
VKAPI_ATTR VkResult VKAPI_CALL
fgvk_EnumerateInstanceExtensionProperties(const char *pLayerName,
uint32_t *pPropertyCount,
VkExtensionProperties *pProperties)
{
if (pLayerName)
return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT);
return vk_enumerate_instance_extension_properties(
&instance_extensions, pPropertyCount, pProperties);
}
VKAPI_ATTR VkResult VKAPI_CALL
fgvk_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance)
{
struct fgvk_instance *instance;
VkResult result;
if (pAllocator == NULL)
pAllocator = vk_default_allocator();
instance = vk_alloc(pAllocator, sizeof(*instance), 8,
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (!instance)
return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
struct vk_instance_dispatch_table dispatch_table;
vk_instance_dispatch_table_from_entrypoints(&dispatch_table,
&fgvk_instance_entrypoints,
true);
vk_instance_dispatch_table_from_entrypoints(&dispatch_table,
&wsi_instance_entrypoints,
false);
result = vk_instance_init(&instance->vk, &instance_extensions,
&dispatch_table, pCreateInfo, pAllocator);
if (result != VK_SUCCESS)
goto fail_alloc;
//fgvk_init_debug_flags(instance);
instance->vk.physical_devices.enumerate = fgvk_physical_device_enumerate;
instance->vk.physical_devices.destroy = fgvk_physical_device_destroy;
const struct build_id_note *note =
build_id_find_nhdr_for_addr(fgvk_CreateInstance);
if (!note) {
result = vk_errorf(NULL, VK_ERROR_INITIALIZATION_FAILED,
"Failed to find build-id");
goto fail_init;
}
unsigned build_id_len = build_id_length(note);
if (build_id_len < SHA1_DIGEST_LENGTH) {
result = vk_errorf(NULL, VK_ERROR_INITIALIZATION_FAILED,
"build-id too short. It needs to be a SHA");
goto fail_init;
}
STATIC_ASSERT(sizeof(instance->driver_build_sha) == SHA1_DIGEST_LENGTH);
memcpy(instance->driver_build_sha, build_id_data(note), SHA1_DIGEST_LENGTH);
*pInstance = fgvk_instance_to_handle(instance);
return VK_SUCCESS;
fail_init:
vk_instance_finish(&instance->vk);
fail_alloc:
vk_free(pAllocator, instance);
return result;
}
VKAPI_ATTR void VKAPI_CALL
fgvk_DestroyInstance(VkInstance _instance,
const VkAllocationCallbacks *pAllocator)
{
VK_FROM_HANDLE(fgvk_instance, instance, _instance);
if (!instance)
return;
vk_instance_finish(&instance->vk);
vk_free(&instance->vk.alloc, instance);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
fgvk_GetInstanceProcAddr(VkInstance _instance, const char *pName)
{
VK_FROM_HANDLE(fgvk_instance, instance, _instance);
return vk_instance_get_proc_addr(&instance->vk,
&fgvk_instance_entrypoints,
pName);
}
PUBLIC VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
vk_icdGetInstanceProcAddr(VkInstance instance, const char *pName)
{
return fgvk_GetInstanceProcAddr(instance, pName);
}
|
