From 02a06bec3fa6d34733a0aa3abacece0151a6ec65 Mon Sep 17 00:00:00 2001 From: ahmad Date: Fri, 9 Oct 2026 23:36:58 +0300 Subject: [PATCH] feat(vkbridge): vertex attribute divisor emulation; host regression suite; dispatch/version fixes - divisor != 1 bindings get stride 0 and are rebound per draw; d > 1 splits draws, with a BaseInstance-as-0 vertex shader variant so DXVK's SV_InstanceID stays exact - device-level dispatch never falls back to a loader trampoline (crashed in vkCmdSetLineStipple) - core commands newer than the device's version are not handed out; the app's instance version is passed through as asked (Zink 26.2 aborted on a 1.4 entry point) - run_tests.sh: smoke, bcn_check, DXVK d3d11_check, vkcube x3, gamescope+Zink, in plain and Mali-imitation modes - 14/14 pass Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR --- app/src/main/cpp/vkbridge/server_emu.h | 14 +- .../main/cpp/vkbridge/server_emu_divisor.c | 454 +++++++++ .../main/cpp/vkbridge/server_emu_features.c | 9 +- app/src/main/cpp/vkbridge/server_emu_layer.c | 7 + app/src/main/cpp/vkbridge/server_emu_shader.c | 44 +- app/src/main/cpp/vkbridge/server_instance.c | 8 - app/src/main/cpp/vkbridge/server_main.c | 7 + tools/vkbridge/client/icd.c | 16 +- tools/vkbridge/client/vkb_client.h | 1 + tools/vkbridge/codegen/gen_vkbridge.py | 15 +- tools/vkbridge/common/gen/vkb_gen.h | 2 +- tools/vkbridge/common/gen/vkb_gen_client.c | 882 +++++++++--------- tools/vkbridge/common/gen/vkb_gen_server.c | 516 +++++----- tools/vkbridge/host/Makefile | 2 +- tools/vkbridge/host/bridge_env.sh | 6 +- tools/vkbridge/host/mali_env.sh | 2 +- tools/vkbridge/host/run_tests.sh | 32 + tools/vkbridge/tests/bcn_check.c | 6 +- 18 files changed, 1289 insertions(+), 734 deletions(-) create mode 100644 app/src/main/cpp/vkbridge/server_emu_divisor.c create mode 100755 tools/vkbridge/host/run_tests.sh diff --git a/app/src/main/cpp/vkbridge/server_emu.h b/app/src/main/cpp/vkbridge/server_emu.h index aa91532f8..0df55d990 100644 --- a/app/src/main/cpp/vkbridge/server_emu.h +++ b/app/src/main/cpp/vkbridge/server_emu.h @@ -5,7 +5,8 @@ #include "vkb_server.h" /* Emulations that are implemented (the rest are never offered to the client). */ -#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE | VKB_EMU_BCN) +#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE | VKB_EMU_BCN | \ + VKB_EMU_DIVISOR) #define VKB_EMU_BUCKETS 1024 @@ -34,6 +35,7 @@ typedef struct vkb_emu_device { vkb_emu_buffer *buffers[VKB_EMU_BUCKETS]; void *bcn; /* server_emu_bcn.c */ void *cmdstate; /* server_emu_cmdstate.c */ + void *divisor; /* server_emu_divisor.c */ void *shaders; /* server_emu_shader.c */ } vkb_emu_device; @@ -42,7 +44,14 @@ void vkb_emu_cmdstate_install(vkb_srv_table *dev); void vkb_emu_cmdstate_uninstall(vkb_srv_table *dev); void vkb_emu_restore_compute(vkb_emu_device *e, VkCommandBuffer cb); void *vkb_emu_cb_gfx(vkb_emu_device *e, VkCommandBuffer cb, size_t size); -/* graphics-side hooks (server_emu_divisor.c) */ +/* vertex attribute divisor (server_emu_divisor.c) */ +typedef struct div_info div_info; +size_t vkb_emu_divisor_info_size(void); +void vkb_emu_divisor_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, div_info *out); +void vkb_emu_divisor_created(vkb_emu_device *e, VkDevice device, VkPipelineCache cache, const VkGraphicsPipelineCreateInfo *ci, + VkPipeline p, div_info *info); +void vkb_emu_divisor_install(vkb_srv_table *dev); +void vkb_emu_divisor_uninstall(vkb_srv_table *dev); void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p); void vkb_emu_gfx_reset(void *gfx); void vkb_emu_gfx_free(void *gfx); @@ -72,6 +81,7 @@ void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img); void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, VkShaderModule *mods, uint32_t *nmods, uint32_t cap); void vkb_emu_shader_install(vkb_srv_table *dev); +VkShaderModule vkb_emu_shader_zero_base_instance(vkb_emu_device *e, VkDevice device, const VkPipelineShaderStageCreateInfo *vs); void vkb_emu_shader_uninstall(vkb_srv_table *dev); /* 1 = handled (the emulation recorded its own commands instead). */ int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, diff --git a/app/src/main/cpp/vkbridge/server_emu_divisor.c b/app/src/main/cpp/vkbridge/server_emu_divisor.c new file mode 100644 index 000000000..e19fca47d --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_emu_divisor.c @@ -0,0 +1,454 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Vertex attribute divisor (VK_EXT/KHR_vertex_attribute_divisor) on a GPU without it. + * + * A binding with divisor d != 1 fetches element firstInstance + i / d for instance i (d = 0: always + * firstInstance). Emulated by giving such bindings a stride of 0 - every instance reads the same + * element - and rebinding the buffer at that element before each draw. With d > 1 the draw is + * split into runs of instances that share elements; each run keeps its own firstInstance, so + * gl_InstanceIndex and every ordinary instance-rate attribute stay exactly as they were. + * Indirect draws cannot be split on the CPU: divisor-0 bindings use element 0 there, d > 1 is + * approximated the same way (logged once). + */ +#define _GNU_SOURCE +#include "server_emu.h" + +#include +#include + +#define MAX_BIND 32 + +typedef struct div_info { + uint32_t mask; /* bindings emulated */ + uint32_t divisor[MAX_BIND]; + uint32_t stride[MAX_BIND]; /* the app's stride (baked pipelines) */ + int dynamic_stride; /* the pipeline takes strides at bind time */ + int dynamic_input; /* the pipeline takes vertex input at record time */ + int split; /* some divisor > 1: draws are split */ + VkPipeline zero_base; /* variant whose vertex shader reads BaseInstance as 0 */ + VkShaderModule zero_vs; /* its vertex shader, between creation steps */ + uint32_t vs_stage; +} div_info; + +typedef struct pipe_rec { + VkPipeline p; + div_info info; + struct pipe_rec *next; +} pipe_rec; + +typedef struct gfx_state { + VkPipeline pipeline; /* bound graphics pipeline */ + div_info pipe; /* the bound pipeline's */ + div_info dyn; /* from vkCmdSetVertexInputEXT */ + int use_dyn; + VkBuffer buf[MAX_BIND]; + VkDeviceSize off[MAX_BIND], size[MAX_BIND], stride[MAX_BIND]; + uint32_t bound; /* slots the app bound */ + uint32_t tampered; /* slots we rebound */ +} gfx_state; + +typedef struct div_state { + pthread_mutex_t lock; + pipe_rec *b[256]; +} div_state; + +static div_state *dstate(vkb_emu_device *e) { return e->divisor; } + +static unsigned ph(VkPipeline p) +{ + uint64_t k = (uint64_t)p; + k ^= k >> 33; + k *= 0xff51afd7ed558ccdull; + return (unsigned)(k >> 56); +} + +static const div_info *find_pipe(vkb_emu_device *e, VkPipeline p) +{ + div_state *s = dstate(e); + pthread_mutex_lock(&s->lock); + pipe_rec *r = s->b[ph(p)]; + while (r && r->p != p) r = r->next; + pthread_mutex_unlock(&s->lock); + return r ? &r->info : NULL; +} + +static void store_pipe(vkb_emu_device *e, VkPipeline p, const div_info *info) +{ + div_state *s = dstate(e); + pipe_rec *r = calloc(1, sizeof(*r)); + r->p = p; + r->info = *info; + pthread_mutex_lock(&s->lock); + r->next = s->b[ph(p)]; + s->b[ph(p)] = r; + pthread_mutex_unlock(&s->lock); +} + +static void drop_pipe(vkb_emu_device *e, VkPipeline p) +{ + div_state *s = dstate(e); + pthread_mutex_lock(&s->lock); + pipe_rec **pp = &s->b[ph(p)]; + while (*pp && (*pp)->p != p) pp = &(*pp)->next; + pipe_rec *r = *pp; + if (r) *pp = r->next; + pthread_mutex_unlock(&s->lock); + if (r && r->info.zero_base) e->dev->real.vkDestroyPipeline(e->dev->device, r->info.zero_base, NULL); + free(r); +} + +/* ------------------------------------------------------------------ pipelines */ + +static int has_dynamic(const VkGraphicsPipelineCreateInfo *ci, VkDynamicState d) +{ + if (!ci->pDynamicState) return 0; + for (uint32_t i = 0; i < ci->pDynamicState->dynamicStateCount; i++) + if (ci->pDynamicState->pDynamicStates[i] == d) return 1; + return 0; +} + +/* Strips the divisor state of one create info; returns what the pipeline needs at draw time. */ +void vkb_emu_divisor_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, div_info *out) +{ + memset(out, 0, sizeof(*out)); + if (!(e->flags & VKB_EMU_DIVISOR)) return; + out->dynamic_stride = has_dynamic(ci, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE); + out->dynamic_input = has_dynamic(ci, VK_DYNAMIC_STATE_VERTEX_INPUT_EXT); + /* Pieces linked from libraries bring their own records. */ + for (const VkBaseInStructure *b = ci->pNext; b; b = b->pNext) { + if (b->sType != VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR) continue; + const VkPipelineLibraryCreateInfoKHR *l = (const void *)b; + for (uint32_t i = 0; i < l->libraryCount; i++) { + const div_info *li = find_pipe(e, l->pLibraries[i]); + if (!li || !li->mask) continue; + for (uint32_t k = 0; k < MAX_BIND; k++) + if (li->mask & (1u << k)) { + out->mask |= 1u << k; + out->divisor[k] = li->divisor[k]; + out->stride[k] = li->stride[k]; + if (li->divisor[k] > 1) out->split = 1; + } + } + } + VkPipelineVertexInputStateCreateInfo *vi = (VkPipelineVertexInputStateCreateInfo *)ci->pVertexInputState; + if (!vi || out->dynamic_input) return; + VkPipelineVertexInputDivisorStateCreateInfo *d = + vkb_emu_chain_take(vi, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO); + if (!d) return; + VkVertexInputBindingDescription *bd = (VkVertexInputBindingDescription *)vi->pVertexBindingDescriptions; + for (uint32_t i = 0; i < d->vertexBindingDivisorCount; i++) { + uint32_t b = d->pVertexBindingDivisors[i].binding, div = d->pVertexBindingDivisors[i].divisor; + if (div == 1 || b >= MAX_BIND) continue; + for (uint32_t k = 0; k < vi->vertexBindingDescriptionCount; k++) { + if (bd[k].binding != b) continue; + out->mask |= 1u << b; + out->divisor[b] = div; + out->stride[b] = bd[k].stride; + if (div > 1) out->split = 1; + bd[k].stride = 0; + } + } + /* The vertex shader's SPIR-V is still at hand here (it may be inline). */ + if (out->split && ci->pStages) { + for (uint32_t st = 0; st < ci->stageCount; st++) { + if (ci->pStages[st].stage != VK_SHADER_STAGE_VERTEX_BIT) continue; + out->zero_vs = vkb_emu_shader_zero_base_instance(e, device, &ci->pStages[st]); + out->vs_stage = st; + } + } +} + +void vkb_emu_divisor_created(vkb_emu_device *e, VkDevice device, VkPipelineCache cache, const VkGraphicsPipelineCreateInfo *ci, + VkPipeline p, div_info *info) +{ + if (!(e->flags & VKB_EMU_DIVISOR)) return; + if (!p) { + if (info->zero_vs) vkb_emu_real()->vkDestroyShaderModule(device, info->zero_vs, NULL); + return; + } + if (info->zero_vs) { + /* Split draws move BaseInstance: a variant that reads it as 0 serves the usual + * firstInstance = 0 draws exactly. */ + VkPipelineShaderStageCreateInfo *st = malloc(ci->stageCount * sizeof(*st)); + memcpy(st, ci->pStages, ci->stageCount * sizeof(*st)); + st[info->vs_stage].module = info->zero_vs; + st[info->vs_stage].pNext = NULL; + VkGraphicsPipelineCreateInfo v = *ci; + v.pStages = st; + if (vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, 1, &v, NULL, &info->zero_base) != VK_SUCCESS) + info->zero_base = VK_NULL_HANDLE; + vkb_emu_real()->vkDestroyShaderModule(device, info->zero_vs, NULL); + info->zero_vs = VK_NULL_HANDLE; + free(st); + } + if (info->mask || info->dynamic_input || info->dynamic_stride) store_pipe(e, p, info); + if (info->mask) + VKB_DBG("divisor: pipeline %p emulates bindings 0x%x (dynamic stride %d, dynamic input %d, split %d, variant %p)", (void *)p, + info->mask, info->dynamic_stride, info->dynamic_input, info->split, (void *)info->zero_base); +} + +size_t vkb_emu_divisor_info_size(void) { return sizeof(div_info); } + +static VKAPI_ATTR void VKAPI_CALL emu_DestroyPipeline(VkDevice device, VkPipeline p, const VkAllocationCallbacks *pAllocator) +{ + if (p) drop_pipe(vkb_emu_cur(), p); + vkb_emu_real()->vkDestroyPipeline(device, p, pAllocator); +} + +/* ------------------------------------------------------------------ command buffers */ + +static gfx_state *gfx(vkb_emu_device *e, VkCommandBuffer cb) { return vkb_emu_cb_gfx(e, cb, sizeof(gfx_state)); } + +void vkb_emu_gfx_reset(void *g) +{ + if (g) memset(g, 0, sizeof(gfx_state)); +} + +void vkb_emu_gfx_free(void *g) { free(g); } + +void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p) +{ + if (!(e->flags & VKB_EMU_DIVISOR)) return; + gfx_state *g = gfx(e, cb); + g->pipeline = p; + const div_info *i = find_pipe(e, p); + if (i) g->pipe = *i; + else memset(&g->pipe, 0, sizeof(g->pipe)); + g->use_dyn = g->pipe.dynamic_input; +} + +static void record_bind(gfx_state *g, uint32_t first, uint32_t n, const VkBuffer *b, const VkDeviceSize *o, const VkDeviceSize *s, + const VkDeviceSize *st) +{ + for (uint32_t i = 0; i < n && first + i < MAX_BIND; i++) { + uint32_t k = first + i; + g->buf[k] = b[i]; + g->off[k] = o[i]; + g->size[k] = s ? s[i] : VK_WHOLE_SIZE; + if (st) g->stride[k] = st[i]; + g->bound |= 1u << k; + g->tampered &= ~(1u << k); + } +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *b, + const VkDeviceSize *o) +{ + vkb_emu_device *e = vkb_emu_cur(); + record_bind(gfx(e, cb), first, n, b, o, NULL, NULL); + vkb_emu_real()->vkCmdBindVertexBuffers(cb, first, n, b, o); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers2(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *b, + const VkDeviceSize *o, const VkDeviceSize *s, const VkDeviceSize *st) +{ + vkb_emu_device *e = vkb_emu_cur(); + record_bind(gfx(e, cb), first, n, b, o, s, st); + vkb_emu_real()->vkCmdBindVertexBuffers2(cb, first, n, b, o, s, st); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdSetVertexInputEXT(VkCommandBuffer cb, uint32_t nb, const VkVertexInputBindingDescription2EXT *bd, + uint32_t na, const VkVertexInputAttributeDescription2EXT *ad) +{ + vkb_emu_device *e = vkb_emu_cur(); + gfx_state *g = gfx(e, cb); + memset(&g->dyn, 0, sizeof(g->dyn)); + g->dyn.dynamic_stride = 1; + g->dyn.dynamic_input = 1; + VkVertexInputBindingDescription2EXT *w = (VkVertexInputBindingDescription2EXT *)bd; + for (uint32_t i = 0; i < nb; i++) { + uint32_t b = w[i].binding; + if (w[i].inputRate != VK_VERTEX_INPUT_RATE_INSTANCE || w[i].divisor == 1 || b >= MAX_BIND) continue; + g->dyn.mask |= 1u << b; + g->dyn.divisor[b] = w[i].divisor; + g->dyn.stride[b] = w[i].stride; + g->stride[b] = w[i].stride; + w[i].stride = 0; + w[i].divisor = 1; + } + vkb_emu_real()->vkCmdSetVertexInputEXT(cb, nb, bd, na, ad); +} + +/* Rebinds the emulated bindings for instances starting at `inst` (relative to the draw), and puts + * back any slot we changed that the current pipeline does not emulate. */ +static void prepare(vkb_emu_device *e, VkCommandBuffer cb, gfx_state *g, const div_info *di, uint32_t first_instance, uint32_t inst) +{ + const vkb_dispatch *r = vkb_emu_real(); + for (uint32_t k = 0; k < MAX_BIND; k++) { + uint32_t bit = 1u << k; + if (!(g->bound & bit)) continue; + if (di->mask & bit) { + uint32_t d = di->divisor[k]; + VkDeviceSize stride = di->dynamic_input ? g->dyn.stride[k] : (di->dynamic_stride ? g->stride[k] : di->stride[k]); + VkDeviceSize elem = (VkDeviceSize)first_instance + (d ? inst / d : 0); + VkDeviceSize off = g->off[k] + elem * stride; + if (di->dynamic_stride || di->dynamic_input) { + VkDeviceSize size = g->size[k] == VK_WHOLE_SIZE ? VK_WHOLE_SIZE : (g->size[k] > elem * stride ? g->size[k] - elem * stride : 0); + VkDeviceSize zero = 0; + r->vkCmdBindVertexBuffers2(cb, k, 1, &g->buf[k], &off, size == VK_WHOLE_SIZE ? NULL : &size, &zero); + } else { + r->vkCmdBindVertexBuffers(cb, k, 1, &g->buf[k], &off); + } + g->tampered |= bit; + } else if (g->tampered & bit) { + if (di->dynamic_stride) { + VkDeviceSize size = g->size[k]; + r->vkCmdBindVertexBuffers2(cb, k, 1, &g->buf[k], &g->off[k], size == VK_WHOLE_SIZE ? NULL : &size, &g->stride[k]); + } else { + r->vkCmdBindVertexBuffers(cb, k, 1, &g->buf[k], &g->off[k]); + } + g->tampered &= ~bit; + } + } + (void)e; +} + +static const div_info *active(gfx_state *g) +{ + return g->use_dyn ? &g->dyn : &g->pipe; +} + +/* The next instance where some emulated binding moves to its next element. */ +static uint32_t next_boundary(const div_info *di, uint32_t i, uint32_t count) +{ + uint32_t next = count; + for (uint32_t k = 0; k < MAX_BIND; k++) { + if (!(di->mask & (1u << k)) || di->divisor[k] <= 1) continue; + uint32_t d = di->divisor[k], nb = (i / d + 1) * d; + if (nb < next) next = nb; + } + return next; +} + +/* A split draw binds the BaseInstance-as-0 variant when that keeps it exact. */ +static int split_begin(vkb_emu_device *e, VkCommandBuffer cb, gfx_state *g, const div_info *di, uint32_t fi, uint32_t ic) +{ + (void)e; + if (!di->split || next_boundary(di, 0, ic) >= ic) return 0; + if (fi == 0 && di->zero_base) { + vkb_emu_real()->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, di->zero_base); + return 1; + } + if (fi != 0) VKB_ONCE(VKB_LOG_WARN, "divisor emulation: a split draw with firstInstance > 0 may see SV_InstanceID offset (logged once)"); + (void)g; + return 0; +} + +static void split_end(VkCommandBuffer cb, gfx_state *g, int variant) +{ + if (variant) vkb_emu_real()->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, g->pipeline); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDraw(VkCommandBuffer cb, uint32_t vc, uint32_t ic, uint32_t fv, uint32_t fi) +{ + vkb_emu_device *e = vkb_emu_cur(); + gfx_state *g = gfx(e, cb); + const div_info *di = active(g); + if (!di->mask && !g->tampered) { + vkb_emu_real()->vkCmdDraw(cb, vc, ic, fv, fi); + return; + } + VKB_DBG("divisor: draw %u instances from %u, bindings 0x%x (dyn %d), bound 0x%x", ic, fi, di->mask, g->use_dyn, g->bound); + int variant = split_begin(e, cb, g, di, fi, ic); + for (uint32_t i = 0; i < ic || (ic == 0 && i == 0);) { + uint32_t end = next_boundary(di, i, ic); + prepare(e, cb, g, di, fi, i); + if (ic) vkb_emu_real()->vkCmdDraw(cb, vc, end - i, fv, fi + i); + if (!ic) break; + i = end; + } + split_end(cb, g, variant); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexed(VkCommandBuffer cb, uint32_t xc, uint32_t ic, uint32_t fx, int32_t vo, uint32_t fi) +{ + vkb_emu_device *e = vkb_emu_cur(); + gfx_state *g = gfx(e, cb); + const div_info *di = active(g); + if (!di->mask && !g->tampered) { + vkb_emu_real()->vkCmdDrawIndexed(cb, xc, ic, fx, vo, fi); + return; + } + int variant = split_begin(e, cb, g, di, fi, ic); + for (uint32_t i = 0; i < ic || (ic == 0 && i == 0);) { + uint32_t end = next_boundary(di, i, ic); + prepare(e, cb, g, di, fi, i); + if (ic) vkb_emu_real()->vkCmdDrawIndexed(cb, xc, end - i, fx, vo, fi + i); + if (!ic) break; + i = end; + } + split_end(cb, g, variant); +} + +static void indirect_prepare(vkb_emu_device *e, VkCommandBuffer cb) +{ + gfx_state *g = gfx(e, cb); + const div_info *di = active(g); + if (!di->mask && !g->tampered) return; + for (uint32_t k = 0; k < MAX_BIND; k++) + if ((di->mask & (1u << k)) && di->divisor[k] > 1) + VKB_ONCE(VKB_LOG_WARN, "divisor emulation: an indirect draw with an instance divisor > 1 is approximated (logged once)"); + prepare(e, cb, g, di, 0, 0); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndirect(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, uint32_t n, uint32_t s) +{ + indirect_prepare(vkb_emu_cur(), cb); + vkb_emu_real()->vkCmdDrawIndirect(cb, b, o, n, s); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexedIndirect(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, uint32_t n, uint32_t s) +{ + indirect_prepare(vkb_emu_cur(), cb); + vkb_emu_real()->vkCmdDrawIndexedIndirect(cb, b, o, n, s); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndirectCount(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, VkBuffer cbuf, VkDeviceSize co, + uint32_t max, uint32_t s) +{ + indirect_prepare(vkb_emu_cur(), cb); + vkb_emu_real()->vkCmdDrawIndirectCount(cb, b, o, cbuf, co, max, s); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexedIndirectCount(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, VkBuffer cbuf, + VkDeviceSize co, uint32_t max, uint32_t s) +{ + indirect_prepare(vkb_emu_cur(), cb); + vkb_emu_real()->vkCmdDrawIndexedIndirectCount(cb, b, o, cbuf, co, max, s); +} + +void vkb_emu_divisor_install(vkb_srv_table *dev) +{ + vkb_emu_device *e = dev->emu; + if (!(e->flags & VKB_EMU_DIVISOR)) return; + div_state *s = calloc(1, sizeof(*s)); + pthread_mutex_init(&s->lock, NULL); + e->divisor = s; + vkb_dispatch *dt = &dev->dt; + dt->vkDestroyPipeline = emu_DestroyPipeline; + dt->vkCmdBindVertexBuffers = emu_CmdBindVertexBuffers; + if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2; + if (dev->real.vkCmdSetVertexInputEXT) dt->vkCmdSetVertexInputEXT = emu_CmdSetVertexInputEXT; + dt->vkCmdDraw = emu_CmdDraw; + dt->vkCmdDrawIndexed = emu_CmdDrawIndexed; + dt->vkCmdDrawIndirect = emu_CmdDrawIndirect; + dt->vkCmdDrawIndexedIndirect = emu_CmdDrawIndexedIndirect; + if (dev->real.vkCmdDrawIndirectCount) dt->vkCmdDrawIndirectCount = emu_CmdDrawIndirectCount; + if (dev->real.vkCmdDrawIndexedIndirectCount) dt->vkCmdDrawIndexedIndirectCount = emu_CmdDrawIndexedIndirectCount; +} + +void vkb_emu_divisor_uninstall(vkb_srv_table *dev) +{ + div_state *s = dev->emu->divisor; + if (!s) return; + for (int i = 0; i < 256; i++) { + while (s->b[i]) { + pipe_rec *r = s->b[i]; + s->b[i] = r->next; + free(r); + } + } + pthread_mutex_destroy(&s->lock); + free(s); + dev->emu->divisor = NULL; +} diff --git a/app/src/main/cpp/vkbridge/server_emu_features.c b/app/src/main/cpp/vkbridge/server_emu_features.c index 086f0ef93..33bef1f10 100644 --- a/app/src/main/cpp/vkbridge/server_emu_features.c +++ b/app/src/main/cpp/vkbridge/server_emu_features.c @@ -1,7 +1,6 @@ /* SPDX-License-Identifier: GPL-3.0-or-later * - * Installs the feature emulations into a device, and the graphics-state hooks of the ones that - * are not implemented yet (vertex attribute divisor). + * Installs the feature emulations into a device. */ #define _GNU_SOURCE #include "server_emu.h" @@ -11,15 +10,13 @@ void vkb_emu_install_features(vkb_srv_table *dev) vkb_emu_cmdstate_install(dev); vkb_emu_shader_install(dev); vkb_emu_bcn_install(dev); + vkb_emu_divisor_install(dev); } void vkb_emu_uninstall_features(vkb_srv_table *dev) { + vkb_emu_divisor_uninstall(dev); vkb_emu_bcn_uninstall(dev); vkb_emu_shader_uninstall(dev); vkb_emu_cmdstate_uninstall(dev); } - -void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p) { (void)e; (void)cb; (void)p; } -void vkb_emu_gfx_reset(void *gfx) { (void)gfx; } -void vkb_emu_gfx_free(void *gfx) { (void)gfx; } diff --git a/app/src/main/cpp/vkbridge/server_emu_layer.c b/app/src/main/cpp/vkbridge/server_emu_layer.c index 77c1a732a..3b3b248e3 100644 --- a/app/src/main/cpp/vkbridge/server_emu_layer.c +++ b/app/src/main/cpp/vkbridge/server_emu_layer.c @@ -199,8 +199,11 @@ static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice devic vkb_emu_device *e = vkb_emu_cur(); VkShaderModule mods[64]; uint32_t nmods = 0; + size_t dsz = vkb_emu_divisor_info_size(); + uint8_t *divs = calloc(n ? n : 1, dsz); for (uint32_t i = 0; i < n; i++) { VkGraphicsPipelineCreateInfo *ci = (VkGraphicsPipelineCreateInfo *)&infos[i]; + vkb_emu_divisor_pipeline(e, device, ci, (div_info *)(divs + i * dsz)); /* Shader rewrites first: they read inline SPIR-V before it becomes a module. */ vkb_emu_shader_pipeline(e, device, ci, mods, &nmods, 64); if (e->flags & VKB_EMU_MAINT5) { @@ -211,7 +214,11 @@ static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice devic } } VkResult r = vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, n, infos, pAllocator, pPipelines); + /* Before the temporary modules go: a divisor variant is built from the same stages. */ + for (uint32_t i = 0; i < n; i++) + vkb_emu_divisor_created(e, device, cache, &infos[i], r >= 0 ? pPipelines[i] : VK_NULL_HANDLE, (div_info *)(divs + i * dsz)); for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL); + free(divs); return r; } diff --git a/app/src/main/cpp/vkbridge/server_emu_shader.c b/app/src/main/cpp/vkbridge/server_emu_shader.c index 4fe7dbc13..64dda0be8 100644 --- a/app/src/main/cpp/vkbridge/server_emu_shader.c +++ b/app/src/main/cpp/vkbridge/server_emu_shader.c @@ -36,6 +36,8 @@ typedef struct shader_state { } shader_state; #define SHADER_EMU (VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE) +/* Emulations that need the shader modules' SPIR-V kept. */ +#define SHADER_STORE (SHADER_EMU | VKB_EMU_DIVISOR) static unsigned mh(VkShaderModule m) { @@ -358,10 +360,50 @@ void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipel if (have_frag) spv_free(&fm); } +/* A vertex shader that reads BaseInstance as 0 (divisor emulation splits draws, which moves + * BaseInstance; DXVK derives SV_InstanceID from it). VK_NULL_HANDLE when the shader never reads it. */ +VkShaderModule vkb_emu_shader_zero_base_instance(vkb_emu_device *e, VkDevice device, const VkPipelineShaderStageCreateInfo *vs) +{ + const uint32_t *code; + size_t size; + if (!e->shaders || !stage_code(e, vs, &code, &size)) return VK_NULL_HANDLE; + spv_mod m; + if (spv_parse(&m, code, size) != 0) return VK_NULL_HANDLE; + int in_block; + uint32_t var = builtin_var(&m, SpvBuiltInBaseInstance, SpvStorageClassInput, &in_block); + VkShaderModule out = VK_NULL_HANDLE; + if (var) { + int d = spv_find_def(&m, var); + int p = d >= 0 ? spv_find_def(&m, m.ins[d].w[0]) : -1; + uint32_t type = p >= 0 ? m.ins[p].w[2] : 0; + int td = spv_find_def(&m, type); + uint32_t zero = 0; + if (td >= 0 && m.ins[td].op == SpvOpTypeInt) { + zero = spv_new_id(&m); + uint32_t ops[3] = {type, zero, 0}; + spv_insert(&m, spv_types_end(&m), SpvOpConstant, ops, 3); + } + int changed = 0; + for (uint32_t i = 0; zero && i < m.count; i++) { + spv_inst *in = &m.ins[i]; + if (in->op == SpvOpLoad && in->w[2] == var) { + /* %r = OpLoad %int %BaseInstance -> %r = OpCopyObject %int %zero */ + in->op = 83; /* OpCopyObject */ + in->w[2] = zero; + in->n = 4; + changed = 1; + } + } + if (changed) make_module(device, &m, &out); + } + spv_free(&m); + return out; +} + void vkb_emu_shader_install(vkb_srv_table *dev) { vkb_emu_device *e = dev->emu; - if (!(e->flags & SHADER_EMU)) return; + if (!(e->flags & SHADER_STORE)) return; shader_state *s = calloc(1, sizeof(*s)); pthread_mutex_init(&s->lock, NULL); e->shaders = s; diff --git a/app/src/main/cpp/vkbridge/server_instance.c b/app/src/main/cpp/vkbridge/server_instance.c index 7c968e89d..cc2f6baf1 100644 --- a/app/src/main/cpp/vkbridge/server_instance.c +++ b/app/src/main/cpp/vkbridge/server_instance.c @@ -144,14 +144,6 @@ void vkb_sv_vkCreateInstance(vkb_srv_call *c) vkb_srv_bad_message(c); return; } - VkApplicationInfo app; - uint32_t loader_api = VK_API_VERSION_1_0; - if (vkb_global_dt.vkEnumerateInstanceVersion) vkb_global_dt.vkEnumerateInstanceVersion(&loader_api); - if (ci->pApplicationInfo) { - app = *ci->pApplicationInfo; - if (app.apiVersion > loader_api) app.apiVersion = loader_api; - ci->pApplicationInfo = &app; - } VkInstance inst = VK_NULL_HANDLE; VkResult r = vkb_global_dt.vkCreateInstance(ci, NULL, &inst); uint32_t id = 0; diff --git a/app/src/main/cpp/vkbridge/server_main.c b/app/src/main/cpp/vkbridge/server_main.c index 13664b7af..75d21e8dd 100644 --- a/app/src/main/cpp/vkbridge/server_main.c +++ b/app/src/main/cpp/vkbridge/server_main.c @@ -30,6 +30,8 @@ #ifdef __ANDROID__ #include +#elif defined(__GLIBC__) +#include #endif PFN_vkGetInstanceProcAddr vkb_gipa; @@ -81,6 +83,11 @@ static void on_crash(int sig) if (write(2, buf, (size_t)n) < 0) {} #ifdef __ANDROID__ __android_log_write(ANDROID_LOG_FATAL, "vkbridge", buf); +#elif defined(__GLIBC__) + void *frames[32]; + int nf = backtrace(frames, 32); + backtrace_symbols_fd(frames, nf, 2); + if (log_file) backtrace_symbols_fd(frames, nf, fileno(log_file)); #endif signal(sig, SIG_DFL); raise(sig); diff --git a/tools/vkbridge/client/icd.c b/tools/vkbridge/client/icd.c index 8da7b5bff..5eddc9c83 100644 --- a/tools/vkbridge/client/icd.c +++ b/tools/vkbridge/client/icd.c @@ -50,6 +50,8 @@ PFN_vkVoidFunction vkb_lookup_proc(const char *name, int level_max, vkb_device * if (level_max == VKB_LEVEL_DEVICE) { if (p->level != VKB_LEVEL_DEVICE) return NULL; if (dev && p->ext && !vkb_device_ext_enabled(dev, p->ext)) return NULL; + /* Core commands newer than the device's Vulkan version do not exist for it. */ + if (dev && p->core && p->core > dev->api_version) return NULL; } return p->fn; } @@ -288,13 +290,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateInstance(const VkInstanceCreateInf ci.ppEnabledExtensionNames = exts; ci.enabledLayerCount = 0; ci.ppEnabledLayerNames = NULL; - VkApplicationInfo app; - uint32_t api = server_instance_version(); + /* The app's version goes through as asked: the device's effective version is the lower of it + * and the GPU's, which is what a driver does (and what apps compute for themselves). */ if (ci.pApplicationInfo) { - app = *ci.pApplicationInfo; - if (app.apiVersion > api) app.apiVersion = api; - ci.pApplicationInfo = &app; - inst->api_version = app.apiVersion ? app.apiVersion : VK_API_VERSION_1_0; + inst->api_version = ci.pApplicationInfo->apiVersion ? ci.pApplicationInfo->apiVersion : VK_API_VERSION_1_0; } else { inst->api_version = VK_API_VERSION_1_0; } @@ -472,6 +471,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDevice(VkPhysicalDevice physicalDe free(dev); return r; } + { + extern uint32_t vkb_max_api(void); + uint32_t v = pd->props.apiVersion < vkb_max_api() ? pd->props.apiVersion : vkb_max_api(); + dev->api_version = v < pd->instance->api_version ? v : pd->instance->api_version; + } vkb_map_init(&dev->memories); vkb_map_init(&dev->templates); vkb_map_init(&dev->pools); diff --git a/tools/vkbridge/client/vkb_client.h b/tools/vkbridge/client/vkb_client.h index f1456cf9c..b40455f03 100644 --- a/tools/vkbridge/client/vkb_client.h +++ b/tools/vkbridge/client/vkb_client.h @@ -95,6 +95,7 @@ typedef struct vkb_device { const char **enabled_exts; uint32_t enabled_ext_count; uint8_t ext_swapchain; + uint32_t api_version; } vkb_device; typedef struct vkb_queue { diff --git a/tools/vkbridge/codegen/gen_vkbridge.py b/tools/vkbridge/codegen/gen_vkbridge.py index f971bba2a..c181c6a15 100644 --- a/tools/vkbridge/codegen/gen_vkbridge.py +++ b/tools/vkbridge/codegen/gen_vkbridge.py @@ -262,6 +262,7 @@ included_cmds = set() cmd_aliases_included = {} # alias name -> canonical ext_info = {} # ext name -> (type, [commands]) cmd_origin = {} # canonical cmd -> 'core' or ext name +cmd_version = {} # canonical cmd -> core version (major, minor) that introduced it def require_blocks(el): @@ -275,10 +276,13 @@ for f in reg.root.findall('feature'): if f.get('name') not in CORE_FEATURES or not api_ok(f): continue for req in require_blocks(f): + ver = tuple(int(x) for x in f.get('number').split('.')) for c in req.findall('command'): n = reg.canon_cmd(c.get('name')) included_cmds.add(n) cmd_origin.setdefault(n, 'core') + if c.get('name') == n: + cmd_version[n] = min(cmd_version.get(n, ver), ver) if c.get('name') != n: cmd_aliases_included[c.get('name')] = n @@ -888,7 +892,7 @@ hw(f'#define VKB_EXT_COUNT {len(bridged_exts)}') hw('extern const vkb_ext_desc vkb_exts[VKB_EXT_COUNT];') hw() hw('/* Client: name -> entry point (canonical names and aliases). */') -hw('typedef struct vkb_proc_desc { const char *name; PFN_vkVoidFunction fn; uint8_t level; const char *ext; } vkb_proc_desc;') +hw('typedef struct vkb_proc_desc { const char *name; PFN_vkVoidFunction fn; uint8_t level; const char *ext; uint32_t core; } vkb_proc_desc;') hw('#define VKB_LEVEL_GLOBAL 0') hw('#define VKB_LEVEL_INSTANCE 1') hw('#define VKB_LEVEL_PHYSDEV 2') @@ -940,7 +944,9 @@ for c in dispatch_cmds: vw(f'PFN_{c} f_ = (PFN_{c})gdpa(device, "{c}");') for a in sorted(aliases_of.get(c, [])): vw(f'if (!f_) f_ = (PFN_{c})gdpa(device, "{a}");') - vw(f'if (f_) dt->{c} = f_;') + # Device-level entries come only from the device: an instance-level trampoline would dispatch + # through loader data the server's objects do not carry. + vw(f'dt->{c} = f_;') vw('}') vw('}') vw() @@ -1325,7 +1331,10 @@ for name, c, origin in sorted(entries): else: o = 'core' ext = 'NULL' if o in (None, 'core') else f'"{o}"' - cw(f'{{"{name}", (PFN_vkVoidFunction)vkb_ep_{c}, {level_of(c)}, {ext}}},') + core = 0 + if name == c and o == 'core' and c in cmd_version: + core = f'VK_MAKE_API_VERSION(0, {cmd_version[c][0]}, {cmd_version[c][1]}, 0)' + cw(f'{{"{name}", (PFN_vkVoidFunction)vkb_ep_{c}, {level_of(c)}, {ext}, {core}}},') cw('};') cw('const size_t vkb_client_proc_count = sizeof(vkb_client_procs) / sizeof(vkb_client_procs[0]);') diff --git a/tools/vkbridge/common/gen/vkb_gen.h b/tools/vkbridge/common/gen/vkb_gen.h index bdb05adb9..4df87b7d1 100644 --- a/tools/vkbridge/common/gen/vkb_gen.h +++ b/tools/vkbridge/common/gen/vkb_gen.h @@ -2595,7 +2595,7 @@ typedef struct vkb_ext_desc { const char *name; uint8_t device; uint8_t client; extern const vkb_ext_desc vkb_exts[VKB_EXT_COUNT]; /* Client: name -> entry point (canonical names and aliases). */ -typedef struct vkb_proc_desc { const char *name; PFN_vkVoidFunction fn; uint8_t level; const char *ext; } vkb_proc_desc; +typedef struct vkb_proc_desc { const char *name; PFN_vkVoidFunction fn; uint8_t level; const char *ext; uint32_t core; } vkb_proc_desc; #define VKB_LEVEL_GLOBAL 0 #define VKB_LEVEL_INSTANCE 1 #define VKB_LEVEL_PHYSDEV 2 diff --git a/tools/vkbridge/common/gen/vkb_gen_client.c b/tools/vkbridge/common/gen/vkb_gen_client.c index e445bb98d..921fc9c62 100644 --- a/tools/vkbridge/common/gen/vkb_gen_client.c +++ b/tools/vkbridge/common/gen/vkb_gen_client.c @@ -6806,446 +6806,446 @@ static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSets(VkDevice device, } const vkb_proc_desc vkb_client_procs[] = { - {"vkAcquireNextImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkAcquireNextImage2KHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkAcquireNextImageKHR", (PFN_vkVoidFunction)vkb_ep_vkAcquireNextImageKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkAllocateCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkAllocateCommandBuffers, VKB_LEVEL_DEVICE, NULL}, - {"vkAllocateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkAllocateDescriptorSets, VKB_LEVEL_DEVICE, NULL}, - {"vkAllocateMemory", (PFN_vkVoidFunction)vkb_ep_vkAllocateMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkBeginCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkBeginCommandBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkBindBufferMemory", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkBindBufferMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, NULL}, - {"vkBindBufferMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2"}, - {"vkBindImageMemory", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkBindImageMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, NULL}, - {"vkBindImageMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2"}, - {"vkBindTensorMemoryARM", (PFN_vkVoidFunction)vkb_ep_vkBindTensorMemoryARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkCmdBeginConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering"}, - {"vkCmdBeginCustomResolveEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginCustomResolveEXT, VKB_LEVEL_DEVICE, "VK_EXT_custom_resolve"}, - {"vkCmdBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkCmdBeginQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQuery, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBeginQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdBeginRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBeginRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBeginRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2"}, - {"vkCmdBeginRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBeginRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering"}, - {"vkCmdBeginTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdBindDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindDescriptorSets2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindDescriptorSets2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6"}, - {"vkCmdBindIndexBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindIndexBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindIndexBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5"}, - {"vkCmdBindPipeline", (PFN_vkVoidFunction)vkb_ep_vkCmdBindPipeline, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindTransformFeedbackBuffersEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindTransformFeedbackBuffersEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdBindVertexBuffers", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindVertexBuffers2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBindVertexBuffers2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdBlitImage", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBlitImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdBlitImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdClearAttachments", (PFN_vkVoidFunction)vkb_ep_vkCmdClearAttachments, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdClearColorImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearColorImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdClearDepthStencilImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearDepthStencilImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdCopyBufferToImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyBufferToImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyBufferToImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdCopyImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdCopyImageToBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyImageToBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyImageToBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdCopyQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyQueryPoolResults, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdCopyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkCmdDispatch", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatch, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDispatchBase", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDispatchBaseKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, "VK_KHR_device_group"}, - {"vkCmdDispatchIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchIndirect, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDraw", (PFN_vkVoidFunction)vkb_ep_vkCmdDraw, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndexed", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexed, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndexedIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirect, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndexedIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndexedIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndexedIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count"}, - {"vkCmdDrawIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirect, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndirectByteCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectByteCountEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdDrawIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdDrawIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count"}, - {"vkCmdDrawMultiEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw"}, - {"vkCmdDrawMultiIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw"}, - {"vkCmdEndConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering"}, - {"vkCmdEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkCmdEndQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQuery, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdEndQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdEndRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdEndRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdEndRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2"}, - {"vkCmdEndRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdEndRendering2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdEndRendering2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, "VK_KHR_maintenance10"}, - {"vkCmdEndRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering"}, - {"vkCmdEndTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback"}, - {"vkCmdExecuteCommands", (PFN_vkVoidFunction)vkb_ep_vkCmdExecuteCommands, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdFillBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdFillBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkCmdNextSubpass", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdNextSubpass2", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdNextSubpass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2"}, - {"vkCmdPipelineBarrier", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPipelineBarrier2", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPipelineBarrier2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkCmdPushConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushConstants2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushConstants2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6"}, - {"vkCmdPushDescriptorSet", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushDescriptorSet2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushDescriptorSet2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6"}, - {"vkCmdPushDescriptorSetKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor"}, - {"vkCmdPushDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushDescriptorSetWithTemplate2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdPushDescriptorSetWithTemplate2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6"}, - {"vkCmdPushDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor"}, - {"vkCmdResetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdResetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdResetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkCmdResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCmdResetQueryPool, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdResolveImage", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdResolveImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdResolveImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2"}, - {"vkCmdSetAlphaToCoverageEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToCoverageEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetAlphaToOneEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToOneEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAttachmentFeedbackLoopEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_attachment_feedback_loop_dynamic_state"}, - {"vkCmdSetBlendConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdSetBlendConstants, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetColorBlendAdvancedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendAdvancedEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetColorBlendEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetColorBlendEquationEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEquationEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetColorWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_color_write_enable"}, - {"vkCmdSetColorWriteMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetConservativeRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetConservativeRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetCullMode", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetCullModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetDepthBias", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthBias2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias2EXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_bias_control"}, - {"vkCmdSetDepthBiasEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthBiasEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2"}, - {"vkCmdSetDepthBounds", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBounds, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthBoundsTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthBoundsTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetDepthClampEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetDepthClampRangeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampRangeEXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_clamp_control"}, - {"vkCmdSetDepthClipEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetDepthClipNegativeOneToOneEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipNegativeOneToOneEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetDepthCompareOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthCompareOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetDepthTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetDepthWriteEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDepthWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetDeviceMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetDeviceMaskKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, "VK_KHR_device_group"}, - {"vkCmdSetDiscardRectangleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles"}, - {"vkCmdSetDiscardRectangleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles"}, - {"vkCmdSetDiscardRectangleModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles"}, - {"vkCmdSetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetExtraPrimitiveOverestimationSizeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetFragmentShadingRateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFragmentShadingRateKHR, VKB_LEVEL_DEVICE, "VK_KHR_fragment_shading_rate"}, - {"vkCmdSetFrontFace", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetFrontFaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetLineRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetLineStipple", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetLineStippleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_EXT_line_rasterization"}, - {"vkCmdSetLineStippleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStippleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetLineStippleKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_KHR_line_rasterization"}, - {"vkCmdSetLineWidth", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineWidth, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetLogicOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2"}, - {"vkCmdSetLogicOpEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetPatchControlPointsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPatchControlPointsEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2"}, - {"vkCmdSetPolygonModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPolygonModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetPrimitiveRestartEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetPrimitiveRestartEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2"}, - {"vkCmdSetPrimitiveTopology", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetPrimitiveTopologyEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetProvokingVertexModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetProvokingVertexModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetRasterizationSamplesEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationSamplesEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetRasterizationStreamEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationStreamEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetRasterizerDiscardEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetRasterizerDiscardEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2"}, - {"vkCmdSetRenderingAttachmentLocations", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetRenderingAttachmentLocationsKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read"}, - {"vkCmdSetRenderingInputAttachmentIndices", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetRenderingInputAttachmentIndicesKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read"}, - {"vkCmdSetSampleLocationsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEXT, VKB_LEVEL_DEVICE, "VK_EXT_sample_locations"}, - {"vkCmdSetSampleLocationsEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetSampleMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetScissor", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissor, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetScissorWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetScissorWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetStencilCompareMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilCompareMask, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetStencilOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetStencilOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetStencilReference", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilReference, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetStencilTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetStencilTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdSetStencilWriteMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilWriteMask, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetTessellationDomainOriginEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetTessellationDomainOriginEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3"}, - {"vkCmdSetVertexInputEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetVertexInputEXT, VKB_LEVEL_DEVICE, "VK_EXT_vertex_input_dynamic_state"}, - {"vkCmdSetViewport", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewport, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetViewportWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdSetViewportWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state"}, - {"vkCmdUpdateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdUpdateBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdWaitEvents", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdWaitEvents2", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdWaitEvents2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkCmdWriteTimestamp", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdWriteTimestamp2", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, NULL}, - {"vkCmdWriteTimestamp2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkCopyImageToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCopyImageToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCopyImageToMemory", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkCopyImageToMemoryEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkCopyMemoryToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCopyMemoryToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateBufferView", (PFN_vkVoidFunction)vkb_ep_vkCreateBufferView, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateCommandPool", (PFN_vkVoidFunction)vkb_ep_vkCreateCommandPool, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateComputePipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateComputePipelines, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils"}, - {"vkCreateDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorPool, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template"}, - {"vkCreateDevice", (PFN_vkVoidFunction)vkb_ep_vkCreateDevice, VKB_LEVEL_PHYSDEV, NULL}, - {"vkCreateEvent", (PFN_vkVoidFunction)vkb_ep_vkCreateEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateFence", (PFN_vkVoidFunction)vkb_ep_vkCreateFence, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateFramebuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateGraphicsPipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateGraphicsPipelines, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateHeadlessSurfaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateHeadlessSurfaceEXT, VKB_LEVEL_INSTANCE, "VK_EXT_headless_surface"}, - {"vkCreateImage", (PFN_vkVoidFunction)vkb_ep_vkCreateImage, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateImageView", (PFN_vkVoidFunction)vkb_ep_vkCreateImageView, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateInstance", (PFN_vkVoidFunction)vkb_ep_vkCreateInstance, VKB_LEVEL_GLOBAL, NULL}, - {"vkCreatePipelineCache", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineCache, VKB_LEVEL_DEVICE, NULL}, - {"vkCreatePipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkCreatePrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, NULL}, - {"vkCreatePrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data"}, - {"vkCreateQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCreateQueryPool, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2"}, - {"vkCreateSampler", (PFN_vkVoidFunction)vkb_ep_vkCreateSampler, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateSamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateSamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion"}, - {"vkCreateSemaphore", (PFN_vkVoidFunction)vkb_ep_vkCreateSemaphore, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateShaderModule", (PFN_vkVoidFunction)vkb_ep_vkCreateShaderModule, VKB_LEVEL_DEVICE, NULL}, - {"vkCreateSwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkCreateTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkCreateTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkCreateWaylandSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateWaylandSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_wayland_surface"}, - {"vkCreateXcbSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXcbSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xcb_surface"}, - {"vkCreateXlibSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXlibSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xlib_surface"}, - {"vkDestroyBuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyBufferView", (PFN_vkVoidFunction)vkb_ep_vkDestroyBufferView, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyCommandPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyCommandPool, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils"}, - {"vkDestroyDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorPool, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template"}, - {"vkDestroyDevice", (PFN_vkVoidFunction)vkb_ep_vkDestroyDevice, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyEvent", (PFN_vkVoidFunction)vkb_ep_vkDestroyEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyFence", (PFN_vkVoidFunction)vkb_ep_vkDestroyFence, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyFramebuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyImage", (PFN_vkVoidFunction)vkb_ep_vkDestroyImage, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyImageView", (PFN_vkVoidFunction)vkb_ep_vkDestroyImageView, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyInstance", (PFN_vkVoidFunction)vkb_ep_vkDestroyInstance, VKB_LEVEL_INSTANCE, NULL}, - {"vkDestroyPipeline", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipeline, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyPipelineCache", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineCache, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyPipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyPrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyPrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data"}, - {"vkDestroyQueryPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyQueryPool, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyRenderPass", (PFN_vkVoidFunction)vkb_ep_vkDestroyRenderPass, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroySampler", (PFN_vkVoidFunction)vkb_ep_vkDestroySampler, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroySamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroySamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion"}, - {"vkDestroySemaphore", (PFN_vkVoidFunction)vkb_ep_vkDestroySemaphore, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroyShaderModule", (PFN_vkVoidFunction)vkb_ep_vkDestroyShaderModule, VKB_LEVEL_DEVICE, NULL}, - {"vkDestroySurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_surface"}, - {"vkDestroySwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkDestroyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkDestroyTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkDeviceWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkDeviceWaitIdle, VKB_LEVEL_DEVICE, NULL}, - {"vkEndCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkEndCommandBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkEnumerateDeviceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceExtensionProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkEnumerateDeviceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceLayerProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkEnumerateInstanceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceExtensionProperties, VKB_LEVEL_GLOBAL, NULL}, - {"vkEnumerateInstanceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceLayerProperties, VKB_LEVEL_GLOBAL, NULL}, - {"vkEnumerateInstanceVersion", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceVersion, VKB_LEVEL_GLOBAL, NULL}, - {"vkEnumeratePhysicalDeviceGroups", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, NULL}, - {"vkEnumeratePhysicalDeviceGroupsKHR", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, "VK_KHR_device_group_creation"}, - {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, VKB_LEVEL_PHYSDEV, "VK_ARM_performance_counters_by_region"}, - {"vkEnumeratePhysicalDevices", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDevices, VKB_LEVEL_INSTANCE, NULL}, - {"vkFlushMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkFlushMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL}, - {"vkFreeCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkFreeCommandBuffers, VKB_LEVEL_DEVICE, NULL}, - {"vkFreeDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkFreeDescriptorSets, VKB_LEVEL_DEVICE, NULL}, - {"vkFreeMemory", (PFN_vkVoidFunction)vkb_ep_vkFreeMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkGetBufferDeviceAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, NULL}, - {"vkGetBufferDeviceAddressEXT", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_EXT_buffer_device_address"}, - {"vkGetBufferDeviceAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address"}, - {"vkGetBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetBufferMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, NULL}, - {"vkGetBufferMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2"}, - {"vkGetBufferOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL}, - {"vkGetBufferOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address"}, - {"vkGetCalibratedTimestampsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps"}, - {"vkGetCalibratedTimestampsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps"}, - {"vkGetDescriptorSetLayoutSupport", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDescriptorSetLayoutSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, "VK_KHR_maintenance3"}, - {"vkGetDeviceBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceBufferMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4"}, - {"vkGetDeviceGroupPeerMemoryFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, "VK_KHR_device_group"}, - {"vkGetDeviceGroupPresentCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkGetDeviceGroupSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkGetDeviceImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceImageMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4"}, - {"vkGetDeviceImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceImageSparseMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4"}, - {"vkGetDeviceImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceImageSubresourceLayoutKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5"}, - {"vkGetDeviceMemoryCommitment", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryCommitment, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceMemoryOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address"}, - {"vkGetDeviceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceProcAddr, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceQueue", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceQueue2", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue2, VKB_LEVEL_DEVICE, NULL}, - {"vkGetDeviceTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkGetEventStatus", (PFN_vkVoidFunction)vkb_ep_vkGetEventStatus, VKB_LEVEL_DEVICE, NULL}, - {"vkGetFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd"}, - {"vkGetFenceStatus", (PFN_vkVoidFunction)vkb_ep_vkGetFenceStatus, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageDrmFormatModifierPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageDrmFormatModifierPropertiesEXT, VKB_LEVEL_DEVICE, "VK_EXT_image_drm_format_modifier"}, - {"vkGetImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2"}, - {"vkGetImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageSparseMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageSparseMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2"}, - {"vkGetImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageSubresourceLayout2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, NULL}, - {"vkGetImageSubresourceLayout2EXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_EXT_image_compression_control"}, - {"vkGetImageSubresourceLayout2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5"}, - {"vkGetInstanceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetInstanceProcAddr, VKB_LEVEL_INSTANCE, NULL}, - {"vkGetMemoryFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd"}, - {"vkGetMemoryFdPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdPropertiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd"}, - {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps"}, - {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps"}, - {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_cooperative_matrix"}, - {"vkGetPhysicalDeviceExternalBufferProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_memory_capabilities"}, - {"vkGetPhysicalDeviceExternalFenceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_fence_capabilities"}, - {"vkGetPhysicalDeviceExternalSemaphoreProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_semaphore_capabilities"}, - {"vkGetPhysicalDeviceExternalTensorPropertiesARM", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalTensorPropertiesARM, VKB_LEVEL_PHYSDEV, "VK_ARM_tensors"}, - {"vkGetPhysicalDeviceFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceFeatures2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceFeatures2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFragmentShadingRatesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_fragment_shading_rate"}, - {"vkGetPhysicalDeviceImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceMemoryProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceMemoryProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceMemoryProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT, VKB_LEVEL_PHYSDEV, "VK_EXT_sample_locations"}, - {"vkGetPhysicalDevicePresentRectanglesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_swapchain"}, - {"vkGetPhysicalDeviceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceQueueFamilyProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceQueueFamilyProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceSparseImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceSparseImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2"}, - {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2"}, - {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface"}, - {"vkGetPhysicalDeviceSurfaceFormats2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2"}, - {"vkGetPhysicalDeviceSurfaceFormatsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface"}, - {"vkGetPhysicalDeviceSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface"}, - {"vkGetPhysicalDeviceSurfaceSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface"}, - {"vkGetPhysicalDeviceToolProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, NULL}, - {"vkGetPhysicalDeviceToolPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, "VK_EXT_tooling_info"}, - {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_wayland_surface"}, - {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xcb_surface"}, - {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xlib_surface"}, - {"vkGetPipelineCacheData", (PFN_vkVoidFunction)vkb_ep_vkGetPipelineCacheData, VKB_LEVEL_DEVICE, NULL}, - {"vkGetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, NULL}, - {"vkGetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data"}, - {"vkGetQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkGetQueryPoolResults, VKB_LEVEL_DEVICE, NULL}, - {"vkGetRenderAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderAreaGranularity, VKB_LEVEL_DEVICE, NULL}, - {"vkGetRenderingAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, NULL}, - {"vkGetRenderingAreaGranularityKHR", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5"}, - {"vkGetSemaphoreCounterValue", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, NULL}, - {"vkGetSemaphoreCounterValueKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore"}, - {"vkGetSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd"}, - {"vkGetShaderModuleCreateInfoIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleCreateInfoIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier"}, - {"vkGetShaderModuleIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier"}, - {"vkGetSwapchainImagesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSwapchainImagesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkGetTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors"}, - {"vkImportFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd"}, - {"vkImportSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd"}, - {"vkInvalidateMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkInvalidateMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL}, - {"vkMapMemory", (PFN_vkVoidFunction)vkb_ep_vkMapMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkMapMemory2", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, NULL}, - {"vkMapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2"}, - {"vkMergePipelineCaches", (PFN_vkVoidFunction)vkb_ep_vkMergePipelineCaches, VKB_LEVEL_DEVICE, NULL}, - {"vkQueueBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkQueueBindSparse", (PFN_vkVoidFunction)vkb_ep_vkQueueBindSparse, VKB_LEVEL_DEVICE, NULL}, - {"vkQueueEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkQueueInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkQueuePresentKHR", (PFN_vkVoidFunction)vkb_ep_vkQueuePresentKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain"}, - {"vkQueueSubmit", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit, VKB_LEVEL_DEVICE, NULL}, - {"vkQueueSubmit2", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, NULL}, - {"vkQueueSubmit2KHR", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2"}, - {"vkQueueWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkQueueWaitIdle, VKB_LEVEL_DEVICE, NULL}, - {"vkResetCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkResetCommandBuffer, VKB_LEVEL_DEVICE, NULL}, - {"vkResetCommandPool", (PFN_vkVoidFunction)vkb_ep_vkResetCommandPool, VKB_LEVEL_DEVICE, NULL}, - {"vkResetDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkResetDescriptorPool, VKB_LEVEL_DEVICE, NULL}, - {"vkResetEvent", (PFN_vkVoidFunction)vkb_ep_vkResetEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkResetFences", (PFN_vkVoidFunction)vkb_ep_vkResetFences, VKB_LEVEL_DEVICE, NULL}, - {"vkResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, NULL}, - {"vkResetQueryPoolEXT", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, "VK_EXT_host_query_reset"}, - {"vkSetDebugUtilsObjectNameEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectNameEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkSetDebugUtilsObjectTagEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectTagEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils"}, - {"vkSetDeviceMemoryPriorityEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDeviceMemoryPriorityEXT, VKB_LEVEL_DEVICE, "VK_EXT_pageable_device_local_memory"}, - {"vkSetEvent", (PFN_vkVoidFunction)vkb_ep_vkSetEvent, VKB_LEVEL_DEVICE, NULL}, - {"vkSetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, NULL}, - {"vkSetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data"}, - {"vkSignalSemaphore", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, NULL}, - {"vkSignalSemaphoreKHR", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore"}, - {"vkSubmitDebugUtilsMessageEXT", (PFN_vkVoidFunction)vkb_ep_vkSubmitDebugUtilsMessageEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils"}, - {"vkTransitionImageLayout", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkTransitionImageLayoutEXT", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL}, - {"vkTrimCommandPool", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, NULL}, - {"vkTrimCommandPoolKHR", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, "VK_KHR_maintenance1"}, - {"vkUnmapMemory", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory, VKB_LEVEL_DEVICE, NULL}, - {"vkUnmapMemory2", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, NULL}, - {"vkUnmapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2"}, - {"vkUpdateDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL}, - {"vkUpdateDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template"}, - {"vkUpdateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSets, VKB_LEVEL_DEVICE, NULL}, - {"vkWaitForFences", (PFN_vkVoidFunction)vkb_ep_vkWaitForFences, VKB_LEVEL_DEVICE, NULL}, - {"vkWaitSemaphores", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, NULL}, - {"vkWaitSemaphoresKHR", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore"}, + {"vkAcquireNextImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkAcquireNextImage2KHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkAcquireNextImageKHR", (PFN_vkVoidFunction)vkb_ep_vkAcquireNextImageKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkAllocateCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkAllocateCommandBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkAllocateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkAllocateDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkAllocateMemory", (PFN_vkVoidFunction)vkb_ep_vkAllocateMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkBeginCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkBeginCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkBindBufferMemory", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkBindBufferMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkBindBufferMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindBufferMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2", 0}, + {"vkBindImageMemory", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkBindImageMemory2", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkBindImageMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkBindImageMemory2, VKB_LEVEL_DEVICE, "VK_KHR_bind_memory2", 0}, + {"vkBindTensorMemoryARM", (PFN_vkVoidFunction)vkb_ep_vkBindTensorMemoryARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkCmdBeginConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering", 0}, + {"vkCmdBeginCustomResolveEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginCustomResolveEXT, VKB_LEVEL_DEVICE, "VK_EXT_custom_resolve", 0}, + {"vkCmdBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkCmdBeginQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQuery, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBeginQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdBeginRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBeginRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCmdBeginRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0}, + {"vkCmdBeginRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdBeginRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering", 0}, + {"vkCmdBeginTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBeginTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdBindDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBindDescriptorSets2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdBindDescriptorSets2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindDescriptorSets2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0}, + {"vkCmdBindIndexBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBindIndexBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdBindIndexBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBindIndexBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0}, + {"vkCmdBindPipeline", (PFN_vkVoidFunction)vkb_ep_vkCmdBindPipeline, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBindTransformFeedbackBuffersEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindTransformFeedbackBuffersEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdBindVertexBuffers", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBindVertexBuffers2", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdBindVertexBuffers2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdBindVertexBuffers2, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdBlitImage", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdBlitImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdBlitImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdBlitImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdClearAttachments", (PFN_vkVoidFunction)vkb_ep_vkCmdClearAttachments, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdClearColorImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearColorImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdClearDepthStencilImage", (PFN_vkVoidFunction)vkb_ep_vkCmdClearDepthStencilImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdCopyBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdCopyBufferToImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyBufferToImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdCopyBufferToImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyBufferToImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdCopyImage", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdCopyImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdCopyImageToBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyImageToBuffer2", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdCopyImageToBuffer2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyImageToBuffer2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdCopyQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyQueryPoolResults, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdCopyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCmdCopyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkCmdDispatch", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatch, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDispatchBase", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkCmdDispatchBaseKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchBase, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0}, + {"vkCmdDispatchIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDispatchIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDraw", (PFN_vkVoidFunction)vkb_ep_vkCmdDraw, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDrawIndexed", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexed, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDrawIndexedIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDrawIndexedIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCmdDrawIndexedIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCmdDrawIndexedIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndexedIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count", 0}, + {"vkCmdDrawIndirect", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirect, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdDrawIndirectByteCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectByteCountEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdDrawIndirectCount", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCmdDrawIndirectCountAMD", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCmdDrawIndirectCountKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawIndirectCount, VKB_LEVEL_DEVICE, "VK_KHR_draw_indirect_count", 0}, + {"vkCmdDrawMultiEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw", 0}, + {"vkCmdDrawMultiIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdDrawMultiIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_multi_draw", 0}, + {"vkCmdEndConditionalRenderingEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndConditionalRenderingEXT, VKB_LEVEL_DEVICE, "VK_EXT_conditional_rendering", 0}, + {"vkCmdEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkCmdEndQuery", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQuery, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdEndQueryIndexedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndQueryIndexedEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdEndRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdEndRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCmdEndRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0}, + {"vkCmdEndRendering", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdEndRendering2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCmdEndRendering2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering2KHR, VKB_LEVEL_DEVICE, "VK_KHR_maintenance10", 0}, + {"vkCmdEndRenderingKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdEndRendering, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering", 0}, + {"vkCmdEndTransformFeedbackEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdEndTransformFeedbackEXT, VKB_LEVEL_DEVICE, "VK_EXT_transform_feedback", 0}, + {"vkCmdExecuteCommands", (PFN_vkVoidFunction)vkb_ep_vkCmdExecuteCommands, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdFillBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdFillBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkCmdNextSubpass", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdNextSubpass2", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCmdNextSubpass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdNextSubpass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0}, + {"vkCmdPipelineBarrier", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdPipelineBarrier2", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdPipelineBarrier2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPipelineBarrier2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkCmdPushConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdPushConstants2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdPushConstants2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushConstants2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0}, + {"vkCmdPushDescriptorSet", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdPushDescriptorSet2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdPushDescriptorSet2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0}, + {"vkCmdPushDescriptorSetKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSet, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor", 0}, + {"vkCmdPushDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdPushDescriptorSetWithTemplate2", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdPushDescriptorSetWithTemplate2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance6", 0}, + {"vkCmdPushDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdPushDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_push_descriptor", 0}, + {"vkCmdResetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdResetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdResetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkCmdResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCmdResetQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdResolveImage", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdResolveImage2", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdResolveImage2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdResolveImage2, VKB_LEVEL_DEVICE, "VK_KHR_copy_commands2", 0}, + {"vkCmdSetAlphaToCoverageEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToCoverageEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetAlphaToOneEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAlphaToOneEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetAttachmentFeedbackLoopEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_attachment_feedback_loop_dynamic_state", 0}, + {"vkCmdSetBlendConstants", (PFN_vkVoidFunction)vkb_ep_vkCmdSetBlendConstants, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetColorBlendAdvancedEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendAdvancedEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetColorBlendEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetColorBlendEquationEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorBlendEquationEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetColorWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_color_write_enable", 0}, + {"vkCmdSetColorWriteMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetColorWriteMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetConservativeRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetConservativeRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetCullMode", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetCullModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetCullMode, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetDepthBias", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetDepthBias2EXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBias2EXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_bias_control", 0}, + {"vkCmdSetDepthBiasEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetDepthBiasEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBiasEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0}, + {"vkCmdSetDepthBounds", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBounds, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetDepthBoundsTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetDepthBoundsTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthBoundsTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetDepthClampEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetDepthClampRangeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClampRangeEXT, VKB_LEVEL_DEVICE, "VK_EXT_depth_clamp_control", 0}, + {"vkCmdSetDepthClipEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetDepthClipNegativeOneToOneEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthClipNegativeOneToOneEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetDepthCompareOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetDepthCompareOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthCompareOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetDepthTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetDepthTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetDepthWriteEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetDepthWriteEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDepthWriteEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetDeviceMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkCmdSetDeviceMaskKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDeviceMask, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0}, + {"vkCmdSetDiscardRectangleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0}, + {"vkCmdSetDiscardRectangleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0}, + {"vkCmdSetDiscardRectangleModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetDiscardRectangleModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_discard_rectangles", 0}, + {"vkCmdSetEvent", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetEvent2", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetEvent2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetEvent2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetExtraPrimitiveOverestimationSizeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetFragmentShadingRateKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFragmentShadingRateKHR, VKB_LEVEL_DEVICE, "VK_KHR_fragment_shading_rate", 0}, + {"vkCmdSetFrontFace", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetFrontFaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetFrontFace, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetLineRasterizationModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineRasterizationModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetLineStipple", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdSetLineStippleEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_EXT_line_rasterization", 0}, + {"vkCmdSetLineStippleEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStippleEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetLineStippleKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineStipple, VKB_LEVEL_DEVICE, "VK_KHR_line_rasterization", 0}, + {"vkCmdSetLineWidth", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLineWidth, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetLogicOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0}, + {"vkCmdSetLogicOpEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetLogicOpEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetPatchControlPointsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPatchControlPointsEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0}, + {"vkCmdSetPolygonModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPolygonModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetPrimitiveRestartEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetPrimitiveRestartEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveRestartEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0}, + {"vkCmdSetPrimitiveTopology", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetPrimitiveTopologyEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetPrimitiveTopology, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetProvokingVertexModeEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetProvokingVertexModeEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetRasterizationSamplesEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationSamplesEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetRasterizationStreamEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizationStreamEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetRasterizerDiscardEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetRasterizerDiscardEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRasterizerDiscardEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state2", 0}, + {"vkCmdSetRenderingAttachmentLocations", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdSetRenderingAttachmentLocationsKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingAttachmentLocations, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read", 0}, + {"vkCmdSetRenderingInputAttachmentIndices", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCmdSetRenderingInputAttachmentIndicesKHR", (PFN_vkVoidFunction)vkb_ep_vkCmdSetRenderingInputAttachmentIndices, VKB_LEVEL_DEVICE, "VK_KHR_dynamic_rendering_local_read", 0}, + {"vkCmdSetSampleLocationsEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEXT, VKB_LEVEL_DEVICE, "VK_EXT_sample_locations", 0}, + {"vkCmdSetSampleLocationsEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleLocationsEnableEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetSampleMaskEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetSampleMaskEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetScissor", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissor, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetScissorWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetScissorWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetScissorWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetStencilCompareMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilCompareMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetStencilOp", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetStencilOpEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilOp, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetStencilReference", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilReference, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetStencilTestEnable", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetStencilTestEnableEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilTestEnable, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdSetStencilWriteMask", (PFN_vkVoidFunction)vkb_ep_vkCmdSetStencilWriteMask, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetTessellationDomainOriginEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetTessellationDomainOriginEXT, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state3", 0}, + {"vkCmdSetVertexInputEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetVertexInputEXT, VKB_LEVEL_DEVICE, "VK_EXT_vertex_input_dynamic_state", 0}, + {"vkCmdSetViewport", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewport, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdSetViewportWithCount", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdSetViewportWithCountEXT", (PFN_vkVoidFunction)vkb_ep_vkCmdSetViewportWithCount, VKB_LEVEL_DEVICE, "VK_EXT_extended_dynamic_state", 0}, + {"vkCmdUpdateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCmdUpdateBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdWaitEvents", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdWaitEvents2", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdWaitEvents2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWaitEvents2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkCmdWriteTimestamp", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCmdWriteTimestamp2", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCmdWriteTimestamp2KHR", (PFN_vkVoidFunction)vkb_ep_vkCmdWriteTimestamp2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkCopyImageToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCopyImageToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToImage, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCopyImageToMemory", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCopyImageToMemoryEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyImageToMemory, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCopyMemoryToImage", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkCopyMemoryToImageEXT", (PFN_vkVoidFunction)vkb_ep_vkCopyMemoryToImage, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkCreateBuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateBufferView", (PFN_vkVoidFunction)vkb_ep_vkCreateBufferView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateCommandPool", (PFN_vkVoidFunction)vkb_ep_vkCreateCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateComputePipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateComputePipelines, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0}, + {"vkCreateDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkCreateDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0}, + {"vkCreateDevice", (PFN_vkVoidFunction)vkb_ep_vkCreateDevice, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateEvent", (PFN_vkVoidFunction)vkb_ep_vkCreateEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateFence", (PFN_vkVoidFunction)vkb_ep_vkCreateFence, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkCreateFramebuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateGraphicsPipelines", (PFN_vkVoidFunction)vkb_ep_vkCreateGraphicsPipelines, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateHeadlessSurfaceEXT", (PFN_vkVoidFunction)vkb_ep_vkCreateHeadlessSurfaceEXT, VKB_LEVEL_INSTANCE, "VK_EXT_headless_surface", 0}, + {"vkCreateImage", (PFN_vkVoidFunction)vkb_ep_vkCreateImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateImageView", (PFN_vkVoidFunction)vkb_ep_vkCreateImageView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateInstance", (PFN_vkVoidFunction)vkb_ep_vkCreateInstance, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreatePipelineCache", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineCache, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreatePipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkCreatePipelineLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreatePrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkCreatePrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkCreatePrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0}, + {"vkCreateQueryPool", (PFN_vkVoidFunction)vkb_ep_vkCreateQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateRenderPass", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateRenderPass2", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkCreateRenderPass2KHR", (PFN_vkVoidFunction)vkb_ep_vkCreateRenderPass2, VKB_LEVEL_DEVICE, "VK_KHR_create_renderpass2", 0}, + {"vkCreateSampler", (PFN_vkVoidFunction)vkb_ep_vkCreateSampler, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateSamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkCreateSamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion", 0}, + {"vkCreateSemaphore", (PFN_vkVoidFunction)vkb_ep_vkCreateSemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateShaderModule", (PFN_vkVoidFunction)vkb_ep_vkCreateShaderModule, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkCreateSwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateSwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkCreateTensorARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkCreateTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkCreateTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkCreateWaylandSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateWaylandSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_wayland_surface", 0}, + {"vkCreateXcbSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXcbSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xcb_surface", 0}, + {"vkCreateXlibSurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkCreateXlibSurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_xlib_surface", 0}, + {"vkDestroyBuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyBufferView", (PFN_vkVoidFunction)vkb_ep_vkDestroyBufferView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyCommandPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyDebugUtilsMessengerEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyDebugUtilsMessengerEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0}, + {"vkDestroyDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyDescriptorSetLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorSetLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyDescriptorUpdateTemplate", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkDestroyDescriptorUpdateTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroyDescriptorUpdateTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0}, + {"vkDestroyDevice", (PFN_vkVoidFunction)vkb_ep_vkDestroyDevice, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyEvent", (PFN_vkVoidFunction)vkb_ep_vkDestroyEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyFence", (PFN_vkVoidFunction)vkb_ep_vkDestroyFence, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyFramebuffer", (PFN_vkVoidFunction)vkb_ep_vkDestroyFramebuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyImage", (PFN_vkVoidFunction)vkb_ep_vkDestroyImage, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyImageView", (PFN_vkVoidFunction)vkb_ep_vkDestroyImageView, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyInstance", (PFN_vkVoidFunction)vkb_ep_vkDestroyInstance, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyPipeline", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipeline, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyPipelineCache", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineCache, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyPipelineLayout", (PFN_vkVoidFunction)vkb_ep_vkDestroyPipelineLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyPrivateDataSlot", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkDestroyPrivateDataSlotEXT", (PFN_vkVoidFunction)vkb_ep_vkDestroyPrivateDataSlot, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0}, + {"vkDestroyQueryPool", (PFN_vkVoidFunction)vkb_ep_vkDestroyQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyRenderPass", (PFN_vkVoidFunction)vkb_ep_vkDestroyRenderPass, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroySampler", (PFN_vkVoidFunction)vkb_ep_vkDestroySampler, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroySamplerYcbcrConversion", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkDestroySamplerYcbcrConversionKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySamplerYcbcrConversion, VKB_LEVEL_DEVICE, "VK_KHR_sampler_ycbcr_conversion", 0}, + {"vkDestroySemaphore", (PFN_vkVoidFunction)vkb_ep_vkDestroySemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroyShaderModule", (PFN_vkVoidFunction)vkb_ep_vkDestroyShaderModule, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkDestroySurfaceKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySurfaceKHR, VKB_LEVEL_INSTANCE, "VK_KHR_surface", 0}, + {"vkDestroySwapchainKHR", (PFN_vkVoidFunction)vkb_ep_vkDestroySwapchainKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkDestroyTensorARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkDestroyTensorViewARM", (PFN_vkVoidFunction)vkb_ep_vkDestroyTensorViewARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkDeviceWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkDeviceWaitIdle, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEndCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkEndCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEnumerateDeviceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceExtensionProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEnumerateDeviceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateDeviceLayerProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEnumerateInstanceExtensionProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceExtensionProperties, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEnumerateInstanceLayerProperties", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceLayerProperties, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkEnumerateInstanceVersion", (PFN_vkVoidFunction)vkb_ep_vkEnumerateInstanceVersion, VKB_LEVEL_GLOBAL, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkEnumeratePhysicalDeviceGroups", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkEnumeratePhysicalDeviceGroupsKHR", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceGroups, VKB_LEVEL_INSTANCE, "VK_KHR_device_group_creation", 0}, + {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, VKB_LEVEL_PHYSDEV, "VK_ARM_performance_counters_by_region", 0}, + {"vkEnumeratePhysicalDevices", (PFN_vkVoidFunction)vkb_ep_vkEnumeratePhysicalDevices, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkFlushMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkFlushMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkFreeCommandBuffers", (PFN_vkVoidFunction)vkb_ep_vkFreeCommandBuffers, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkFreeDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkFreeDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkFreeMemory", (PFN_vkVoidFunction)vkb_ep_vkFreeMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetBufferDeviceAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkGetBufferDeviceAddressEXT", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_EXT_buffer_device_address", 0}, + {"vkGetBufferDeviceAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferDeviceAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0}, + {"vkGetBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetBufferMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetBufferMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0}, + {"vkGetBufferOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkGetBufferOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetBufferOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0}, + {"vkGetCalibratedTimestampsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps", 0}, + {"vkGetCalibratedTimestampsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetCalibratedTimestampsKHR, VKB_LEVEL_DEVICE, "VK_EXT_calibrated_timestamps", 0}, + {"vkGetDescriptorSetLayoutSupport", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetDescriptorSetLayoutSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDescriptorSetLayoutSupport, VKB_LEVEL_DEVICE, "VK_KHR_maintenance3", 0}, + {"vkGetDeviceBufferMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkGetDeviceBufferMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceBufferMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0}, + {"vkGetDeviceGroupPeerMemoryFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPeerMemoryFeatures, VKB_LEVEL_DEVICE, "VK_KHR_device_group", 0}, + {"vkGetDeviceGroupPresentCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupPresentCapabilitiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkGetDeviceGroupSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceGroupSurfacePresentModesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkGetDeviceImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkGetDeviceImageMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0}, + {"vkGetDeviceImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkGetDeviceImageSparseMemoryRequirementsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, "VK_KHR_maintenance4", 0}, + {"vkGetDeviceImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkGetDeviceImageSubresourceLayoutKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceImageSubresourceLayout, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0}, + {"vkGetDeviceMemoryCommitment", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryCommitment, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetDeviceMemoryOpaqueCaptureAddress", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceMemoryOpaqueCaptureAddress, VKB_LEVEL_DEVICE, "VK_KHR_buffer_device_address", 0}, + {"vkGetDeviceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceProcAddr, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetDeviceQueue", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetDeviceQueue2", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceQueue2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetDeviceTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetDeviceTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkGetEventStatus", (PFN_vkVoidFunction)vkb_ep_vkGetEventStatus, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd", 0}, + {"vkGetFenceStatus", (PFN_vkVoidFunction)vkb_ep_vkGetFenceStatus, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetImageDrmFormatModifierPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageDrmFormatModifierPropertiesEXT, VKB_LEVEL_DEVICE, "VK_EXT_image_drm_format_modifier", 0}, + {"vkGetImageMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetImageMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetImageMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0}, + {"vkGetImageSparseMemoryRequirements", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetImageSparseMemoryRequirements2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetImageSparseMemoryRequirements2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSparseMemoryRequirements2, VKB_LEVEL_DEVICE, "VK_KHR_get_memory_requirements2", 0}, + {"vkGetImageSubresourceLayout", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetImageSubresourceLayout2", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkGetImageSubresourceLayout2EXT", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_EXT_image_compression_control", 0}, + {"vkGetImageSubresourceLayout2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetImageSubresourceLayout2, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0}, + {"vkGetInstanceProcAddr", (PFN_vkVoidFunction)vkb_ep_vkGetInstanceProcAddr, VKB_LEVEL_INSTANCE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetMemoryFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd", 0}, + {"vkGetMemoryFdPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetMemoryFdPropertiesKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_memory_fd", 0}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps", 0}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, VKB_LEVEL_PHYSDEV, "VK_EXT_calibrated_timestamps", 0}, + {"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_cooperative_matrix", 0}, + {"vkGetPhysicalDeviceExternalBufferProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalBufferProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_memory_capabilities", 0}, + {"vkGetPhysicalDeviceExternalFenceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalFenceProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_fence_capabilities", 0}, + {"vkGetPhysicalDeviceExternalSemaphoreProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalSemaphoreProperties, VKB_LEVEL_PHYSDEV, "VK_KHR_external_semaphore_capabilities", 0}, + {"vkGetPhysicalDeviceExternalTensorPropertiesARM", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceExternalTensorPropertiesARM, VKB_LEVEL_PHYSDEV, "VK_ARM_tensors", 0}, + {"vkGetPhysicalDeviceFeatures", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceFeatures2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceFeatures2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFeatures2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceFragmentShadingRatesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_fragment_shading_rate", 0}, + {"vkGetPhysicalDeviceImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceMemoryProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceMemoryProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceMemoryProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMemoryProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceMultisamplePropertiesEXT, VKB_LEVEL_PHYSDEV, "VK_EXT_sample_locations", 0}, + {"vkGetPhysicalDevicePresentRectanglesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDevicePresentRectanglesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_swapchain", 0}, + {"vkGetPhysicalDeviceProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceQueueFamilyProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceQueueFamilyProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceQueueFamilyProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceSparseImageFormatProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSparseImageFormatProperties2, VKB_LEVEL_PHYSDEV, "VK_KHR_get_physical_device_properties2", 0}, + {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilities2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2", 0}, + {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0}, + {"vkGetPhysicalDeviceSurfaceFormats2KHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormats2KHR, VKB_LEVEL_PHYSDEV, "VK_KHR_get_surface_capabilities2", 0}, + {"vkGetPhysicalDeviceSurfaceFormatsKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceFormatsKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0}, + {"vkGetPhysicalDeviceSurfacePresentModesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfacePresentModesKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0}, + {"vkGetPhysicalDeviceSurfaceSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceSurfaceSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_surface", 0}, + {"vkGetPhysicalDeviceToolProperties", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkGetPhysicalDeviceToolPropertiesEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceToolProperties, VKB_LEVEL_PHYSDEV, "VK_EXT_tooling_info", 0}, + {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceWaylandPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_wayland_surface", 0}, + {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXcbPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xcb_surface", 0}, + {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (PFN_vkVoidFunction)vkb_ep_vkGetPhysicalDeviceXlibPresentationSupportKHR, VKB_LEVEL_PHYSDEV, "VK_KHR_xlib_surface", 0}, + {"vkGetPipelineCacheData", (PFN_vkVoidFunction)vkb_ep_vkGetPipelineCacheData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkGetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkGetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0}, + {"vkGetQueryPoolResults", (PFN_vkVoidFunction)vkb_ep_vkGetQueryPoolResults, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetRenderAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderAreaGranularity, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkGetRenderingAreaGranularity", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkGetRenderingAreaGranularityKHR", (PFN_vkVoidFunction)vkb_ep_vkGetRenderingAreaGranularity, VKB_LEVEL_DEVICE, "VK_KHR_maintenance5", 0}, + {"vkGetSemaphoreCounterValue", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkGetSemaphoreCounterValueKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreCounterValue, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0}, + {"vkGetSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd", 0}, + {"vkGetShaderModuleCreateInfoIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleCreateInfoIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier", 0}, + {"vkGetShaderModuleIdentifierEXT", (PFN_vkVoidFunction)vkb_ep_vkGetShaderModuleIdentifierEXT, VKB_LEVEL_DEVICE, "VK_EXT_shader_module_identifier", 0}, + {"vkGetSwapchainImagesKHR", (PFN_vkVoidFunction)vkb_ep_vkGetSwapchainImagesKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkGetTensorMemoryRequirementsARM", (PFN_vkVoidFunction)vkb_ep_vkGetTensorMemoryRequirementsARM, VKB_LEVEL_DEVICE, "VK_ARM_tensors", 0}, + {"vkImportFenceFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportFenceFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_fence_fd", 0}, + {"vkImportSemaphoreFdKHR", (PFN_vkVoidFunction)vkb_ep_vkImportSemaphoreFdKHR, VKB_LEVEL_DEVICE, "VK_KHR_external_semaphore_fd", 0}, + {"vkInvalidateMappedMemoryRanges", (PFN_vkVoidFunction)vkb_ep_vkInvalidateMappedMemoryRanges, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkMapMemory", (PFN_vkVoidFunction)vkb_ep_vkMapMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkMapMemory2", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkMapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkMapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2", 0}, + {"vkMergePipelineCaches", (PFN_vkVoidFunction)vkb_ep_vkMergePipelineCaches, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkQueueBeginDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueBeginDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkQueueBindSparse", (PFN_vkVoidFunction)vkb_ep_vkQueueBindSparse, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkQueueEndDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueEndDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkQueueInsertDebugUtilsLabelEXT", (PFN_vkVoidFunction)vkb_ep_vkQueueInsertDebugUtilsLabelEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkQueuePresentKHR", (PFN_vkVoidFunction)vkb_ep_vkQueuePresentKHR, VKB_LEVEL_DEVICE, "VK_KHR_swapchain", 0}, + {"vkQueueSubmit", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkQueueSubmit2", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkQueueSubmit2KHR", (PFN_vkVoidFunction)vkb_ep_vkQueueSubmit2, VKB_LEVEL_DEVICE, "VK_KHR_synchronization2", 0}, + {"vkQueueWaitIdle", (PFN_vkVoidFunction)vkb_ep_vkQueueWaitIdle, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetCommandBuffer", (PFN_vkVoidFunction)vkb_ep_vkResetCommandBuffer, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetCommandPool", (PFN_vkVoidFunction)vkb_ep_vkResetCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetDescriptorPool", (PFN_vkVoidFunction)vkb_ep_vkResetDescriptorPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetEvent", (PFN_vkVoidFunction)vkb_ep_vkResetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetFences", (PFN_vkVoidFunction)vkb_ep_vkResetFences, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkResetQueryPool", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkResetQueryPoolEXT", (PFN_vkVoidFunction)vkb_ep_vkResetQueryPool, VKB_LEVEL_DEVICE, "VK_EXT_host_query_reset", 0}, + {"vkSetDebugUtilsObjectNameEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectNameEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkSetDebugUtilsObjectTagEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDebugUtilsObjectTagEXT, VKB_LEVEL_DEVICE, "VK_EXT_debug_utils", 0}, + {"vkSetDeviceMemoryPriorityEXT", (PFN_vkVoidFunction)vkb_ep_vkSetDeviceMemoryPriorityEXT, VKB_LEVEL_DEVICE, "VK_EXT_pageable_device_local_memory", 0}, + {"vkSetEvent", (PFN_vkVoidFunction)vkb_ep_vkSetEvent, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkSetPrivateData", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 3, 0)}, + {"vkSetPrivateDataEXT", (PFN_vkVoidFunction)vkb_ep_vkSetPrivateData, VKB_LEVEL_DEVICE, "VK_EXT_private_data", 0}, + {"vkSignalSemaphore", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkSignalSemaphoreKHR", (PFN_vkVoidFunction)vkb_ep_vkSignalSemaphore, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0}, + {"vkSubmitDebugUtilsMessageEXT", (PFN_vkVoidFunction)vkb_ep_vkSubmitDebugUtilsMessageEXT, VKB_LEVEL_INSTANCE, "VK_EXT_debug_utils", 0}, + {"vkTransitionImageLayout", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkTransitionImageLayoutEXT", (PFN_vkVoidFunction)vkb_ep_vkTransitionImageLayout, VKB_LEVEL_DEVICE, NULL, 0}, + {"vkTrimCommandPool", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkTrimCommandPoolKHR", (PFN_vkVoidFunction)vkb_ep_vkTrimCommandPool, VKB_LEVEL_DEVICE, "VK_KHR_maintenance1", 0}, + {"vkUnmapMemory", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkUnmapMemory2", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 4, 0)}, + {"vkUnmapMemory2KHR", (PFN_vkVoidFunction)vkb_ep_vkUnmapMemory2, VKB_LEVEL_DEVICE, "VK_KHR_map_memory2", 0}, + {"vkUpdateDescriptorSetWithTemplate", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 1, 0)}, + {"vkUpdateDescriptorSetWithTemplateKHR", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSetWithTemplate, VKB_LEVEL_DEVICE, "VK_KHR_descriptor_update_template", 0}, + {"vkUpdateDescriptorSets", (PFN_vkVoidFunction)vkb_ep_vkUpdateDescriptorSets, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkWaitForFences", (PFN_vkVoidFunction)vkb_ep_vkWaitForFences, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 0, 0)}, + {"vkWaitSemaphores", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, NULL, VK_MAKE_API_VERSION(0, 1, 2, 0)}, + {"vkWaitSemaphoresKHR", (PFN_vkVoidFunction)vkb_ep_vkWaitSemaphores, VKB_LEVEL_DEVICE, "VK_KHR_timeline_semaphore", 0}, }; const size_t vkb_client_proc_count = sizeof(vkb_client_procs) / sizeof(vkb_client_procs[0]); diff --git a/tools/vkbridge/common/gen/vkb_gen_server.c b/tools/vkbridge/common/gen/vkb_gen_server.c index 1ca59f5ae..e1d2627c0 100644 --- a/tools/vkbridge/common/gen/vkb_gen_server.c +++ b/tools/vkbridge/common/gen/vkb_gen_server.c @@ -397,1114 +397,1114 @@ void vkb_dispatch_load_device(vkb_dispatch *dt, PFN_vkGetDeviceProcAddr gdpa, Vk { { PFN_vkAllocateCommandBuffers f_ = (PFN_vkAllocateCommandBuffers)gdpa(device, "vkAllocateCommandBuffers"); - if (f_) dt->vkAllocateCommandBuffers = f_; + dt->vkAllocateCommandBuffers = f_; } { PFN_vkAllocateDescriptorSets f_ = (PFN_vkAllocateDescriptorSets)gdpa(device, "vkAllocateDescriptorSets"); - if (f_) dt->vkAllocateDescriptorSets = f_; + dt->vkAllocateDescriptorSets = f_; } { PFN_vkAllocateMemory f_ = (PFN_vkAllocateMemory)gdpa(device, "vkAllocateMemory"); - if (f_) dt->vkAllocateMemory = f_; + dt->vkAllocateMemory = f_; } { PFN_vkBeginCommandBuffer f_ = (PFN_vkBeginCommandBuffer)gdpa(device, "vkBeginCommandBuffer"); - if (f_) dt->vkBeginCommandBuffer = f_; + dt->vkBeginCommandBuffer = f_; } { PFN_vkBindBufferMemory f_ = (PFN_vkBindBufferMemory)gdpa(device, "vkBindBufferMemory"); - if (f_) dt->vkBindBufferMemory = f_; + dt->vkBindBufferMemory = f_; } { PFN_vkBindBufferMemory2 f_ = (PFN_vkBindBufferMemory2)gdpa(device, "vkBindBufferMemory2"); if (!f_) f_ = (PFN_vkBindBufferMemory2)gdpa(device, "vkBindBufferMemory2KHR"); - if (f_) dt->vkBindBufferMemory2 = f_; + dt->vkBindBufferMemory2 = f_; } { PFN_vkBindImageMemory f_ = (PFN_vkBindImageMemory)gdpa(device, "vkBindImageMemory"); - if (f_) dt->vkBindImageMemory = f_; + dt->vkBindImageMemory = f_; } { PFN_vkBindImageMemory2 f_ = (PFN_vkBindImageMemory2)gdpa(device, "vkBindImageMemory2"); if (!f_) f_ = (PFN_vkBindImageMemory2)gdpa(device, "vkBindImageMemory2KHR"); - if (f_) dt->vkBindImageMemory2 = f_; + dt->vkBindImageMemory2 = f_; } { PFN_vkBindTensorMemoryARM f_ = (PFN_vkBindTensorMemoryARM)gdpa(device, "vkBindTensorMemoryARM"); - if (f_) dt->vkBindTensorMemoryARM = f_; + dt->vkBindTensorMemoryARM = f_; } { PFN_vkCmdBeginConditionalRenderingEXT f_ = (PFN_vkCmdBeginConditionalRenderingEXT)gdpa(device, "vkCmdBeginConditionalRenderingEXT"); - if (f_) dt->vkCmdBeginConditionalRenderingEXT = f_; + dt->vkCmdBeginConditionalRenderingEXT = f_; } { PFN_vkCmdBeginCustomResolveEXT f_ = (PFN_vkCmdBeginCustomResolveEXT)gdpa(device, "vkCmdBeginCustomResolveEXT"); - if (f_) dt->vkCmdBeginCustomResolveEXT = f_; + dt->vkCmdBeginCustomResolveEXT = f_; } { PFN_vkCmdBeginQuery f_ = (PFN_vkCmdBeginQuery)gdpa(device, "vkCmdBeginQuery"); - if (f_) dt->vkCmdBeginQuery = f_; + dt->vkCmdBeginQuery = f_; } { PFN_vkCmdBeginQueryIndexedEXT f_ = (PFN_vkCmdBeginQueryIndexedEXT)gdpa(device, "vkCmdBeginQueryIndexedEXT"); - if (f_) dt->vkCmdBeginQueryIndexedEXT = f_; + dt->vkCmdBeginQueryIndexedEXT = f_; } { PFN_vkCmdBeginRenderPass f_ = (PFN_vkCmdBeginRenderPass)gdpa(device, "vkCmdBeginRenderPass"); - if (f_) dt->vkCmdBeginRenderPass = f_; + dt->vkCmdBeginRenderPass = f_; } { PFN_vkCmdBeginRenderPass2 f_ = (PFN_vkCmdBeginRenderPass2)gdpa(device, "vkCmdBeginRenderPass2"); if (!f_) f_ = (PFN_vkCmdBeginRenderPass2)gdpa(device, "vkCmdBeginRenderPass2KHR"); - if (f_) dt->vkCmdBeginRenderPass2 = f_; + dt->vkCmdBeginRenderPass2 = f_; } { PFN_vkCmdBeginRendering f_ = (PFN_vkCmdBeginRendering)gdpa(device, "vkCmdBeginRendering"); if (!f_) f_ = (PFN_vkCmdBeginRendering)gdpa(device, "vkCmdBeginRenderingKHR"); - if (f_) dt->vkCmdBeginRendering = f_; + dt->vkCmdBeginRendering = f_; } { PFN_vkCmdBeginTransformFeedbackEXT f_ = (PFN_vkCmdBeginTransformFeedbackEXT)gdpa(device, "vkCmdBeginTransformFeedbackEXT"); - if (f_) dt->vkCmdBeginTransformFeedbackEXT = f_; + dt->vkCmdBeginTransformFeedbackEXT = f_; } { PFN_vkCmdBindDescriptorSets f_ = (PFN_vkCmdBindDescriptorSets)gdpa(device, "vkCmdBindDescriptorSets"); - if (f_) dt->vkCmdBindDescriptorSets = f_; + dt->vkCmdBindDescriptorSets = f_; } { PFN_vkCmdBindDescriptorSets2 f_ = (PFN_vkCmdBindDescriptorSets2)gdpa(device, "vkCmdBindDescriptorSets2"); if (!f_) f_ = (PFN_vkCmdBindDescriptorSets2)gdpa(device, "vkCmdBindDescriptorSets2KHR"); - if (f_) dt->vkCmdBindDescriptorSets2 = f_; + dt->vkCmdBindDescriptorSets2 = f_; } { PFN_vkCmdBindIndexBuffer f_ = (PFN_vkCmdBindIndexBuffer)gdpa(device, "vkCmdBindIndexBuffer"); - if (f_) dt->vkCmdBindIndexBuffer = f_; + dt->vkCmdBindIndexBuffer = f_; } { PFN_vkCmdBindIndexBuffer2 f_ = (PFN_vkCmdBindIndexBuffer2)gdpa(device, "vkCmdBindIndexBuffer2"); if (!f_) f_ = (PFN_vkCmdBindIndexBuffer2)gdpa(device, "vkCmdBindIndexBuffer2KHR"); - if (f_) dt->vkCmdBindIndexBuffer2 = f_; + dt->vkCmdBindIndexBuffer2 = f_; } { PFN_vkCmdBindPipeline f_ = (PFN_vkCmdBindPipeline)gdpa(device, "vkCmdBindPipeline"); - if (f_) dt->vkCmdBindPipeline = f_; + dt->vkCmdBindPipeline = f_; } { PFN_vkCmdBindTransformFeedbackBuffersEXT f_ = (PFN_vkCmdBindTransformFeedbackBuffersEXT)gdpa(device, "vkCmdBindTransformFeedbackBuffersEXT"); - if (f_) dt->vkCmdBindTransformFeedbackBuffersEXT = f_; + dt->vkCmdBindTransformFeedbackBuffersEXT = f_; } { PFN_vkCmdBindVertexBuffers f_ = (PFN_vkCmdBindVertexBuffers)gdpa(device, "vkCmdBindVertexBuffers"); - if (f_) dt->vkCmdBindVertexBuffers = f_; + dt->vkCmdBindVertexBuffers = f_; } { PFN_vkCmdBindVertexBuffers2 f_ = (PFN_vkCmdBindVertexBuffers2)gdpa(device, "vkCmdBindVertexBuffers2"); if (!f_) f_ = (PFN_vkCmdBindVertexBuffers2)gdpa(device, "vkCmdBindVertexBuffers2EXT"); - if (f_) dt->vkCmdBindVertexBuffers2 = f_; + dt->vkCmdBindVertexBuffers2 = f_; } { PFN_vkCmdBlitImage f_ = (PFN_vkCmdBlitImage)gdpa(device, "vkCmdBlitImage"); - if (f_) dt->vkCmdBlitImage = f_; + dt->vkCmdBlitImage = f_; } { PFN_vkCmdBlitImage2 f_ = (PFN_vkCmdBlitImage2)gdpa(device, "vkCmdBlitImage2"); if (!f_) f_ = (PFN_vkCmdBlitImage2)gdpa(device, "vkCmdBlitImage2KHR"); - if (f_) dt->vkCmdBlitImage2 = f_; + dt->vkCmdBlitImage2 = f_; } { PFN_vkCmdClearAttachments f_ = (PFN_vkCmdClearAttachments)gdpa(device, "vkCmdClearAttachments"); - if (f_) dt->vkCmdClearAttachments = f_; + dt->vkCmdClearAttachments = f_; } { PFN_vkCmdClearColorImage f_ = (PFN_vkCmdClearColorImage)gdpa(device, "vkCmdClearColorImage"); - if (f_) dt->vkCmdClearColorImage = f_; + dt->vkCmdClearColorImage = f_; } { PFN_vkCmdClearDepthStencilImage f_ = (PFN_vkCmdClearDepthStencilImage)gdpa(device, "vkCmdClearDepthStencilImage"); - if (f_) dt->vkCmdClearDepthStencilImage = f_; + dt->vkCmdClearDepthStencilImage = f_; } { PFN_vkCmdCopyBuffer f_ = (PFN_vkCmdCopyBuffer)gdpa(device, "vkCmdCopyBuffer"); - if (f_) dt->vkCmdCopyBuffer = f_; + dt->vkCmdCopyBuffer = f_; } { PFN_vkCmdCopyBuffer2 f_ = (PFN_vkCmdCopyBuffer2)gdpa(device, "vkCmdCopyBuffer2"); if (!f_) f_ = (PFN_vkCmdCopyBuffer2)gdpa(device, "vkCmdCopyBuffer2KHR"); - if (f_) dt->vkCmdCopyBuffer2 = f_; + dt->vkCmdCopyBuffer2 = f_; } { PFN_vkCmdCopyBufferToImage f_ = (PFN_vkCmdCopyBufferToImage)gdpa(device, "vkCmdCopyBufferToImage"); - if (f_) dt->vkCmdCopyBufferToImage = f_; + dt->vkCmdCopyBufferToImage = f_; } { PFN_vkCmdCopyBufferToImage2 f_ = (PFN_vkCmdCopyBufferToImage2)gdpa(device, "vkCmdCopyBufferToImage2"); if (!f_) f_ = (PFN_vkCmdCopyBufferToImage2)gdpa(device, "vkCmdCopyBufferToImage2KHR"); - if (f_) dt->vkCmdCopyBufferToImage2 = f_; + dt->vkCmdCopyBufferToImage2 = f_; } { PFN_vkCmdCopyImage f_ = (PFN_vkCmdCopyImage)gdpa(device, "vkCmdCopyImage"); - if (f_) dt->vkCmdCopyImage = f_; + dt->vkCmdCopyImage = f_; } { PFN_vkCmdCopyImage2 f_ = (PFN_vkCmdCopyImage2)gdpa(device, "vkCmdCopyImage2"); if (!f_) f_ = (PFN_vkCmdCopyImage2)gdpa(device, "vkCmdCopyImage2KHR"); - if (f_) dt->vkCmdCopyImage2 = f_; + dt->vkCmdCopyImage2 = f_; } { PFN_vkCmdCopyImageToBuffer f_ = (PFN_vkCmdCopyImageToBuffer)gdpa(device, "vkCmdCopyImageToBuffer"); - if (f_) dt->vkCmdCopyImageToBuffer = f_; + dt->vkCmdCopyImageToBuffer = f_; } { PFN_vkCmdCopyImageToBuffer2 f_ = (PFN_vkCmdCopyImageToBuffer2)gdpa(device, "vkCmdCopyImageToBuffer2"); if (!f_) f_ = (PFN_vkCmdCopyImageToBuffer2)gdpa(device, "vkCmdCopyImageToBuffer2KHR"); - if (f_) dt->vkCmdCopyImageToBuffer2 = f_; + dt->vkCmdCopyImageToBuffer2 = f_; } { PFN_vkCmdCopyQueryPoolResults f_ = (PFN_vkCmdCopyQueryPoolResults)gdpa(device, "vkCmdCopyQueryPoolResults"); - if (f_) dt->vkCmdCopyQueryPoolResults = f_; + dt->vkCmdCopyQueryPoolResults = f_; } { PFN_vkCmdCopyTensorARM f_ = (PFN_vkCmdCopyTensorARM)gdpa(device, "vkCmdCopyTensorARM"); - if (f_) dt->vkCmdCopyTensorARM = f_; + dt->vkCmdCopyTensorARM = f_; } { PFN_vkCmdDispatch f_ = (PFN_vkCmdDispatch)gdpa(device, "vkCmdDispatch"); - if (f_) dt->vkCmdDispatch = f_; + dt->vkCmdDispatch = f_; } { PFN_vkCmdDispatchBase f_ = (PFN_vkCmdDispatchBase)gdpa(device, "vkCmdDispatchBase"); if (!f_) f_ = (PFN_vkCmdDispatchBase)gdpa(device, "vkCmdDispatchBaseKHR"); - if (f_) dt->vkCmdDispatchBase = f_; + dt->vkCmdDispatchBase = f_; } { PFN_vkCmdDispatchIndirect f_ = (PFN_vkCmdDispatchIndirect)gdpa(device, "vkCmdDispatchIndirect"); - if (f_) dt->vkCmdDispatchIndirect = f_; + dt->vkCmdDispatchIndirect = f_; } { PFN_vkCmdDraw f_ = (PFN_vkCmdDraw)gdpa(device, "vkCmdDraw"); - if (f_) dt->vkCmdDraw = f_; + dt->vkCmdDraw = f_; } { PFN_vkCmdDrawIndexed f_ = (PFN_vkCmdDrawIndexed)gdpa(device, "vkCmdDrawIndexed"); - if (f_) dt->vkCmdDrawIndexed = f_; + dt->vkCmdDrawIndexed = f_; } { PFN_vkCmdDrawIndexedIndirect f_ = (PFN_vkCmdDrawIndexedIndirect)gdpa(device, "vkCmdDrawIndexedIndirect"); - if (f_) dt->vkCmdDrawIndexedIndirect = f_; + dt->vkCmdDrawIndexedIndirect = f_; } { PFN_vkCmdDrawIndexedIndirectCount f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCount"); if (!f_) f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCountAMD"); if (!f_) f_ = (PFN_vkCmdDrawIndexedIndirectCount)gdpa(device, "vkCmdDrawIndexedIndirectCountKHR"); - if (f_) dt->vkCmdDrawIndexedIndirectCount = f_; + dt->vkCmdDrawIndexedIndirectCount = f_; } { PFN_vkCmdDrawIndirect f_ = (PFN_vkCmdDrawIndirect)gdpa(device, "vkCmdDrawIndirect"); - if (f_) dt->vkCmdDrawIndirect = f_; + dt->vkCmdDrawIndirect = f_; } { PFN_vkCmdDrawIndirectByteCountEXT f_ = (PFN_vkCmdDrawIndirectByteCountEXT)gdpa(device, "vkCmdDrawIndirectByteCountEXT"); - if (f_) dt->vkCmdDrawIndirectByteCountEXT = f_; + dt->vkCmdDrawIndirectByteCountEXT = f_; } { PFN_vkCmdDrawIndirectCount f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCount"); if (!f_) f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCountAMD"); if (!f_) f_ = (PFN_vkCmdDrawIndirectCount)gdpa(device, "vkCmdDrawIndirectCountKHR"); - if (f_) dt->vkCmdDrawIndirectCount = f_; + dt->vkCmdDrawIndirectCount = f_; } { PFN_vkCmdDrawMultiEXT f_ = (PFN_vkCmdDrawMultiEXT)gdpa(device, "vkCmdDrawMultiEXT"); - if (f_) dt->vkCmdDrawMultiEXT = f_; + dt->vkCmdDrawMultiEXT = f_; } { PFN_vkCmdDrawMultiIndexedEXT f_ = (PFN_vkCmdDrawMultiIndexedEXT)gdpa(device, "vkCmdDrawMultiIndexedEXT"); - if (f_) dt->vkCmdDrawMultiIndexedEXT = f_; + dt->vkCmdDrawMultiIndexedEXT = f_; } { PFN_vkCmdEndConditionalRenderingEXT f_ = (PFN_vkCmdEndConditionalRenderingEXT)gdpa(device, "vkCmdEndConditionalRenderingEXT"); - if (f_) dt->vkCmdEndConditionalRenderingEXT = f_; + dt->vkCmdEndConditionalRenderingEXT = f_; } { PFN_vkCmdEndQuery f_ = (PFN_vkCmdEndQuery)gdpa(device, "vkCmdEndQuery"); - if (f_) dt->vkCmdEndQuery = f_; + dt->vkCmdEndQuery = f_; } { PFN_vkCmdEndQueryIndexedEXT f_ = (PFN_vkCmdEndQueryIndexedEXT)gdpa(device, "vkCmdEndQueryIndexedEXT"); - if (f_) dt->vkCmdEndQueryIndexedEXT = f_; + dt->vkCmdEndQueryIndexedEXT = f_; } { PFN_vkCmdEndRenderPass f_ = (PFN_vkCmdEndRenderPass)gdpa(device, "vkCmdEndRenderPass"); - if (f_) dt->vkCmdEndRenderPass = f_; + dt->vkCmdEndRenderPass = f_; } { PFN_vkCmdEndRenderPass2 f_ = (PFN_vkCmdEndRenderPass2)gdpa(device, "vkCmdEndRenderPass2"); if (!f_) f_ = (PFN_vkCmdEndRenderPass2)gdpa(device, "vkCmdEndRenderPass2KHR"); - if (f_) dt->vkCmdEndRenderPass2 = f_; + dt->vkCmdEndRenderPass2 = f_; } { PFN_vkCmdEndRendering f_ = (PFN_vkCmdEndRendering)gdpa(device, "vkCmdEndRendering"); if (!f_) f_ = (PFN_vkCmdEndRendering)gdpa(device, "vkCmdEndRenderingKHR"); - if (f_) dt->vkCmdEndRendering = f_; + dt->vkCmdEndRendering = f_; } { PFN_vkCmdEndRendering2KHR f_ = (PFN_vkCmdEndRendering2KHR)gdpa(device, "vkCmdEndRendering2KHR"); if (!f_) f_ = (PFN_vkCmdEndRendering2KHR)gdpa(device, "vkCmdEndRendering2EXT"); - if (f_) dt->vkCmdEndRendering2KHR = f_; + dt->vkCmdEndRendering2KHR = f_; } { PFN_vkCmdEndTransformFeedbackEXT f_ = (PFN_vkCmdEndTransformFeedbackEXT)gdpa(device, "vkCmdEndTransformFeedbackEXT"); - if (f_) dt->vkCmdEndTransformFeedbackEXT = f_; + dt->vkCmdEndTransformFeedbackEXT = f_; } { PFN_vkCmdExecuteCommands f_ = (PFN_vkCmdExecuteCommands)gdpa(device, "vkCmdExecuteCommands"); - if (f_) dt->vkCmdExecuteCommands = f_; + dt->vkCmdExecuteCommands = f_; } { PFN_vkCmdFillBuffer f_ = (PFN_vkCmdFillBuffer)gdpa(device, "vkCmdFillBuffer"); - if (f_) dt->vkCmdFillBuffer = f_; + dt->vkCmdFillBuffer = f_; } { PFN_vkCmdNextSubpass f_ = (PFN_vkCmdNextSubpass)gdpa(device, "vkCmdNextSubpass"); - if (f_) dt->vkCmdNextSubpass = f_; + dt->vkCmdNextSubpass = f_; } { PFN_vkCmdNextSubpass2 f_ = (PFN_vkCmdNextSubpass2)gdpa(device, "vkCmdNextSubpass2"); if (!f_) f_ = (PFN_vkCmdNextSubpass2)gdpa(device, "vkCmdNextSubpass2KHR"); - if (f_) dt->vkCmdNextSubpass2 = f_; + dt->vkCmdNextSubpass2 = f_; } { PFN_vkCmdPipelineBarrier f_ = (PFN_vkCmdPipelineBarrier)gdpa(device, "vkCmdPipelineBarrier"); - if (f_) dt->vkCmdPipelineBarrier = f_; + dt->vkCmdPipelineBarrier = f_; } { PFN_vkCmdPipelineBarrier2 f_ = (PFN_vkCmdPipelineBarrier2)gdpa(device, "vkCmdPipelineBarrier2"); if (!f_) f_ = (PFN_vkCmdPipelineBarrier2)gdpa(device, "vkCmdPipelineBarrier2KHR"); - if (f_) dt->vkCmdPipelineBarrier2 = f_; + dt->vkCmdPipelineBarrier2 = f_; } { PFN_vkCmdPushConstants f_ = (PFN_vkCmdPushConstants)gdpa(device, "vkCmdPushConstants"); - if (f_) dt->vkCmdPushConstants = f_; + dt->vkCmdPushConstants = f_; } { PFN_vkCmdPushConstants2 f_ = (PFN_vkCmdPushConstants2)gdpa(device, "vkCmdPushConstants2"); if (!f_) f_ = (PFN_vkCmdPushConstants2)gdpa(device, "vkCmdPushConstants2KHR"); - if (f_) dt->vkCmdPushConstants2 = f_; + dt->vkCmdPushConstants2 = f_; } { PFN_vkCmdPushDescriptorSet f_ = (PFN_vkCmdPushDescriptorSet)gdpa(device, "vkCmdPushDescriptorSet"); if (!f_) f_ = (PFN_vkCmdPushDescriptorSet)gdpa(device, "vkCmdPushDescriptorSetKHR"); - if (f_) dt->vkCmdPushDescriptorSet = f_; + dt->vkCmdPushDescriptorSet = f_; } { PFN_vkCmdPushDescriptorSet2 f_ = (PFN_vkCmdPushDescriptorSet2)gdpa(device, "vkCmdPushDescriptorSet2"); if (!f_) f_ = (PFN_vkCmdPushDescriptorSet2)gdpa(device, "vkCmdPushDescriptorSet2KHR"); - if (f_) dt->vkCmdPushDescriptorSet2 = f_; + dt->vkCmdPushDescriptorSet2 = f_; } { PFN_vkCmdPushDescriptorSetWithTemplate f_ = (PFN_vkCmdPushDescriptorSetWithTemplate)gdpa(device, "vkCmdPushDescriptorSetWithTemplate"); if (!f_) f_ = (PFN_vkCmdPushDescriptorSetWithTemplate)gdpa(device, "vkCmdPushDescriptorSetWithTemplateKHR"); - if (f_) dt->vkCmdPushDescriptorSetWithTemplate = f_; + dt->vkCmdPushDescriptorSetWithTemplate = f_; } { PFN_vkCmdResetEvent f_ = (PFN_vkCmdResetEvent)gdpa(device, "vkCmdResetEvent"); - if (f_) dt->vkCmdResetEvent = f_; + dt->vkCmdResetEvent = f_; } { PFN_vkCmdResetEvent2 f_ = (PFN_vkCmdResetEvent2)gdpa(device, "vkCmdResetEvent2"); if (!f_) f_ = (PFN_vkCmdResetEvent2)gdpa(device, "vkCmdResetEvent2KHR"); - if (f_) dt->vkCmdResetEvent2 = f_; + dt->vkCmdResetEvent2 = f_; } { PFN_vkCmdResetQueryPool f_ = (PFN_vkCmdResetQueryPool)gdpa(device, "vkCmdResetQueryPool"); - if (f_) dt->vkCmdResetQueryPool = f_; + dt->vkCmdResetQueryPool = f_; } { PFN_vkCmdResolveImage f_ = (PFN_vkCmdResolveImage)gdpa(device, "vkCmdResolveImage"); - if (f_) dt->vkCmdResolveImage = f_; + dt->vkCmdResolveImage = f_; } { PFN_vkCmdResolveImage2 f_ = (PFN_vkCmdResolveImage2)gdpa(device, "vkCmdResolveImage2"); if (!f_) f_ = (PFN_vkCmdResolveImage2)gdpa(device, "vkCmdResolveImage2KHR"); - if (f_) dt->vkCmdResolveImage2 = f_; + dt->vkCmdResolveImage2 = f_; } { PFN_vkCmdSetAlphaToCoverageEnableEXT f_ = (PFN_vkCmdSetAlphaToCoverageEnableEXT)gdpa(device, "vkCmdSetAlphaToCoverageEnableEXT"); - if (f_) dt->vkCmdSetAlphaToCoverageEnableEXT = f_; + dt->vkCmdSetAlphaToCoverageEnableEXT = f_; } { PFN_vkCmdSetAlphaToOneEnableEXT f_ = (PFN_vkCmdSetAlphaToOneEnableEXT)gdpa(device, "vkCmdSetAlphaToOneEnableEXT"); - if (f_) dt->vkCmdSetAlphaToOneEnableEXT = f_; + dt->vkCmdSetAlphaToOneEnableEXT = f_; } { PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT f_ = (PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)gdpa(device, "vkCmdSetAttachmentFeedbackLoopEnableEXT"); - if (f_) dt->vkCmdSetAttachmentFeedbackLoopEnableEXT = f_; + dt->vkCmdSetAttachmentFeedbackLoopEnableEXT = f_; } { PFN_vkCmdSetBlendConstants f_ = (PFN_vkCmdSetBlendConstants)gdpa(device, "vkCmdSetBlendConstants"); - if (f_) dt->vkCmdSetBlendConstants = f_; + dt->vkCmdSetBlendConstants = f_; } { PFN_vkCmdSetColorBlendAdvancedEXT f_ = (PFN_vkCmdSetColorBlendAdvancedEXT)gdpa(device, "vkCmdSetColorBlendAdvancedEXT"); - if (f_) dt->vkCmdSetColorBlendAdvancedEXT = f_; + dt->vkCmdSetColorBlendAdvancedEXT = f_; } { PFN_vkCmdSetColorBlendEnableEXT f_ = (PFN_vkCmdSetColorBlendEnableEXT)gdpa(device, "vkCmdSetColorBlendEnableEXT"); - if (f_) dt->vkCmdSetColorBlendEnableEXT = f_; + dt->vkCmdSetColorBlendEnableEXT = f_; } { PFN_vkCmdSetColorBlendEquationEXT f_ = (PFN_vkCmdSetColorBlendEquationEXT)gdpa(device, "vkCmdSetColorBlendEquationEXT"); - if (f_) dt->vkCmdSetColorBlendEquationEXT = f_; + dt->vkCmdSetColorBlendEquationEXT = f_; } { PFN_vkCmdSetColorWriteEnableEXT f_ = (PFN_vkCmdSetColorWriteEnableEXT)gdpa(device, "vkCmdSetColorWriteEnableEXT"); - if (f_) dt->vkCmdSetColorWriteEnableEXT = f_; + dt->vkCmdSetColorWriteEnableEXT = f_; } { PFN_vkCmdSetColorWriteMaskEXT f_ = (PFN_vkCmdSetColorWriteMaskEXT)gdpa(device, "vkCmdSetColorWriteMaskEXT"); - if (f_) dt->vkCmdSetColorWriteMaskEXT = f_; + dt->vkCmdSetColorWriteMaskEXT = f_; } { PFN_vkCmdSetConservativeRasterizationModeEXT f_ = (PFN_vkCmdSetConservativeRasterizationModeEXT)gdpa(device, "vkCmdSetConservativeRasterizationModeEXT"); - if (f_) dt->vkCmdSetConservativeRasterizationModeEXT = f_; + dt->vkCmdSetConservativeRasterizationModeEXT = f_; } { PFN_vkCmdSetCullMode f_ = (PFN_vkCmdSetCullMode)gdpa(device, "vkCmdSetCullMode"); if (!f_) f_ = (PFN_vkCmdSetCullMode)gdpa(device, "vkCmdSetCullModeEXT"); - if (f_) dt->vkCmdSetCullMode = f_; + dt->vkCmdSetCullMode = f_; } { PFN_vkCmdSetDepthBias f_ = (PFN_vkCmdSetDepthBias)gdpa(device, "vkCmdSetDepthBias"); - if (f_) dt->vkCmdSetDepthBias = f_; + dt->vkCmdSetDepthBias = f_; } { PFN_vkCmdSetDepthBias2EXT f_ = (PFN_vkCmdSetDepthBias2EXT)gdpa(device, "vkCmdSetDepthBias2EXT"); - if (f_) dt->vkCmdSetDepthBias2EXT = f_; + dt->vkCmdSetDepthBias2EXT = f_; } { PFN_vkCmdSetDepthBiasEnable f_ = (PFN_vkCmdSetDepthBiasEnable)gdpa(device, "vkCmdSetDepthBiasEnable"); if (!f_) f_ = (PFN_vkCmdSetDepthBiasEnable)gdpa(device, "vkCmdSetDepthBiasEnableEXT"); - if (f_) dt->vkCmdSetDepthBiasEnable = f_; + dt->vkCmdSetDepthBiasEnable = f_; } { PFN_vkCmdSetDepthBounds f_ = (PFN_vkCmdSetDepthBounds)gdpa(device, "vkCmdSetDepthBounds"); - if (f_) dt->vkCmdSetDepthBounds = f_; + dt->vkCmdSetDepthBounds = f_; } { PFN_vkCmdSetDepthBoundsTestEnable f_ = (PFN_vkCmdSetDepthBoundsTestEnable)gdpa(device, "vkCmdSetDepthBoundsTestEnable"); if (!f_) f_ = (PFN_vkCmdSetDepthBoundsTestEnable)gdpa(device, "vkCmdSetDepthBoundsTestEnableEXT"); - if (f_) dt->vkCmdSetDepthBoundsTestEnable = f_; + dt->vkCmdSetDepthBoundsTestEnable = f_; } { PFN_vkCmdSetDepthClampEnableEXT f_ = (PFN_vkCmdSetDepthClampEnableEXT)gdpa(device, "vkCmdSetDepthClampEnableEXT"); - if (f_) dt->vkCmdSetDepthClampEnableEXT = f_; + dt->vkCmdSetDepthClampEnableEXT = f_; } { PFN_vkCmdSetDepthClampRangeEXT f_ = (PFN_vkCmdSetDepthClampRangeEXT)gdpa(device, "vkCmdSetDepthClampRangeEXT"); - if (f_) dt->vkCmdSetDepthClampRangeEXT = f_; + dt->vkCmdSetDepthClampRangeEXT = f_; } { PFN_vkCmdSetDepthClipEnableEXT f_ = (PFN_vkCmdSetDepthClipEnableEXT)gdpa(device, "vkCmdSetDepthClipEnableEXT"); - if (f_) dt->vkCmdSetDepthClipEnableEXT = f_; + dt->vkCmdSetDepthClipEnableEXT = f_; } { PFN_vkCmdSetDepthClipNegativeOneToOneEXT f_ = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)gdpa(device, "vkCmdSetDepthClipNegativeOneToOneEXT"); - if (f_) dt->vkCmdSetDepthClipNegativeOneToOneEXT = f_; + dt->vkCmdSetDepthClipNegativeOneToOneEXT = f_; } { PFN_vkCmdSetDepthCompareOp f_ = (PFN_vkCmdSetDepthCompareOp)gdpa(device, "vkCmdSetDepthCompareOp"); if (!f_) f_ = (PFN_vkCmdSetDepthCompareOp)gdpa(device, "vkCmdSetDepthCompareOpEXT"); - if (f_) dt->vkCmdSetDepthCompareOp = f_; + dt->vkCmdSetDepthCompareOp = f_; } { PFN_vkCmdSetDepthTestEnable f_ = (PFN_vkCmdSetDepthTestEnable)gdpa(device, "vkCmdSetDepthTestEnable"); if (!f_) f_ = (PFN_vkCmdSetDepthTestEnable)gdpa(device, "vkCmdSetDepthTestEnableEXT"); - if (f_) dt->vkCmdSetDepthTestEnable = f_; + dt->vkCmdSetDepthTestEnable = f_; } { PFN_vkCmdSetDepthWriteEnable f_ = (PFN_vkCmdSetDepthWriteEnable)gdpa(device, "vkCmdSetDepthWriteEnable"); if (!f_) f_ = (PFN_vkCmdSetDepthWriteEnable)gdpa(device, "vkCmdSetDepthWriteEnableEXT"); - if (f_) dt->vkCmdSetDepthWriteEnable = f_; + dt->vkCmdSetDepthWriteEnable = f_; } { PFN_vkCmdSetDeviceMask f_ = (PFN_vkCmdSetDeviceMask)gdpa(device, "vkCmdSetDeviceMask"); if (!f_) f_ = (PFN_vkCmdSetDeviceMask)gdpa(device, "vkCmdSetDeviceMaskKHR"); - if (f_) dt->vkCmdSetDeviceMask = f_; + dt->vkCmdSetDeviceMask = f_; } { PFN_vkCmdSetDiscardRectangleEXT f_ = (PFN_vkCmdSetDiscardRectangleEXT)gdpa(device, "vkCmdSetDiscardRectangleEXT"); - if (f_) dt->vkCmdSetDiscardRectangleEXT = f_; + dt->vkCmdSetDiscardRectangleEXT = f_; } { PFN_vkCmdSetDiscardRectangleEnableEXT f_ = (PFN_vkCmdSetDiscardRectangleEnableEXT)gdpa(device, "vkCmdSetDiscardRectangleEnableEXT"); - if (f_) dt->vkCmdSetDiscardRectangleEnableEXT = f_; + dt->vkCmdSetDiscardRectangleEnableEXT = f_; } { PFN_vkCmdSetDiscardRectangleModeEXT f_ = (PFN_vkCmdSetDiscardRectangleModeEXT)gdpa(device, "vkCmdSetDiscardRectangleModeEXT"); - if (f_) dt->vkCmdSetDiscardRectangleModeEXT = f_; + dt->vkCmdSetDiscardRectangleModeEXT = f_; } { PFN_vkCmdSetEvent f_ = (PFN_vkCmdSetEvent)gdpa(device, "vkCmdSetEvent"); - if (f_) dt->vkCmdSetEvent = f_; + dt->vkCmdSetEvent = f_; } { PFN_vkCmdSetEvent2 f_ = (PFN_vkCmdSetEvent2)gdpa(device, "vkCmdSetEvent2"); if (!f_) f_ = (PFN_vkCmdSetEvent2)gdpa(device, "vkCmdSetEvent2KHR"); - if (f_) dt->vkCmdSetEvent2 = f_; + dt->vkCmdSetEvent2 = f_; } { PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT f_ = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gdpa(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); - if (f_) dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT = f_; + dt->vkCmdSetExtraPrimitiveOverestimationSizeEXT = f_; } { PFN_vkCmdSetFragmentShadingRateKHR f_ = (PFN_vkCmdSetFragmentShadingRateKHR)gdpa(device, "vkCmdSetFragmentShadingRateKHR"); - if (f_) dt->vkCmdSetFragmentShadingRateKHR = f_; + dt->vkCmdSetFragmentShadingRateKHR = f_; } { PFN_vkCmdSetFrontFace f_ = (PFN_vkCmdSetFrontFace)gdpa(device, "vkCmdSetFrontFace"); if (!f_) f_ = (PFN_vkCmdSetFrontFace)gdpa(device, "vkCmdSetFrontFaceEXT"); - if (f_) dt->vkCmdSetFrontFace = f_; + dt->vkCmdSetFrontFace = f_; } { PFN_vkCmdSetLineRasterizationModeEXT f_ = (PFN_vkCmdSetLineRasterizationModeEXT)gdpa(device, "vkCmdSetLineRasterizationModeEXT"); - if (f_) dt->vkCmdSetLineRasterizationModeEXT = f_; + dt->vkCmdSetLineRasterizationModeEXT = f_; } { PFN_vkCmdSetLineStipple f_ = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStipple"); if (!f_) f_ = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStippleEXT"); if (!f_) f_ = (PFN_vkCmdSetLineStipple)gdpa(device, "vkCmdSetLineStippleKHR"); - if (f_) dt->vkCmdSetLineStipple = f_; + dt->vkCmdSetLineStipple = f_; } { PFN_vkCmdSetLineStippleEnableEXT f_ = (PFN_vkCmdSetLineStippleEnableEXT)gdpa(device, "vkCmdSetLineStippleEnableEXT"); - if (f_) dt->vkCmdSetLineStippleEnableEXT = f_; + dt->vkCmdSetLineStippleEnableEXT = f_; } { PFN_vkCmdSetLineWidth f_ = (PFN_vkCmdSetLineWidth)gdpa(device, "vkCmdSetLineWidth"); - if (f_) dt->vkCmdSetLineWidth = f_; + dt->vkCmdSetLineWidth = f_; } { PFN_vkCmdSetLogicOpEXT f_ = (PFN_vkCmdSetLogicOpEXT)gdpa(device, "vkCmdSetLogicOpEXT"); - if (f_) dt->vkCmdSetLogicOpEXT = f_; + dt->vkCmdSetLogicOpEXT = f_; } { PFN_vkCmdSetLogicOpEnableEXT f_ = (PFN_vkCmdSetLogicOpEnableEXT)gdpa(device, "vkCmdSetLogicOpEnableEXT"); - if (f_) dt->vkCmdSetLogicOpEnableEXT = f_; + dt->vkCmdSetLogicOpEnableEXT = f_; } { PFN_vkCmdSetPatchControlPointsEXT f_ = (PFN_vkCmdSetPatchControlPointsEXT)gdpa(device, "vkCmdSetPatchControlPointsEXT"); - if (f_) dt->vkCmdSetPatchControlPointsEXT = f_; + dt->vkCmdSetPatchControlPointsEXT = f_; } { PFN_vkCmdSetPolygonModeEXT f_ = (PFN_vkCmdSetPolygonModeEXT)gdpa(device, "vkCmdSetPolygonModeEXT"); - if (f_) dt->vkCmdSetPolygonModeEXT = f_; + dt->vkCmdSetPolygonModeEXT = f_; } { PFN_vkCmdSetPrimitiveRestartEnable f_ = (PFN_vkCmdSetPrimitiveRestartEnable)gdpa(device, "vkCmdSetPrimitiveRestartEnable"); if (!f_) f_ = (PFN_vkCmdSetPrimitiveRestartEnable)gdpa(device, "vkCmdSetPrimitiveRestartEnableEXT"); - if (f_) dt->vkCmdSetPrimitiveRestartEnable = f_; + dt->vkCmdSetPrimitiveRestartEnable = f_; } { PFN_vkCmdSetPrimitiveTopology f_ = (PFN_vkCmdSetPrimitiveTopology)gdpa(device, "vkCmdSetPrimitiveTopology"); if (!f_) f_ = (PFN_vkCmdSetPrimitiveTopology)gdpa(device, "vkCmdSetPrimitiveTopologyEXT"); - if (f_) dt->vkCmdSetPrimitiveTopology = f_; + dt->vkCmdSetPrimitiveTopology = f_; } { PFN_vkCmdSetProvokingVertexModeEXT f_ = (PFN_vkCmdSetProvokingVertexModeEXT)gdpa(device, "vkCmdSetProvokingVertexModeEXT"); - if (f_) dt->vkCmdSetProvokingVertexModeEXT = f_; + dt->vkCmdSetProvokingVertexModeEXT = f_; } { PFN_vkCmdSetRasterizationSamplesEXT f_ = (PFN_vkCmdSetRasterizationSamplesEXT)gdpa(device, "vkCmdSetRasterizationSamplesEXT"); - if (f_) dt->vkCmdSetRasterizationSamplesEXT = f_; + dt->vkCmdSetRasterizationSamplesEXT = f_; } { PFN_vkCmdSetRasterizationStreamEXT f_ = (PFN_vkCmdSetRasterizationStreamEXT)gdpa(device, "vkCmdSetRasterizationStreamEXT"); - if (f_) dt->vkCmdSetRasterizationStreamEXT = f_; + dt->vkCmdSetRasterizationStreamEXT = f_; } { PFN_vkCmdSetRasterizerDiscardEnable f_ = (PFN_vkCmdSetRasterizerDiscardEnable)gdpa(device, "vkCmdSetRasterizerDiscardEnable"); if (!f_) f_ = (PFN_vkCmdSetRasterizerDiscardEnable)gdpa(device, "vkCmdSetRasterizerDiscardEnableEXT"); - if (f_) dt->vkCmdSetRasterizerDiscardEnable = f_; + dt->vkCmdSetRasterizerDiscardEnable = f_; } { PFN_vkCmdSetRenderingAttachmentLocations f_ = (PFN_vkCmdSetRenderingAttachmentLocations)gdpa(device, "vkCmdSetRenderingAttachmentLocations"); if (!f_) f_ = (PFN_vkCmdSetRenderingAttachmentLocations)gdpa(device, "vkCmdSetRenderingAttachmentLocationsKHR"); - if (f_) dt->vkCmdSetRenderingAttachmentLocations = f_; + dt->vkCmdSetRenderingAttachmentLocations = f_; } { PFN_vkCmdSetRenderingInputAttachmentIndices f_ = (PFN_vkCmdSetRenderingInputAttachmentIndices)gdpa(device, "vkCmdSetRenderingInputAttachmentIndices"); if (!f_) f_ = (PFN_vkCmdSetRenderingInputAttachmentIndices)gdpa(device, "vkCmdSetRenderingInputAttachmentIndicesKHR"); - if (f_) dt->vkCmdSetRenderingInputAttachmentIndices = f_; + dt->vkCmdSetRenderingInputAttachmentIndices = f_; } { PFN_vkCmdSetSampleLocationsEXT f_ = (PFN_vkCmdSetSampleLocationsEXT)gdpa(device, "vkCmdSetSampleLocationsEXT"); - if (f_) dt->vkCmdSetSampleLocationsEXT = f_; + dt->vkCmdSetSampleLocationsEXT = f_; } { PFN_vkCmdSetSampleLocationsEnableEXT f_ = (PFN_vkCmdSetSampleLocationsEnableEXT)gdpa(device, "vkCmdSetSampleLocationsEnableEXT"); - if (f_) dt->vkCmdSetSampleLocationsEnableEXT = f_; + dt->vkCmdSetSampleLocationsEnableEXT = f_; } { PFN_vkCmdSetSampleMaskEXT f_ = (PFN_vkCmdSetSampleMaskEXT)gdpa(device, "vkCmdSetSampleMaskEXT"); - if (f_) dt->vkCmdSetSampleMaskEXT = f_; + dt->vkCmdSetSampleMaskEXT = f_; } { PFN_vkCmdSetScissor f_ = (PFN_vkCmdSetScissor)gdpa(device, "vkCmdSetScissor"); - if (f_) dt->vkCmdSetScissor = f_; + dt->vkCmdSetScissor = f_; } { PFN_vkCmdSetScissorWithCount f_ = (PFN_vkCmdSetScissorWithCount)gdpa(device, "vkCmdSetScissorWithCount"); if (!f_) f_ = (PFN_vkCmdSetScissorWithCount)gdpa(device, "vkCmdSetScissorWithCountEXT"); - if (f_) dt->vkCmdSetScissorWithCount = f_; + dt->vkCmdSetScissorWithCount = f_; } { PFN_vkCmdSetStencilCompareMask f_ = (PFN_vkCmdSetStencilCompareMask)gdpa(device, "vkCmdSetStencilCompareMask"); - if (f_) dt->vkCmdSetStencilCompareMask = f_; + dt->vkCmdSetStencilCompareMask = f_; } { PFN_vkCmdSetStencilOp f_ = (PFN_vkCmdSetStencilOp)gdpa(device, "vkCmdSetStencilOp"); if (!f_) f_ = (PFN_vkCmdSetStencilOp)gdpa(device, "vkCmdSetStencilOpEXT"); - if (f_) dt->vkCmdSetStencilOp = f_; + dt->vkCmdSetStencilOp = f_; } { PFN_vkCmdSetStencilReference f_ = (PFN_vkCmdSetStencilReference)gdpa(device, "vkCmdSetStencilReference"); - if (f_) dt->vkCmdSetStencilReference = f_; + dt->vkCmdSetStencilReference = f_; } { PFN_vkCmdSetStencilTestEnable f_ = (PFN_vkCmdSetStencilTestEnable)gdpa(device, "vkCmdSetStencilTestEnable"); if (!f_) f_ = (PFN_vkCmdSetStencilTestEnable)gdpa(device, "vkCmdSetStencilTestEnableEXT"); - if (f_) dt->vkCmdSetStencilTestEnable = f_; + dt->vkCmdSetStencilTestEnable = f_; } { PFN_vkCmdSetStencilWriteMask f_ = (PFN_vkCmdSetStencilWriteMask)gdpa(device, "vkCmdSetStencilWriteMask"); - if (f_) dt->vkCmdSetStencilWriteMask = f_; + dt->vkCmdSetStencilWriteMask = f_; } { PFN_vkCmdSetTessellationDomainOriginEXT f_ = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(device, "vkCmdSetTessellationDomainOriginEXT"); - if (f_) dt->vkCmdSetTessellationDomainOriginEXT = f_; + dt->vkCmdSetTessellationDomainOriginEXT = f_; } { PFN_vkCmdSetVertexInputEXT f_ = (PFN_vkCmdSetVertexInputEXT)gdpa(device, "vkCmdSetVertexInputEXT"); - if (f_) dt->vkCmdSetVertexInputEXT = f_; + dt->vkCmdSetVertexInputEXT = f_; } { PFN_vkCmdSetViewport f_ = (PFN_vkCmdSetViewport)gdpa(device, "vkCmdSetViewport"); - if (f_) dt->vkCmdSetViewport = f_; + dt->vkCmdSetViewport = f_; } { PFN_vkCmdSetViewportWithCount f_ = (PFN_vkCmdSetViewportWithCount)gdpa(device, "vkCmdSetViewportWithCount"); if (!f_) f_ = (PFN_vkCmdSetViewportWithCount)gdpa(device, "vkCmdSetViewportWithCountEXT"); - if (f_) dt->vkCmdSetViewportWithCount = f_; + dt->vkCmdSetViewportWithCount = f_; } { PFN_vkCmdUpdateBuffer f_ = (PFN_vkCmdUpdateBuffer)gdpa(device, "vkCmdUpdateBuffer"); - if (f_) dt->vkCmdUpdateBuffer = f_; + dt->vkCmdUpdateBuffer = f_; } { PFN_vkCmdWaitEvents f_ = (PFN_vkCmdWaitEvents)gdpa(device, "vkCmdWaitEvents"); - if (f_) dt->vkCmdWaitEvents = f_; + dt->vkCmdWaitEvents = f_; } { PFN_vkCmdWaitEvents2 f_ = (PFN_vkCmdWaitEvents2)gdpa(device, "vkCmdWaitEvents2"); if (!f_) f_ = (PFN_vkCmdWaitEvents2)gdpa(device, "vkCmdWaitEvents2KHR"); - if (f_) dt->vkCmdWaitEvents2 = f_; + dt->vkCmdWaitEvents2 = f_; } { PFN_vkCmdWriteTimestamp f_ = (PFN_vkCmdWriteTimestamp)gdpa(device, "vkCmdWriteTimestamp"); - if (f_) dt->vkCmdWriteTimestamp = f_; + dt->vkCmdWriteTimestamp = f_; } { PFN_vkCmdWriteTimestamp2 f_ = (PFN_vkCmdWriteTimestamp2)gdpa(device, "vkCmdWriteTimestamp2"); if (!f_) f_ = (PFN_vkCmdWriteTimestamp2)gdpa(device, "vkCmdWriteTimestamp2KHR"); - if (f_) dt->vkCmdWriteTimestamp2 = f_; + dt->vkCmdWriteTimestamp2 = f_; } { PFN_vkCreateBuffer f_ = (PFN_vkCreateBuffer)gdpa(device, "vkCreateBuffer"); - if (f_) dt->vkCreateBuffer = f_; + dt->vkCreateBuffer = f_; } { PFN_vkCreateBufferView f_ = (PFN_vkCreateBufferView)gdpa(device, "vkCreateBufferView"); - if (f_) dt->vkCreateBufferView = f_; + dt->vkCreateBufferView = f_; } { PFN_vkCreateCommandPool f_ = (PFN_vkCreateCommandPool)gdpa(device, "vkCreateCommandPool"); - if (f_) dt->vkCreateCommandPool = f_; + dt->vkCreateCommandPool = f_; } { PFN_vkCreateComputePipelines f_ = (PFN_vkCreateComputePipelines)gdpa(device, "vkCreateComputePipelines"); - if (f_) dt->vkCreateComputePipelines = f_; + dt->vkCreateComputePipelines = f_; } { PFN_vkCreateDescriptorPool f_ = (PFN_vkCreateDescriptorPool)gdpa(device, "vkCreateDescriptorPool"); - if (f_) dt->vkCreateDescriptorPool = f_; + dt->vkCreateDescriptorPool = f_; } { PFN_vkCreateDescriptorSetLayout f_ = (PFN_vkCreateDescriptorSetLayout)gdpa(device, "vkCreateDescriptorSetLayout"); - if (f_) dt->vkCreateDescriptorSetLayout = f_; + dt->vkCreateDescriptorSetLayout = f_; } { PFN_vkCreateDescriptorUpdateTemplate f_ = (PFN_vkCreateDescriptorUpdateTemplate)gdpa(device, "vkCreateDescriptorUpdateTemplate"); if (!f_) f_ = (PFN_vkCreateDescriptorUpdateTemplate)gdpa(device, "vkCreateDescriptorUpdateTemplateKHR"); - if (f_) dt->vkCreateDescriptorUpdateTemplate = f_; + dt->vkCreateDescriptorUpdateTemplate = f_; } { PFN_vkCreateEvent f_ = (PFN_vkCreateEvent)gdpa(device, "vkCreateEvent"); - if (f_) dt->vkCreateEvent = f_; + dt->vkCreateEvent = f_; } { PFN_vkCreateFence f_ = (PFN_vkCreateFence)gdpa(device, "vkCreateFence"); - if (f_) dt->vkCreateFence = f_; + dt->vkCreateFence = f_; } { PFN_vkCreateFramebuffer f_ = (PFN_vkCreateFramebuffer)gdpa(device, "vkCreateFramebuffer"); - if (f_) dt->vkCreateFramebuffer = f_; + dt->vkCreateFramebuffer = f_; } { PFN_vkCreateGraphicsPipelines f_ = (PFN_vkCreateGraphicsPipelines)gdpa(device, "vkCreateGraphicsPipelines"); - if (f_) dt->vkCreateGraphicsPipelines = f_; + dt->vkCreateGraphicsPipelines = f_; } { PFN_vkCreateImage f_ = (PFN_vkCreateImage)gdpa(device, "vkCreateImage"); - if (f_) dt->vkCreateImage = f_; + dt->vkCreateImage = f_; } { PFN_vkCreateImageView f_ = (PFN_vkCreateImageView)gdpa(device, "vkCreateImageView"); - if (f_) dt->vkCreateImageView = f_; + dt->vkCreateImageView = f_; } { PFN_vkCreatePipelineCache f_ = (PFN_vkCreatePipelineCache)gdpa(device, "vkCreatePipelineCache"); - if (f_) dt->vkCreatePipelineCache = f_; + dt->vkCreatePipelineCache = f_; } { PFN_vkCreatePipelineLayout f_ = (PFN_vkCreatePipelineLayout)gdpa(device, "vkCreatePipelineLayout"); - if (f_) dt->vkCreatePipelineLayout = f_; + dt->vkCreatePipelineLayout = f_; } { PFN_vkCreateQueryPool f_ = (PFN_vkCreateQueryPool)gdpa(device, "vkCreateQueryPool"); - if (f_) dt->vkCreateQueryPool = f_; + dt->vkCreateQueryPool = f_; } { PFN_vkCreateRenderPass f_ = (PFN_vkCreateRenderPass)gdpa(device, "vkCreateRenderPass"); - if (f_) dt->vkCreateRenderPass = f_; + dt->vkCreateRenderPass = f_; } { PFN_vkCreateRenderPass2 f_ = (PFN_vkCreateRenderPass2)gdpa(device, "vkCreateRenderPass2"); if (!f_) f_ = (PFN_vkCreateRenderPass2)gdpa(device, "vkCreateRenderPass2KHR"); - if (f_) dt->vkCreateRenderPass2 = f_; + dt->vkCreateRenderPass2 = f_; } { PFN_vkCreateSampler f_ = (PFN_vkCreateSampler)gdpa(device, "vkCreateSampler"); - if (f_) dt->vkCreateSampler = f_; + dt->vkCreateSampler = f_; } { PFN_vkCreateSamplerYcbcrConversion f_ = (PFN_vkCreateSamplerYcbcrConversion)gdpa(device, "vkCreateSamplerYcbcrConversion"); if (!f_) f_ = (PFN_vkCreateSamplerYcbcrConversion)gdpa(device, "vkCreateSamplerYcbcrConversionKHR"); - if (f_) dt->vkCreateSamplerYcbcrConversion = f_; + dt->vkCreateSamplerYcbcrConversion = f_; } { PFN_vkCreateSemaphore f_ = (PFN_vkCreateSemaphore)gdpa(device, "vkCreateSemaphore"); - if (f_) dt->vkCreateSemaphore = f_; + dt->vkCreateSemaphore = f_; } { PFN_vkCreateShaderModule f_ = (PFN_vkCreateShaderModule)gdpa(device, "vkCreateShaderModule"); - if (f_) dt->vkCreateShaderModule = f_; + dt->vkCreateShaderModule = f_; } { PFN_vkCreateTensorARM f_ = (PFN_vkCreateTensorARM)gdpa(device, "vkCreateTensorARM"); - if (f_) dt->vkCreateTensorARM = f_; + dt->vkCreateTensorARM = f_; } { PFN_vkCreateTensorViewARM f_ = (PFN_vkCreateTensorViewARM)gdpa(device, "vkCreateTensorViewARM"); - if (f_) dt->vkCreateTensorViewARM = f_; + dt->vkCreateTensorViewARM = f_; } { PFN_vkDestroyBuffer f_ = (PFN_vkDestroyBuffer)gdpa(device, "vkDestroyBuffer"); - if (f_) dt->vkDestroyBuffer = f_; + dt->vkDestroyBuffer = f_; } { PFN_vkDestroyBufferView f_ = (PFN_vkDestroyBufferView)gdpa(device, "vkDestroyBufferView"); - if (f_) dt->vkDestroyBufferView = f_; + dt->vkDestroyBufferView = f_; } { PFN_vkDestroyCommandPool f_ = (PFN_vkDestroyCommandPool)gdpa(device, "vkDestroyCommandPool"); - if (f_) dt->vkDestroyCommandPool = f_; + dt->vkDestroyCommandPool = f_; } { PFN_vkDestroyDescriptorPool f_ = (PFN_vkDestroyDescriptorPool)gdpa(device, "vkDestroyDescriptorPool"); - if (f_) dt->vkDestroyDescriptorPool = f_; + dt->vkDestroyDescriptorPool = f_; } { PFN_vkDestroyDescriptorSetLayout f_ = (PFN_vkDestroyDescriptorSetLayout)gdpa(device, "vkDestroyDescriptorSetLayout"); - if (f_) dt->vkDestroyDescriptorSetLayout = f_; + dt->vkDestroyDescriptorSetLayout = f_; } { PFN_vkDestroyDescriptorUpdateTemplate f_ = (PFN_vkDestroyDescriptorUpdateTemplate)gdpa(device, "vkDestroyDescriptorUpdateTemplate"); if (!f_) f_ = (PFN_vkDestroyDescriptorUpdateTemplate)gdpa(device, "vkDestroyDescriptorUpdateTemplateKHR"); - if (f_) dt->vkDestroyDescriptorUpdateTemplate = f_; + dt->vkDestroyDescriptorUpdateTemplate = f_; } { PFN_vkDestroyDevice f_ = (PFN_vkDestroyDevice)gdpa(device, "vkDestroyDevice"); - if (f_) dt->vkDestroyDevice = f_; + dt->vkDestroyDevice = f_; } { PFN_vkDestroyEvent f_ = (PFN_vkDestroyEvent)gdpa(device, "vkDestroyEvent"); - if (f_) dt->vkDestroyEvent = f_; + dt->vkDestroyEvent = f_; } { PFN_vkDestroyFence f_ = (PFN_vkDestroyFence)gdpa(device, "vkDestroyFence"); - if (f_) dt->vkDestroyFence = f_; + dt->vkDestroyFence = f_; } { PFN_vkDestroyFramebuffer f_ = (PFN_vkDestroyFramebuffer)gdpa(device, "vkDestroyFramebuffer"); - if (f_) dt->vkDestroyFramebuffer = f_; + dt->vkDestroyFramebuffer = f_; } { PFN_vkDestroyImage f_ = (PFN_vkDestroyImage)gdpa(device, "vkDestroyImage"); - if (f_) dt->vkDestroyImage = f_; + dt->vkDestroyImage = f_; } { PFN_vkDestroyImageView f_ = (PFN_vkDestroyImageView)gdpa(device, "vkDestroyImageView"); - if (f_) dt->vkDestroyImageView = f_; + dt->vkDestroyImageView = f_; } { PFN_vkDestroyPipeline f_ = (PFN_vkDestroyPipeline)gdpa(device, "vkDestroyPipeline"); - if (f_) dt->vkDestroyPipeline = f_; + dt->vkDestroyPipeline = f_; } { PFN_vkDestroyPipelineCache f_ = (PFN_vkDestroyPipelineCache)gdpa(device, "vkDestroyPipelineCache"); - if (f_) dt->vkDestroyPipelineCache = f_; + dt->vkDestroyPipelineCache = f_; } { PFN_vkDestroyPipelineLayout f_ = (PFN_vkDestroyPipelineLayout)gdpa(device, "vkDestroyPipelineLayout"); - if (f_) dt->vkDestroyPipelineLayout = f_; + dt->vkDestroyPipelineLayout = f_; } { PFN_vkDestroyQueryPool f_ = (PFN_vkDestroyQueryPool)gdpa(device, "vkDestroyQueryPool"); - if (f_) dt->vkDestroyQueryPool = f_; + dt->vkDestroyQueryPool = f_; } { PFN_vkDestroyRenderPass f_ = (PFN_vkDestroyRenderPass)gdpa(device, "vkDestroyRenderPass"); - if (f_) dt->vkDestroyRenderPass = f_; + dt->vkDestroyRenderPass = f_; } { PFN_vkDestroySampler f_ = (PFN_vkDestroySampler)gdpa(device, "vkDestroySampler"); - if (f_) dt->vkDestroySampler = f_; + dt->vkDestroySampler = f_; } { PFN_vkDestroySamplerYcbcrConversion f_ = (PFN_vkDestroySamplerYcbcrConversion)gdpa(device, "vkDestroySamplerYcbcrConversion"); if (!f_) f_ = (PFN_vkDestroySamplerYcbcrConversion)gdpa(device, "vkDestroySamplerYcbcrConversionKHR"); - if (f_) dt->vkDestroySamplerYcbcrConversion = f_; + dt->vkDestroySamplerYcbcrConversion = f_; } { PFN_vkDestroySemaphore f_ = (PFN_vkDestroySemaphore)gdpa(device, "vkDestroySemaphore"); - if (f_) dt->vkDestroySemaphore = f_; + dt->vkDestroySemaphore = f_; } { PFN_vkDestroyShaderModule f_ = (PFN_vkDestroyShaderModule)gdpa(device, "vkDestroyShaderModule"); - if (f_) dt->vkDestroyShaderModule = f_; + dt->vkDestroyShaderModule = f_; } { PFN_vkDestroyTensorARM f_ = (PFN_vkDestroyTensorARM)gdpa(device, "vkDestroyTensorARM"); - if (f_) dt->vkDestroyTensorARM = f_; + dt->vkDestroyTensorARM = f_; } { PFN_vkDestroyTensorViewARM f_ = (PFN_vkDestroyTensorViewARM)gdpa(device, "vkDestroyTensorViewARM"); - if (f_) dt->vkDestroyTensorViewARM = f_; + dt->vkDestroyTensorViewARM = f_; } { PFN_vkDeviceWaitIdle f_ = (PFN_vkDeviceWaitIdle)gdpa(device, "vkDeviceWaitIdle"); - if (f_) dt->vkDeviceWaitIdle = f_; + dt->vkDeviceWaitIdle = f_; } { PFN_vkEndCommandBuffer f_ = (PFN_vkEndCommandBuffer)gdpa(device, "vkEndCommandBuffer"); - if (f_) dt->vkEndCommandBuffer = f_; + dt->vkEndCommandBuffer = f_; } { PFN_vkFlushMappedMemoryRanges f_ = (PFN_vkFlushMappedMemoryRanges)gdpa(device, "vkFlushMappedMemoryRanges"); - if (f_) dt->vkFlushMappedMemoryRanges = f_; + dt->vkFlushMappedMemoryRanges = f_; } { PFN_vkFreeCommandBuffers f_ = (PFN_vkFreeCommandBuffers)gdpa(device, "vkFreeCommandBuffers"); - if (f_) dt->vkFreeCommandBuffers = f_; + dt->vkFreeCommandBuffers = f_; } { PFN_vkFreeDescriptorSets f_ = (PFN_vkFreeDescriptorSets)gdpa(device, "vkFreeDescriptorSets"); - if (f_) dt->vkFreeDescriptorSets = f_; + dt->vkFreeDescriptorSets = f_; } { PFN_vkFreeMemory f_ = (PFN_vkFreeMemory)gdpa(device, "vkFreeMemory"); - if (f_) dt->vkFreeMemory = f_; + dt->vkFreeMemory = f_; } { PFN_vkGetBufferDeviceAddress f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddress"); if (!f_) f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddressEXT"); if (!f_) f_ = (PFN_vkGetBufferDeviceAddress)gdpa(device, "vkGetBufferDeviceAddressKHR"); - if (f_) dt->vkGetBufferDeviceAddress = f_; + dt->vkGetBufferDeviceAddress = f_; } { PFN_vkGetBufferMemoryRequirements f_ = (PFN_vkGetBufferMemoryRequirements)gdpa(device, "vkGetBufferMemoryRequirements"); - if (f_) dt->vkGetBufferMemoryRequirements = f_; + dt->vkGetBufferMemoryRequirements = f_; } { PFN_vkGetBufferMemoryRequirements2 f_ = (PFN_vkGetBufferMemoryRequirements2)gdpa(device, "vkGetBufferMemoryRequirements2"); if (!f_) f_ = (PFN_vkGetBufferMemoryRequirements2)gdpa(device, "vkGetBufferMemoryRequirements2KHR"); - if (f_) dt->vkGetBufferMemoryRequirements2 = f_; + dt->vkGetBufferMemoryRequirements2 = f_; } { PFN_vkGetBufferOpaqueCaptureAddress f_ = (PFN_vkGetBufferOpaqueCaptureAddress)gdpa(device, "vkGetBufferOpaqueCaptureAddress"); if (!f_) f_ = (PFN_vkGetBufferOpaqueCaptureAddress)gdpa(device, "vkGetBufferOpaqueCaptureAddressKHR"); - if (f_) dt->vkGetBufferOpaqueCaptureAddress = f_; + dt->vkGetBufferOpaqueCaptureAddress = f_; } { PFN_vkGetCalibratedTimestampsKHR f_ = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsKHR"); if (!f_) f_ = (PFN_vkGetCalibratedTimestampsKHR)gdpa(device, "vkGetCalibratedTimestampsEXT"); - if (f_) dt->vkGetCalibratedTimestampsKHR = f_; + dt->vkGetCalibratedTimestampsKHR = f_; } { PFN_vkGetDescriptorSetLayoutSupport f_ = (PFN_vkGetDescriptorSetLayoutSupport)gdpa(device, "vkGetDescriptorSetLayoutSupport"); if (!f_) f_ = (PFN_vkGetDescriptorSetLayoutSupport)gdpa(device, "vkGetDescriptorSetLayoutSupportKHR"); - if (f_) dt->vkGetDescriptorSetLayoutSupport = f_; + dt->vkGetDescriptorSetLayoutSupport = f_; } { PFN_vkGetDeviceBufferMemoryRequirements f_ = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirements"); if (!f_) f_ = (PFN_vkGetDeviceBufferMemoryRequirements)gdpa(device, "vkGetDeviceBufferMemoryRequirementsKHR"); - if (f_) dt->vkGetDeviceBufferMemoryRequirements = f_; + dt->vkGetDeviceBufferMemoryRequirements = f_; } { PFN_vkGetDeviceGroupPeerMemoryFeatures f_ = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gdpa(device, "vkGetDeviceGroupPeerMemoryFeatures"); if (!f_) f_ = (PFN_vkGetDeviceGroupPeerMemoryFeatures)gdpa(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR"); - if (f_) dt->vkGetDeviceGroupPeerMemoryFeatures = f_; + dt->vkGetDeviceGroupPeerMemoryFeatures = f_; } { PFN_vkGetDeviceImageMemoryRequirements f_ = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirements"); if (!f_) f_ = (PFN_vkGetDeviceImageMemoryRequirements)gdpa(device, "vkGetDeviceImageMemoryRequirementsKHR"); - if (f_) dt->vkGetDeviceImageMemoryRequirements = f_; + dt->vkGetDeviceImageMemoryRequirements = f_; } { PFN_vkGetDeviceImageSparseMemoryRequirements f_ = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirements"); if (!f_) f_ = (PFN_vkGetDeviceImageSparseMemoryRequirements)gdpa(device, "vkGetDeviceImageSparseMemoryRequirementsKHR"); - if (f_) dt->vkGetDeviceImageSparseMemoryRequirements = f_; + dt->vkGetDeviceImageSparseMemoryRequirements = f_; } { PFN_vkGetDeviceImageSubresourceLayout f_ = (PFN_vkGetDeviceImageSubresourceLayout)gdpa(device, "vkGetDeviceImageSubresourceLayout"); if (!f_) f_ = (PFN_vkGetDeviceImageSubresourceLayout)gdpa(device, "vkGetDeviceImageSubresourceLayoutKHR"); - if (f_) dt->vkGetDeviceImageSubresourceLayout = f_; + dt->vkGetDeviceImageSubresourceLayout = f_; } { PFN_vkGetDeviceMemoryCommitment f_ = (PFN_vkGetDeviceMemoryCommitment)gdpa(device, "vkGetDeviceMemoryCommitment"); - if (f_) dt->vkGetDeviceMemoryCommitment = f_; + dt->vkGetDeviceMemoryCommitment = f_; } { PFN_vkGetDeviceMemoryOpaqueCaptureAddress f_ = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gdpa(device, "vkGetDeviceMemoryOpaqueCaptureAddress"); if (!f_) f_ = (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)gdpa(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR"); - if (f_) dt->vkGetDeviceMemoryOpaqueCaptureAddress = f_; + dt->vkGetDeviceMemoryOpaqueCaptureAddress = f_; } { PFN_vkGetDeviceQueue f_ = (PFN_vkGetDeviceQueue)gdpa(device, "vkGetDeviceQueue"); - if (f_) dt->vkGetDeviceQueue = f_; + dt->vkGetDeviceQueue = f_; } { PFN_vkGetDeviceQueue2 f_ = (PFN_vkGetDeviceQueue2)gdpa(device, "vkGetDeviceQueue2"); - if (f_) dt->vkGetDeviceQueue2 = f_; + dt->vkGetDeviceQueue2 = f_; } { PFN_vkGetDeviceTensorMemoryRequirementsARM f_ = (PFN_vkGetDeviceTensorMemoryRequirementsARM)gdpa(device, "vkGetDeviceTensorMemoryRequirementsARM"); - if (f_) dt->vkGetDeviceTensorMemoryRequirementsARM = f_; + dt->vkGetDeviceTensorMemoryRequirementsARM = f_; } { PFN_vkGetEventStatus f_ = (PFN_vkGetEventStatus)gdpa(device, "vkGetEventStatus"); - if (f_) dt->vkGetEventStatus = f_; + dt->vkGetEventStatus = f_; } { PFN_vkGetFenceFdKHR f_ = (PFN_vkGetFenceFdKHR)gdpa(device, "vkGetFenceFdKHR"); - if (f_) dt->vkGetFenceFdKHR = f_; + dt->vkGetFenceFdKHR = f_; } { PFN_vkGetFenceStatus f_ = (PFN_vkGetFenceStatus)gdpa(device, "vkGetFenceStatus"); - if (f_) dt->vkGetFenceStatus = f_; + dt->vkGetFenceStatus = f_; } { PFN_vkGetImageDrmFormatModifierPropertiesEXT f_ = (PFN_vkGetImageDrmFormatModifierPropertiesEXT)gdpa(device, "vkGetImageDrmFormatModifierPropertiesEXT"); - if (f_) dt->vkGetImageDrmFormatModifierPropertiesEXT = f_; + dt->vkGetImageDrmFormatModifierPropertiesEXT = f_; } { PFN_vkGetImageMemoryRequirements f_ = (PFN_vkGetImageMemoryRequirements)gdpa(device, "vkGetImageMemoryRequirements"); - if (f_) dt->vkGetImageMemoryRequirements = f_; + dt->vkGetImageMemoryRequirements = f_; } { PFN_vkGetImageMemoryRequirements2 f_ = (PFN_vkGetImageMemoryRequirements2)gdpa(device, "vkGetImageMemoryRequirements2"); if (!f_) f_ = (PFN_vkGetImageMemoryRequirements2)gdpa(device, "vkGetImageMemoryRequirements2KHR"); - if (f_) dt->vkGetImageMemoryRequirements2 = f_; + dt->vkGetImageMemoryRequirements2 = f_; } { PFN_vkGetImageSparseMemoryRequirements f_ = (PFN_vkGetImageSparseMemoryRequirements)gdpa(device, "vkGetImageSparseMemoryRequirements"); - if (f_) dt->vkGetImageSparseMemoryRequirements = f_; + dt->vkGetImageSparseMemoryRequirements = f_; } { PFN_vkGetImageSparseMemoryRequirements2 f_ = (PFN_vkGetImageSparseMemoryRequirements2)gdpa(device, "vkGetImageSparseMemoryRequirements2"); if (!f_) f_ = (PFN_vkGetImageSparseMemoryRequirements2)gdpa(device, "vkGetImageSparseMemoryRequirements2KHR"); - if (f_) dt->vkGetImageSparseMemoryRequirements2 = f_; + dt->vkGetImageSparseMemoryRequirements2 = f_; } { PFN_vkGetImageSubresourceLayout f_ = (PFN_vkGetImageSubresourceLayout)gdpa(device, "vkGetImageSubresourceLayout"); - if (f_) dt->vkGetImageSubresourceLayout = f_; + dt->vkGetImageSubresourceLayout = f_; } { PFN_vkGetImageSubresourceLayout2 f_ = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2"); if (!f_) f_ = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2EXT"); if (!f_) f_ = (PFN_vkGetImageSubresourceLayout2)gdpa(device, "vkGetImageSubresourceLayout2KHR"); - if (f_) dt->vkGetImageSubresourceLayout2 = f_; + dt->vkGetImageSubresourceLayout2 = f_; } { PFN_vkGetMemoryFdKHR f_ = (PFN_vkGetMemoryFdKHR)gdpa(device, "vkGetMemoryFdKHR"); - if (f_) dt->vkGetMemoryFdKHR = f_; + dt->vkGetMemoryFdKHR = f_; } { PFN_vkGetMemoryFdPropertiesKHR f_ = (PFN_vkGetMemoryFdPropertiesKHR)gdpa(device, "vkGetMemoryFdPropertiesKHR"); - if (f_) dt->vkGetMemoryFdPropertiesKHR = f_; + dt->vkGetMemoryFdPropertiesKHR = f_; } { PFN_vkGetMemoryHostPointerPropertiesEXT f_ = (PFN_vkGetMemoryHostPointerPropertiesEXT)gdpa(device, "vkGetMemoryHostPointerPropertiesEXT"); - if (f_) dt->vkGetMemoryHostPointerPropertiesEXT = f_; + dt->vkGetMemoryHostPointerPropertiesEXT = f_; } { PFN_vkGetPipelineCacheData f_ = (PFN_vkGetPipelineCacheData)gdpa(device, "vkGetPipelineCacheData"); - if (f_) dt->vkGetPipelineCacheData = f_; + dt->vkGetPipelineCacheData = f_; } { PFN_vkGetQueryPoolResults f_ = (PFN_vkGetQueryPoolResults)gdpa(device, "vkGetQueryPoolResults"); - if (f_) dt->vkGetQueryPoolResults = f_; + dt->vkGetQueryPoolResults = f_; } { PFN_vkGetRenderAreaGranularity f_ = (PFN_vkGetRenderAreaGranularity)gdpa(device, "vkGetRenderAreaGranularity"); - if (f_) dt->vkGetRenderAreaGranularity = f_; + dt->vkGetRenderAreaGranularity = f_; } { PFN_vkGetRenderingAreaGranularity f_ = (PFN_vkGetRenderingAreaGranularity)gdpa(device, "vkGetRenderingAreaGranularity"); if (!f_) f_ = (PFN_vkGetRenderingAreaGranularity)gdpa(device, "vkGetRenderingAreaGranularityKHR"); - if (f_) dt->vkGetRenderingAreaGranularity = f_; + dt->vkGetRenderingAreaGranularity = f_; } { PFN_vkGetSemaphoreCounterValue f_ = (PFN_vkGetSemaphoreCounterValue)gdpa(device, "vkGetSemaphoreCounterValue"); if (!f_) f_ = (PFN_vkGetSemaphoreCounterValue)gdpa(device, "vkGetSemaphoreCounterValueKHR"); - if (f_) dt->vkGetSemaphoreCounterValue = f_; + dt->vkGetSemaphoreCounterValue = f_; } { PFN_vkGetSemaphoreFdKHR f_ = (PFN_vkGetSemaphoreFdKHR)gdpa(device, "vkGetSemaphoreFdKHR"); - if (f_) dt->vkGetSemaphoreFdKHR = f_; + dt->vkGetSemaphoreFdKHR = f_; } { PFN_vkGetShaderModuleCreateInfoIdentifierEXT f_ = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT"); - if (f_) dt->vkGetShaderModuleCreateInfoIdentifierEXT = f_; + dt->vkGetShaderModuleCreateInfoIdentifierEXT = f_; } { PFN_vkGetShaderModuleIdentifierEXT f_ = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(device, "vkGetShaderModuleIdentifierEXT"); - if (f_) dt->vkGetShaderModuleIdentifierEXT = f_; + dt->vkGetShaderModuleIdentifierEXT = f_; } { PFN_vkGetTensorMemoryRequirementsARM f_ = (PFN_vkGetTensorMemoryRequirementsARM)gdpa(device, "vkGetTensorMemoryRequirementsARM"); - if (f_) dt->vkGetTensorMemoryRequirementsARM = f_; + dt->vkGetTensorMemoryRequirementsARM = f_; } { PFN_vkImportFenceFdKHR f_ = (PFN_vkImportFenceFdKHR)gdpa(device, "vkImportFenceFdKHR"); - if (f_) dt->vkImportFenceFdKHR = f_; + dt->vkImportFenceFdKHR = f_; } { PFN_vkImportSemaphoreFdKHR f_ = (PFN_vkImportSemaphoreFdKHR)gdpa(device, "vkImportSemaphoreFdKHR"); - if (f_) dt->vkImportSemaphoreFdKHR = f_; + dt->vkImportSemaphoreFdKHR = f_; } { PFN_vkInvalidateMappedMemoryRanges f_ = (PFN_vkInvalidateMappedMemoryRanges)gdpa(device, "vkInvalidateMappedMemoryRanges"); - if (f_) dt->vkInvalidateMappedMemoryRanges = f_; + dt->vkInvalidateMappedMemoryRanges = f_; } { PFN_vkMapMemory f_ = (PFN_vkMapMemory)gdpa(device, "vkMapMemory"); - if (f_) dt->vkMapMemory = f_; + dt->vkMapMemory = f_; } { PFN_vkMergePipelineCaches f_ = (PFN_vkMergePipelineCaches)gdpa(device, "vkMergePipelineCaches"); - if (f_) dt->vkMergePipelineCaches = f_; + dt->vkMergePipelineCaches = f_; } { PFN_vkQueueBindSparse f_ = (PFN_vkQueueBindSparse)gdpa(device, "vkQueueBindSparse"); - if (f_) dt->vkQueueBindSparse = f_; + dt->vkQueueBindSparse = f_; } { PFN_vkQueueSubmit f_ = (PFN_vkQueueSubmit)gdpa(device, "vkQueueSubmit"); - if (f_) dt->vkQueueSubmit = f_; + dt->vkQueueSubmit = f_; } { PFN_vkQueueSubmit2 f_ = (PFN_vkQueueSubmit2)gdpa(device, "vkQueueSubmit2"); if (!f_) f_ = (PFN_vkQueueSubmit2)gdpa(device, "vkQueueSubmit2KHR"); - if (f_) dt->vkQueueSubmit2 = f_; + dt->vkQueueSubmit2 = f_; } { PFN_vkQueueWaitIdle f_ = (PFN_vkQueueWaitIdle)gdpa(device, "vkQueueWaitIdle"); - if (f_) dt->vkQueueWaitIdle = f_; + dt->vkQueueWaitIdle = f_; } { PFN_vkResetCommandBuffer f_ = (PFN_vkResetCommandBuffer)gdpa(device, "vkResetCommandBuffer"); - if (f_) dt->vkResetCommandBuffer = f_; + dt->vkResetCommandBuffer = f_; } { PFN_vkResetCommandPool f_ = (PFN_vkResetCommandPool)gdpa(device, "vkResetCommandPool"); - if (f_) dt->vkResetCommandPool = f_; + dt->vkResetCommandPool = f_; } { PFN_vkResetDescriptorPool f_ = (PFN_vkResetDescriptorPool)gdpa(device, "vkResetDescriptorPool"); - if (f_) dt->vkResetDescriptorPool = f_; + dt->vkResetDescriptorPool = f_; } { PFN_vkResetEvent f_ = (PFN_vkResetEvent)gdpa(device, "vkResetEvent"); - if (f_) dt->vkResetEvent = f_; + dt->vkResetEvent = f_; } { PFN_vkResetFences f_ = (PFN_vkResetFences)gdpa(device, "vkResetFences"); - if (f_) dt->vkResetFences = f_; + dt->vkResetFences = f_; } { PFN_vkResetQueryPool f_ = (PFN_vkResetQueryPool)gdpa(device, "vkResetQueryPool"); if (!f_) f_ = (PFN_vkResetQueryPool)gdpa(device, "vkResetQueryPoolEXT"); - if (f_) dt->vkResetQueryPool = f_; + dt->vkResetQueryPool = f_; } { PFN_vkSetDeviceMemoryPriorityEXT f_ = (PFN_vkSetDeviceMemoryPriorityEXT)gdpa(device, "vkSetDeviceMemoryPriorityEXT"); - if (f_) dt->vkSetDeviceMemoryPriorityEXT = f_; + dt->vkSetDeviceMemoryPriorityEXT = f_; } { PFN_vkSetEvent f_ = (PFN_vkSetEvent)gdpa(device, "vkSetEvent"); - if (f_) dt->vkSetEvent = f_; + dt->vkSetEvent = f_; } { PFN_vkSignalSemaphore f_ = (PFN_vkSignalSemaphore)gdpa(device, "vkSignalSemaphore"); if (!f_) f_ = (PFN_vkSignalSemaphore)gdpa(device, "vkSignalSemaphoreKHR"); - if (f_) dt->vkSignalSemaphore = f_; + dt->vkSignalSemaphore = f_; } { PFN_vkTrimCommandPool f_ = (PFN_vkTrimCommandPool)gdpa(device, "vkTrimCommandPool"); if (!f_) f_ = (PFN_vkTrimCommandPool)gdpa(device, "vkTrimCommandPoolKHR"); - if (f_) dt->vkTrimCommandPool = f_; + dt->vkTrimCommandPool = f_; } { PFN_vkUnmapMemory f_ = (PFN_vkUnmapMemory)gdpa(device, "vkUnmapMemory"); - if (f_) dt->vkUnmapMemory = f_; + dt->vkUnmapMemory = f_; } { PFN_vkUpdateDescriptorSetWithTemplate f_ = (PFN_vkUpdateDescriptorSetWithTemplate)gdpa(device, "vkUpdateDescriptorSetWithTemplate"); if (!f_) f_ = (PFN_vkUpdateDescriptorSetWithTemplate)gdpa(device, "vkUpdateDescriptorSetWithTemplateKHR"); - if (f_) dt->vkUpdateDescriptorSetWithTemplate = f_; + dt->vkUpdateDescriptorSetWithTemplate = f_; } { PFN_vkUpdateDescriptorSets f_ = (PFN_vkUpdateDescriptorSets)gdpa(device, "vkUpdateDescriptorSets"); - if (f_) dt->vkUpdateDescriptorSets = f_; + dt->vkUpdateDescriptorSets = f_; } { PFN_vkWaitForFences f_ = (PFN_vkWaitForFences)gdpa(device, "vkWaitForFences"); - if (f_) dt->vkWaitForFences = f_; + dt->vkWaitForFences = f_; } { PFN_vkWaitSemaphores f_ = (PFN_vkWaitSemaphores)gdpa(device, "vkWaitSemaphores"); if (!f_) f_ = (PFN_vkWaitSemaphores)gdpa(device, "vkWaitSemaphoresKHR"); - if (f_) dt->vkWaitSemaphores = f_; + dt->vkWaitSemaphores = f_; } } diff --git a/tools/vkbridge/host/Makefile b/tools/vkbridge/host/Makefile index 7e1c1f7c2..36f408a5f 100644 --- a/tools/vkbridge/host/Makefile +++ b/tools/vkbridge/host/Makefile @@ -19,7 +19,7 @@ all: $(OUT)/vkbridge-server $(OUT)/libvulkan_droidbridge.so $(OUT)/vkbridge_icd. $(OUT)/vkbridge-server: $(SERVER_SRC) $(wildcard $(SRV)/*.h $(VKB)/common/*.h $(VKB)/common/gen/*.h) @mkdir -p $(OUT) - $(CC) $(CFLAGS) $(WARN) $(INC) -I$(SRV) -o $@ $(SERVER_SRC) -ldl -lpthread -lm + $(CC) $(CFLAGS) $(WARN) $(INC) -I$(SRV) -o $@ $(SERVER_SRC) -ldl -lpthread -lm -rdynamic $(OUT)/libvulkan_droidbridge.so: $(CLIENT_SRC) $(wildcard $(VKB)/client/*.h $(VKB)/common/*.h $(VKB)/common/gen/*.h) @mkdir -p $(OUT) diff --git a/tools/vkbridge/host/bridge_env.sh b/tools/vkbridge/host/bridge_env.sh index 0d4d7efbf..5659a6eb9 100755 --- a/tools/vkbridge/host/bridge_env.sh +++ b/tools/vkbridge/host/bridge_env.sh @@ -1,9 +1,9 @@ #!/bin/bash -# Source this: starts a host vkbridge server on the given desktop driver (default RADV) and +# Source this: starts a host vkbridge server on a desktop driver (VKB_HOST_ICD, default RADV) and # points this shell's Vulkan programs at the bridge ICD. -# . tools/vkbridge/host/bridge_env.sh [icd-json] +# [VKB_HOST_ICD=...] . tools/vkbridge/host/bridge_env.sh _vkb_host=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) -_vkb_icd=${1:-/usr/share/vulkan/icd.d/radeon_icd.json} +_vkb_icd=${VKB_HOST_ICD:-/usr/share/vulkan/icd.d/radeon_icd.json} export VKBRIDGE_SOCKET=${VKBRIDGE_SOCKET:-${XDG_RUNTIME_DIR:-/tmp}/vkbridge-host.sock} pgrep -x vkbridge-server >/dev/null && kill $(pgrep -x vkbridge-server) 2>/dev/null; sleep 0.3 rm -f "$VKBRIDGE_SOCKET" diff --git a/tools/vkbridge/host/mali_env.sh b/tools/vkbridge/host/mali_env.sh index 7ec508894..81addd97a 100755 --- a/tools/vkbridge/host/mali_env.sh +++ b/tools/vkbridge/host/mali_env.sh @@ -5,7 +5,7 @@ _vkb_host=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) export VKBRIDGE_SOCKET=${XDG_RUNTIME_DIR:-/tmp}/vkbridge-host.sock pgrep -x vkbridge-server >/dev/null && kill $(pgrep -x vkbridge-server) 2>/dev/null; sleep 0.3 rm -f "$VKBRIDGE_SOCKET" -VKBRIDGE_FAKE_MISSING=${VKB_MISSING:-bc,clip,cull,divisor,maint5} VK_DRIVER_FILES=${1:-/usr/share/vulkan/icd.d/radeon_icd.json} \ +VKBRIDGE_FAKE_MISSING=${VKB_MISSING:-bc,clip,cull,divisor,maint5} VK_DRIVER_FILES=${VKB_HOST_ICD:-/usr/share/vulkan/icd.d/radeon_icd.json} \ nohup "$_vkb_host/out/vkbridge-server" --socket "$VKBRIDGE_SOCKET" --log "$_vkb_host/out/server.log" >/dev/null 2>&1 & for _i in $(seq 50); do [ -S "$VKBRIDGE_SOCKET" ] && break; sleep 0.1; done chmod 666 "$VKBRIDGE_SOCKET" diff --git a/tools/vkbridge/host/run_tests.sh b/tools/vkbridge/host/run_tests.sh new file mode 100755 index 000000000..23764fa65 --- /dev/null +++ b/tools/vkbridge/host/run_tests.sh @@ -0,0 +1,32 @@ +#!/bin/bash +# Host regression suite for the bridge: every automated check, in two server modes - +# plain the desktop driver as it is (RADV) +# mali the desktop driver with Mali-G720's known gaps imitated (mali_env.sh) +# Needs: make (out/), Proton Experimental for the DXVK check (VKB_WINE_DIR prepared, see README), +# docker image vkb-arch-gamescope for the gamescope/Zink check (skipped if absent). +cd "$(dirname "$0")" +pass=0; fail=0 +result() { if [ "$1" = 0 ]; then pass=$((pass+1)); echo " ok $2"; else fail=$((fail+1)); echo " FAIL $2"; fi; } +run_mode() { + local mode=$1 + echo "== $mode" + if [ "$mode" = mali ]; then . ./mali_env.sh >/dev/null; else unset VKBRIDGE_HIDE_EXTS VKBRIDGE_MAX_API; . ./bridge_env.sh >/dev/null; fi + timeout 120 ./out/vkbridge-smoke >out/t-smoke.log 2>&1; result $? "smoke ($(tail -1 out/t-smoke.log))" + timeout 180 ./out/bcn_check >out/t-bcn.log 2>&1; result $? "bcn_check ($(tail -1 out/t-bcn.log))" + if [ -n "${VKB_WINE_DIR:-}" ] && [ -d "$VKB_WINE_DIR/app" ]; then + ./d3d11_test.sh >out/t-d3d11.log 2>&1; grep -q "^OK:" out/t-d3d11.log; result $? "d3d11_check via DXVK ($(grep -E '^(OK|FAILED)' out/t-d3d11.log))" + fi + timeout 60 vkcube-wayland --c 120 >out/t-vkcube.log 2>&1; result $? "vkcube-wayland (dma-buf)" + VKBRIDGE_WSI_SHM=1 timeout 60 vkcube-wayland --c 120 >>out/t-vkcube.log 2>&1; result $? "vkcube-wayland (wl_shm)" + timeout 60 vkcube --c 120 >>out/t-vkcube.log 2>&1; result $? "vkcube (X11)" + if docker image inspect vkb-arch-gamescope >/dev/null 2>&1; then + VKB_DOCKER_EXTRA="--device /dev/dri/renderD128" VKBRIDGE_DRM_RENDER=226:128 timeout 120 ./gamescope_test.sh \ + "bash -c 'export MESA_LOADER_DRIVER_OVERRIDE=zink GALLIUM_DRIVER=zink LIBGL_KOPPER_DRI2=true; timeout 20 glxgears 2>&1 | grep -m1 frames'" \ + >out/t-gamescope-$mode.log 2>&1 + grep -q "frames in" out/t-gamescope-$mode.log; result $? "gamescope + Zink glxgears ($(grep -m1 -o '[0-9.]* FPS' out/t-gamescope-$mode.log))" + fi +} +run_mode plain +run_mode mali +echo "== $pass passed, $fail failed" +[ "$fail" = 0 ] diff --git a/tools/vkbridge/tests/bcn_check.c b/tools/vkbridge/tests/bcn_check.c index 0dd7b595d..d6da603a4 100644 --- a/tools/vkbridge/tests/bcn_check.c +++ b/tools/vkbridge/tests/bcn_check.c @@ -303,14 +303,14 @@ int main(int argc, char **argv) vkGetDeviceQueue(dev, 0, 0, &queue); VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, 0}; vkCreateCommandPool(dev, &pci, NULL, &pool); - float u8 = 1.5f / 255.0f; + float u8 = 2.5f / 255.0f; /* hardware decoders round differently from bcdec by up to 2 */ test_format(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, "BC1", u8); test_format(VK_FORMAT_BC2_UNORM_BLOCK, "BC2", u8); test_format(VK_FORMAT_BC3_UNORM_BLOCK, "BC3", u8); test_format(VK_FORMAT_BC4_UNORM_BLOCK, "BC4 unorm", u8); - test_format(VK_FORMAT_BC4_SNORM_BLOCK, "BC4 snorm", 1.5f / 127.0f); + test_format(VK_FORMAT_BC4_SNORM_BLOCK, "BC4 snorm", 2.5f / 127.0f); test_format(VK_FORMAT_BC5_UNORM_BLOCK, "BC5 unorm", u8); - test_format(VK_FORMAT_BC5_SNORM_BLOCK, "BC5 snorm", 1.5f / 127.0f); + test_format(VK_FORMAT_BC5_SNORM_BLOCK, "BC5 snorm", 2.5f / 127.0f); test_format(VK_FORMAT_BC6H_UFLOAT_BLOCK, "BC6H ufloat (all 14 modes)", 0.002f); test_format(VK_FORMAT_BC6H_SFLOAT_BLOCK, "BC6H sfloat (all 14 modes)", 0.002f); test_format(VK_FORMAT_BC7_UNORM_BLOCK, "BC7 (all 8 modes)", u8);