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 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR
This commit is contained in:
ahmadandClaude Opus 5.5 authored and Ahmad Sayed Alsayed Ebrahim committed 2026-10-10 14:28:13 +03:00
1 parent 92c94c5c15
commit 02a06bec3f
18 files changed
+1289 -734

No files matched your search

+12 -2
View File
@@ -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,
@@ -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 <stdlib.h>
#include <string.h>
#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;
}
@@ -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; }
@@ -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;
}
+43 -1
View File
@@ -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;
@@ -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;
+7
View File
@@ -30,6 +30,8 @@
#ifdef __ANDROID__
#include <android/log.h>
#elif defined(__GLIBC__)
#include <execinfo.h>
#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);
+10 -6
View File
@@ -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);
+1
View File
@@ -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 {
+12 -3
View File
@@ -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]);')
+1 -1
View File
@@ -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
+441 -441
View File
@@ -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]);
File diff suppressed because it is too large. Load diff
+1 -1
View File
@@ -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)
+3 -3
View File
@@ -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"
+1 -1
View File
@@ -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"
+32
View File
@@ -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 ]
+3 -3
View File
@@ -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);